Optimize JsonRpcMessage.Converter.Read with single-pass deserialization

- Add private Union struct to hold parsed message data
- Implement hand-crafted Parse method for single-pass JSON reading
- Replace double-deserialization pattern with direct object construction
- Use GetTypeInfo for AOT compatibility
- All tests pass (1019 tests in ModelContextProtocol.Tests)

Co-authored-by: eiriktsarpalis <2813363+eiriktsarpalis@users.noreply.github.com>

Author: Copilot

src/ModelContextProtocol.Core/Protocol/JsonRpcMessage.cs

@@ -1,6 +1,7 @@
 using ModelContextProtocol.Server;
 using System.ComponentModel;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 
 namespace ModelContextProtocol.Protocol;
@@ -70,59 +71,150 @@ private protected JsonRpcMessage()
     [EditorBrowsable(EditorBrowsableState.Never)]
     public sealed class Converter : JsonConverter<JsonRpcMessage>
     {
-        /// <inheritdoc/>
-        public override JsonRpcMessage? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        /// <summary>
+        /// Private struct to hold parsed JSON-RPC message data during deserialization.
+        /// </summary>
+        private struct Union
         {
-            if (reader.TokenType != JsonTokenType.StartObject)
+            public string JsonRpc;
+            public RequestId Id;
+            public string? Method;
+            public JsonNode? Params;
+            public JsonRpcErrorDetail? Error;
+            public JsonNode? Result;
+            public bool HasId;
+            public bool HasMethod;
+            public bool HasError;
+            public bool HasResult;
+
+            /// <summary>
+            /// Manually parses a JSON-RPC message from the reader into the Union struct.
+            /// </summary>
+            public static Union Parse(ref Utf8JsonReader reader, JsonSerializerOptions options)
             {
-                throw new JsonException("Expected StartObject token");
+                var union = new Union();
+
+                if (reader.TokenType != JsonTokenType.StartObject)
+                {
+                    throw new JsonException("Expected StartObject token");
+                }
+
+                while (reader.Read())
+                {
+                    if (reader.TokenType == JsonTokenType.EndObject)
+                    {
+                        break;
+                    }
+
+                    if (reader.TokenType != JsonTokenType.PropertyName)
+                    {
+                        throw new JsonException("Expected PropertyName token");
+                    }
+
+                    string propertyName = reader.GetString()!;
+                    reader.Read();
+
+                    switch (propertyName)
+                    {
+                        case "jsonrpc":
+                            union.JsonRpc = reader.GetString()!;
+                            break;
+
+                        case "id":
+                            union.Id = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo<RequestId>());
+                            union.HasId = true;
+                            break;
+
+                        case "method":
+                            union.Method = reader.GetString();
+                            union.HasMethod = true;
+                            break;
+
+                        case "params":
+                            union.Params = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo<JsonNode>());
+                            break;
+
+                        case "error":
+                            union.Error = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo<JsonRpcErrorDetail>());
+                            union.HasError = true;
+                            break;
+
+                        case "result":
+                            union.Result = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo<JsonNode>());
+                            union.HasResult = true;
+                            break;
+
+                        default:
+                            // Skip unknown properties
+                            reader.Skip();
+                            break;
+                    }
+                }
+
+                return union;
             }
+        }
 
-            using var doc = JsonDocument.ParseValue(ref reader);
-            var root = doc.RootElement;
+        /// <inheritdoc/>
+        public override JsonRpcMessage? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            var union = Union.Parse(ref reader, options);
 
             // All JSON-RPC messages must have a jsonrpc property with value "2.0"
-            if (!root.TryGetProperty("jsonrpc", out var versionProperty) ||
-                versionProperty.GetString() != "2.0")
+            if (union.JsonRpc != "2.0")
             {
                 throw new JsonException("Invalid or missing jsonrpc version");
             }
 
-            // Determine the message type based on the presence of id, method, and error properties
-            bool hasId = root.TryGetProperty("id", out _);
-            bool hasMethod = root.TryGetProperty("method", out _);
-            bool hasError = root.TryGetProperty("error", out _);
-
-            var rawText = root.GetRawText();
-
             // Messages with an id but no method are responses
-            if (hasId && !hasMethod)
+            if (union.HasId && !union.HasMethod)
             {
                 // Messages with an error property are error responses
-                if (hasError)
+                if (union.HasError)
                 {
-                    return JsonSerializer.Deserialize(rawText, options.GetTypeInfo<JsonRpcError>());
+                    return new JsonRpcError
+                    {
+                        JsonRpc = union.JsonRpc,
+                        Id = union.Id,
+                        Error = union.Error!
+                    };
                 }
 
                 // Messages with a result property are success responses
-                if (root.TryGetProperty("result", out _))
+                if (union.HasResult)
                 {
-                    return JsonSerializer.Deserialize(rawText, options.GetTypeInfo<JsonRpcResponse>());
+                    return new JsonRpcResponse
+                    {
+                        JsonRpc = union.JsonRpc,
+                        Id = union.Id,
+                        Result = union.Result
+                    };
                 }
 
                 throw new JsonException("Response must have either result or error");
             }
 
             // Messages with a method but no id are notifications
-            if (hasMethod && !hasId)
+            if (union.HasMethod && !union.HasId)
             {
-                return JsonSerializer.Deserialize(rawText, options.GetTypeInfo<JsonRpcNotification>());
+                return new JsonRpcNotification
+                {
+                    JsonRpc = union.JsonRpc,
+                    Method = union.Method!,
+                    Params = union.Params
+                };
             }
 
             // Messages with both method and id are requests
-            if (hasMethod && hasId)
+            if (union.HasMethod && union.HasId)
             {
-                return JsonSerializer.Deserialize(rawText, options.GetTypeInfo<JsonRpcRequest>());
+                return new JsonRpcRequest
+                {
+                    JsonRpc = union.JsonRpc,
+                    Id = union.Id,
+                    Method = union.Method!,
+                    Params = union.Params
+                };
             }
 
             throw new JsonException("Invalid JSON-RPC message format");