Fix sse-retry hang: add timeout to background SSE task await during disposal

Revert the previous incorrect fix in McpSessionHandler.SendRequestAsync that
targeted a race condition between background/foreground GET streams. That race
doesn't actually occur because the conformance test server only sends the tool
response when a NEW GET request arrives in handleGetSSEStream, not through
previously-established background streams.

The actual hang occurs in StreamableHttpClientSessionTransport.DisposeAsync()
and SseClientSessionTransport.CloseAsync(), which await the background SSE
receive task with no timeout. If cancellation doesn't promptly interrupt the
SSE stream read (a platform-dependent behavior, especially on Windows), the
await hangs indefinitely, preventing the client process from exiting and
triggering the 5-minute conformance test timeout.

Fix by using WaitAsync(TimeSpan.FromSeconds(10)) so disposal completes even
if the background task doesn't respond to cancellation promptly.

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

Author: Copilot

src/ModelContextProtocol.Core/Client/SseClientSessionTransport.cs

@@ -114,7 +114,9 @@ private async Task CloseAsync()
             {
                 if (_receiveTask != null)
                 {
-                    await _receiveTask.ConfigureAwait(false);
+                    // Use a timeout to prevent hanging if cancellation doesn't
+                    // promptly interrupt the SSE stream read.
+                    await _receiveTask.WaitAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
                 }
             }
             finally

src/ModelContextProtocol.Core/Client/StreamableHttpClientSessionTransport.cs

@@ -174,7 +174,11 @@ public override async ValueTask DisposeAsync()
 
                 if (_getReceiveTask != null)
                 {
-                    await _getReceiveTask.ConfigureAwait(false);
+                    // Use a timeout to prevent hanging if cancellation doesn't
+                    // promptly interrupt the background SSE stream read. This can
+                    // occur on some platforms where Stream.ReadAsync doesn't always
+                    // respect the cancellation token immediately.
+                    await _getReceiveTask.WaitAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
                 }
             }
             catch (OperationCanceledException)

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -528,31 +528,7 @@ public async Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest request, Canc
                 LogSendingRequest(EndpointName, request.Method);
             }
 
-            // Create a linked CTS that cancels when the response arrives through any channel.
-            // This prevents transport retry loops from running indefinitely when a concurrent
-            // receive stream (e.g., Streamable HTTP's background GET SSE) already delivered the
-            // response to the session via the shared message channel.
-            using var sendCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-            _ = tcs.Task.ContinueWith(
-                static (_, state) =>
-                {
-                    try { ((CancellationTokenSource)state!).Cancel(); }
-                    catch (ObjectDisposedException) { }
-                },
-                sendCts,
-                CancellationToken.None,
-                TaskContinuationOptions.ExecuteSynchronously,
-                TaskScheduler.Default);
-
-            try
-            {
-                await SendToRelatedTransportAsync(request, sendCts.Token).ConfigureAwait(false);
-            }
-            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
-            {
-                // The send was canceled because the response arrived through another channel
-                // (e.g., a background GET SSE stream in the Streamable HTTP transport).
-            }
+            await SendToRelatedTransportAsync(request, cancellationToken).ConfigureAwait(false);
 
             // Now that the request has been sent, register for cancellation. If we registered before,
             // a cancellation request could arrive before the server knew about that request ID, in which