Merge branch 'main' into localden/experimental

localden · web-flow · commit 0c10b093f620 · 2025-06-18T14:17:33.000-07:00
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <LangVersion>13</LangVersion>
+    <LangVersion>preview</LangVersion>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
diff --git a/src/Common/Polyfills/System/Runtime/CompilerServices/DefaultInterpolatedStringHandler.cs b/src/Common/Polyfills/System/Runtime/CompilerServices/DefaultInterpolatedStringHandler.cs
@@ -12,7 +12,7 @@
 namespace System.Runtime.CompilerServices
 {
     /// <summary>Provides a handler used by the language compiler to process interpolated strings into <see cref="string"/> instances.</summary>
-    public ref struct DefaultInterpolatedStringHandler
+    internal ref struct DefaultInterpolatedStringHandler
     {
         // Implementation note:
         // As this type lives in CompilerServices and is only intended to be targeted by the compiler,
diff --git a/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs b/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs
@@ -28,7 +28,7 @@ public class HttpServerTransportOptions
     /// </summary>
     /// <remarks>
     /// If <see langword="true"/>, the "/sse" endpoint will be disabled, and client information will be round-tripped as part
-    /// of the "mcp-session-id" header instead of stored in memory. Unsolicited server-to-client messages and all server-to-client
+    /// of the "MCP-Session-Id" header instead of stored in memory. Unsolicited server-to-client messages and all server-to-client
     /// requests are also unsupported, because any responses may arrive at another ASP.NET Core application process.
     /// Client sampling and roots capabilities are also disabled in stateless mode, because the server cannot make requests.
     /// Defaults to <see langword="false"/>.
diff --git a/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs b/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs
@@ -26,6 +26,7 @@ internal sealed class StreamableHttpHandler(
     ILoggerFactory loggerFactory,
     IServiceProvider applicationServices)
 {
+    private const string McpSessionIdHeaderName = "Mcp-Session-Id";
     private static readonly JsonTypeInfo<JsonRpcError> s_errorTypeInfo = GetRequiredJsonTypeInfo<JsonRpcError>();
 
     public ConcurrentDictionary<string, HttpMcpSession<StreamableHttpServerTransport>> Sessions { get; } = new(StringComparer.Ordinal);
@@ -70,8 +71,8 @@ await WriteJsonRpcErrorAsync(context,
         }
         finally
         {
-            // Stateless sessions are 1:1 with HTTP requests and are outlived by the MCP session tracked by the mcp-session-id.
-            // Non-stateless sessions are 1:1 with the mcp-session-id and outlive the POST request.
+            // Stateless sessions are 1:1 with HTTP requests and are outlived by the MCP session tracked by the Mcp-Session-Id.
+            // Non-stateless sessions are 1:1 with the Mcp-Session-Id and outlive the POST request.
             // Non-stateless sessions get disposed by a DELETE request or the IdleTrackingBackgroundService.
             if (HttpServerTransportOptions.Stateless)
             {
@@ -90,7 +91,7 @@ await WriteJsonRpcErrorAsync(context,
             return;
         }
 
-        var sessionId = context.Request.Headers["mcp-session-id"].ToString();
+        var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();
         var session = await GetSessionAsync(context, sessionId);
         if (session is null)
         {
@@ -117,7 +118,7 @@ await WriteJsonRpcErrorAsync(context,
 
     public async Task HandleDeleteRequestAsync(HttpContext context)
     {
-        var sessionId = context.Request.Headers["mcp-session-id"].ToString();
+        var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();
         if (Sessions.TryRemove(sessionId, out var session))
         {
             await session.DisposeAsync();
@@ -157,14 +158,14 @@ await WriteJsonRpcErrorAsync(context,
             return null;
         }
 
-        context.Response.Headers["mcp-session-id"] = session.Id;
+        context.Response.Headers[McpSessionIdHeaderName] = session.Id;
         context.Features.Set(session.Server);
         return session;
     }
 
     private async ValueTask<HttpMcpSession<StreamableHttpServerTransport>?> GetOrCreateSessionAsync(HttpContext context)
     {
-        var sessionId = context.Request.Headers["mcp-session-id"].ToString();
+        var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();
 
         if (string.IsNullOrEmpty(sessionId))
         {
@@ -188,11 +189,11 @@ private async ValueTask<HttpMcpSession<StreamableHttpServerTransport>> StartNewS
             {
                 SessionId = sessionId,
             };
-            context.Response.Headers["mcp-session-id"] = sessionId;
+            context.Response.Headers[McpSessionIdHeaderName] = sessionId;
         }
         else
         {
-            // "(uninitialized stateless id)" is not written anywhere. We delay writing the mcp-session-id
+            // "(uninitialized stateless id)" is not written anywhere. We delay writing the MCP-Session-Id
             // until after we receive the initialize request with the client info we need to serialize.
             sessionId = "(uninitialized stateless id)";
             transport = new()
@@ -204,7 +205,7 @@ private async ValueTask<HttpMcpSession<StreamableHttpServerTransport>> StartNewS
 
         var session = await CreateSessionAsync(context, transport, sessionId);
 
-        // The HttpMcpSession is not stored between requests in stateless mode. Instead, the session is recreated from the mcp-session-id.
+        // The HttpMcpSession is not stored between requests in stateless mode. Instead, the session is recreated from the MCP-Session-Id.
         if (!HttpServerTransportOptions.Stateless)
         {
             if (!Sessions.TryAdd(sessionId, session))
@@ -299,7 +300,7 @@ private void ScheduleStatelessSessionIdWrite(HttpContext context, StreamableHttp
 
             var sessionJson = JsonSerializer.Serialize(statelessId, StatelessSessionIdJsonContext.Default.StatelessSessionId);
             transport.SessionId = Protector.Protect(sessionJson);
-            context.Response.Headers["mcp-session-id"] = transport.SessionId;
+            context.Response.Headers[McpSessionIdHeaderName] = transport.SessionId;
             return ValueTask.CompletedTask;
         };
     }
diff --git a/src/ModelContextProtocol.Core/Client/StdioClientTransport.cs b/src/ModelContextProtocol.Core/Client/StdioClientTransport.cs
@@ -146,6 +146,8 @@ public async Task<ITransport> ConnectAsync(CancellationToken cancellationToken =
                         stderrRollingLog.Enqueue(data);
                     }
 
+                    _options.StandardErrorLines?.Invoke(data);
+
                     LogReadStderr(logger, endpointName, data);
                 }
             };
diff --git a/src/ModelContextProtocol.Core/Client/StdioClientTransportOptions.cs b/src/ModelContextProtocol.Core/Client/StdioClientTransportOptions.cs
@@ -69,4 +69,9 @@ public required string Command
     /// </para>
     /// </remarks>
     public TimeSpan ShutdownTimeout { get; set; } = TimeSpan.FromSeconds(5);
+
+    /// <summary>
+    /// Gets or sets a callback that is invoked for each line of stderr received from the server process.
+    /// </summary>
+    public Action<string>? StandardErrorLines { get; set; }
 }
diff --git a/src/ModelContextProtocol.Core/Client/StreamableHttpClientSessionTransport.cs b/src/ModelContextProtocol.Core/Client/StreamableHttpClientSessionTransport.cs
@@ -27,6 +27,7 @@ internal sealed partial class StreamableHttpClientSessionTransport : TransportBa
     private readonly CancellationTokenSource _connectionCts;
     private readonly ILogger _logger;
 
+    private string? _negotiatedProtocolVersion;
     private Task? _getReceiveTask;
     private int _disposed;
 
@@ -85,7 +86,7 @@ internal async Task<HttpResponseMessage> SendHttpRequestAsync(JsonRpcMessage mes
             },
         };
 
-        CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders, SessionId);
+        CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders, SessionId, _negotiatedProtocolVersion);
 
         var response = await _httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
 
@@ -119,14 +120,17 @@ internal async Task<HttpResponseMessage> SendHttpRequestAsync(JsonRpcMessage mes
             throw new McpException($"Streamable HTTP POST response completed without a reply to request with ID: {rpcRequest.Id}");
         }
 
-        if (rpcRequest.Method == RequestMethods.Initialize && rpcResponseOrError is JsonRpcResponse)
+        if (rpcRequest.Method == RequestMethods.Initialize && rpcResponseOrError is JsonRpcResponse initResponse)
         {
-            // We've successfully initialized! Copy session-id and start GET request if any.
-            if (response.Headers.TryGetValues("mcp-session-id", out var sessionIdValues))
+            // We've successfully initialized! Copy session-id and protocol version, then start GET request if any.
+            if (response.Headers.TryGetValues("Mcp-Session-Id", out var sessionIdValues))
             {
                 SessionId = sessionIdValues.FirstOrDefault();
             }
 
+            var initializeResult = JsonSerializer.Deserialize(initResponse.Result, McpJsonUtilities.JsonContext.Default.InitializeResult);
+            _negotiatedProtocolVersion = initializeResult?.ProtocolVersion;
+
             _getReceiveTask = ReceiveUnsolicitedMessagesAsync();
         }
 
@@ -175,7 +179,7 @@ private async Task ReceiveUnsolicitedMessagesAsync()
         // Send a GET request to handle any unsolicited messages not sent over a POST response.
         using var request = new HttpRequestMessage(HttpMethod.Get, _options.Endpoint);
         request.Headers.Accept.Add(s_textEventStreamMediaType);
-        CopyAdditionalHeaders(request.Headers, _options.AdditionalHeaders, SessionId);
+        CopyAdditionalHeaders(request.Headers, _options.AdditionalHeaders, SessionId, _negotiatedProtocolVersion);
 
         using var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, _connectionCts.Token).ConfigureAwait(false);
 
@@ -250,11 +254,20 @@ private void LogJsonException(JsonException ex, string data)
         }
     }
 
-    internal static void CopyAdditionalHeaders(HttpRequestHeaders headers, IDictionary<string, string>? additionalHeaders, string? sessionId = null)
+    internal static void CopyAdditionalHeaders(
+        HttpRequestHeaders headers,
+        IDictionary<string, string>? additionalHeaders,
+        string? sessionId = null,
+        string? protocolVersion = null)
     {
         if (sessionId is not null)
         {
-            headers.Add("mcp-session-id", sessionId);
+            headers.Add("Mcp-Session-Id", sessionId);
+        }
+
+        if (protocolVersion is not null)
+        {
+            headers.Add("MCP-Protocol-Version", protocolVersion);
         }
 
         if (additionalHeaders is null)
diff --git a/src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj b/src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj
@@ -7,7 +7,6 @@
     <PackageId>ModelContextProtocol.Core</PackageId>
     <Description>Core .NET SDK for the Model Context Protocol (MCP)</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
-    <LangVersion>preview</LangVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
diff --git a/src/ModelContextProtocol/ModelContextProtocol.csproj b/src/ModelContextProtocol/ModelContextProtocol.csproj
@@ -7,7 +7,6 @@
     <PackageId>ModelContextProtocol</PackageId>
     <Description>.NET SDK for the Model Context Protocol (MCP) with hosting and dependency injection extensions.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
-    <LangVersion>preview</LangVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStreamableHttpTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStreamableHttpTests.cs
@@ -1,5 +1,6 @@
 ﻿using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Primitives;
 using ModelContextProtocol.Client;
 
 namespace ModelContextProtocol.AspNetCore.Tests;
@@ -143,4 +144,38 @@ public async Task SseMode_Works_WithSseEndpoint()
 
         Assert.Equal("SseTestServer", mcpClient.ServerInfo.Name);
     }
+
+    [Fact]
+    public async Task StreamableHttpClient_SendsMcpProtocolVersionHeader_AfterInitialization()
+    {
+        var protocolVersionHeaderValues = new List<string?>();
+
+        Builder.Services.AddMcpServer().WithHttpTransport(ConfigureStateless).WithTools<EchoHttpContextUserTools>();
+
+        await using var app = Builder.Build();
+
+        app.Use(next =>
+        {
+            return async context =>
+            {
+                if (!StringValues.IsNullOrEmpty(context.Request.Headers["mcp-session-id"]))
+                {
+                    protocolVersionHeaderValues.Add(context.Request.Headers["mcp-protocol-version"]);
+                }
+
+                await next(context);
+            };
+        });
+
+        app.MapMcp();
+
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        await using var mcpClient = await ConnectAsync();
+        await mcpClient.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        // The header should be included in the GET request, the initialized notification, and the tools/list call.
+        Assert.Equal(3, protocolVersionHeaderValues.Count);
+        Assert.All(protocolVersionHeaderValues, v => Assert.Equal("2025-03-26", v));
+    }
 }
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs
@@ -195,7 +195,7 @@ private ClaimsPrincipal CreateUser(string name)
             "TestAuthType", "name", "role"));
 
     [McpServerToolType]
-    private class EchoHttpContextUserTools(IHttpContextAccessor contextAccessor)
+    protected class EchoHttpContextUserTools(IHttpContextAccessor contextAccessor)
     {
         [McpServerTool, Description("Echoes the input back to the client with their user name.")]
         public string EchoWithUserName(string message)
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj b/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj
@@ -4,7 +4,6 @@
     <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <LangVersion>Latest</LangVersion>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
     <RootNamespace>ModelContextProtocol.AspNetCore.Tests</RootNamespace>
diff --git a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
@@ -5,7 +5,6 @@
     <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <LangVersion>Latest</LangVersion>
 
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
diff --git a/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs b/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs
@@ -1,6 +1,7 @@
 ﻿using ModelContextProtocol.Client;
 using ModelContextProtocol.Tests.Utils;
 using System.Runtime.InteropServices;
+using System.Text;
 
 namespace ModelContextProtocol.Tests.Transport;
 
@@ -18,4 +19,31 @@ public async Task CreateAsync_ValidProcessInvalidServer_Throws()
         IOException e = await Assert.ThrowsAsync<IOException>(() => McpClientFactory.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken));
         Assert.Contains(id, e.ToString());
     }
+
+    [Fact]
+    public async Task CreateAsync_ValidProcessInvalidServer_StdErrCallbackInvoked()
+    {
+        string id = Guid.NewGuid().ToString("N");
+
+        int count = 0;
+        StringBuilder sb = new();
+        Action<string> stdErrCallback = line =>
+        {
+            Assert.NotNull(line);
+            lock (sb)
+            {
+                sb.AppendLine(line);
+                count++;
+            }
+        };
+
+        StdioClientTransport transport = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
+            new(new() { Command = "cmd", Arguments = ["/C", $"echo \"{id}\" >&2"], StandardErrorLines = stdErrCallback }, LoggerFactory) :
+            new(new() { Command = "ls", Arguments = [id], StandardErrorLines = stdErrCallback }, LoggerFactory);
+
+        await Assert.ThrowsAsync<IOException>(() => McpClientFactory.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken));
+
+        Assert.InRange(count, 1, int.MaxValue);
+        Assert.Contains(id, sb.ToString());
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	`namespace System.Runtime.CompilerServices`
`13`	`13`	`{`
`14`	`14`	`/// <summary>Provides a handler used by the language compiler to process interpolated strings into <see cref="string"/> instances.</summary>`
`15`		`- public ref struct DefaultInterpolatedStringHandler`
	`15`	`+ internal ref struct DefaultInterpolatedStringHandler`
`16`	`16`	`{`
`17`	`17`	`// Implementation note:`
`18`	`18`	`// As this type lives in CompilerServices and is only intended to be targeted by the compiler,`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ internal sealed class StreamableHttpHandler(`
`26`	`26`	`ILoggerFactory loggerFactory,`
`27`	`27`	`IServiceProvider applicationServices)`
`28`	`28`	`{`
	`29`	`+ private const string McpSessionIdHeaderName = "Mcp-Session-Id";`
`29`	`30`	`private static readonly JsonTypeInfo<JsonRpcError> s_errorTypeInfo = GetRequiredJsonTypeInfo<JsonRpcError>();`
`30`	`31`
`31`	`32`	`public ConcurrentDictionary<string, HttpMcpSession<StreamableHttpServerTransport>> Sessions { get; } = new(StringComparer.Ordinal);`
`@@ -70,8 +71,8 @@ await WriteJsonRpcErrorAsync(context,`
`70`	`71`	`}`
`71`	`72`	`finally`
`72`	`73`	`{`
`73`		`- // Stateless sessions are 1:1 with HTTP requests and are outlived by the MCP session tracked by the mcp-session-id.`
`74`		`- // Non-stateless sessions are 1:1 with the mcp-session-id and outlive the POST request.`
	`74`	`+ // Stateless sessions are 1:1 with HTTP requests and are outlived by the MCP session tracked by the Mcp-Session-Id.`
	`75`	`+ // Non-stateless sessions are 1:1 with the Mcp-Session-Id and outlive the POST request.`
`75`	`76`	`// Non-stateless sessions get disposed by a DELETE request or the IdleTrackingBackgroundService.`
`76`	`77`	`if (HttpServerTransportOptions.Stateless)`
`77`	`78`	`{`
`@@ -90,7 +91,7 @@ await WriteJsonRpcErrorAsync(context,`
`90`	`91`	`return;`
`91`	`92`	`}`
`92`	`93`
`93`		`- var sessionId = context.Request.Headers["mcp-session-id"].ToString();`
	`94`	`+ var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();`
`94`	`95`	`var session = await GetSessionAsync(context, sessionId);`
`95`	`96`	`if (session is null)`
`96`	`97`	`{`
`@@ -117,7 +118,7 @@ await WriteJsonRpcErrorAsync(context,`
`117`	`118`
`118`	`119`	`public async Task HandleDeleteRequestAsync(HttpContext context)`
`119`	`120`	`{`
`120`		`- var sessionId = context.Request.Headers["mcp-session-id"].ToString();`
	`121`	`+ var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();`
`121`	`122`	`if (Sessions.TryRemove(sessionId, out var session))`
`122`	`123`	`{`
`123`	`124`	`await session.DisposeAsync();`
`@@ -157,14 +158,14 @@ await WriteJsonRpcErrorAsync(context,`
`157`	`158`	`return null;`
`158`	`159`	`}`
`159`	`160`
`160`		`- context.Response.Headers["mcp-session-id"] = session.Id;`
	`161`	`+ context.Response.Headers[McpSessionIdHeaderName] = session.Id;`
`161`	`162`	`context.Features.Set(session.Server);`
`162`	`163`	`return session;`
`163`	`164`	`}`
`164`	`165`
`165`	`166`	`private async ValueTask<HttpMcpSession<StreamableHttpServerTransport>?> GetOrCreateSessionAsync(HttpContext context)`
`166`	`167`	`{`
`167`		`- var sessionId = context.Request.Headers["mcp-session-id"].ToString();`
	`168`	`+ var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();`
`168`	`169`
`169`	`170`	`if (string.IsNullOrEmpty(sessionId))`
`170`	`171`	`{`
`@@ -188,11 +189,11 @@ private async ValueTask<HttpMcpSession<StreamableHttpServerTransport>> StartNewS`
`188`	`189`	`{`
`189`	`190`	`SessionId = sessionId,`
`190`	`191`	`};`
`191`		`- context.Response.Headers["mcp-session-id"] = sessionId;`
	`192`	`+ context.Response.Headers[McpSessionIdHeaderName] = sessionId;`
`192`	`193`	`}`
`193`	`194`	`else`
`194`	`195`	`{`
`195`		`- // "(uninitialized stateless id)" is not written anywhere. We delay writing the mcp-session-id`
	`196`	`+ // "(uninitialized stateless id)" is not written anywhere. We delay writing the MCP-Session-Id`
`196`	`197`	`// until after we receive the initialize request with the client info we need to serialize.`
`197`	`198`	`sessionId = "(uninitialized stateless id)";`
`198`	`199`	`transport = new()`
`@@ -204,7 +205,7 @@ private async ValueTask<HttpMcpSession<StreamableHttpServerTransport>> StartNewS`
`204`	`205`
`205`	`206`	`var session = await CreateSessionAsync(context, transport, sessionId);`
`206`	`207`
`207`		`- // The HttpMcpSession is not stored between requests in stateless mode. Instead, the session is recreated from the mcp-session-id.`
	`208`	`+ // The HttpMcpSession is not stored between requests in stateless mode. Instead, the session is recreated from the MCP-Session-Id.`
`208`	`209`	`if (!HttpServerTransportOptions.Stateless)`
`209`	`210`	`{`
`210`	`211`	`if (!Sessions.TryAdd(sessionId, session))`
`@@ -299,7 +300,7 @@ private void ScheduleStatelessSessionIdWrite(HttpContext context, StreamableHttp`
`299`	`300`
`300`	`301`	`var sessionJson = JsonSerializer.Serialize(statelessId, StatelessSessionIdJsonContext.Default.StatelessSessionId);`
`301`	`302`	`transport.SessionId = Protector.Protect(sessionJson);`
`302`		`- context.Response.Headers["mcp-session-id"] = transport.SessionId;`
	`303`	`+ context.Response.Headers[McpSessionIdHeaderName] = transport.SessionId;`
`303`	`304`	`return ValueTask.CompletedTask;`
`304`	`305`	`};`
`305`	`306`	`}`
Original file line number	Diff line number	Diff line change
`@@ -146,6 +146,8 @@ public async Task<ITransport> ConnectAsync(CancellationToken cancellationToken =`
`146`	`146`	`stderrRollingLog.Enqueue(data);`
`147`	`147`	`}`
`148`	`148`
	`149`	`+ _options.StandardErrorLines?.Invoke(data);`
	`150`	`+`
`149`	`151`	`LogReadStderr(logger, endpointName, data);`
`150`	`152`	`}`
`151`	`153`	`};`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ internal sealed partial class StreamableHttpClientSessionTransport : TransportBa`
`27`	`27`	`private readonly CancellationTokenSource _connectionCts;`
`28`	`28`	`private readonly ILogger _logger;`
`29`	`29`
	`30`	`+ private string? _negotiatedProtocolVersion;`
`30`	`31`	`private Task? _getReceiveTask;`
`31`	`32`	`private int _disposed;`
`32`	`33`
`@@ -85,7 +86,7 @@ internal async Task<HttpResponseMessage> SendHttpRequestAsync(JsonRpcMessage mes`
`85`	`86`	`},`
`86`	`87`	`};`
`87`	`88`
`88`		`- CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders, SessionId);`
	`89`	`+ CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders, SessionId, _negotiatedProtocolVersion);`
`89`	`90`
`90`	`91`	`var response = await _httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);`
`91`	`92`
`@@ -119,14 +120,17 @@ internal async Task<HttpResponseMessage> SendHttpRequestAsync(JsonRpcMessage mes`
`119`	`120`	`throw new McpException($"Streamable HTTP POST response completed without a reply to request with ID: {rpcRequest.Id}");`
`120`	`121`	`}`
`121`	`122`
`122`		`- if (rpcRequest.Method == RequestMethods.Initialize && rpcResponseOrError is JsonRpcResponse)`
	`123`	`+ if (rpcRequest.Method == RequestMethods.Initialize && rpcResponseOrError is JsonRpcResponse initResponse)`
`123`	`124`	`{`
`124`		`- // We've successfully initialized! Copy session-id and start GET request if any.`
`125`		`- if (response.Headers.TryGetValues("mcp-session-id", out var sessionIdValues))`
	`125`	`+ // We've successfully initialized! Copy session-id and protocol version, then start GET request if any.`
	`126`	`+ if (response.Headers.TryGetValues("Mcp-Session-Id", out var sessionIdValues))`
`126`	`127`	`{`
`127`	`128`	`SessionId = sessionIdValues.FirstOrDefault();`
`128`	`129`	`}`
`129`	`130`
	`131`	`+ var initializeResult = JsonSerializer.Deserialize(initResponse.Result, McpJsonUtilities.JsonContext.Default.InitializeResult);`
	`132`	`+ _negotiatedProtocolVersion = initializeResult?.ProtocolVersion;`
	`133`	`+`
`130`	`134`	`_getReceiveTask = ReceiveUnsolicitedMessagesAsync();`
`131`	`135`	`}`
`132`	`136`
`@@ -175,7 +179,7 @@ private async Task ReceiveUnsolicitedMessagesAsync()`
`175`	`179`	`// Send a GET request to handle any unsolicited messages not sent over a POST response.`
`176`	`180`	`using var request = new HttpRequestMessage(HttpMethod.Get, _options.Endpoint);`
`177`	`181`	`request.Headers.Accept.Add(s_textEventStreamMediaType);`
`178`		`- CopyAdditionalHeaders(request.Headers, _options.AdditionalHeaders, SessionId);`
	`182`	`+ CopyAdditionalHeaders(request.Headers, _options.AdditionalHeaders, SessionId, _negotiatedProtocolVersion);`
`179`	`183`
`180`	`184`	`using var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, _connectionCts.Token).ConfigureAwait(false);`
`181`	`185`
`@@ -250,11 +254,20 @@ private void LogJsonException(JsonException ex, string data)`
`250`	`254`	`}`
`251`	`255`	`}`
`252`	`256`
`253`		`- internal static void CopyAdditionalHeaders(HttpRequestHeaders headers, IDictionary<string, string>? additionalHeaders, string? sessionId = null)`
	`257`	`+ internal static void CopyAdditionalHeaders(`
	`258`	`+ HttpRequestHeaders headers,`
	`259`	`+ IDictionary<string, string>? additionalHeaders,`
	`260`	`+ string? sessionId = null,`
	`261`	`+ string? protocolVersion = null)`
`254`	`262`	`{`
`255`	`263`	`if (sessionId is not null)`
`256`	`264`	`{`
`257`		`- headers.Add("mcp-session-id", sessionId);`
	`265`	`+ headers.Add("Mcp-Session-Id", sessionId);`
	`266`	`+ }`
	`267`	`+`
	`268`	`+ if (protocolVersion is not null)`
	`269`	`+ {`
	`270`	`+ headers.Add("MCP-Protocol-Version", protocolVersion);`
`258`	`271`	`}`
`259`	`272`
`260`	`273`	`if (additionalHeaders is null)`