Revert to string-based JSON values for McpMetaAttribute with StringSyntax annotation

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

Author: Copilot

samples/AspNetCoreMcpServer/Tools/WeatherTools.cs

@@ -17,8 +17,8 @@ public WeatherTools(IHttpClientFactory httpClientFactory)
     }
 
     [McpServerTool, Description("Get weather alerts for a US state.")]
-    [McpMeta("category", "weather")]
-    [McpMeta("dataSource", "weather.gov")]
+    [McpMeta("category", "\"weather\"")]
+    [McpMeta("dataSource", "\"weather.gov\"")]
     public async Task<string> GetAlerts(
         [Description("The US state to get alerts for. Use the 2 letter abbreviation for the state (e.g. NY).")] string state)
     {

src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs

@@ -360,7 +360,7 @@ internal static IReadOnlyList<object> CreateMetadata(MethodInfo method)
     /// <summary>Creates a Meta <see cref="JsonObject"/> from <see cref="McpMetaAttribute"/> instances on the specified method.</summary>
     /// <param name="method">The method to extract <see cref="McpMetaAttribute"/> instances from.</param>
     /// <param name="meta">Optional <see cref="JsonObject"/> to seed the Meta with. Properties from this object take precedence over attributes.</param>
-    /// <param name="serializerOptions">Optional <see cref="JsonSerializerOptions"/> to use for serialization. Defaults to <see cref="McpJsonUtilities.DefaultOptions"/> if not provided.</param>
+    /// <param name="serializerOptions">Optional <see cref="JsonSerializerOptions"/> to use for serialization. This parameter is ignored when parsing JSON strings from attributes.</param>
     /// <returns>A <see cref="JsonObject"/> with metadata, or null if no metadata is present.</returns>
     internal static JsonObject? CreateMetaFromAttributes(MethodInfo method, JsonObject? meta = null, JsonSerializerOptions? serializerOptions = null)
     {
@@ -372,20 +372,8 @@ internal static IReadOnlyList<object> CreateMetadata(MethodInfo method)
             meta ??= [];
             if (!meta.ContainsKey(attr.Name))
             {
-                JsonTypeInfo? valueTypeInfo = null;
-                if (attr.Value?.GetType() is { } valueType)
-                {
-                    if (serializerOptions?.TryGetTypeInfo(valueType, out valueTypeInfo) is not true &&
-                        McpJsonUtilities.DefaultOptions.TryGetTypeInfo(valueType, out valueTypeInfo) is not true)
-                    {
-                        // Throw using GetTypeInfo in order to get a good exception message.
-                        (serializerOptions ?? McpJsonUtilities.DefaultOptions).GetTypeInfo(valueType);
-                    }
-                    
-                    Debug.Assert(valueTypeInfo is not null, "GetTypeInfo should have thrown an exception");
-                }
-
-                meta[attr.Name] = valueTypeInfo is not null ? JsonSerializer.SerializeToNode(attr.Value, valueTypeInfo) : null;
+                // Parse the JSON string value into a JsonNode
+                meta[attr.Name] = JsonNode.Parse(attr.Value);
             }
         }
 

src/ModelContextProtocol.Core/Server/McpMetaAttribute.cs

@@ -1,4 +1,5 @@
 using ModelContextProtocol.Protocol;
+using System.Diagnostics.CodeAnalysis;
 
 namespace ModelContextProtocol.Server;
 
@@ -18,8 +19,9 @@ namespace ModelContextProtocol.Server;
 /// <example>
 /// <code>
 /// [McpServerTool]
-/// [McpMeta("model", "gpt-4o")]
-/// [McpMeta("version", "1.0")]
+/// [McpMeta("model", "\"gpt-4o\"")]
+/// [McpMeta("version", "\"1.0\"")]
+/// [McpMeta("priority", "5")]
 /// public string MyTool(string input)
 /// {
 ///     return $"Processed: {input}";
@@ -34,8 +36,8 @@ public sealed class McpMetaAttribute : Attribute
     /// Initializes a new instance of the <see cref="McpMetaAttribute"/> class.
     /// </summary>
     /// <param name="name">The name (key) of the metadata entry.</param>
-    /// <param name="value">The value of the metadata entry. This can be any value that can be encoded in .NET metadata.</param>
-    public McpMetaAttribute(string name, object? value)
+    /// <param name="value">The value of the metadata entry as a JSON string. This must be well-formed JSON.</param>
+    public McpMetaAttribute(string name, [StringSyntax(StringSyntaxAttribute.Json)] string value)
     {
         Name = name;
         Value = value;
@@ -51,19 +53,20 @@ public McpMetaAttribute(string name, object? value)
     public string Name { get; }
 
     /// <summary>
-    /// Gets the value of the metadata entry.
+    /// Gets the value of the metadata entry as a JSON string.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// This value can be any object that can be encoded in .NET metadata (strings, numbers, booleans, etc.).
-    /// The value will be serialized to JSON using <see cref="System.Text.Json.JsonSerializer"/> when
-    /// populating the metadata JsonObject.
+    /// This value must be well-formed JSON. It will be parsed and added to the metadata JsonObject.
+    /// Simple values can be represented as JSON literals like <c>"\"my-string\""</c>, <c>"123"</c>, 
+    /// <c>"true"</c>, etc. Complex structures can be represented as JSON objects or arrays.
     /// </para>
     /// <para>
-    /// For complex JSON structures that cannot be represented as .NET metadata, use the
-    /// <see cref="McpServerToolCreateOptions.Meta"/>, <see cref="McpServerPromptCreateOptions.Meta"/>, 
-    /// or <see cref="McpServerResourceCreateOptions.Meta"/> property to provide a JsonObject directly.
+    /// For programmatic scenarios where you want to construct complex metadata without dealing with
+    /// JSON strings, use the <see cref="McpServerToolCreateOptions.Meta"/>, 
+    /// <see cref="McpServerPromptCreateOptions.Meta"/>, or <see cref="McpServerResourceCreateOptions.Meta"/> 
+    /// property to provide a JsonObject directly.
     /// </para>
     /// </remarks>
-    public object? Value { get; }
+    public string Value { get; }
 }

tests/ModelContextProtocol.Tests/Server/McpMetaAttributeTests.cs

@@ -1,6 +1,5 @@
 using ModelContextProtocol.Server;
 using System.Text.Json.Nodes;
-using System.Text.Json.Serialization;
 
 namespace ModelContextProtocol.Tests.Server;
 
@@ -192,12 +191,11 @@ public void McpMetaAttribute_DuplicateKeys_WithSeedMeta_SeedTakesPrecedence()
     public void McpMetaAttribute_NonStringValues_Serialized()
     {
         var method = typeof(TestToolNonStringMetaClass).GetMethod(nameof(TestToolNonStringMetaClass.ToolWithNonStringMeta))!;
-        var tool = McpServerTool.Create(method, target: null, options: new() { SerializerOptions = JsonContext5.Default.Options });
+        var tool = McpServerTool.Create(method, target: null);
         Assert.NotNull(tool.ProtocolTool.Meta);
         Assert.Equal("42", tool.ProtocolTool.Meta["intValue"]?.ToString());
-        Assert.Equal("true", tool.ProtocolTool.Meta["boolValue"]?.ToString());
-        // Enum serialized as numeric by default
-        Assert.Equal(((int)TestEnum.Second).ToString(), tool.ProtocolTool.Meta["enumValue"]?.ToString());
+        Assert.Equal("True", tool.ProtocolTool.Meta["boolValue"]?.ToString());
+        Assert.Equal("1", tool.ProtocolTool.Meta["enumValue"]?.ToString());
     }
 
     [Fact]
@@ -237,8 +235,8 @@ public void McpMetaAttribute_DelegateOverload_PopulatesMeta()
     private class TestToolClass
     {
         [McpServerTool]
-        [McpMeta("model", "gpt-4o")]
-        [McpMeta("version", "1.0")]
+        [McpMeta("model", "\"gpt-4o\"")]
+        [McpMeta("version", "\"1.0\"")]
         public static string ToolWithMeta(string input)
         {
             return input;
@@ -251,7 +249,7 @@ public static string ToolWithoutMeta(string input)
         }
 
         [McpServerTool]
-        [McpMeta("test-key", "test-value")]
+        [McpMeta("test-key", "\"test-value\"")]
         public static string ToolWithSingleMeta(string input)
         {
             return input;
@@ -261,8 +259,8 @@ public static string ToolWithSingleMeta(string input)
     private class TestPromptClass
     {
         [McpServerPrompt]
-        [McpMeta("type", "reasoning")]
-        [McpMeta("model", "claude-3")]
+        [McpMeta("type", "\"reasoning\"")]
+        [McpMeta("model", "\"claude-3\"")]
         public static string PromptWithMeta(string input)
         {
             return input;
@@ -272,8 +270,8 @@ public static string PromptWithMeta(string input)
     private class TestResourceClass
     {
         [McpServerResource(UriTemplate = "resource://test/{id}")]
-        [McpMeta("encoding", "text/plain")]
-        [McpMeta("caching", "cached")]
+        [McpMeta("encoding", "\"text/plain\"")]
+        [McpMeta("caching", "\"cached\"")]
         public static string ResourceWithMeta(string id)
         {
             return $"Resource content for {id}";
@@ -295,39 +293,32 @@ private class TestPromptNoMetaClass
     private class TestToolDuplicateMetaClass
     {
         [McpServerTool]
-        [McpMeta("key", "first")]
-        [McpMeta("key", "second")]
-        [McpMeta("other", "other-value")]
+        [McpMeta("key", "\"first\"")]
+        [McpMeta("key", "\"second\"")]
+        [McpMeta("other", "\"other-value\"")]
         public static string ToolWithDuplicateMeta(string input) => input;
     }
 
-    private enum TestEnum { First = 0, Second = 1 }
-
     private class TestToolNonStringMetaClass
     {
         [McpServerTool]
-        [McpMeta("intValue", 42)]
-        [McpMeta("boolValue", true)]
-        [McpMeta("enumValue", TestEnum.Second)]
+        [McpMeta("intValue", "42")]
+        [McpMeta("boolValue", "true")]
+        [McpMeta("enumValue", "1")]
         public static string ToolWithNonStringMeta(string input) => input;
     }
 
     private class TestToolNullMetaClass
     {
         [McpServerTool]
-        [McpMeta("nullable", null)]
+        [McpMeta("nullable", "null")]
         public static string ToolWithNullMeta(string input) => input;
     }
 
     private class TestToolMethodMetaOnlyClass
     {
         [McpServerTool]
-        [McpMeta("methodKey", "method")]
+        [McpMeta("methodKey", "\"method\"")]
         public static string ToolWithMethodMeta(string input) => input;
     }
-
-    [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
-    [JsonSerializable(typeof(string))]
-    [JsonSerializable(typeof(TestEnum))]
-    private partial class JsonContext5 : JsonSerializerContext;
 }