Fix spec compliance: Tool.Name required, CancelledNotificationParams.RequestId optional, LoggingMessageNotificationParams.Data required

- Tool.Name: Add `required` modifier to match Prompt.Name, Resource.Name,
  ResourceTemplate.Name. An empty string is not a valid tool name per spec.
- CancelledNotificationParams.RequestId: Make optional (RequestId?) per
  2025-11-25 spec. Required for request cancellation, must not be used
  for task cancellation.
- LoggingMessageNotificationParams.Data: Make required non-nullable
  (JsonElement instead of JsonElement?) per spec where `data: unknown`
  is required.
- Update McpSessionHandler to use pattern matching for nullable RequestId.
- Update tests to reflect the new type constraints.

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

Author: Copilot

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -380,11 +380,11 @@ private async Task HandleNotificationAsync(JsonRpcNotification notification, Can
         {
             try
             {
-                if (GetCancelledNotificationParams(notification.Params) is CancelledNotificationParams cn &&
-                    _handlingRequests.TryGetValue(cn.RequestId, out var cts))
+                if (GetCancelledNotificationParams(notification.Params) is CancelledNotificationParams { RequestId: { } requestId } cn &&
+                    _handlingRequests.TryGetValue(requestId, out var cts))
                 {
                     await cts.CancelAsync().ConfigureAwait(false);
-                    LogRequestCanceled(EndpointName, cn.RequestId, cn.Reason);
+                    LogRequestCanceled(EndpointName, requestId, cn.Reason);
                 }
             }
             catch
@@ -625,8 +625,8 @@ await _outgoingMessageFilter(async (msg, ct) =>
                 // server won't be sending a response, or per the specification, the response should be ignored. There are inherent
                 // race conditions here, so it's possible and allowed for the operation to complete before we get to this point.
                 if (msg is JsonRpcNotification { Method: NotificationMethods.CancelledNotification } notification &&
-                    GetCancelledNotificationParams(notification.Params) is CancelledNotificationParams cn &&
-                    _pendingRequests.TryRemove(cn.RequestId, out var tcs))
+                    GetCancelledNotificationParams(notification.Params) is CancelledNotificationParams { RequestId: { } requestId } &&
+                    _pendingRequests.TryRemove(requestId, out var tcs))
                 {
                     tcs.TrySetCanceled(default);
                 }

src/ModelContextProtocol.Core/Protocol/CancelledNotificationParams.cs

@@ -17,10 +17,16 @@ public sealed class CancelledNotificationParams : NotificationParams
     /// Gets or sets the ID of the request to cancel.
     /// </summary>
     /// <remarks>
-    /// This value must match the ID of an in-flight request that the sender wishes to cancel.
+    /// <para>
+    /// This value must correspond to the ID of a request previously issued in the same direction.
+    /// It must be provided for cancelling non-task requests.
+    /// </para>
+    /// <para>
+    /// This must not be used for cancelling tasks; use the <c>tasks/cancel</c> request instead.
+    /// </para>
     /// </remarks>
     [JsonPropertyName("requestId")]
-    public required RequestId RequestId { get; set; }
+    public RequestId? RequestId { get; set; }
 
     /// <summary>
     /// Gets or sets an optional string describing the reason for the cancellation request.

src/ModelContextProtocol.Core/Protocol/LoggingMessageNotificationParams.cs

@@ -45,8 +45,11 @@ public sealed class LoggingMessageNotificationParams : NotificationParams
     public string? Logger { get; set; }
 
     /// <summary>
-    /// Gets or sets the data to be logged, such as a string message.
+    /// Gets or sets the data to be logged, such as a string message or an object.
     /// </summary>
+    /// <remarks>
+    /// Any JSON serializable type is allowed here. This property is required by the MCP specification.
+    /// </remarks>
     [JsonPropertyName("data")]
-    public JsonElement? Data { get; set; }
+    public required JsonElement Data { get; set; }
 }

src/ModelContextProtocol.Core/Protocol/Tool.cs

@@ -15,7 +15,7 @@ public sealed class Tool : IBaseMetadata
 {
     /// <inheritdoc />
     [JsonPropertyName("name")]
-    public string Name { get; set; } = string.Empty;
+    public required string Name { get; set; }
 
     /// <inheritdoc />
     [JsonPropertyName("title")]

tests/ModelContextProtocol.Tests/Client/McpClientTests.cs

@@ -539,11 +539,11 @@ public async Task AsClientLoggerProvider_MessagesSentToClient()
             {
                 var m = await channel.Reader.ReadAsync(TestContext.Current.CancellationToken);
                 Assert.NotNull(m);
-                Assert.NotNull(m.Data);
+                Assert.NotEqual(JsonValueKind.Undefined, m.Data.ValueKind);
 
                 Assert.Equal("TestLogger", m.Logger);
 
-                string? s = JsonSerializer.Deserialize<string>(m.Data.Value, McpJsonUtilities.DefaultOptions);
+                string? s = JsonSerializer.Deserialize<string>(m.Data, McpJsonUtilities.DefaultOptions);
                 Assert.NotNull(s);
 
                 if (s.Contains("Information"))

tests/ModelContextProtocol.Tests/Protocol/LoggingMessageNotificationParamsTests.cs

@@ -23,8 +23,8 @@ public static void LoggingMessageNotificationParams_SerializationRoundTrip_Prese
         Assert.NotNull(deserialized);
         Assert.Equal(LoggingLevel.Warning, deserialized.Level);
         Assert.Equal("MyApp.Services", deserialized.Logger);
-        Assert.NotNull(deserialized.Data);
-        Assert.Equal("Something went wrong", deserialized.Data.Value.GetString());
+        Assert.NotEqual(JsonValueKind.Undefined, deserialized.Data.ValueKind);
+        Assert.Equal("Something went wrong", deserialized.Data.GetString());
         Assert.NotNull(deserialized.Meta);
         Assert.Equal("value", (string)deserialized.Meta["key"]!);
     }
@@ -34,7 +34,8 @@ public static void LoggingMessageNotificationParams_SerializationRoundTrip_WithM
     {
         var original = new LoggingMessageNotificationParams
         {
-            Level = LoggingLevel.Error
+            Level = LoggingLevel.Error,
+            Data = JsonDocument.Parse("null").RootElement.Clone(),
         };
 
         string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
@@ -43,7 +44,7 @@ public static void LoggingMessageNotificationParams_SerializationRoundTrip_WithM
         Assert.NotNull(deserialized);
         Assert.Equal(LoggingLevel.Error, deserialized.Level);
         Assert.Null(deserialized.Logger);
-        Assert.Null(deserialized.Data);
+        Assert.Equal(JsonValueKind.Null, deserialized.Data.ValueKind);
         Assert.Null(deserialized.Meta);
     }
 }

tests/ModelContextProtocol.Tests/Protocol/ToolTests.cs

@@ -95,7 +95,7 @@ public static void Tool_HasCorrectJsonPropertyNames()
     [Fact]
     public static void ToolInputSchema_HasValidDefaultSchema()
     {
-        var tool = new Tool();
+        var tool = new Tool { Name = "test" };
         JsonElement jsonElement = tool.InputSchema;
 
         Assert.Equal(JsonValueKind.Object, jsonElement.ValueKind);
@@ -119,7 +119,7 @@ public static void ToolInputSchema_HasValidDefaultSchema()
     public static void ToolInputSchema_RejectsInvalidSchemaDocuments(string invalidSchema)
     {
         using var document = JsonDocument.Parse(invalidSchema);
-        var tool = new Tool();
+        var tool = new Tool { Name = "test" };
 
         Assert.Throws<ArgumentException>(() => tool.InputSchema = document.RootElement);
     }
@@ -133,6 +133,7 @@ public static void ToolInputSchema_AcceptsValidSchemaDocuments(string validSchem
         using var document = JsonDocument.Parse(validSchema);
         Tool tool = new()
         {
+            Name = "test",
             InputSchema = document.RootElement
         };