Suppress ExecutionContext flow in BeginErrorReadLine

src/ModelContextProtocol.Core/Client/StdioClientTransport.cs

@@ -203,7 +203,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, errorHandler, _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;
 
@@ -60,6 +61,46 @@
     }
 
     [Fact(Skip = "Platform not supported by this test.", SkipUnless = nameof(IsStdErrCallbackSupported))]
+<<<<<<< suppress-ec-flow-stderr
+    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);
+=======
     public async Task CreateAsync_StdErrCallbackThrows_DoesNotCrashProcess()
     {
         StdioClientTransport transport = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
@@ -68,6 +109,7 @@
 
         // Should throw IOException for the failed server, not crash the host process.
         await Assert.ThrowsAnyAsync<IOException>(() => McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken));
+>>>>>>> main
     }
 
     [Theory]