work in progress attempting to implement RFC 356

Author: davemssavage

src/mcp/server/fastmcp/server.py

@@ -251,6 +251,7 @@ async def list_tools(self) -> list[MCPTool]:
                 name=info.name,
                 description=info.description,
                 inputSchema=info.parameters,
+                outputSchema=info.output,
                 annotations=info.annotations,
             )
             for info in tools

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

@@ -23,6 +23,7 @@ class Tool(BaseModel):
     name: str = Field(description="Name of the tool")
     description: str = Field(description="Description of what the tool does")
     parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
+    output: dict[str, Any] = Field(description="JSON schema for tool output")
     fn_metadata: FuncMetadata = Field(
         description="Metadata about the function including a pydantic model for tool"
         " arguments"
@@ -69,12 +70,14 @@ def from_function(
             skip_names=[context_kwarg] if context_kwarg is not None else [],
         )
         parameters = func_arg_metadata.arg_model.model_json_schema()
+        output = func_arg_metadata.output_model.model_json_schema()
 
         return cls(
             fn=fn,
             name=func_name,
             description=func_doc,
             parameters=parameters,
+            output=output,
             fn_metadata=func_arg_metadata,
             is_async=is_async,
             context_kwarg=context_kwarg,

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

@@ -38,6 +38,7 @@ def model_dump_one_level(self) -> dict[str, Any]:
 
 class FuncMetadata(BaseModel):
     arg_model: Annotated[type[ArgModelBase], WithJsonSchema(None)]
+    output_model: Annotated[type[ArgModelBase], WithJsonSchema(None)]
     # We can add things in the future like
     #  - Maybe some args are excluded from attempting to parse from JSON
     #  - Maybe some args are special (like context) for dependency injection
@@ -128,6 +129,7 @@ def func_metadata(
     sig = _get_typed_signature(func)
     params = sig.parameters
     dynamic_pydantic_model_params: dict[str, Any] = {}
+    dynamic_pydantic_model_output: dict[str, Any] = {} 
     globalns = getattr(func, "__globals__", {})
     for param in params.values():
         if param.name.startswith("_"):
@@ -167,12 +169,20 @@ def func_metadata(
         dynamic_pydantic_model_params[param.name] = (field_info.annotation, field_info)
         continue
 
+    # dynamic_pydantic_model_output[]
+
     arguments_model = create_model(
         f"{func.__name__}Arguments",
         **dynamic_pydantic_model_params,
         __base__=ArgModelBase,
     )
-    resp = FuncMetadata(arg_model=arguments_model)
+
+    output_model = create_model(
+        f"{func.__name__}Output",
+        **dynamic_pydantic_model_output,
+        __base__=ArgModelBase
+    )
+    resp = FuncMetadata(arg_model=arguments_model, output_model=output_model)
     return resp
 
 
@@ -210,5 +220,5 @@ def _get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
         )
         for param in signature.parameters.values()
     ]
-    typed_signature = inspect.Signature(typed_params)
+    typed_signature = inspect.Signature(typed_params, return_annotation=signature.return_annotation)
     return typed_signature

src/mcp/types.py

@@ -762,6 +762,8 @@ class Tool(BaseModel):
     """A human-readable description of the tool."""
     inputSchema: dict[str, Any]
     """A JSON Schema object defining the expected parameters for the tool."""
+    outputSchema: dict[str, Any] | None = None
+    """A JSON Schema object defining the expected outputs for the tool."""
     annotations: ToolAnnotations | None = None
     """Optional additional tool information."""
     model_config = ConfigDict(extra="allow")