Add schema validation in the InputSchema property setter.

Author: eiriktsarpalis

src/ModelContextProtocol/Protocol/Types/Tool.cs

@@ -1,4 +1,5 @@
-using System.Text.Json;
+using ModelContextProtocol.Utils.Json;
+using System.Text.Json;
 using System.Text.Json.Serialization;
 
 namespace ModelContextProtocol.Protocol.Types;
@@ -24,6 +25,23 @@ public class Tool
     /// <summary>
     /// A JSON Schema object defining the expected parameters for the tool.
     /// </summary>
+    /// <remarks>
+    /// Needs to a valid JSON schema object that additionally is of type object.
+    /// </remarks>
     [JsonPropertyName("inputSchema")]
-    public JsonElement InputSchema { get; set; }
+    public JsonElement InputSchema 
+    { 
+        get => _inputSchema; 
+        set
+        {
+            if (!McpJsonUtilities.IsValidMcpToolSchema(value))
+            {
+                throw new ArgumentException("The specified document is not a valid MPC tool JSON schema.", nameof(InputSchema));
+            }
+
+            _inputSchema = value;
+        }
+    }
+
+    private JsonElement _inputSchema = McpJsonUtilities.DefaultMcpToolSchema;
 }

src/ModelContextProtocol/Utils/Json/McpJsonUtilities.cs

@@ -77,6 +77,31 @@ private static JsonSerializerOptions CreateDefaultOptions()
     internal static JsonTypeInfo<T> GetTypeInfo<T>(this JsonSerializerOptions options) =>
         (JsonTypeInfo<T>)options.GetTypeInfo(typeof(T));
 
+    internal static JsonElement DefaultMcpToolSchema = ParseJsonElement("{\"type\":\"object\"}"u8);
+    internal static bool IsValidMcpToolSchema(JsonElement element)
+    {
+        if (element.ValueKind is not JsonValueKind.Object)
+        {
+            return false;
+        }
+
+        foreach (JsonProperty property in element.EnumerateObject())
+        {
+            if (property.NameEquals("type"))
+            {
+                if (property.Value.ValueKind is not JsonValueKind.String ||
+                    !property.Value.ValueEquals("object"))
+                {
+                    return false;
+                }
+
+                return true; // No need to check other properties
+            }
+        }
+
+        return false; // No type keyword found.
+    }
+
     // Keep in sync with CreateDefaultOptions above.
     [JsonSourceGenerationOptions(JsonSerializerDefaults.Web,
         UseStringEnumConverter = true,
@@ -98,4 +123,11 @@ internal static JsonTypeInfo<T> GetTypeInfo<T>(this JsonSerializerOptions option
     [JsonSerializable(typeof(InitializeResult))]
     [JsonSerializable(typeof(CallToolResponse))]
     internal sealed partial class JsonContext : JsonSerializerContext;
+
+    private static JsonElement ParseJsonElement(ReadOnlySpan<byte> utf8Json)
+    {
+        Utf8JsonReader reader = new(utf8Json);
+        return JsonElement.ParseValue(ref reader);
+    }
+
 }

tests/ModelContextProtocol.TestServer/Program.cs

@@ -92,7 +92,7 @@ private static ToolsCapability ConfigureTools()
                         {
                             Name = "echo",
                             Description = "Echoes the input back to the client.",
-                            InputSchema = JsonSerializer.SerializeToElement("""
+                            InputSchema = JsonSerializer.Deserialize<JsonElement>("""
                                 {
                                     "type": "object",
                                     "properties": {
@@ -109,7 +109,7 @@ private static ToolsCapability ConfigureTools()
                         {
                             Name = "sampleLLM",
                             Description = "Samples from an LLM using MCP's sampling feature.",
-                            InputSchema = JsonSerializer.SerializeToElement("""
+                            InputSchema = JsonSerializer.Deserialize<JsonElement>("""
                                 {
                                     "type": "object",
                                     "properties": {

tests/ModelContextProtocol.TestSseServer/Program.cs

@@ -122,7 +122,7 @@ static CreateMessageRequestParams CreateRequestSamplingParams(string context, st
                             {
                                 Name = "echo",
                                 Description = "Echoes the input back to the client.",
-                                InputSchema = JsonSerializer.SerializeToElement("""
+                                InputSchema = JsonSerializer.Deserialize<JsonElement>("""
                                     {
                                         "type": "object",
                                         "properties": {
@@ -139,7 +139,7 @@ static CreateMessageRequestParams CreateRequestSamplingParams(string context, st
                             {
                                 Name = "sampleLLM",
                                 Description = "Samples from an LLM using MCP's sampling feature.",
-                                InputSchema = JsonSerializer.SerializeToElement("""
+                                InputSchema = JsonSerializer.Deserialize<JsonElement>("""
                                     {
                                         "type": "object",
                                         "properties": {

tests/ModelContextProtocol.Tests/Protocol/ProtocolTypeTests.cs

@@ -0,0 +1,52 @@
+using ModelContextProtocol.Protocol.Types;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ProtocolTypeTests
+{
+    [Fact]
+    public static void ToolInputSchema_HasValidDefaultSchema()
+    {
+        var tool = new Tool();
+        JsonElement jsonElement = tool.InputSchema;
+
+        Assert.Equal(JsonValueKind.Object, jsonElement.ValueKind);
+        Assert.Single(jsonElement.EnumerateObject());
+        Assert.True(jsonElement.TryGetProperty("type", out JsonElement typeElement));
+        Assert.Equal(JsonValueKind.String, typeElement.ValueKind);
+        Assert.Equal("object", typeElement.GetString());
+    }
+
+    [Theory]
+    [InlineData("null")]
+    [InlineData("false")]
+    [InlineData("true")]
+    [InlineData("3.5e3")]
+    [InlineData("[]")]
+    [InlineData("{}")]
+    [InlineData("""{"properties":{}}""")]
+    [InlineData("""{"type":"number"}""")]
+    [InlineData("""{"type":"array"}""")]
+    [InlineData("""{"type":["object"]}""")]
+    public static void ToolInputSchema_RejectsInvalidSchemaDocuments(string invalidSchema)
+    {
+        using var document = JsonDocument.Parse(invalidSchema);
+        var tool = new Tool();
+
+        Assert.Throws<ArgumentException>(() => tool.InputSchema = document.RootElement);
+    }
+
+    [Theory]
+    [InlineData("""{"type":"object"}""")]
+    [InlineData("""{"type":"object", "properties": {}, "required" : [] }""")]
+    [InlineData("""{"type":"object", "title": "MyAwesomeTool", "description": "It's awesome!", "properties": {}, "required" : ["NotAParam"] }""")]
+    public static void ToolInputSchema_AcceptsValidSchemaDocuments(string validSchema)
+    {
+        using var document = JsonDocument.Parse(validSchema);
+        var tool = new Tool();
+
+        tool.InputSchema = document.RootElement;
+        Assert.True(JsonElement.DeepEquals(document.RootElement, tool.InputSchema));
+    }
+}

tests/ModelContextProtocol.Tests/Utils/TestServerTransport.cs

@@ -1,6 +1,7 @@
 using System.Threading.Channels;
 using ModelContextProtocol.Protocol.Messages;
 using ModelContextProtocol.Protocol.Transport;
+using ModelContextProtocol.Protocol.Types;
 
 namespace ModelContextProtocol.Tests.Utils;
 
@@ -71,7 +72,7 @@ private async Task Sampling(JsonRpcRequest request, CancellationToken cancellati
         await WriteMessageAsync(new JsonRpcResponse
         {
             Id = request.Id,
-            Result = new Protocol.Types.CreateMessageResult { Content = new(), Model = "model", Role = "role" }
+            Result = new CreateMessageResult { Content = new(), Model = "model", Role = "role" }
         }, cancellationToken);
     }