Build CallToolResult directly in convert_result

Have FuncMetadata.convert_result return a CallToolResult instead of the
intermediate (content, structured_content) tuple / bare content sequence
shapes. MCPServer.call_tool becomes a passthrough, and the ToolResult
alias plus the convert_result overloads on ToolManager.call_tool are no
longer needed.

Author: Kludex

src/mcp/server/mcpserver/server.py

@@ -384,13 +384,7 @@ async def call_tool(
         """Call a tool by name with arguments."""
         if context is None:
             context = Context(mcp_server=self)
-        result = await self._tool_manager.call_tool(name, arguments, context, convert_result=True)
-        if isinstance(result, CallToolResult):
-            return result
-        if isinstance(result, tuple):
-            content, structured_content = result
-            return CallToolResult(content=list(content), structured_content=structured_content)
-        return CallToolResult(content=list(result))
+        return await self._tool_manager.call_tool(name, arguments, context, convert_result=True)
 
     async def list_resources(self) -> list[MCPResource]:
         """List all available resources."""

src/mcp/server/mcpserver/tools/tool_manager.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, Literal, overload
+from typing import TYPE_CHECKING, Any
 
 from mcp.server.mcpserver.exceptions import ToolError
 from mcp.server.mcpserver.tools.base import Tool
-from mcp.server.mcpserver.utilities.func_metadata import ToolResult
 from mcp.server.mcpserver.utilities.logging import get_logger
 from mcp.types import Icon, ToolAnnotations
 
@@ -72,22 +71,6 @@ def remove_tool(self, name: str) -> None:
             raise ToolError(f"Unknown tool: {name}")
         del self._tools[name]
 
-    @overload
-    async def call_tool(
-        self,
-        name: str,
-        arguments: dict[str, Any],
-        context: Context[LifespanContextT, RequestT],
-        convert_result: Literal[True],
-    ) -> ToolResult: ...
-    @overload
-    async def call_tool(
-        self,
-        name: str,
-        arguments: dict[str, Any],
-        context: Context[LifespanContextT, RequestT],
-        convert_result: Literal[False] = False,
-    ) -> Any: ...
     async def call_tool(
         self,
         name: str,

src/mcp/server/mcpserver/utilities/func_metadata.py

@@ -4,7 +4,7 @@
 from collections.abc import Awaitable, Callable, Sequence
 from itertools import chain
 from types import GenericAlias
-from typing import Annotated, Any, TypeAlias, cast, get_args, get_origin, get_type_hints
+from typing import Annotated, Any, cast, get_args, get_origin, get_type_hints
 
 import anyio
 import anyio.to_thread
@@ -28,8 +28,6 @@
 
 logger = get_logger(__name__)
 
-ToolResult: TypeAlias = CallToolResult | list[ContentBlock] | tuple[list[ContentBlock], dict[str, Any]]
-
 
 class StrictJsonSchema(GenerateJsonSchema):
     """A JSON schema generator that raises exceptions instead of emitting warnings.
@@ -90,14 +88,10 @@ async def call_fn_with_arg_validation(
         else:
             return await anyio.to_thread.run_sync(functools.partial(fn, **arguments_parsed_dict))
 
-    def convert_result(self, result: Any) -> ToolResult:
-        """Convert a function call result to the format for the lowlevel tool call handler.
-
-        - If output_model is None, return the unstructured content directly.
-        - If output_model is not None, convert the result to structured output format
-            (dict[str, Any]) and return both unstructured and structured content.
+    def convert_result(self, result: Any) -> CallToolResult:
+        """Convert a function call result into a `CallToolResult`.
 
-        Note: we return unstructured content here **even though the lowlevel server
+        Note: we build unstructured content here **even though the lowlevel server
         tool call handler provides generic backwards compatibility serialization of
         structured content**. This is for MCPServer backwards compatibility: we need to
         retain MCPServer's ad hoc conversion logic for constructing unstructured output
@@ -113,16 +107,16 @@ def convert_result(self, result: Any) -> ToolResult:
         unstructured_content = _convert_to_content(result)
 
         if self.output_schema is None:
-            return unstructured_content
-        else:
-            if self.wrap_output:
-                result = {"result": result}
+            return CallToolResult(content=unstructured_content)
+
+        if self.wrap_output:
+            result = {"result": result}
 
-            assert self.output_model is not None, "Output model must be set if output schema is defined"
-            validated = self.output_model.model_validate(result)
-            structured_content = validated.model_dump(mode="json", by_alias=True)
+        assert self.output_model is not None, "Output model must be set if output schema is defined"
+        validated = self.output_model.model_validate(result)
+        structured_content = validated.model_dump(mode="json", by_alias=True)
 
-            return (unstructured_content, structured_content)
+        return CallToolResult(content=unstructured_content, structured_content=structured_content)
 
     def pre_parse_json(self, data: dict[str, Any]) -> dict[str, Any]:
         """Pre-parse data from JSON.

tests/server/mcpserver/test_func_metadata.py

@@ -1038,9 +1038,8 @@ def func_with_aliases() -> ModelWithAliases:  # pragma: no cover
 
     # Check that the actual output uses aliases too
     result = ModelWithAliases(**{"first": "hello", "second": "world"})
-    converted = meta.convert_result(result)
-    assert isinstance(converted, tuple)
-    _, structured_content = converted
+    structured_content = meta.convert_result(result).structured_content
+    assert structured_content is not None
 
     # The structured content should use aliases to match the schema
     assert "first" in structured_content
@@ -1052,9 +1051,8 @@ def func_with_aliases() -> ModelWithAliases:  # pragma: no cover
 
     # Also test the case where we have a model with defaults to ensure aliases work in all cases
     result_with_defaults = ModelWithAliases()  # Uses default None values
-    converted_defaults = meta.convert_result(result_with_defaults)
-    assert isinstance(converted_defaults, tuple)
-    _, structured_content_defaults = converted_defaults
+    structured_content_defaults = meta.convert_result(result_with_defaults).structured_content
+    assert structured_content_defaults is not None
 
     # Even with defaults, should use aliases in output
     assert "first" in structured_content_defaults

tests/server/mcpserver/test_tool_manager.py

@@ -11,7 +11,7 @@
 from mcp.server.mcpserver.exceptions import ToolError
 from mcp.server.mcpserver.tools import Tool, ToolManager
 from mcp.server.mcpserver.utilities.func_metadata import ArgModelBase, FuncMetadata
-from mcp.types import TextContent, ToolAnnotations
+from mcp.types import CallToolResult, TextContent, ToolAnnotations
 
 
 class TestAddTools:
@@ -455,8 +455,8 @@ def get_user(user_id: int) -> UserOutput:
         manager.add_tool(get_user)
         result = await manager.call_tool("get_user", {"user_id": 1}, Context(), convert_result=True)
         # don't test unstructured output here, just the structured conversion
-        assert isinstance(result, tuple)
-        assert result[1] == {"name": "John", "age": 30}
+        assert isinstance(result, CallToolResult)
+        assert result.structured_content == {"name": "John", "age": 30}
 
     @pytest.mark.anyio
     async def test_tool_with_primitive_output(self):
@@ -471,8 +471,8 @@ def double_number(n: int) -> int:
         result = await manager.call_tool("double_number", {"n": 5}, Context())
         assert result == 10
         result = await manager.call_tool("double_number", {"n": 5}, Context(), convert_result=True)
-        assert isinstance(result, tuple)
-        assert isinstance(result[0][0], TextContent) and result[1] == {"result": 10}
+        assert isinstance(result, CallToolResult)
+        assert isinstance(result.content[0], TextContent) and result.structured_content == {"result": 10}
 
     @pytest.mark.anyio
     async def test_tool_with_typeddict_output(self):
@@ -512,8 +512,8 @@ def get_person() -> Person:
         manager.add_tool(get_person)
         result = await manager.call_tool("get_person", {}, Context(), convert_result=True)
         # don't test unstructured output here, just the structured conversion
-        assert isinstance(result, tuple)
-        assert result[1] == expected_output
+        assert isinstance(result, CallToolResult)
+        assert result.structured_content == expected_output
 
     @pytest.mark.anyio
     async def test_tool_with_list_output(self):
@@ -531,8 +531,8 @@ def get_numbers() -> list[int]:
         result = await manager.call_tool("get_numbers", {}, Context())
         assert result == expected_list
         result = await manager.call_tool("get_numbers", {}, Context(), convert_result=True)
-        assert isinstance(result, tuple)
-        assert isinstance(result[0][0], TextContent) and result[1] == expected_output
+        assert isinstance(result, CallToolResult)
+        assert isinstance(result.content[0], TextContent) and result.structured_content == expected_output
 
     @pytest.mark.anyio
     async def test_tool_without_structured_output(self):