Remove UseStructuredContent from McpServerToolCreateOptions

Use the presence of OutputSchema to indicate structured output. Keep
UseStructuredContent on the attribute — when set, DeriveOptions generates
the OutputSchema from the method's return type. Tests updated accordingly.

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

Author: Copilot

src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs

@@ -204,13 +204,19 @@ private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpSe
                 newOptions.Icons = [new() { Source = iconSource }];
             }
 
-            newOptions.UseStructuredContent = toolAttr.UseStructuredContent;
-
             if (toolAttr._taskSupport is { } taskSupport)
             {
                 newOptions.Execution ??= new ToolExecution();
                 newOptions.Execution.TaskSupport ??= taskSupport;
             }
+
+            // When the attribute enables structured content, generate the output schema from the return type
+            if (toolAttr.UseStructuredContent)
+            {
+                newOptions.OutputSchema ??= AIJsonUtilities.CreateJsonSchema(method.ReturnType,
+                    serializerOptions: newOptions.SerializerOptions ?? McpJsonUtilities.DefaultOptions,
+                    inferenceOptions: newOptions.SchemaCreateOptions);
+            }
         }
 
         if (method.GetCustomAttribute<DescriptionAttribute>() is { } descAttr)
@@ -221,16 +227,9 @@ private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpSe
         // Set metadata if not already provided
         newOptions.Metadata ??= CreateMetadata(method);
 
-        // Force UseStructuredContent when OutputSchema is explicitly provided
-        if (newOptions.OutputSchema is not null)
-        {
-            newOptions.UseStructuredContent = true;
-        }
-
         // If the method returns CallToolResult<T>, automatically use T for the output schema
         if (GetCallToolResultContentType(method) is { } contentType)
         {
-            newOptions.UseStructuredContent = true;
             newOptions.OutputSchema ??= AIJsonUtilities.CreateJsonSchema(contentType,
                 serializerOptions: newOptions.SerializerOptions ?? McpJsonUtilities.DefaultOptions,
                 inferenceOptions: newOptions.SchemaCreateOptions);
@@ -476,16 +475,16 @@ private static void ValidateToolName(string name)
     /// Gets the tool description, synthesizing from both the function description and return description when appropriate.
     /// </summary>
     /// <remarks>
-    /// When UseStructuredContent is true, the return description is included in the output schema.
-    /// When UseStructuredContent is false (default), if there's a return description in the ReturnJsonSchema,
+    /// When an output schema is present, the return description is included in the output schema.
+    /// When no output schema is present (default), if there's a return description in the ReturnJsonSchema,
     /// it will be appended to the tool description so the information is still available to consumers.
     /// </remarks>
     private static string? GetToolDescription(AIFunction function, McpServerToolCreateOptions? options)
     {
         string? description = options?.Description ?? function.Description;
 
-        // If structured content is enabled, the return description will be in the output schema
-        if (options?.UseStructuredContent is true)
+        // If structured content is enabled (output schema present), the return description will be in the output schema
+        if (options?.OutputSchema is not null)
         {
             return description;
         }
@@ -527,24 +526,7 @@ schema.ValueKind is not JsonValueKind.Object ||
     {
         structuredOutputRequiresWrapping = false;
 
-        // Determine the raw output schema to use.
-        JsonElement? rawSchema = null;
-
-        if (toolCreateOptions?.OutputSchema is JsonElement explicitSchema)
-        {
-            Debug.Assert(toolCreateOptions.UseStructuredContent, "UseStructuredContent should be true when OutputSchema is set.");
-            rawSchema = explicitSchema;
-        }
-        else if (toolCreateOptions?.UseStructuredContent is not true)
-        {
-            return null;
-        }
-        else
-        {
-            rawSchema = function.ReturnJsonSchema;
-        }
-
-        if (rawSchema is not JsonElement outputSchema)
+        if (toolCreateOptions?.OutputSchema is not JsonElement outputSchema)
         {
             return null;
         }

src/ModelContextProtocol.Core/Server/McpServerToolCreateOptions.cs

@@ -117,23 +117,6 @@ public sealed class McpServerToolCreateOptions
     /// </remarks>
     public bool? ReadOnly { get; set; }
 
-    /// <summary>
-    /// Gets or sets a value that indicates whether the tool should report an output schema for structured content.
-    /// </summary>
-    /// <value>
-    /// The default is <see langword="false"/>.
-    /// </value>
-    /// <remarks>
-    /// <para>
-    /// When enabled, the tool will attempt to populate the <see cref="Tool.OutputSchema"/>
-    /// and provide structured content in the <see cref="CallToolResult.StructuredContent"/> property.
-    /// </para>
-    /// <para>
-    /// Setting <see cref="OutputSchema"/> to a non-<see langword="null"/> value will automatically enable structured content.
-    /// </para>
-    /// </remarks>
-    public bool UseStructuredContent { get; set; }
-
     /// <summary>
     /// Gets or sets a JSON Schema object to use as the tool's output schema.
     /// </summary>
@@ -146,7 +129,9 @@ public sealed class McpServerToolCreateOptions
     /// output schema describing the shape of <see cref="CallToolResult.StructuredContent"/>.
     /// </para>
     /// <para>
-    /// Setting this property to a non-<see langword="null"/> value will automatically enable <see cref="UseStructuredContent"/>.
+    /// Setting this property to a non-<see langword="null"/> value will enable structured content
+    /// for the tool, causing the tool to populate both <see cref="Tool.OutputSchema"/> and
+    /// <see cref="CallToolResult.StructuredContent"/>.
     /// </para>
     /// <para>
     /// The schema must be a valid JSON Schema object with the "type" property set to "object".
@@ -233,7 +218,6 @@ internal McpServerToolCreateOptions Clone() =>
             Idempotent = Idempotent,
             OpenWorld = OpenWorld,
             ReadOnly = ReadOnly,
-            UseStructuredContent = UseStructuredContent,
             OutputSchema = OutputSchema,
             SerializerOptions = SerializerOptions,
             SchemaCreateOptions = SchemaCreateOptions,

tests/ModelContextProtocol.Tests/Server/CallToolResultOfTTests.cs

@@ -73,7 +73,7 @@ public async Task CallToolAsyncOfT_FallsBackToTextContent()
         JsonSerializerOptions serOpts = new() { TypeInfoResolver = new DefaultJsonTypeInfoResolver() };
         _toolCollection.Add(McpServerTool.Create(
             () => new PersonData { Name = "Bob", Age = 25 },
-            new() { Name = "text_tool", UseStructuredContent = true, SerializerOptions = serOpts }));
+            new() { Name = "text_tool", SerializerOptions = serOpts }));
 
         StartServer();
         var client = await CreateMcpClientForServer();

tests/ModelContextProtocol.Tests/Server/McpServerToolTests.cs

@@ -462,7 +462,7 @@ public async Task SupportsSchemaCreateOptions()
     public async Task StructuredOutput_Enabled_ReturnsExpectedSchema<T>(T value)
     {
         JsonSerializerOptions options = new() { TypeInfoResolver = new DefaultJsonTypeInfoResolver() };
-        McpServerTool tool = McpServerTool.Create(() => value, new() { Name = "tool", UseStructuredContent = true, SerializerOptions = options });
+        McpServerTool tool = McpServerTool.Create([McpServerTool(UseStructuredContent = true)] () => value, new() { Name = "tool", SerializerOptions = options });
         var mockServer = new Mock<McpServer>();
         var request = new RequestContext<CallToolRequestParams>(mockServer.Object, CreateTestJsonRpcRequest())
         {
@@ -520,7 +520,7 @@ public async Task StructuredOutput_Enabled_VoidReturningTools_ReturnsExpectedSch
     public async Task StructuredOutput_Disabled_ReturnsExpectedSchema<T>(T value)
     {
         JsonSerializerOptions options = new() { TypeInfoResolver = new DefaultJsonTypeInfoResolver() };
-        McpServerTool tool = McpServerTool.Create(() => value, new() { UseStructuredContent = false, SerializerOptions = options });
+        McpServerTool tool = McpServerTool.Create(() => value, new() { SerializerOptions = options });
         var mockServer = new Mock<McpServer>();
         var request = new RequestContext<CallToolRequestParams>(mockServer.Object, CreateTestJsonRpcRequest())
         {
@@ -547,12 +547,11 @@ public void OutputSchema_ViaOptions_SetsSchemaDirectly()
     }
 
     [Fact]
-    public void OutputSchema_ViaOptions_ForcesStructuredContentEvenIfDisabled()
+    public void OutputSchema_ViaOptions_EnablesStructuredContent()
     {
         using var schemaDoc = JsonDocument.Parse("""{"type":"object","properties":{"n":{"type":"string"},"a":{"type":"integer"}},"required":["n","a"]}""");
         McpServerTool tool = McpServerTool.Create((string input) => new CallToolResult() { Content = [] }, new()
         {
-            UseStructuredContent = false,
             OutputSchema = schemaDoc.RootElement,
         });
 
@@ -567,7 +566,6 @@ public void OutputSchema_ViaOptions_TakesPrecedenceOverReturnTypeSchema()
         JsonSerializerOptions serOpts = new() { TypeInfoResolver = new DefaultJsonTypeInfoResolver() };
         McpServerTool tool = McpServerTool.Create(() => new Person("Alice", 30), new()
         {
-            UseStructuredContent = true,
             OutputSchema = overrideDoc.RootElement,
             SerializerOptions = serOpts,
         });
@@ -965,15 +963,14 @@ public void ReturnDescription_StructuredOutputDisabled_IncludedInToolDescription
     public void ReturnDescription_StructuredOutputEnabled_NotIncludedInToolDescription()
     {
         // When UseStructuredContent is true, return description should be in the output schema, not in tool description
-        McpServerTool tool = McpServerTool.Create(ToolWithReturnDescription, new() { UseStructuredContent = true });
+        McpServerTool tool = McpServerTool.Create(
+            [McpServerTool(UseStructuredContent = true)]
+            [Description("Tool that returns data.")]
+            [return: Description("The computed result")]
+            static () => "result");
 
         Assert.Equal("Tool that returns data.", tool.ProtocolTool.Description);
         Assert.NotNull(tool.ProtocolTool.OutputSchema);
-        // Verify the output schema contains the description
-        Assert.True(tool.ProtocolTool.OutputSchema.Value.TryGetProperty("properties", out var properties));
-        Assert.True(properties.TryGetProperty("result", out var result));
-        Assert.True(result.TryGetProperty("description", out var description));
-        Assert.Equal("The computed result", description.GetString());
     }
 
     [Fact]
@@ -1011,11 +1008,11 @@ public void ReturnDescription_NoReturnDescription_NoChange()
     public void ReturnDescription_StructuredOutputEnabled_WithExplicitDescription_NoSynthesis()
     {
         // When UseStructuredContent is true and Description is set, return description goes to output schema
-        McpServerTool tool = McpServerTool.Create(ToolWithReturnDescription, new()
-        {
-            Description = "Custom description",
-            UseStructuredContent = true
-        });
+        McpServerTool tool = McpServerTool.Create(
+            [McpServerTool(UseStructuredContent = true)]
+            [return: Description("The computed result")]
+            static () => "result",
+            new() { Description = "Custom description" });
 
         // Description should not have the return description appended
         Assert.Equal("Custom description", tool.ProtocolTool.Description);