Add serialization roundtrip tests for all Protocol namespace types (#1289)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

tests/ModelContextProtocol.Tests/Protocol/AnnotationsTests.cs

@@ -0,0 +1,43 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class AnnotationsTests
+{
+    [Fact]
+    public static void Annotations_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new Annotations
+        {
+            Audience = [Role.User, Role.Assistant],
+            Priority = 0.75f,
+            LastModified = new DateTimeOffset(2025, 6, 15, 10, 30, 0, TimeSpan.Zero)
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Annotations>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Audience);
+        Assert.Equal(2, deserialized.Audience.Count);
+        Assert.Equal(Role.User, deserialized.Audience[0]);
+        Assert.Equal(Role.Assistant, deserialized.Audience[1]);
+        Assert.Equal(original.Priority, deserialized.Priority);
+        Assert.Equal(original.LastModified, deserialized.LastModified);
+    }
+
+    [Fact]
+    public static void Annotations_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new Annotations();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Annotations>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Null(deserialized.Audience);
+        Assert.Null(deserialized.Priority);
+        Assert.Null(deserialized.LastModified);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ArgumentTests.cs

@@ -0,0 +1,24 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ArgumentTests
+{
+    [Fact]
+    public static void Argument_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new Argument
+        {
+            Name = "temperature",
+            Value = "72"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Argument>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.Name, deserialized.Name);
+        Assert.Equal(original.Value, deserialized.Value);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CallToolRequestParamsTests.cs

@@ -0,0 +1,56 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CallToolRequestParamsTests
+{
+    [Fact]
+    public static void CallToolRequestParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CallToolRequestParams
+        {
+            Name = "get_weather",
+            Arguments = new Dictionary<string, JsonElement>
+            {
+                ["city"] = JsonDocument.Parse("\"Seattle\"").RootElement.Clone(),
+                ["units"] = JsonDocument.Parse("\"metric\"").RootElement.Clone()
+            },
+            Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromHours(1) },
+            Meta = new JsonObject { ["progressToken"] = "token-123" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.Name, deserialized.Name);
+        Assert.NotNull(deserialized.Arguments);
+        Assert.Equal(2, deserialized.Arguments.Count);
+        Assert.Equal("Seattle", deserialized.Arguments["city"].GetString());
+        Assert.Equal("metric", deserialized.Arguments["units"].GetString());
+        Assert.NotNull(deserialized.Task);
+        Assert.Equal(original.Task.TimeToLive, deserialized.Task.TimeToLive);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("token-123", (string)deserialized.Meta["progressToken"]!);
+    }
+
+    [Fact]
+    public static void CallToolRequestParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CallToolRequestParams
+        {
+            Name = "simple_tool"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.Name, deserialized.Name);
+        Assert.Null(deserialized.Arguments);
+        Assert.Null(deserialized.Task);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CallToolResultTests.cs

@@ -0,0 +1,58 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CallToolResultTests
+{
+    [Fact]
+    public static void CallToolResult_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CallToolResult
+        {
+            Content = [new TextContentBlock { Text = "Result text" }],
+            StructuredContent = JsonNode.Parse("""{"temperature":72}"""),
+            IsError = false,
+            Task = new McpTask
+            {
+                TaskId = "task-1",
+                Status = McpTaskStatus.Completed,
+                CreatedAt = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero),
+                LastUpdatedAt = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero)
+            },
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Single(deserialized.Content);
+        var textBlock = Assert.IsType<TextContentBlock>(deserialized.Content[0]);
+        Assert.Equal("Result text", textBlock.Text);
+        Assert.NotNull(deserialized.StructuredContent);
+        Assert.Equal(72, deserialized.StructuredContent["temperature"]!.GetValue<int>());
+        Assert.False(deserialized.IsError);
+        Assert.NotNull(deserialized.Task);
+        Assert.Equal("task-1", deserialized.Task.TaskId);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void CallToolResult_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CallToolResult();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CallToolResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Empty(deserialized.Content);
+        Assert.Null(deserialized.StructuredContent);
+        Assert.Null(deserialized.IsError);
+        Assert.Null(deserialized.Task);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskRequestParamsTests.cs

@@ -0,0 +1,25 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CancelMcpTaskRequestParamsTests
+{
+    [Fact]
+    public static void CancelMcpTaskRequestParams_SerializationRoundTrip()
+    {
+        // Arrange
+        var original = new CancelMcpTaskRequestParams
+        {
+            TaskId = "cancel-task-456"
+        };
+
+        // Act
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelMcpTaskRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        // Assert
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.TaskId, deserialized.TaskId);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskResultTests.cs

@@ -0,0 +1,33 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CancelMcpTaskResultTests
+{
+    [Fact]
+    public static void CancelMcpTaskResult_SerializationRoundTrip()
+    {
+        // Arrange
+        var original = new CancelMcpTaskResult
+        {
+            TaskId = "cancelled-789",
+            Status = McpTaskStatus.Cancelled,
+            StatusMessage = "Cancelled by user",
+            CreatedAt = DateTimeOffset.UtcNow,
+            LastUpdatedAt = DateTimeOffset.UtcNow,
+            TimeToLive = null,
+            PollInterval = null
+        };
+
+        // Act
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelMcpTaskResult>(json, McpJsonUtilities.DefaultOptions);
+
+        // Assert
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.TaskId, deserialized.TaskId);
+        Assert.Equal(original.Status, deserialized.Status);
+        Assert.Equal(original.StatusMessage, deserialized.StatusMessage);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CancelledNotificationParamsTests.cs

@@ -0,0 +1,45 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CancelledNotificationParamsTests
+{
+    [Fact]
+    public static void CancelledNotificationParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CancelledNotificationParams
+        {
+            RequestId = new RequestId(42),
+            Reason = "User cancelled the operation",
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelledNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.RequestId, deserialized.RequestId);
+        Assert.Equal(original.Reason, deserialized.Reason);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void CancelledNotificationParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CancelledNotificationParams
+        {
+            RequestId = new RequestId("req-123")
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CancelledNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.RequestId, deserialized.RequestId);
+        Assert.Null(deserialized.Reason);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ClientCapabilitiesTests.cs

@@ -0,0 +1,57 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ClientCapabilitiesTests
+{
+    [Fact]
+    public static void ClientCapabilities_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new ClientCapabilities
+        {
+            Roots = new RootsCapability { ListChanged = true },
+            Sampling = new SamplingCapability
+            {
+                Context = new SamplingContextCapability(),
+                Tools = new SamplingToolsCapability()
+            },
+            Elicitation = new ElicitationCapability
+            {
+                Form = new FormElicitationCapability(),
+                Url = new UrlElicitationCapability()
+            },
+            Tasks = new McpTasksCapability()
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ClientCapabilities>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Roots);
+        Assert.True(deserialized.Roots.ListChanged);
+        Assert.NotNull(deserialized.Sampling);
+        Assert.NotNull(deserialized.Sampling.Context);
+        Assert.NotNull(deserialized.Sampling.Tools);
+        Assert.NotNull(deserialized.Elicitation);
+        Assert.NotNull(deserialized.Elicitation.Form);
+        Assert.NotNull(deserialized.Elicitation.Url);
+        Assert.NotNull(deserialized.Tasks);
+    }
+
+    [Fact]
+    public static void ClientCapabilities_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new ClientCapabilities();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ClientCapabilities>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Null(deserialized.Experimental);
+        Assert.Null(deserialized.Roots);
+        Assert.Null(deserialized.Sampling);
+        Assert.Null(deserialized.Elicitation);
+        Assert.Null(deserialized.Tasks);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CompleteContextTests.cs

@@ -0,0 +1,41 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CompleteContextTests
+{
+    [Fact]
+    public static void CompleteContext_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CompleteContext
+        {
+            Arguments = new Dictionary<string, string>
+            {
+                ["language"] = "en",
+                ["region"] = "us"
+            }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteContext>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Arguments);
+        Assert.Equal(2, deserialized.Arguments.Count);
+        Assert.Equal("en", deserialized.Arguments["language"]);
+        Assert.Equal("us", deserialized.Arguments["region"]);
+    }
+
+    [Fact]
+    public static void CompleteContext_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CompleteContext();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteContext>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Null(deserialized.Arguments);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CompleteRequestParamsTests.cs

@@ -0,0 +1,58 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CompleteRequestParamsTests
+{
+    [Fact]
+    public static void CompleteRequestParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CompleteRequestParams
+        {
+            Ref = new PromptReference { Name = "my_prompt" },
+            Argument = new Argument { Name = "topic", Value = "wea" },
+            Context = new CompleteContext
+            {
+                Arguments = new Dictionary<string, string> { ["language"] = "en" }
+            },
+            Meta = new JsonObject { ["progressToken"] = "tok-1" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        var promptRef = Assert.IsType<PromptReference>(deserialized.Ref);
+        Assert.Equal("my_prompt", promptRef.Name);
+        Assert.Equal(original.Argument.Name, deserialized.Argument.Name);
+        Assert.Equal(original.Argument.Value, deserialized.Argument.Value);
+        Assert.NotNull(deserialized.Context);
+        Assert.NotNull(deserialized.Context.Arguments);
+        Assert.Equal("en", deserialized.Context.Arguments["language"]);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("tok-1", (string)deserialized.Meta["progressToken"]!);
+    }
+
+    [Fact]
+    public static void CompleteRequestParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CompleteRequestParams
+        {
+            Ref = new ResourceTemplateReference { Uri = "file:///{path}" },
+            Argument = new Argument { Name = "path", Value = "/ho" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        var resourceRef = Assert.IsType<ResourceTemplateReference>(deserialized.Ref);
+        Assert.Equal("file:///{path}", resourceRef.Uri);
+        Assert.Equal("path", deserialized.Argument.Name);
+        Assert.Equal("/ho", deserialized.Argument.Value);
+        Assert.Null(deserialized.Context);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CompleteResultTests.cs

@@ -0,0 +1,53 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CompleteResultTests
+{
+    [Fact]
+    public static void CompleteResult_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CompleteResult
+        {
+            Completion = new Completion
+            {
+                Values = ["weather", "web", "webhook"],
+                Total = 10,
+                HasMore = true
+            },
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Completion);
+        Assert.Equal(3, deserialized.Completion.Values.Count);
+        Assert.Equal("weather", deserialized.Completion.Values[0]);
+        Assert.Equal("web", deserialized.Completion.Values[1]);
+        Assert.Equal("webhook", deserialized.Completion.Values[2]);
+        Assert.Equal(10, deserialized.Completion.Total);
+        Assert.True(deserialized.Completion.HasMore);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void CompleteResult_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new CompleteResult();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CompleteResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Completion);
+        Assert.Empty(deserialized.Completion.Values);
+        Assert.Null(deserialized.Completion.Total);
+        Assert.Null(deserialized.Completion.HasMore);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CompletionTests.cs

@@ -0,0 +1,43 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CompletionTests
+{
+    [Fact]
+    public static void Completion_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new Completion
+        {
+            Values = ["option1", "option2", "option3"],
+            Total = 50,
+            HasMore = true
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Completion>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(3, deserialized.Values.Count);
+        Assert.Equal("option1", deserialized.Values[0]);
+        Assert.Equal("option2", deserialized.Values[1]);
+        Assert.Equal("option3", deserialized.Values[2]);
+        Assert.Equal(50, deserialized.Total);
+        Assert.True(deserialized.HasMore);
+    }
+
+    [Fact]
+    public static void Completion_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new Completion();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<Completion>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Empty(deserialized.Values);
+        Assert.Null(deserialized.Total);
+        Assert.Null(deserialized.HasMore);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/CreateMessageResultTests.cs

@@ -164,6 +164,7 @@ public class CreateMessageResultTests
         Assert.Equal(2, deserialized.Content.Count);
         Assert.Equal("toolUse", deserialized.StopReason);
         Assert.NotNull(deserialized.Meta);
+        Assert.Equal("metadata", (string)deserialized.Meta["custom"]!);
     }
 
     [Fact]

tests/ModelContextProtocol.Tests/Protocol/CreateTaskResultTests.cs

@@ -0,0 +1,41 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class CreateTaskResultTests
+{
+    [Fact]
+    public static void CreateTaskResult_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new CreateTaskResult
+        {
+            Task = new McpTask
+            {
+                TaskId = "task-123",
+                Status = McpTaskStatus.Working,
+                StatusMessage = "Processing",
+                CreatedAt = new DateTimeOffset(2025, 6, 1, 12, 0, 0, TimeSpan.Zero),
+                LastUpdatedAt = new DateTimeOffset(2025, 6, 1, 12, 5, 0, TimeSpan.Zero),
+                TimeToLive = TimeSpan.FromHours(1),
+                PollInterval = TimeSpan.FromSeconds(5)
+            },
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CreateTaskResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("task-123", deserialized.Task.TaskId);
+        Assert.Equal(McpTaskStatus.Working, deserialized.Task.Status);
+        Assert.Equal("Processing", deserialized.Task.StatusMessage);
+        Assert.Equal(original.Task.CreatedAt, deserialized.Task.CreatedAt);
+        Assert.Equal(original.Task.LastUpdatedAt, deserialized.Task.LastUpdatedAt);
+        Assert.Equal(original.Task.TimeToLive, deserialized.Task.TimeToLive);
+        Assert.Equal(original.Task.PollInterval, deserialized.Task.PollInterval);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ElicitRequestParamsTests.cs

@@ -0,0 +1,89 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ElicitRequestParamsTests
+{
+    [Fact]
+    public static void ElicitRequestParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new ElicitRequestParams
+        {
+            Mode = "form",
+            ElicitationId = "elicit-123",
+            Url = null,
+            Message = "Please provide your details",
+            RequestedSchema = new ElicitRequestParams.RequestSchema
+            {
+                Properties =
+                {
+                    ["name"] = new ElicitRequestParams.StringSchema { Description = "Your name" },
+                    ["age"] = new ElicitRequestParams.NumberSchema { Description = "Your age" }
+                }
+            },
+            Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(10) },
+            Meta = new JsonObject { ["progressToken"] = "tok-1" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("form", deserialized.Mode);
+        Assert.Equal("elicit-123", deserialized.ElicitationId);
+        Assert.Null(deserialized.Url);
+        Assert.Equal("Please provide your details", deserialized.Message);
+        Assert.NotNull(deserialized.RequestedSchema);
+        Assert.Equal(2, deserialized.RequestedSchema.Properties.Count);
+        Assert.NotNull(deserialized.Task);
+        Assert.Equal(TimeSpan.FromMinutes(10), deserialized.Task.TimeToLive);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("tok-1", (string)deserialized.Meta["progressToken"]!);
+    }
+
+    [Fact]
+    public static void ElicitRequestParams_SerializationRoundTrip_UrlMode()
+    {
+        var original = new ElicitRequestParams
+        {
+            Mode = "url",
+            ElicitationId = "elicit-456",
+            Url = "https://example.com/auth",
+            Message = "Please authenticate"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("url", deserialized.Mode);
+        Assert.Equal("elicit-456", deserialized.ElicitationId);
+        Assert.Equal("https://example.com/auth", deserialized.Url);
+        Assert.Equal("Please authenticate", deserialized.Message);
+        Assert.Null(deserialized.RequestedSchema);
+        Assert.Null(deserialized.Task);
+    }
+
+    [Fact]
+    public static void ElicitRequestParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new ElicitRequestParams
+        {
+            Message = "Confirm action"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("form", deserialized.Mode);
+        Assert.Equal("Confirm action", deserialized.Message);
+        Assert.Null(deserialized.ElicitationId);
+        Assert.Null(deserialized.Url);
+        Assert.Null(deserialized.RequestedSchema);
+        Assert.Null(deserialized.Task);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ElicitResultTests.cs

@@ -0,0 +1,51 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ElicitResultTests
+{
+    [Fact]
+    public static void ElicitResult_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new ElicitResult
+        {
+            Action = "accept",
+            Content = new Dictionary<string, JsonElement>
+            {
+                ["name"] = JsonDocument.Parse("\"John\"").RootElement.Clone(),
+                ["age"] = JsonDocument.Parse("30").RootElement.Clone()
+            },
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("accept", deserialized.Action);
+        Assert.True(deserialized.IsAccepted);
+        Assert.NotNull(deserialized.Content);
+        Assert.Equal(2, deserialized.Content.Count);
+        Assert.Equal("John", deserialized.Content["name"].GetString());
+        Assert.Equal(30, deserialized.Content["age"].GetInt32());
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void ElicitResult_SerializationRoundTrip_WithDefaultAction()
+    {
+        var original = new ElicitResult();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("cancel", deserialized.Action);
+        Assert.False(deserialized.IsAccepted);
+        Assert.Null(deserialized.Content);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ElicitationCapabilityTests.cs

@@ -0,0 +1,38 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ElicitationCapabilityTests
+{
+    [Fact]
+    public static void ElicitationCapability_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new ElicitationCapability
+        {
+            Form = new FormElicitationCapability(),
+            Url = new UrlElicitationCapability()
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitationCapability>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Form);
+        Assert.NotNull(deserialized.Url);
+    }
+
+    [Fact]
+    public static void ElicitationCapability_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new ElicitationCapability();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitationCapability>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        // The custom converter defaults Form to non-null when both Form and Url are null for backward compatibility
+        Assert.NotNull(deserialized.Form);
+        Assert.Null(deserialized.Url);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/ElicitationCompleteNotificationParamsTests.cs

@@ -0,0 +1,42 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class ElicitationCompleteNotificationParamsTests
+{
+    [Fact]
+    public static void ElicitationCompleteNotificationParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new ElicitationCompleteNotificationParams
+        {
+            ElicitationId = "elicit-abc-123",
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitationCompleteNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("elicit-abc-123", deserialized.ElicitationId);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void ElicitationCompleteNotificationParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new ElicitationCompleteNotificationParams
+        {
+            ElicitationId = "elicit-min"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<ElicitationCompleteNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("elicit-min", deserialized.ElicitationId);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/EmptyResultTests.cs

@@ -0,0 +1,36 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class EmptyResultTests
+{
+    [Fact]
+    public static void EmptyResult_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new EmptyResult
+        {
+            Meta = new JsonObject { ["key"] = "value" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<EmptyResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("value", (string)deserialized.Meta["key"]!);
+    }
+
+    [Fact]
+    public static void EmptyResult_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new EmptyResult();
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<EmptyResult>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Null(deserialized.Meta);
+    }
+}

tests/ModelContextProtocol.Tests/Protocol/GetPromptRequestParamsTests.cs

@@ -0,0 +1,49 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Tests.Protocol;
+
+public static class GetPromptRequestParamsTests
+{
+    [Fact]
+    public static void GetPromptRequestParams_SerializationRoundTrip_PreservesAllProperties()
+    {
+        var original = new GetPromptRequestParams
+        {
+            Name = "code_review",
+            Arguments = new Dictionary<string, JsonElement>
+            {
+                ["language"] = JsonDocument.Parse("\"csharp\"").RootElement.Clone()
+            },
+            Meta = new JsonObject { ["progressToken"] = "tok-1" }
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<GetPromptRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("code_review", deserialized.Name);
+        Assert.NotNull(deserialized.Arguments);
+        Assert.Equal("csharp", deserialized.Arguments["language"].GetString());
+        Assert.NotNull(deserialized.Meta);
+        Assert.Equal("tok-1", (string)deserialized.Meta["progressToken"]!);
+    }
+
+    [Fact]
+    public static void GetPromptRequestParams_SerializationRoundTrip_WithMinimalProperties()
+    {
+        var original = new GetPromptRequestParams
+        {
+            Name = "simple_prompt"
+        };
+
+        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<GetPromptRequestParams>(json, McpJsonUtilities.DefaultOptions);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal("simple_prompt", deserialized.Name);
+        Assert.Null(deserialized.Arguments);
+        Assert.Null(deserialized.Meta);
+    }
+}