Add session DELETE mid-MRTR tests and fix disposal cleanup

- Add SessionDelete_CancelsPendingMrtrContinuation test verifying:
  - MRTR continuation is cancelled on session DELETE
  - Debug-level log emitted for cancelled continuations
  - No Error-level log noise from handler cancellation
- Add SessionDelete_RetryAfterDelete_ReturnsSessionNotFound test
  verifying retry with stale requestState returns 404
- Add MrtrContinuationsCancelled debug log in DisposeAsync
- Skip ToolCallError log for OperationCanceledException during
  disposal (not a tool bug, just session teardown)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: halter73

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -206,14 +206,21 @@ public override async ValueTask DisposeAsync()
         _disposed = true;
 
         // Cancel all suspended MRTR handlers by faulting their pending exchanges.
+        int cancelledCount = 0;
         foreach (var kvp in _mrtrContinuations)
         {
             if (_mrtrContinuations.TryRemove(kvp.Key, out var continuation))
             {
                 continuation.PendingExchange.ResponseTcs.TrySetCanceled();
+                cancelledCount++;
             }
         }
 
+        if (cancelledCount > 0)
+        {
+            MrtrContinuationsCancelled(cancelledCount);
+        }
+
         _taskCancellationTokenProvider?.Dispose();
         _disposables.ForEach(d => d());
         await _sessionHandler.DisposeAsync().ConfigureAwait(false);
@@ -775,7 +782,12 @@ await originalListToolsHandler(request, cancellationToken).ConfigureAwait(false)
                 }
                 catch (Exception e)
                 {
-                    ToolCallError(request.Params?.Name ?? string.Empty, e);
+                    // Skip logging for OperationCanceledException during server disposal —
+                    // MRTR handler cancellation during session teardown is expected, not an error.
+                    if (!(e is OperationCanceledException && _disposed))
+                    {
+                        ToolCallError(request.Params?.Name ?? string.Empty, e);
+                    }
 
                     if ((e is OperationCanceledException && cancellationToken.IsCancellationRequested) || e is McpProtocolException || e is IncompleteResultException)
                     {
@@ -1142,6 +1154,9 @@ internal static LoggingLevel ToLoggingLevel(LogLevel level) =>
     [LoggerMessage(Level = LogLevel.Information, Message = "ReadResource \"{ResourceUri}\" completed.")]
     private partial void ReadResourceCompleted(string resourceUri);
 
+    [LoggerMessage(Level = LogLevel.Debug, Message = "Cancelled {Count} pending MRTR continuation(s) during session disposal.")]
+    private partial void MrtrContinuationsCancelled(int count);
+
     /// <summary>
     /// Checks whether the negotiated protocol version enables MRTR.
     /// </summary>

tests/ModelContextProtocol.AspNetCore.Tests/MrtrProtocolTests.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using ModelContextProtocol.AspNetCore.Tests.Utils;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
@@ -829,6 +830,84 @@ public async Task LowLevel_ToolFallsBackGracefully_WithoutMrtr()
         Assert.Equal("lowlevel-unsupported:MRTR is not available", text);
     }
 
+    [Fact]
+    public async Task SessionDelete_CancelsPendingMrtrContinuation()
+    {
+        await StartAsync();
+        await InitializeWithMrtrAsync();
+
+        // 1. Call a tool that suspends at ElicitAsync (high-level MRTR path).
+        var response = await PostJsonRpcAsync(CallTool("elicit-tool", """{"message":"Please confirm"}"""));
+        var rpcResponse = await AssertSingleSseResponseAsync(response);
+
+        // Verify we got an IncompleteResult (handler is now suspended, continuation stored).
+        var resultObj = Assert.IsType<JsonObject>(rpcResponse.Result);
+        Assert.Equal("incomplete", resultObj["result_type"]?.GetValue<string>());
+        var requestState = resultObj["requestState"]!.GetValue<string>();
+        Assert.False(string.IsNullOrEmpty(requestState));
+
+        // 2. DELETE the session while the handler is suspended.
+        using var deleteResponse = await HttpClient.DeleteAsync("", TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, deleteResponse.StatusCode);
+
+        // Allow a moment for the async cancellation to propagate through the handler task.
+        await Task.Delay(100, TestContext.Current.CancellationToken);
+
+        // 3. Verify that the MRTR cancellation was logged at Debug level.
+        var mrtrCancelledLog = MockLoggerProvider.LogMessages
+            .Where(m => m.Message.Contains("pending MRTR continuation"))
+            .ToList();
+        Assert.Single(mrtrCancelledLog);
+        Assert.Equal(LogLevel.Debug, mrtrCancelledLog[0].LogLevel);
+        Assert.Contains("1", mrtrCancelledLog[0].Message);
+
+        // 4. Verify no error-level log was emitted for the cancellation.
+        // The handler's OperationCanceledException should be silently observed, not logged as an error.
+        var errorLogs = MockLoggerProvider.LogMessages
+            .Where(m => m.LogLevel >= LogLevel.Error && m.Message.Contains("elicit"))
+            .ToList();
+        Assert.Empty(errorLogs);
+    }
+
+    [Fact]
+    public async Task SessionDelete_RetryAfterDelete_ReturnsSessionNotFound()
+    {
+        await StartAsync();
+        await InitializeWithMrtrAsync();
+
+        // 1. Call a tool that suspends at ElicitAsync.
+        var response = await PostJsonRpcAsync(CallTool("elicit-tool", """{"message":"Please confirm"}"""));
+        var rpcResponse = await AssertSingleSseResponseAsync(response);
+
+        var resultObj = Assert.IsType<JsonObject>(rpcResponse.Result);
+        var requestState = resultObj["requestState"]!.GetValue<string>();
+        var inputRequests = resultObj["inputRequests"]!.AsObject();
+        var inputKey = inputRequests.First().Key;
+
+        // 2. DELETE the session.
+        using var deleteResponse = await HttpClient.DeleteAsync("", TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, deleteResponse.StatusCode);
+
+        // 3. Attempt to retry with the old requestState — session is gone.
+        var inputResponse = InputResponse.FromElicitResult(new ElicitResult { Action = "accept" });
+        var retryParams = new JsonObject
+        {
+            ["name"] = "elicit-tool",
+            ["arguments"] = new JsonObject { ["message"] = "Please confirm" },
+            ["requestState"] = requestState,
+            ["inputResponses"] = new JsonObject
+            {
+                [inputKey] = JsonSerializer.SerializeToNode(inputResponse, McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(InputResponse)))
+            },
+        };
+
+        using var retryResponse = await PostJsonRpcAsync(Request("tools/call", retryParams.ToJsonString()));
+
+        // The session was deleted, so we should get a 404 with a JSON-RPC error.
+        Assert.Equal(HttpStatusCode.NotFound, retryResponse.StatusCode);
+        Assert.Equal("application/json", retryResponse.Content.Headers.ContentType?.MediaType);
+    }
+
     // --- Helpers ---
 
     private static StringContent JsonContent(string json) => new(json, Encoding.UTF8, "application/json");