Langchain Content Blocks

LangChain Content Blocks (Python)

Overview

On Claude, AIMessage.content is list[dict] even for pure text — so any code from an OpenAI-first tutorial that calls message.content.lower() or message.content.split() crashes with AttributeError: 'list' object has no attribute 'lower' on the first production Claude call (P02). Multi-modal code that works on GPT-4o breaks on Claude because pre-1.0 image-block shapes differed across providers (P64). Multi-turn Claude replay with extended thinking fails with anthropic.BadRequestError: missing signature when prior thinking blocks are stripped. Forced tool_choice prevents stop_reason="end_turn" and loops forever (P63).

This is the deep-dive companion to langchain-model-inference. That skill's references/content-blocks.md covers the str vs list[dict] divergence and a safe text extractor. This skill goes further:

• tool_use block iteration mechanics — IDs, args as dict vs JSON string, streaming deltas
• thinking blocks — signature, redaction, multi-turn replay semantics
• document blocks — Claude citations API, source types, citation extraction
• Multi-modal composition — universal 1.0 image shape, per-provider adapter behavior
• Per-provider size limits (Anthropic 5 MB/image up to 20 images, OpenAI 20 MB/image, Gemini 20 MB/request)

Pin: langchain-core 1.0.x, langchain-anthropic >= 1.0, langchain-openai >= 1.0, anthropic >= 0.40. Pain-catalog anchors: P02, P58, P63, P64.

Prerequisites

• Python 3.10+
• langchain-core >= 1.0, < 2.0
• At least one provider package: pip install langchain-anthropic langchain-openai
• For extended thinking: langchain-anthropic >= 1.0 and Claude Sonnet 4+ / Opus 4+
• For citations: anthropic >= 0.40 and Claude Sonnet 4+
• Familiarity with langchain-model-inference (reads references/content-blocks.md first)

Instructions

Step 1 — Learn the block-type taxonomy

LangChain 1.0 defines six typed content blocks on AIMessage.content (and on chunks during streaming):

See Block-Type Matrix for the full table with streaming behavior and per-type gotchas.

Step 2 — Iterate mixed content safely

For most code, use the helpers:

text = msg.text()                    # concatenated text across all text blocks
tool_calls = msg.tool_calls          # normalized list[ToolCall]
usage = msg.usage_metadata           # input_tokens, output_tokens, cache_*

Hand-roll block iteration only when you need to (a) preserve order, (b) extract thinking blocks for replay, or (c) read citations metadata from text blocks. Order-preserving iteration:

from langchain_core.messages import AIMessage

def iter_blocks(msg: AIMessage):
    if isinstance(msg.content, str):
        yield "text", {"type": "text", "text": msg.content}
        return
    for block in msg.content:
        if isinstance(block, dict):
            yield block.get("type", "unknown"), block
        else:
            yield getattr(block, "type", "unknown"), block

Step 3 — Compose multi-modal messages with the universal image block

import base64
from pathlib import Path
from langchain_core.messages import HumanMessage

def image_block(path: str) -> dict:
    data = base64.standard_b64encode(Path(path).read_bytes()).decode("ascii")
    mime = {"png": "image/png", "jpg": "image/jpeg",
            "jpeg": "image/jpeg", "webp": "image/webp"}[
        Path(path).suffix.lstrip(".").lower()]
    return {
        "type": "image",
        "source_type": "base64",   # or "url"
        "data": data,
        "mime_type": mime,
    }

msg = HumanMessage(content=[
    image_block("screenshot.png"),                         # put image FIRST
    {"type": "text", "text": "What is broken here?"},      # instruction LAST
])
response = claude.invoke([msg])

Three invariants:

1. content must be list[dict] when including non-text blocks.
2. Put the image before the instruction — Claude attends most to trailing tokens.
3. Respect provider limits (Anthropic: 5 MB/image, up to 20 images; OpenAI: 20 MB/image; Gemini: 20 MB/request total).

LangChain's adapter translates the universal shape to each provider's wire format. See Multi-Modal Composition for the full adapter table, MIME-type compatibility, and the document/citations pattern.

Step 4 — Iterate tool_use correctly across stream deltas

Canonical non-streaming:

for tc in msg.tool_calls:
    output = tools[tc["name"]](**tc["args"])
    history.append(ToolMessage(content=str(output), tool_call_id=tc["id"]))

tc["args"] is already a parsed dict — do not json.loads it. tc["id"] is provider-shaped (toolu_* on Anthropic, call_* on OpenAI, 24+ chars) and must be copied verbatim to the ToolMessage.

Streaming is different. tool_use.input arrives as partial JSON fragments across on_chat_model_stream events. Buffer with tool_call_chunks, parse once at on_chat_model_end:

from collections import defaultdict
import json

partial = defaultdict(str)   # index -> accumulated JSON fragment
meta = {}                     # index -> {name, id}

async for event in model.astream_events({"messages": [...]}, version="v2"):
    if event["event"] != "on_chat_model_stream":
        continue
    for tc_chunk in getattr(event["data"]["chunk"], "tool_call_chunks", []) or []:
        idx = tc_chunk["index"]
        if tc_chunk.get("name"):
            meta[idx] = {"name": tc_chunk["name"], "id": tc_chunk["id"]}
        if tc_chunk.get("args"):
            partial[idx] += tc_chunk["args"]

completed = [{**meta[i], "args": json.loads(partial[i])} for i in meta]

See Tool-Use Iteration for multi-tool-per-turn handling, ToolMessage ordering, and the forced- tool_choice infinite-loop trap (P63).

Step 5 — Preserve Claude thinking blocks for replay

Claude extended thinking (Sonnet 4+, Opus 4+) returns thinking blocks carrying a cryptographic signature. The next turn must round-trip those blocks intact or Anthropic rejects the request:

anthropic.BadRequestError: messages.1.content.0: missing signature

The foot-gun: msg.text() strips thinking blocks. Never do:

# WRONG — thinking blocks lost, replay fails
history.append(AIMessage(content=ai_1.text()))

Correct — pass the AIMessage back verbatim:

history.append(ai_1)   # preserves full content list + signatures

For persistence across sessions, serialize with messages_to_dict(...) (not custom JSON), which preserves block structure:

import json
from langchain_core.messages import messages_to_dict, messages_from_dict

serialized = json.dumps(messages_to_dict([ai_1]))
restored = messages_from_dict(json.loads(serialized))

See Thinking Blocks for redaction handling, the budget-tokens rule, and the interaction with tool calls.