refactor to support approach taken in RFC 371

Author: davemssavage

src/mcp/server/fastmcp/server.py

@@ -52,7 +52,6 @@
 from mcp.shared.context import LifespanContextT, RequestContext
 from mcp.types import (
     AnyFunction,
-    DataContent,
     EmbeddedResource,
     GetPromptResult,
     ImageContent,
@@ -237,7 +236,7 @@ def run(
     def _setup_handlers(self) -> None:
         """Set up core MCP protocol handlers."""
         self._mcp_server.list_tools()(self.list_tools)
-        self._mcp_server.call_tool()(self.call_tool)
+        self._mcp_server.call_tool()(self.call_tool, self._get_schema)
         self._mcp_server.list_resources()(self.list_resources)
         self._mcp_server.read_resource()(self.read_resource)
         self._mcp_server.list_prompts()(self.list_prompts)
@@ -271,13 +270,16 @@ def get_context(self) -> Context[ServerSession, object]:
 
     async def call_tool(
         self, name: str, arguments: dict[str, Any]
-    ) -> Sequence[TextContent | DataContent | ImageContent | EmbeddedResource]:
+    ) -> Sequence[TextContent | ImageContent | EmbeddedResource]:
         """Call a tool by name with arguments."""
         context = self.get_context()
         result = await self._tool_manager.call_tool(name, arguments, context=context)
         converted_result = _convert_to_content(result)
         return converted_result
 
+    def _get_schema(self, name: str) -> dict[str, Any] | None:
+        return self._tool_manager.get_schema(name)
+
     async def list_resources(self) -> list[MCPResource]:
         """List all available resources."""
 
@@ -871,12 +873,12 @@ async def get_prompt(
 
 def _convert_to_content(
     result: Any,
-) -> Sequence[TextContent | ImageContent | EmbeddedResource | DataContent]:
+) -> Sequence[TextContent | ImageContent | EmbeddedResource]:
     """Convert a result to a sequence of content objects."""
     if result is None:
         return []
 
-    if isinstance(result, TextContent | ImageContent | EmbeddedResource | DataContent):
+    if isinstance(result, TextContent | ImageContent | EmbeddedResource):
         return [result]
 
     if isinstance(result, Image):

src/mcp/server/fastmcp/tools/base.py

@@ -8,7 +8,7 @@
 
 from mcp.server.fastmcp.exceptions import ToolError
 from mcp.server.fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
-from mcp.types import DataContent, ToolAnnotations
+from mcp.types import ToolAnnotations
 
 if TYPE_CHECKING:
     from mcp.server.fastmcp.server import Context
@@ -102,12 +102,6 @@ async def run(
                 if self.context_kwarg is not None
                 else None,
             )
-            if self.output and self.output.get("type") == "object":
-                return DataContent(
-                    type="data",
-                    data=result,
-                )
-            else:
-                return result
+            return result
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e

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

@@ -62,3 +62,9 @@ async def call_tool(
             raise ToolError(f"Unknown tool: {name}")
 
         return await tool.run(arguments, context=context)
+
+    def get_schema(self, name: str) -> dict[str, Any] | None:
+        tool = self.get_tool(name)
+        if not tool:
+            raise ToolError(f"Unknown tool: {name}")
+        return tool.output

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

@@ -186,7 +186,9 @@ def func_metadata(
     # TODO this could be moved to a constant or passed in as param as per skip_names
     ignore = [inspect.Parameter.empty, None, types.Image]
     if sig.return_annotation not in ignore:
-        output_schema = TypeAdapter(sig.return_annotation).json_schema()
+        type_schema = TypeAdapter(sig.return_annotation).json_schema()
+        if type_schema.get("type", None) == "object":
+            output_schema = type_schema
 
     return FuncMetadata(arg_model=arguments_model, output_schema=output_schema)
 

src/mcp/server/lowlevel/server.py

@@ -71,11 +71,11 @@ async def main():
 import warnings
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
 from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, TypeVar, cast
 
 import anyio
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from pydantic import AnyUrl
+from pydantic import AnyUrl, BaseModel
 
 import mcp.types as types
 from mcp.server.lowlevel.helper_types import ReadResourceContents
@@ -399,30 +399,119 @@ def decorator(
                 ...,
                 Awaitable[
                     Iterable[
-                        types.TextContent
-                        | types.DataContent
-                        | types.ImageContent
-                        | types.EmbeddedResource
+                        types.TextContent | types.ImageContent | types.EmbeddedResource
                     ]
+                    | BaseModel
+                    | dict[str, Any]
                 ],
             ],
+            schema_func: Callable[..., dict[str, Any] | None] | None = None,
         ):
             logger.debug("Registering handler for CallToolRequest")
 
-            async def handler(req: types.CallToolRequest):
-                try:
-                    results = await func(req.params.name, (req.params.arguments or {}))
+            def handle_result_without_schema(req: types.CallToolRequest, result: Any):
+                if type(result) is dict or isinstance(result, BaseModel):
+                    error = f"""Tool {req.params.name} has no outputSchema and 
+must return content"""
                     return types.ServerResult(
-                        types.CallToolResult(content=list(results), isError=False)
+                        types.CallToolResult(
+                            content=[
+                                types.TextContent(
+                                    type="text",
+                                    text=error,
+                                )
+                            ],
+                            structuredContent=None,
+                            isError=True,
+                        )
+                    )
+                else:
+                    content_result = cast(
+                        Iterable[
+                            types.TextContent
+                            | types.ImageContent
+                            | types.EmbeddedResource
+                        ],
+                        result,
+                    )
+                    return types.ServerResult(
+                        types.CallToolResult(
+                            content=list(content_result),
+                            structuredContent=None,
+                            isError=False,
+                        )
                     )
-                except Exception as e:
+
+            def handle_result_with_schema(
+                req: types.CallToolRequest, result: Any, schema: dict[str, Any]
+            ):
+                if isinstance(result, BaseModel):
+                    model_result = result.model_dump()
                     return types.ServerResult(
                         types.CallToolResult(
-                            content=[types.TextContent(type="text", text=str(e))],
+                            content=[],
+                            structuredContent=model_result,
+                            isError=False,
+                        )
+                    )
+                elif type(result) is dict[str, Any]:
+                    return types.ServerResult(
+                        types.CallToolResult(
+                            content=[], structuredContent=result, isError=False
+                        )
+                    )
+                else:
+                    error = f"""Tool {req.params.name} has outputSchema and "
+must return structured content"""
+                    return types.ServerResult(
+                        types.CallToolResult(
+                            content=[
+                                types.TextContent(
+                                    type="text",
+                                    text=error,
+                                )
+                            ],
+                            structuredContent=None,
                             isError=True,
                         )
                     )
 
+            def handle_error(e: Exception):
+                return types.ServerResult(
+                    types.CallToolResult(
+                        content=[types.TextContent(type="text", text=str(e))],
+                        structuredContent=None,
+                        isError=True,
+                    )
+                )
+
+            if schema_func is None:
+
+                async def handler(req: types.CallToolRequest):
+                    try:
+                        result = await func(
+                            req.params.name, (req.params.arguments or {})
+                        )
+                        return handle_result_without_schema(req, result)
+                    except Exception as e:
+                        return handle_error(e)
+
+            else:
+
+                async def handler(req: types.CallToolRequest):
+                    try:
+                        result = await func(
+                            req.params.name, (req.params.arguments or {})
+                        )
+                        schema = schema_func(req.params.name)
+
+                        if schema:
+                            return handle_result_with_schema(req, result, schema)
+                        else:
+                            return handle_result_without_schema(req, result)
+                    except Exception as e:
+                        return handle_error(e)
+
             self.request_handlers[types.CallToolRequest] = handler
             return func
 

src/mcp/types.py

@@ -646,21 +646,6 @@ class ImageContent(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
-class DataContent(BaseModel):
-    """Data content for a message."""
-
-    type: Literal["data"]
-    data: Any
-    """The JSON serializable object containing structured data."""
-    schema_: str | Any | None = Field(serialization_alias="schema", default=None)
-
-    """
-    Optional reference to a JSON schema that describes the structure of the data.
-    """
-    annotations: Annotations | None = None
-    model_config = ConfigDict(extra="allow")
-
-
 class SamplingMessage(BaseModel):
     """Describes a message issued to or received from an LLM API."""
 
@@ -808,7 +793,8 @@ class CallToolRequest(Request[CallToolRequestParams, Literal["tools/call"]]):
 class CallToolResult(Result):
     """The server's response to a tool call."""
 
-    content: list[TextContent | DataContent | ImageContent | EmbeddedResource]
+    content: list[TextContent | ImageContent | EmbeddedResource]
+    structuredContent: dict[str, Any] | None = None
     isError: bool = False
 
 

tests/server/fastmcp/test_func_metadata.py

@@ -93,6 +93,10 @@ def simple_str_fun() -> str:
     return "ok"
 
 
+def simple_list_str_fun() -> list[str]:
+    return ["ok"]
+
+
 def simple_bool_fun() -> bool:
     return True
 
@@ -444,18 +448,11 @@ def test_simple_function_output_schema():
     """Test JSON schema generation for simple return types."""
 
     assert func_metadata(simple_no_annotation_fun).output_schema is None
-    assert func_metadata(simple_str_fun).output_schema == {
-        "type": "string",
-    }
-    assert func_metadata(simple_bool_fun).output_schema == {
-        "type": "boolean",
-    }
-    assert func_metadata(simple_int_fun).output_schema == {
-        "type": "integer",
-    }
-    assert func_metadata(simple_float_fun).output_schema == {
-        "type": "number",
-    }
+    assert func_metadata(simple_str_fun).output_schema is None
+    assert func_metadata(simple_bool_fun).output_schema is None
+    assert func_metadata(simple_int_fun).output_schema is None
+    assert func_metadata(simple_float_fun).output_schema is None
+    assert func_metadata(simple_list_str_fun).output_schema is None
 
 
 def test_complex_function_output_schema():