Make Exception.Data work on .NET Framework using SerializableJsonElement wrapper

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

Author: Copilot

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -455,19 +455,17 @@ 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.
                 if (error.Error.Data is JsonElement jsonElement && jsonElement.ValueKind == JsonValueKind.Object)
                 {
                     foreach (var property in jsonElement.EnumerateObject())
                     {
-                        exception.Data[property.Name] = property.Value;
+                        // On .NET Framework, Exception.Data requires values to be [Serializable].
+                        // JsonElement is not serializable, so we wrap it in a serializable container.
+                        exception.Data[property.Name] = SerializableJsonElement.Wrap(property.Value);
                     }
                 }
-#endif
 
                 throw exception;
             }

src/ModelContextProtocol.Core/Protocol/SerializableJsonElement.cs

@@ -0,0 +1,48 @@
+using System.Text.Json;
+
+namespace ModelContextProtocol.Protocol;
+
+/// <summary>
+/// A serializable wrapper for <see cref="JsonElement"/> that can be stored in <see cref="Exception.Data"/>
+/// on .NET Framework, where values must be marked with <see cref="SerializableAttribute"/>.
+/// </summary>
+/// <remarks>
+/// On .NET Core/.NET 5+, <see cref="JsonElement"/> can be stored directly in <see cref="Exception.Data"/>,
+/// but on .NET Framework the underlying <c>ListDictionaryInternal</c> requires values to be serializable.
+/// This wrapper stores the JSON as a string and deserializes it back to a <see cref="JsonElement"/> on demand.
+/// </remarks>
+[Serializable]
+public sealed class SerializableJsonElement
+{
+    private readonly string _json;
+
+    private SerializableJsonElement(string json)
+    {
+        _json = json;
+    }
+
+    /// <summary>
+    /// Gets the <see cref="JsonElement"/> value.
+    /// </summary>
+    public JsonElement Value => JsonDocument.Parse(_json).RootElement;
+
+    /// <summary>
+    /// Creates a serializable wrapper for the specified <see cref="JsonElement"/>.
+    /// </summary>
+    /// <param name="element">The JSON element to wrap.</param>
+    /// <returns>
+    /// On .NET Core/.NET 5+, returns the <see cref="JsonElement"/> directly.
+    /// On .NET Framework, returns a <see cref="SerializableJsonElement"/> wrapper.
+    /// </returns>
+    internal static object Wrap(JsonElement element)
+    {
+#if NET
+        return element;
+#else
+        return new SerializableJsonElement(element.GetRawText());
+#endif
+    }
+
+    /// <inheritdoc/>
+    public override string ToString() => _json;
+}

tests/ModelContextProtocol.Tests/McpProtocolExceptionDataTests.cs

@@ -10,11 +10,6 @@ namespace ModelContextProtocol.Tests;
 /// <summary>
 /// 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.
-/// </remarks>
 public class McpProtocolExceptionDataTests : ClientServerTestBase
 {
     public McpProtocolExceptionDataTests(ITestOutputHelper testOutputHelper)
@@ -68,6 +63,20 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer
         });
     }
 
+    /// <summary>
+    /// Gets the JsonElement from an Exception.Data value, handling both direct JsonElement (on .NET Core)
+    /// and SerializableJsonElement wrapper (on .NET Framework).
+    /// </summary>
+    private static JsonElement GetJsonElement(object? value)
+    {
+        return value switch
+        {
+            JsonElement je => je,
+            SerializableJsonElement sje => sje.Value,
+            _ => throw new InvalidOperationException($"Expected JsonElement or SerializableJsonElement, got {value?.GetType().Name ?? "null"}")
+        };
+    }
+
     [Fact]
     public async Task Exception_With_Serializable_Data_Propagates_To_Client()
     {
@@ -78,12 +87,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
@@ -100,11 +103,11 @@ 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"]);
+        // Verify the values (they are JsonElements on .NET Core, SerializableJsonElement on .NET Framework)
+        var uriValue = GetJsonElement(exception.Data["uri"]);
         Assert.Equal("file:///path/to/resource", uriValue.GetString());
 
-        var codeValue = Assert.IsType<JsonElement>(exception.Data["code"]);
+        var codeValue = GetJsonElement(exception.Data["code"]);
         Assert.Equal(404, codeValue.GetInt32());
     }
 
@@ -121,12 +124,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;
@@ -142,7 +139,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"]);
+        var uriValue = GetJsonElement(exception.Data["uri"]);
         Assert.Equal("file:///path/to/resource", uriValue.GetString());
     }
 

tests/ModelContextProtocol.Tests/PlatformDetection.cs

@@ -6,13 +6,4 @@ internal static class PlatformDetection
 {
     public static bool IsMonoRuntime { get; } = Type.GetType("Mono.Runtime") is not null;
     public static bool IsWindows { get; } = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-
-    // On .NET Framework, Exception.Data requires values to be serializable with [Serializable].
-    // JsonElement is not marked as serializable, so certain features are not available on that platform.
-    public static bool IsNetFramework { get; } =
-#if NET
-        false;
-#else
-        true;
-#endif
 }