Prevent shutdown hang on unanswered elicitations in client sample

Disposing SessionClientRegistry waits for each session's in-flight
operation to complete. A tool call blocked in ElicitationBroker.RequestAsync
never completes until a frontend posts a response, so an unanswered
elicitation would stall application shutdown until the host's shutdown
timeout forced the process down.

- Add ElicitationBroker.CancelAll() to release every pending elicitation.
- Register an ApplicationStopping callback that cancels pending
  elicitations before the singleton registry is disposed.
- Collect progress notifications in a ConcurrentQueue, since they are
  reported from the MCP session's message loop while the request thread
  serializes the response.
- Document the disposal behavior and both cancellation paths in the README.
- Cover CancelAll() with a test across multiple sessions.

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

Author: jeffhandley

samples/AspNetCoreMcpClient/ElicitationBroker.cs

@@ -74,6 +74,26 @@ public void Cancel(string sessionId)
         }
     }
 
+    /// <summary>
+    /// Cancels every pending elicitation. Call this during application shutdown so that MCP operations blocked on an
+    /// unanswered elicitation unblock and the session registry can dispose its clients.
+    /// </summary>
+    public int CancelAll()
+    {
+        lock (_lock)
+        {
+            var pending = _pending.Values.ToArray();
+            _pending.Clear();
+
+            foreach (var request in pending)
+            {
+                request.Completion.TrySetCanceled();
+            }
+
+            return pending.Length;
+        }
+    }
+
     private sealed class PendingRequest(Guid id, ElicitRequestParams? request)
     {
         public Guid Id { get; } = id;

samples/AspNetCoreMcpClient/Program.cs

@@ -2,6 +2,7 @@
 using ModelContextProtocol;
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol;
+using System.Collections.Concurrent;
 using System.Text.Json;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -63,6 +64,18 @@
 
 var app = builder.Build();
 
+// Disposing the registry waits for each session's in-flight operation to finish. A tool call blocked on an unanswered
+// elicitation would never finish, so release those requests before shutdown disposes the singleton registry.
+app.Lifetime.ApplicationStopping.Register(() =>
+{
+    var broker = app.Services.GetRequiredService<ElicitationBroker>();
+    var canceled = broker.CancelAll();
+    if (canceled > 0)
+    {
+        app.Logger.LogInformation("Canceled {Count} pending elicitations during shutdown.", canceled);
+    }
+});
+
 app.MapGet("/tools", async (
     HttpContext context,
     SessionClientRegistry<McpClientConnection> registry,
@@ -89,8 +102,9 @@
         ? arguments.Value.Deserialize<Dictionary<string, object?>>()
         : null;
 
-    var progressUpdates = new List<ProgressNotificationValue>();
-    var progress = new InlineProgress<ProgressNotificationValue>(value => progressUpdates.Add(value));
+    // Progress notifications arrive on the MCP session's message loop, so use a thread-safe collection.
+    var progressUpdates = new ConcurrentQueue<ProgressNotificationValue>();
+    var progress = new InlineProgress<ProgressNotificationValue>(progressUpdates.Enqueue);
     var result = await registry.ExecuteAsync(
         sessionId,
         async (connection, token) => await connection.Client.CallToolAsync(

samples/AspNetCoreMcpClient/README.md

@@ -48,6 +48,8 @@ When the MCP server sends an elicitation request during a tool call, `Elicitatio
 
 The broker intentionally permits one pending elicitation per application session because the registry serializes that session's MCP operations.
 
+Because the registry waits for a session's in-flight operation before disposing its client, a tool call blocked on an unanswered elicitation would otherwise stall `DELETE /session` and application shutdown. `DELETE /session` cancels the session's pending elicitation first, and the sample registers an `ApplicationStopping` callback that cancels all pending elicitations before the registry is disposed.
+
 ## Production considerations
 
 - **Never trust a caller-provided session header.** Replace `X-Demo-User` with a key derived from authenticated, server-side identity or session state. Do not use access tokens or other secrets as dictionary keys.

tests/AspNetCoreMcpClient.Tests/ElicitationBrokerTests.cs

@@ -33,4 +33,20 @@ public async Task Cancellation_RemovesPendingRequest()
         await Assert.ThrowsAnyAsync<OperationCanceledException>(() => requestTask);
         Assert.Null(broker.GetPending("alice"));
     }
+
+    [Fact]
+    public async Task CancelAll_ReleasesEveryPendingRequest()
+    {
+        var broker = new ElicitationBroker();
+        var alice = broker.RequestAsync("alice", new() { Message = "Choose" }, TestContext.Current.CancellationToken).AsTask();
+        var bob = broker.RequestAsync("bob", new() { Message = "Choose" }, TestContext.Current.CancellationToken).AsTask();
+
+        Assert.Equal(2, broker.CancelAll());
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => alice);
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => bob);
+        Assert.Null(broker.GetPending("alice"));
+        Assert.Null(broker.GetPending("bob"));
+        Assert.Equal(0, broker.CancelAll());
+    }
 }