Suppress ExecutionContext flow in BeginErrorReadLine

Process.BeginErrorReadLine() captures the caller's ExecutionContext,
causing AsyncLocal values to leak to the background stderr reader
thread. This is undesirable—the stderr handler is a long-lived
background I/O callback that shouldn't inherit ambient state from
whichever call site happened to create the transport.

Wrap BeginErrorReadLine() in ExecutionContext.SuppressFlow() so the
stderr reader gets a clean context.

Add a test that sets an AsyncLocal before creating the transport and
verifies the stderr callback does NOT see the value.

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

Author: ericstj

src/ModelContextProtocol.Core/Client/StdioClientTransport.cs

@@ -191,7 +191,13 @@ public async Task<ITransport> ConnectAsync(CancellationToken cancellationToken =
 
             LogTransportProcessStarted(logger, endpointName, process.Id);
 
-            process.BeginErrorReadLine();
+            // Suppress ExecutionContext flow so the Process's internal async
+            // stderr reader thread doesn't capture the caller's ambient context
+            // (e.g. AsyncLocal values from test infrastructure or HTTP request state).
+            using (ExecutionContext.SuppressFlow())
+            {
+                process.BeginErrorReadLine();
+            }
 
             return new StdioClientSessionTransport(_options, process, endpointName, stderrRollingLog, _loggerFactory);
         }

tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs

@@ -5,6 +5,7 @@
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.Json;
+using System.Threading;
 
 namespace ModelContextProtocol.Tests.Transport;
 
@@ -59,6 +60,47 @@ public async Task CreateAsync_ValidProcessInvalidServer_StdErrCallbackInvoked()
         Assert.Contains(id, sb.ToString());
     }
 
+    [Fact(Skip = "Platform not supported by this test.", SkipUnless = nameof(IsStdErrCallbackSupported))]
+    public async Task CreateAsync_StdErrCallback_DoesNotCaptureCallerAsyncLocal()
+    {
+        var asyncLocal = new AsyncLocal<string>();
+        asyncLocal.Value = "caller-context";
+
+        string? capturedValue = "not-set";
+        var received = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        StdioClientTransport transport = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
+            new(new()
+            {
+                Command = "cmd",
+                Arguments = ["/c", "echo test >&2 & exit /b 1"],
+                StandardErrorLines = _ =>
+                {
+                    capturedValue = asyncLocal.Value;
+                    received.TrySetResult(true);
+                }
+            }, LoggerFactory) :
+            new(new()
+            {
+                Command = "sh",
+                Arguments = ["-c", "echo test >&2; exit 1"],
+                StandardErrorLines = _ =>
+                {
+                    capturedValue = asyncLocal.Value;
+                    received.TrySetResult(true);
+                }
+            }, LoggerFactory);
+
+        await Assert.ThrowsAnyAsync<IOException>(() => McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken));
+
+        // Wait for the stderr callback to fire.
+        await received.Task.WaitAsync(TestContext.Current.CancellationToken);
+
+        // The callback should NOT see the caller's AsyncLocal value because
+        // ExecutionContext flow is suppressed for the stderr reader thread.
+        Assert.Null(capturedValue);
+    }
+
     [Theory]
     [InlineData(null)]
     [InlineData("argument with spaces")]