Address PR feedback: convert if-else to switch and add default value mapping tests

Co-authored-by: eiriktsarpalis <[email protected]>

Author: Copilot

src/ModelContextProtocol.Core/Protocol/ElicitRequestParams.cs

@@ -162,17 +162,18 @@ public class Converter : JsonConverter<PrimitiveSchemaDefinition>
                         case "default":
                             // We need to handle different types for default values
                             // Store the value based on the JSON token type
-                            if (reader.TokenType == JsonTokenType.True || reader.TokenType == JsonTokenType.False)
+                            switch (reader.TokenType)
                             {
-                                defaultBool = reader.GetBoolean();
-                            }
-                            else if (reader.TokenType == JsonTokenType.Number)
-                            {
-                                defaultNumber = reader.GetDouble();
-                            }
-                            else if (reader.TokenType == JsonTokenType.String)
-                            {
-                                defaultString = reader.GetString();
+                                case JsonTokenType.True:
+                                case JsonTokenType.False:
+                                    defaultBool = reader.GetBoolean();
+                                    break;
+                                case JsonTokenType.Number:
+                                    defaultNumber = reader.GetDouble();
+                                    break;
+                                case JsonTokenType.String:
+                                    defaultString = reader.GetString();
+                                    break;
                             }
                             break;
 

src/ModelContextProtocol.Core/Server/McpServer.Methods.cs

@@ -2,7 +2,9 @@
 using Microsoft.Extensions.Logging;
 using ModelContextProtocol.Protocol;
 using System.Collections.Concurrent;
+using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.Json;
@@ -257,9 +259,9 @@ public async ValueTask<ElicitResult<T>> ElicitAsync<T>(
         var dict = s_elicitResultSchemaCache.GetValue(serializerOptions, _ => new());
 
 #if NET
-        var schema = dict.GetOrAdd(typeof(T), static (t, s) => BuildRequestSchema(t, s), serializerOptions);
+        var schema = dict.GetOrAdd(typeof(T), static (t, s) => BuildRequestSchemaHelper(t, s), serializerOptions);
 #else
-        var schema = dict.GetOrAdd(typeof(T), type => BuildRequestSchema(type, serializerOptions));
+        var schema = dict.GetOrAdd(typeof(T), type => BuildRequestSchemaHelper(type, serializerOptions));
 #endif
 
         var request = new ElicitRequestParams
@@ -285,14 +287,21 @@ public async ValueTask<ElicitResult<T>> ElicitAsync<T>(
         return new ElicitResult<T> { Action = raw.Action, Content = typed };
     }
 
+    /// <summary>
+    /// Helper method for BuildRequestSchema that can be called from lambdas without annotation issues.
+    /// </summary>
+    [UnconditionalSuppressMessage("Trimming", "IL2067", Justification = "Type T is preserved via JsonTypeInfo")]
+    private static ElicitRequestParams.RequestSchema BuildRequestSchemaHelper(Type type, JsonSerializerOptions serializerOptions)
+        => BuildRequestSchema(type, serializerOptions);
+
     /// <summary>
     /// Builds a request schema for elicitation based on the public serializable properties of <paramref name="type"/>.
     /// </summary>
     /// <param name="type">The type of the schema being built.</param>
     /// <param name="serializerOptions">The serializer options to use.</param>
     /// <returns>The built request schema.</returns>
     /// <exception cref="McpProtocolException"></exception>
-    private static ElicitRequestParams.RequestSchema BuildRequestSchema(Type type, JsonSerializerOptions serializerOptions)
+    private static ElicitRequestParams.RequestSchema BuildRequestSchema([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type, JsonSerializerOptions serializerOptions)
     {
         var schema = new ElicitRequestParams.RequestSchema();
         var props = schema.Properties;
@@ -307,11 +316,47 @@ private static ElicitRequestParams.RequestSchema BuildRequestSchema(Type type, J
         foreach (JsonPropertyInfo pi in typeInfo.Properties)
         {
             var def = CreatePrimitiveSchema(pi.PropertyType, serializerOptions);
+            
+            // Extract default value from DefaultValueAttribute if present
+            var propInfo = type.GetProperty(pi.Name);
+            if (propInfo != null)
+            {
+                var defaultValueAttr = propInfo.GetCustomAttribute<System.ComponentModel.DefaultValueAttribute>();
+                if (defaultValueAttr?.Value != null)
+                {
+                    SetDefaultValue(def, defaultValueAttr.Value);
+                }
+            }
+            
             props[pi.Name] = def;
         }
 
         return schema;
     }
+    
+    /// <summary>
+    /// Sets the default value on a primitive schema definition based on the value type.
+    /// </summary>
+    /// <param name="schema">The schema to set the default value on.</param>
+    /// <param name="value">The default value.</param>
+    private static void SetDefaultValue(ElicitRequestParams.PrimitiveSchemaDefinition schema, object value)
+    {
+        switch (schema)
+        {
+            case ElicitRequestParams.StringSchema stringSchema:
+                stringSchema.Default = value?.ToString();
+                break;
+            case ElicitRequestParams.NumberSchema numberSchema:
+                numberSchema.Default = Convert.ToDouble(value);
+                break;
+            case ElicitRequestParams.BooleanSchema booleanSchema:
+                booleanSchema.Default = Convert.ToBoolean(value);
+                break;
+            case ElicitRequestParams.EnumSchema enumSchema:
+                enumSchema.Default = value?.ToString();
+                break;
+        }
+    }
 
     /// <summary>
     /// Creates a primitive schema definition for the specified type, if supported.

tests/ModelContextProtocol.Tests/Protocol/ElicitationTypedTests.cs

@@ -86,6 +86,19 @@ await request.Server.ElicitAsync<string>(
                     Content = [new TextContentBlock { Text = "unexpected" }],
                 };
             }
+            else if (request.Params!.Name == "TestElicitationWithDefaults")
+            {
+                var result = await request.Server.ElicitAsync<FormWithDefaults>(
+                    message: "Please provide information.",
+                    serializerOptions: ElicitationDefaultsJsonContext.Default.Options,
+                    cancellationToken: CancellationToken.None);
+
+                // The test will validate the schema in the client handler
+                return new CallToolResult
+                {
+                    Content = [new TextContentBlock { Text = "success" }],
+                };
+            }
             else
             {
                 Assert.Fail($"Unexpected tool name: {request.Params!.Name}");
@@ -360,4 +373,89 @@ public sealed class Nested
     [JsonSerializable(typeof(UnsupportedForm.Nested))]
     [JsonSerializable(typeof(JsonElement))]
     internal partial class ElicitationUnsupportedJsonContext : JsonSerializerContext;
+
+    public sealed class FormWithDefaults
+    {
+        [System.ComponentModel.DefaultValue("John Doe")]
+        public string Name { get; set; } = "John Doe";
+        
+        [System.ComponentModel.DefaultValue(30)]
+        public int Age { get; set; } = 30;
+        
+        [System.ComponentModel.DefaultValue(85.5)]
+        public double Score { get; set; } = 85.5;
+        
+        [System.ComponentModel.DefaultValue(true)]
+        public bool IsActive { get; set; } = true;
+        
+        [System.ComponentModel.DefaultValue("active")]
+        public string Status { get; set; } = "active";
+    }
+
+    [JsonSerializable(typeof(FormWithDefaults))]
+    [JsonSerializable(typeof(JsonElement))]
+    internal partial class ElicitationDefaultsJsonContext : JsonSerializerContext;
+
+    [Fact]
+    public async Task Elicit_Typed_With_Defaults_Maps_To_Schema_Defaults()
+    {
+        await using McpClient client = await CreateMcpClientForServer(new McpClientOptions
+        {
+            Handlers = new()
+            {
+                ElicitationHandler = async (request, cancellationToken) =>
+                {
+                    Assert.NotNull(request);
+                    Assert.Equal("Please provide information.", request.Message);
+
+                    Assert.Equal(5, request.RequestedSchema.Properties.Count);
+
+                    // Verify that default values from the type are mapped to the schema
+                    foreach (var entry in request.RequestedSchema.Properties)
+                    {
+                        switch (entry.Key)
+                        {
+                            case nameof(FormWithDefaults.Name):
+                                var nameSchema = Assert.IsType<ElicitRequestParams.StringSchema>(entry.Value);
+                                Assert.Equal("John Doe", nameSchema.Default);
+                                break;
+
+                            case nameof(FormWithDefaults.Age):
+                                var ageSchema = Assert.IsType<ElicitRequestParams.NumberSchema>(entry.Value);
+                                Assert.Equal(30, ageSchema.Default);
+                                break;
+
+                            case nameof(FormWithDefaults.Score):
+                                var scoreSchema = Assert.IsType<ElicitRequestParams.NumberSchema>(entry.Value);
+                                Assert.Equal(85.5, scoreSchema.Default);
+                                break;
+
+                            case nameof(FormWithDefaults.IsActive):
+                                var activeSchema = Assert.IsType<ElicitRequestParams.BooleanSchema>(entry.Value);
+                                Assert.True(activeSchema.Default);
+                                break;
+
+                            case nameof(FormWithDefaults.Status):
+                                var statusSchema = Assert.IsType<ElicitRequestParams.StringSchema>(entry.Value);
+                                Assert.Equal("active", statusSchema.Default);
+                                break;
+
+                            default:
+                                Assert.Fail($"Unexpected property: {entry.Key}");
+                                break;
+                        }
+                    }
+
+                    return new ElicitResult
+                    {
+                        Action = "accept",
+                        Content = new Dictionary<string, JsonElement>()
+                    };
+                },
+            }
+        });
+
+        var result = await client.CallToolAsync("TestElicitationWithDefaults", cancellationToken: TestContext.Current.CancellationToken);
+        Assert.Equal("success", (result.Content[0] as TextContentBlock)?.Text);
+    }
 }