Merge branch 'main' into localden/experimental

localden · web-flow · commit 5d32edda583f · 2025-06-08T13:38:17.000-07:00
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -78,5 +78,6 @@
     <PackageVersion Include="xunit.v3" Version="2.0.2" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.0" />
     <PackageVersion Include="System.Net.Http" Version="4.3.4" />
+    <PackageVersion Include="JsonSchema.Net" Version="7.3.4" />
   </ItemGroup>
 </Project>
diff --git a/ModelContextProtocol.slnx b/ModelContextProtocol.slnx
@@ -26,7 +26,6 @@
     <File Path="logo.png" />
     <File Path="nuget.config" />
     <File Path="README.MD" />
-    <File Path="version.json" />
   </Folder>
   <Folder Name="/src/">
     <File Path="src/Directory.Build.props" />
diff --git a/src/ModelContextProtocol.Core/McpJsonUtilities.cs b/src/ModelContextProtocol.Core/McpJsonUtilities.cs
@@ -1,6 +1,7 @@
 ﻿using Microsoft.Extensions.AI;
 using ModelContextProtocol.Authentication;
 using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -76,6 +77,30 @@ internal static bool IsValidMcpToolSchema(JsonElement element)
         return false; // No type keyword found.
     }
 
+    internal static JsonElement? GetReturnSchema(this AIFunction function, AIJsonSchemaCreateOptions? schemaCreateOptions)
+    {
+        // TODO replace with https://github.com/dotnet/extensions/pull/6447 once merged.
+        if (function.UnderlyingMethod?.ReturnType is not Type returnType)
+        {
+            return null;
+        }
+
+        if (returnType == typeof(void) || returnType == typeof(Task) || returnType == typeof(ValueTask))
+        {
+            // Do not report an output schema for void or Task methods.
+            return null;
+        }
+
+        if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() is Type genericTypeDef &&
+            (genericTypeDef == typeof(Task<>) || genericTypeDef == typeof(ValueTask<>)))
+        {
+            // Extract the real type from Task<T> or ValueTask<T> if applicable.
+            returnType = returnType.GetGenericArguments()[0];
+        }
+
+        return AIJsonUtilities.CreateJsonSchema(returnType, serializerOptions: function.JsonSerializerOptions, inferenceOptions: schemaCreateOptions);
+    }
+
     // Keep in sync with CreateDefaultOptions above.
     [JsonSourceGenerationOptions(JsonSerializerDefaults.Web,
         DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
diff --git a/src/ModelContextProtocol.Core/Protocol/CallToolResponse.cs b/src/ModelContextProtocol.Core/Protocol/CallToolResponse.cs
@@ -1,3 +1,4 @@
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 
 namespace ModelContextProtocol.Protocol;
@@ -27,6 +28,12 @@ public class CallToolResponse
     [JsonPropertyName("content")]
     public List<Content> Content { get; set; } = [];
 
+    /// <summary>
+    /// Gets or sets an optional JSON object representing the structured result of the tool call.
+    /// </summary>
+    [JsonPropertyName("structuredContent")]
+    public JsonNode? StructuredContent { get; set; }
+
     /// <summary>
     /// Gets or sets an indication of whether the tool call was unsuccessful.
     /// </summary>
diff --git a/src/ModelContextProtocol.Core/Protocol/CompleteContext.cs b/src/ModelContextProtocol.Core/Protocol/CompleteContext.cs
@@ -0,0 +1,19 @@
+using System.Text.Json.Serialization;
+
+namespace ModelContextProtocol.Protocol;
+
+/// <summary>
+/// Represents additional context information for completion requests.
+/// </summary>
+/// <remarks>
+/// This context provides information that helps the server generate more relevant 
+/// completion suggestions, such as previously resolved variables in a template.
+/// </remarks>
+public class CompleteContext
+{
+    /// <summary>
+    /// Gets or sets previously-resolved variables in a URI template or prompt.
+    /// </summary>
+    [JsonPropertyName("arguments")]
+    public IDictionary<string, string>? Arguments { get; init; }
+}
diff --git a/src/ModelContextProtocol.Core/Protocol/CompleteRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/CompleteRequestParams.cs
@@ -30,5 +30,11 @@ public class CompleteRequestParams : RequestParams
     /// and the current partial input.
     /// </summary>
     [JsonPropertyName("argument")]
-    public required Argument Argument { get; init; }    
+    public required Argument Argument { get; init; }
+
+    /// <summary>
+    /// Gets or sets additional, optional context for completions.
+    /// </summary>
+    [JsonPropertyName("context")]
+    public CompleteContext? Context { get; init; }
 }
diff --git a/src/ModelContextProtocol.Core/Protocol/Tool.cs b/src/ModelContextProtocol.Core/Protocol/Tool.cs
@@ -8,8 +8,6 @@ namespace ModelContextProtocol.Protocol;
 /// </summary>
 public class Tool
 {
-    private JsonElement _inputSchema = McpJsonUtilities.DefaultMcpToolSchema;
-
     /// <summary>
     /// Gets or sets the name of the tool.
     /// </summary>
@@ -53,15 +51,44 @@ public class Tool
     [JsonPropertyName("inputSchema")]
     public JsonElement InputSchema  
     { 
-        get => _inputSchema; 
+        get => field; 
         set
         {
             if (!McpJsonUtilities.IsValidMcpToolSchema(value))
             {
-                throw new ArgumentException("The specified document is not a valid MCP tool JSON schema.", nameof(InputSchema));
+                throw new ArgumentException("The specified document is not a valid MCP tool input JSON schema.", nameof(InputSchema));
+            }
+
+            field = value;
+        }
+
+    } = McpJsonUtilities.DefaultMcpToolSchema;
+
+    /// <summary>
+    /// Gets or sets a JSON Schema object defining the expected structured outputs for the tool.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The schema must be a valid JSON Schema object with the "type" property set to "object".
+    /// This is enforced by validation in the setter which will throw an <see cref="ArgumentException"/>
+    /// if an invalid schema is provided.
+    /// </para>
+    /// <para>
+    /// The schema should describe the shape of the data as returned in <see cref="CallToolResponse.StructuredContent"/>.
+    /// </para>
+    /// </remarks>
+    [JsonPropertyName("outputSchema")]
+    public JsonElement? OutputSchema
+    {
+        get => field;
+        set
+        {
+            if (value is not null && !McpJsonUtilities.IsValidMcpToolSchema(value.Value))
+            {
+                throw new ArgumentException("The specified document is not a valid MCP tool output JSON schema.", nameof(OutputSchema));
             }
 
-            _inputSchema = value;
+            field = value;
         }
     }
 
diff --git a/src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs b/src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs
@@ -7,13 +7,15 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 
 namespace ModelContextProtocol.Server;
 
 /// <summary>Provides an <see cref="McpServerTool"/> that's implemented via an <see cref="AIFunction"/>.</summary>
 internal sealed partial class AIFunctionMcpServerTool : McpServerTool
 {
     private readonly ILogger _logger;
+    private readonly bool _structuredOutputRequiresWrapping;
 
     /// <summary>
     /// Creates an <see cref="McpServerTool"/> instance for a method, specified via a <see cref="Delegate"/> instance.
@@ -176,7 +178,8 @@ private static AIFunctionFactoryOptions CreateAIFunctionFactoryOptions(
         {
             Name = options?.Name ?? function.Name,
             Description = options?.Description ?? function.Description,
-            InputSchema = function.JsonSchema,     
+            InputSchema = function.JsonSchema,
+            OutputSchema = CreateOutputSchema(function, options, out bool structuredOutputRequiresWrapping),
         };
 
         if (options is not null)
@@ -198,7 +201,7 @@ options.OpenWorld is not null ||
             }
         }
 
-        return new AIFunctionMcpServerTool(function, tool, options?.Services);
+        return new AIFunctionMcpServerTool(function, tool, options?.Services, structuredOutputRequiresWrapping);
     }
 
     private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpServerToolCreateOptions? options)
@@ -229,6 +232,8 @@ private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpSe
             {
                 newOptions.ReadOnly ??= readOnly;
             }
+
+            newOptions.UseStructuredContent = toolAttr.UseStructuredContent;
         }
 
         if (method.GetCustomAttribute<DescriptionAttribute>() is { } descAttr)
@@ -243,11 +248,12 @@ private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpSe
     internal AIFunction AIFunction { get; }
 
     /// <summary>Initializes a new instance of the <see cref="McpServerTool"/> class.</summary>
-    private AIFunctionMcpServerTool(AIFunction function, Tool tool, IServiceProvider? serviceProvider)
+    private AIFunctionMcpServerTool(AIFunction function, Tool tool, IServiceProvider? serviceProvider, bool structuredOutputRequiresWrapping)
     {
         AIFunction = function;
         ProtocolTool = tool;
         _logger = serviceProvider?.GetService<ILoggerFactory>()?.CreateLogger<McpServerTool>() ?? (ILogger)NullLogger.Instance;
+        _structuredOutputRequiresWrapping = structuredOutputRequiresWrapping;
     }
 
     /// <inheritdoc />
@@ -295,39 +301,46 @@ public override async ValueTask<CallToolResponse> InvokeAsync(
             };
         }
 
+        JsonNode? structuredContent = CreateStructuredResponse(result);
         return result switch
         {
             AIContent aiContent => new()
             {
                 Content = [aiContent.ToContent()],
+                StructuredContent = structuredContent,
                 IsError = aiContent is ErrorContent
             },
 
             null => new()
             {
-                Content = []
+                Content = [],
+                StructuredContent = structuredContent,
             },
             
             string text => new()
             {
-                Content = [new() { Text = text, Type = "text" }]
+                Content = [new() { Text = text, Type = "text" }],
+                StructuredContent = structuredContent,
             },
             
             Content content => new()
             {
-                Content = [content]
+                Content = [content],
+                StructuredContent = structuredContent,
             },
             
             IEnumerable<string> texts => new()
             {
-                Content = [.. texts.Select(x => new Content() { Type = "text", Text = x ?? string.Empty })]
+                Content = [.. texts.Select(x => new Content() { Type = "text", Text = x ?? string.Empty })],
+                StructuredContent = structuredContent,
             },
             
-            IEnumerable<AIContent> contentItems => ConvertAIContentEnumerableToCallToolResponse(contentItems),
+            IEnumerable<AIContent> contentItems => ConvertAIContentEnumerableToCallToolResponse(contentItems, structuredContent),
             
             IEnumerable<Content> contents => new()
             {
-                Content = [.. contents]
+                Content = [.. contents],
+                StructuredContent = structuredContent,
             },
             
             CallToolResponse callToolResponse => callToolResponse,
@@ -338,12 +351,90 @@ public override async ValueTask<CallToolResponse> InvokeAsync(
                 {
                     Text = JsonSerializer.Serialize(result, AIFunction.JsonSerializerOptions.GetTypeInfo(typeof(object))),
                     Type = "text"
-                }]
+                }],
+                StructuredContent = structuredContent,
             },
         };
     }
 
-    private static CallToolResponse ConvertAIContentEnumerableToCallToolResponse(IEnumerable<AIContent> contentItems)
+    private static JsonElement? CreateOutputSchema(AIFunction function, McpServerToolCreateOptions? toolCreateOptions, out bool structuredOutputRequiresWrapping)
+    {
+        structuredOutputRequiresWrapping = false;
+
+        if (toolCreateOptions?.UseStructuredContent is not true)
+        {
+            return null;
+        }
+
+        if (function.GetReturnSchema(toolCreateOptions?.SchemaCreateOptions) is not JsonElement outputSchema)
+        {
+            return null;
+        }
+
+        if (outputSchema.ValueKind is not JsonValueKind.Object ||
+            !outputSchema.TryGetProperty("type", out JsonElement typeProperty) ||
+            typeProperty.ValueKind is not JsonValueKind.String ||
+            typeProperty.GetString() is not "object")
+        {
+            // If the output schema is not an object, need to modify to be a valid MCP output schema.
+            JsonNode? schemaNode = JsonSerializer.SerializeToNode(outputSchema, McpJsonUtilities.JsonContext.Default.JsonElement);
+
+            if (schemaNode is JsonObject objSchema &&
+                objSchema.TryGetPropertyValue("type", out JsonNode? typeNode) &&
+                typeNode is JsonArray { Count: 2 } typeArray && typeArray.Any(type => (string?)type is "object") && typeArray.Any(type => (string?)type is "null"))
+            {
+                // For schemas that are of type ["object", "null"], replace with just "object" to be conformant.
+                objSchema["type"] = "object";
+            }
+            else
+            {
+                // For anything else, wrap the schema in an envelope with a "result" property.
+                schemaNode = new JsonObject
+                {
+                    ["type"] = "object",
+                    ["properties"] = new JsonObject
+                    {
+                        ["result"] = schemaNode
+                    },
+                    ["required"] = new JsonArray { (JsonNode)"result" }
+                };
+
+                structuredOutputRequiresWrapping = true;
+            }
+
+            outputSchema = JsonSerializer.Deserialize(schemaNode, McpJsonUtilities.JsonContext.Default.JsonElement);
+        }
+
+        return outputSchema;
+    }
+
+    private JsonNode? CreateStructuredResponse(object? aiFunctionResult)
+    {
+        if (ProtocolTool.OutputSchema is null)
+        {
+            // Only provide structured responses if the tool has an output schema defined.
+            return null;
+        }
+
+        JsonNode? nodeResult = aiFunctionResult switch
+        {
+            JsonNode node => node,
+            JsonElement jsonElement => JsonSerializer.SerializeToNode(jsonElement, McpJsonUtilities.JsonContext.Default.JsonElement),
+            _ => JsonSerializer.SerializeToNode(aiFunctionResult, AIFunction.JsonSerializerOptions.GetTypeInfo(typeof(object))),
+        };
+
+        if (_structuredOutputRequiresWrapping)
+        {
+            return new JsonObject
+            {
+                ["result"] = nodeResult
+            };
+        }
+
+        return nodeResult;
+    }
+
+    private static CallToolResponse ConvertAIContentEnumerableToCallToolResponse(IEnumerable<AIContent> contentItems, JsonNode? structuredContent)
     {
         List<Content> contentList = [];
         bool allErrorContent = true;
@@ -363,6 +454,7 @@ private static CallToolResponse ConvertAIContentEnumerableToCallToolResponse(IEn
         return new()
         {
             Content = contentList,
+            StructuredContent = structuredContent,
             IsError = allErrorContent && hasAny
         };
     }
diff --git a/src/ModelContextProtocol.Core/Server/McpServerToolAttribute.cs b/src/ModelContextProtocol.Core/Server/McpServerToolAttribute.cs
@@ -240,4 +240,13 @@ public bool ReadOnly
         get => _readOnly ?? ReadOnlyDefault; 
         set => _readOnly = value; 
     }
+
+    /// <summary>
+    /// Gets or sets whether the tool should report an output schema for structured content.
+    /// </summary>
+    /// <remarks>
+    /// When enabled, the tool will attempt to populate the <see cref="Tool.OutputSchema"/>
+    /// and provide structured content in the <see cref="CallToolResponse.StructuredContent"/> property.
+    /// </remarks>
+    public bool UseStructuredContent { get; set; }
 }
diff --git a/src/ModelContextProtocol.Core/Server/McpServerToolCreateOptions.cs b/src/ModelContextProtocol.Core/Server/McpServerToolCreateOptions.cs
diff --git a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerToolTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerToolTests.cs

Original file line number	Diff line number	Diff line change
`@@ -240,4 +240,13 @@ public bool ReadOnly`
`240`	`240`	`get => _readOnly ?? ReadOnlyDefault;`
`241`	`241`	`set => _readOnly = value;`
`242`	`242`	`}`
	`243`	`+`
	`244`	`+ /// <summary>`
	`245`	`+ /// Gets or sets whether the tool should report an output schema for structured content.`
	`246`	`+ /// </summary>`
	`247`	`+ /// <remarks>`
	`248`	`+ /// When enabled, the tool will attempt to populate the <see cref="Tool.OutputSchema"/>`
	`249`	`+ /// and provide structured content in the <see cref="CallToolResponse.StructuredContent"/> property.`
	`250`	`+ /// </remarks>`
	`251`	`+ public bool UseStructuredContent { get; set; }`
`243`	`252`	`}`