Extract primitive values from JsonElements for .NET Framework compatibility

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

Author: Copilot

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -455,19 +455,36 @@ public async Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest request, Canc
                 LogSendingRequestFailed(EndpointName, request.Method, error.Error.Message, error.Error.Code);
                 var exception = new McpProtocolException($"Request failed (remote): {error.Error.Message}", (McpErrorCode)error.Error.Code);
 
-#if NET
                 // Populate exception.Data with the error data if present.
                 // When deserializing JSON, Data will be a JsonElement.
-                // Note: This is not supported on .NET Framework because Exception.Data uses ListDictionaryInternal
-                // which requires values to be marked with [Serializable], and JsonElement is not serializable.
+                // We extract primitive values (strings, numbers, bools) for broader compatibility,
+                // as JsonElement is not [Serializable] and cannot be stored in Exception.Data on .NET Framework.
                 if (error.Error.Data is JsonElement jsonElement && jsonElement.ValueKind == JsonValueKind.Object)
                 {
                     foreach (var property in jsonElement.EnumerateObject())
                     {
-                        exception.Data[property.Name] = property.Value;
+                        object? value = property.Value.ValueKind switch
+                        {
+                            JsonValueKind.String => property.Value.GetString(),
+                            JsonValueKind.Number => property.Value.GetDouble(),
+                            JsonValueKind.True => true,
+                            JsonValueKind.False => false,
+                            JsonValueKind.Null => null,
+#if NET
+                            // Objects and arrays are stored as JsonElement on .NET Core only
+                            _ => property.Value,
+#else
+                            // Skip objects/arrays on .NET Framework as JsonElement is not serializable
+                            _ => (object?)null,
+#endif
+                        };
+
+                        if (value is not null || property.Value.ValueKind == JsonValueKind.Null)
+                        {
+                            exception.Data[property.Name] = value;
+                        }
                     }
                 }
-#endif
 
                 throw exception;
             }

tests/ModelContextProtocol.Tests/McpProtocolExceptionDataTests.cs

@@ -11,9 +11,9 @@ namespace ModelContextProtocol.Tests;
 /// Tests for McpProtocolException.Data propagation to JSON-RPC error responses.
 /// </summary>
 /// <remarks>
-/// Note: On .NET Framework, Exception.Data requires values to be serializable with [Serializable].
-/// Since JsonElement is not marked as serializable, the data population on the client side is skipped
-/// on that platform. These tests verify the error message and code are correct regardless of platform.
+/// Primitive values (strings, numbers, bools) are extracted from JsonElements and stored directly,
+/// which works on all platforms including .NET Framework. Complex objects and arrays are stored as
+/// JsonElement on .NET Core, but skipped on .NET Framework (where JsonElement is not serializable).
 /// </remarks>
 public class McpProtocolExceptionDataTests : ClientServerTestBase
 {
@@ -79,12 +79,6 @@ public async Task Exception_With_Serializable_Data_Propagates_To_Client()
         Assert.Equal("Request failed (remote): Resource not found", exception.Message);
         Assert.Equal((McpErrorCode)(-32002), exception.ErrorCode);
 
-        // Skip data verification on .NET Framework since JsonElement cannot be stored in Exception.Data
-        if (PlatformDetection.IsNetFramework)
-        {
-            return;
-        }
-        
         // Verify the data was propagated to the exception
         // The Data collection should contain the expected keys
         var hasUri = false;
@@ -100,12 +94,9 @@ public async Task Exception_With_Serializable_Data_Propagates_To_Client()
         Assert.True(hasUri, "Exception.Data should contain 'uri' key");
         Assert.True(hasCode, "Exception.Data should contain 'code' key");
 
-        // Verify the values (they should be JsonElements)
-        var uriValue = Assert.IsType<JsonElement>(exception.Data["uri"]);
-        Assert.Equal("file:///path/to/resource", uriValue.GetString());
-        
-        var codeValue = Assert.IsType<JsonElement>(exception.Data["code"]);
-        Assert.Equal(404, codeValue.GetInt32());
+        // Verify the values - primitives are extracted as their native types (string, double, bool)
+        Assert.Equal("file:///path/to/resource", exception.Data["uri"]);
+        Assert.Equal(404.0, exception.Data["code"]); // Numbers are stored as double
     }
 
     [Fact]
@@ -122,12 +113,6 @@ public async Task Exception_With_NonSerializable_Data_Still_Propagates_Error_To_
         Assert.Equal("Request failed (remote): Resource not found", exception.Message);
         Assert.Equal((McpErrorCode)(-32002), exception.ErrorCode);
 
-        // Skip data verification on .NET Framework since JsonElement cannot be stored in Exception.Data
-        if (PlatformDetection.IsNetFramework)
-        {
-            return;
-        }
-        
         // Verify that only the serializable data was propagated (non-serializable was filtered out)
         var hasUri = false;
         var hasNonSerializable = false;
@@ -142,8 +127,7 @@ public async Task Exception_With_NonSerializable_Data_Still_Propagates_Error_To_
         Assert.True(hasUri, "Exception.Data should contain 'uri' key");
         Assert.False(hasNonSerializable, "Exception.Data should not contain 'nonSerializable' key");
 
-        var uriValue = Assert.IsType<JsonElement>(exception.Data["uri"]);
-        Assert.Equal("file:///path/to/resource", uriValue.GetString());
+        Assert.Equal("file:///path/to/resource", exception.Data["uri"]);
     }
 
     [Fact]