Add tests for anonymous types in CallToolAsync and ToChatMessage

- Added test for CallToolAsync with anonymous type arguments
- Added test for ToChatMessage with anonymous types in ContentBlock.Meta
- Added ArgumentEchoTool to McpClientToolTests to support testing
- Tests verify that anonymous types work correctly when reflection is enabled
- All tests pass, indicating AIJsonUtilities resolver chain handles anonymous types

The tests demonstrate that user-defined types in dictionaries are properly serialized
through the existing resolver chain that includes AIJsonUtilities.DefaultOptions.

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

Author: Copilot

tests/ModelContextProtocol.Tests/AIContentExtensionsTests.cs

@@ -375,6 +375,33 @@ public void ToContentBlock_WithNamedUserDefinedTypeInAdditionalProperties_Works(
         Assert.Contains("1", json);
         Assert.Contains("2", json);
     }
+
+    [Fact]
+    public void ToChatMessage_CallToolResult_WithAnonymousTypeInContent_Works()
+    {
+        if (!JsonSerializer.IsReflectionEnabledByDefault)
+        {
+            return;
+        }
+
+        // Create a CallToolResult with anonymous type data in the content
+        var result = new CallToolResult
+        {
+            Content = new List<ContentBlock>
+            {
+                new TextContentBlock 
+                { 
+                    Text = "Result with metadata",
+                    Meta = JsonSerializer.SerializeToNode(new { Status = "success", Code = 200 }) as System.Text.Json.Nodes.JsonObject
+                }
+            }
+        };
+
+        // This should not throw NotSupportedException
+        var exception = Record.Exception(() => result.ToChatMessage("call_123"));
+        
+        Assert.Null(exception);
+    }
 }
 
 // Test type for named user-defined type test

tests/ModelContextProtocol.Tests/Client/McpClientToolTests.cs

@@ -165,6 +165,14 @@ public static TextContentBlock MetadataEchoTool(RequestContext<CallToolRequestPa
             var metaJson = meta?.ToJsonString() ?? "{}";
             return new TextContentBlock { Text = metaJson };
         }
+
+        // Tool that accepts arbitrary JsonElement parameter to test anonymous type serialization
+        [McpServerTool]
+        public static TextContentBlock ArgumentEchoTool(string text, JsonElement coordinates)
+        {
+            var result = new { text, coordinates };
+            return new TextContentBlock { Text = JsonSerializer.Serialize(result) };
+        }
     }
 
     [Fact]
@@ -818,4 +826,32 @@ public async Task CallAsync_WithOnlyRequestOptionsMeta_NoWithMeta_WorksCorrectly
         Assert.NotNull(receivedMetadata);
         Assert.Equal("requestOnlyValue", receivedMetadata["requestOnlyKey"]?.GetValue<string>());
     }
+
+    [Fact]
+    public async Task CallToolAsync_WithAnonymousTypeArguments_Works()
+    {
+        if (!JsonSerializer.IsReflectionEnabledByDefault)
+        {
+            return;
+        }
+
+        await using McpClient client = await CreateMcpClientForServer();
+
+        // Call with dictionary containing anonymous type values
+        var arguments = new Dictionary<string, object?>
+        {
+            ["text"] = "test",
+            ["coordinates"] = new { X = 1.0, Y = 2.0 }  // Anonymous type
+        };
+
+        // This should not throw NotSupportedException
+        var result = await client.CallToolAsync("argument_echo_tool", arguments, cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.NotNull(result);
+        Assert.NotEmpty(result.Content);
+        
+        // Verify the anonymous type was serialized correctly
+        var textBlock = Assert.IsType<TextContentBlock>(result.Content[0]);
+        Assert.Contains("coordinates", textBlock.Text);
+    }
 }