Fixed tests

Author: Tyler-R-Kendrick

src/ModelContextProtocol/Shared/McpSession.cs

@@ -304,9 +304,8 @@ private void RegisterCancellation(CancellationToken cancellationToken, RequestId
             Params = JsonSerializer.SerializeToNode(new CancelledNotification
             {
                 RequestId = requestId,
-                Reason = "Request cancelled"
             }, McpJsonUtilities.JsonContext.Default.CancelledNotification)
-        }, cancellationToken));
+        }));
     }
 
     public IAsyncDisposable RegisterNotificationHandler(string method, Func<JsonRpcNotification, CancellationToken, Task> handler)

tests/ModelContextProtocol.Tests/Server/McpServerTests.cs

@@ -694,23 +694,14 @@ public async Task NotifyCancel_Should_Be_Handled()
     {
         // Arrange
         TaskCompletionSource<JsonRpcNotification> notificationReceived = new();
-        TaskCompletionSource notificationIntercepted = new();
         await using TestServerTransport transport = new(LoggerFactory);
         transport.OnMessageSent = (message) =>
         {
             if (message is JsonRpcNotification notification
                 && notification.Method == NotificationMethods.CancelledNotification)
                 notificationReceived.TrySetResult(notification);
         };
-        var options = CreateOptions(new()
-        {
-            NotificationHandlers = [new(NotificationMethods.CancelledNotification, (notification, cancellationToken) =>
-            {
-                InvalidOperationException exception = new("The sender of a notification shouldn't handle the notification.");
-                notificationIntercepted.TrySetException(exception);
-                return notificationIntercepted.Task;
-            })],
-        });
+        var options = CreateOptions();
         await using var server = McpServerFactory.Create(transport, options, LoggerFactory);
 
         // Act
@@ -732,10 +723,46 @@ await server.SendNotificationAsync(
         Assert.NotNull(cancelled);
         Assert.Equal("abc", cancelled.RequestId.ToString());
         Assert.Equal("Cancelled", cancelled.Reason);
+    }
 
-        Assert.Throws<TimeoutException>(() => notificationIntercepted.Task
-            .Wait(TimeSpan.FromSeconds(5), token));
-        Assert.False(notificationIntercepted.Task.IsCompleted,
-            "Notifications should not be intercepted by the sender of the notification.");
+    [Fact]
+    public async Task SendRequest_Should_Notify_When_Cancelled()
+    {
+        // Arrange
+        TaskCompletionSource<JsonRpcNotification> notificationReceived = new();
+        await using TestServerTransport transport = new(LoggerFactory);
+        transport.OnMessageSent = (message) =>
+        {
+            if (message is JsonRpcNotification notification
+                && notification.Method == NotificationMethods.CancelledNotification)
+                notificationReceived.TrySetResult(notification);
+        };
+        var options = CreateOptions();
+        await using var server = McpServerFactory.Create(transport, options, LoggerFactory);
+
+        // Act
+        var token = TestContext.Current.CancellationToken;
+        Task serverTask = server.RunAsync(token);
+        using CancellationTokenSource cts = new();
+        await cts.CancelAsync();
+
+        await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+        {
+            await server.SendRequestAsync(new JsonRpcRequest
+            {
+                Method = RequestMethods.Ping,
+                Id = new("abc"),
+            }, cts.Token);
+        });
+        
+        await server.DisposeAsync();
+        await serverTask.WaitAsync(TimeSpan.FromSeconds(1), token);
+        var notification = await notificationReceived.Task.WaitAsync(TimeSpan.FromSeconds(1), token);
+
+        // Assert
+        var cancelled = JsonSerializer.Deserialize<CancelledNotification>(notification.Params);
+        Assert.NotNull(cancelled);
+        Assert.Equal("abc", cancelled.RequestId.ToString());
+        Assert.Null(cancelled.Reason);
     }
 }