normalize structured_content for directly-returned CallToolResult

a tool returning an annotated CallToolResult had its structured_content
validated but not re-dumped, so computed fields and serialization aliases
still disagreed with the serialization-mode output schema. dump the
validated model the same way as ordinary return values. also drop a
stale pragma: no cover on the computed-field property, which runs during
serialization.

Author: jayzuccarelli

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

@@ -126,7 +126,12 @@ def convert_result(self, result: Any) -> CallToolResult | InputRequiredResult:
         if isinstance(result, CallToolResult):
             if self.output_schema is not None:
                 assert self.output_model is not None, "Output model must be set if output schema is defined"
-                self.output_model.model_validate(result.structured_content)
+                validated = self.output_model.model_validate(result.structured_content)
+                # Normalize structured content the same way as ordinary return values, so
+                # computed fields and serialization aliases match the output schema.
+                return result.model_copy(
+                    update={"structured_content": validated.model_dump(mode="json", by_alias=True)}
+                )
             return result
 
         unstructured_content = _convert_to_content(result)

tests/server/mcpserver/test_func_metadata.py

@@ -884,6 +884,26 @@ def func_returning_annotated_tool_call_result() -> Annotated[CallToolResult, Per
     assert isinstance(meta.convert_result(func_returning_annotated_tool_call_result()), CallToolResult)
 
 
+def test_tool_call_result_annotated_structured_content_is_normalized():
+    """A directly-returned CallToolResult has its structured_content normalized, so
+    serialization aliases match the declared output schema."""
+
+    class Person(BaseModel):
+        name: str = Field(serialization_alias="full_name")
+
+    def func_returning_annotated_tool_call_result() -> Annotated[CallToolResult, Person]:
+        return CallToolResult(content=[], structured_content={"name": "Brandon"})
+
+    meta = func_metadata(func_returning_annotated_tool_call_result)
+
+    assert meta.output_schema is not None
+    assert "full_name" in meta.output_schema["properties"]
+
+    converted = meta.convert_result(func_returning_annotated_tool_call_result())
+    assert isinstance(converted, CallToolResult)
+    assert converted.structured_content == {"full_name": "Brandon"}
+
+
 def test_tool_call_result_annotated_unioned_with_input_required_result_is_equivalent_to_the_bare_annotated_form():
     """Stripping `InputRequiredResult` makes the residual behave exactly as if it were the
     declared return annotation, including the `Annotated[CallToolResult, Model]` special case
@@ -1120,7 +1140,7 @@ class ModelWithComputed(BaseModel):
 
         @computed_field
         @property
-        def doubled(self) -> int:  # pragma: no cover
+        def doubled(self) -> int:
             return self.value * 2
 
     def func_with_computed() -> ModelWithComputed:  # pragma: no cover