Merge branch 'main' into use-lowercase-derived-uritemplaes

eiriktsarpalis · web-flow · commit 616bd2adec0a · 2025-06-23T06:56:24.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/samples/QuickstartClient/Program.cs b/samples/QuickstartClient/Program.cs
@@ -88,7 +88,7 @@ static void PromptForInput()
     {
         [var script] when script.EndsWith(".py") => ("python", args),
         [var script] when script.EndsWith(".js") => ("node", args),
-        [var script] when Directory.Exists(script) || (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", ["run", "--project", script, "--no-build"]),
-        _ => ("dotnet", ["run", "--project", "../../../../QuickstartWeatherServer", "--no-build"])
+        [var script] when Directory.Exists(script) || (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", ["run", "--project", script]),
+        _ => ("dotnet", ["run", "--project", "../QuickstartWeatherServer"])
     };
 }
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/Directory.Build.props b/src/Directory.Build.props
@@ -5,8 +5,8 @@
     <PackageProjectUrl>https://github.com/modelcontextprotocol/csharp-sdk</PackageProjectUrl>
     <RepositoryUrl>https://github.com/modelcontextprotocol/csharp-sdk</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <VersionPrefix>0.2.0</VersionPrefix>
-    <VersionSuffix>preview.4</VersionSuffix>
+    <VersionPrefix>0.3.0</VersionPrefix>
+    <VersionSuffix>preview.1</VersionSuffix>
     <Authors>ModelContextProtocolOfficial</Authors>
     <Copyright>© Anthropic and Contributors.</Copyright>
     <PackageTags>ModelContextProtocol;mcp;ai;llm</PackageTags>
diff --git a/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs b/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs
@@ -6,7 +6,7 @@ namespace ModelContextProtocol.AspNetCore;
 /// <summary>
 /// Configuration options for <see cref="M:McpEndpointRouteBuilderExtensions.MapMcp"/>.
 /// which implements the Streaming HTTP transport for the Model Context Protocol.
-/// See the protocol specification for details on the Streamable HTTP transport. <see href="https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http"/>
+/// See the protocol specification for details on the Streamable HTTP transport. <see href="https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http"/>
 /// </summary>
 public class HttpServerTransportOptions
 {
@@ -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/McpEndpointRouteBuilderExtensions.cs b/src/ModelContextProtocol.AspNetCore/McpEndpointRouteBuilderExtensions.cs
@@ -15,7 +15,7 @@ public static class McpEndpointRouteBuilderExtensions
 {
     /// <summary>
     /// Sets up endpoints for handling MCP Streamable HTTP transport.
-    /// See <see href="https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http">the 2025-03-26 protocol specification</see> for details about the Streamable HTTP transport.
+    /// See <see href="https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http">the 2025-06-18 protocol specification</see> for details about the Streamable HTTP transport.
     /// Also maps legacy SSE endpoints for backward compatibility at the path "/sse" and "/message". <see href="https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse">the 2024-11-05 protocol specification</see> for details about the HTTP with SSE transport.
     /// </summary>
     /// <param name="endpoints">The web application to attach MCP HTTP endpoints.</param>
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/SseClientSessionTransport.cs b/src/ModelContextProtocol.Core/Client/SseClientSessionTransport.cs
@@ -91,7 +91,7 @@ public override async Task SendMessageAsync(
         {
             Content = content,
         };
-        StreamableHttpClientSessionTransport.CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders);
+        StreamableHttpClientSessionTransport.CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders, sessionId: null, protocolVersion: null);
         var response = await _httpClient.SendAsync(httpRequestMessage, cancellationToken).ConfigureAwait(false);
 
         if (!response.IsSuccessStatusCode)
@@ -152,7 +152,7 @@ private async Task ReceiveMessagesAsync(CancellationToken cancellationToken)
         {
             using var request = new HttpRequestMessage(HttpMethod.Get, _sseEndpoint);
             request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream"));
-            StreamableHttpClientSessionTransport.CopyAdditionalHeaders(request.Headers, _options.AdditionalHeaders);
+            StreamableHttpClientSessionTransport.CopyAdditionalHeaders(request.Headers, _options.AdditionalHeaders, sessionId: null, protocolVersion: null);
 
             using var response = await _httpClient.SendAsync(
                 request,
diff --git a/src/ModelContextProtocol.Core/Client/SseClientTransportOptions.cs b/src/ModelContextProtocol.Core/Client/SseClientTransportOptions.cs
@@ -39,7 +39,7 @@ public required Uri Endpoint
     /// Streamable HTTP transport and automatically fall back to SSE transport if the server doesn't support it.
     /// </para>
     /// <para>
-    /// <see href="https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http">Streamable HTTP transport specification</see>.
+    /// <see href="https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http">Streamable HTTP transport specification</see>.
     /// <see href="https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse">HTTP with SSE transport specification</see>.
     /// </para>
     /// </remarks>
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,8 +27,12 @@ internal sealed partial class StreamableHttpClientSessionTransport : TransportBa
     private readonly CancellationTokenSource _connectionCts;
     private readonly ILogger _logger;
 
+    private string? _negotiatedProtocolVersion;
     private Task? _getReceiveTask;
 
+    private readonly SemaphoreSlim _disposeLock = new(1, 1);
+    private bool _disposed;
+
     public StreamableHttpClientSessionTransport(
         string endpointName,
         SseClientTransportOptions transportOptions,
@@ -84,7 +88,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);
 
@@ -118,14 +122,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();
         }
 
@@ -134,12 +141,26 @@ internal async Task<HttpResponseMessage> SendHttpRequestAsync(JsonRpcMessage mes
 
     public override async ValueTask DisposeAsync()
     {
+        using var _ = await _disposeLock.LockAsync().ConfigureAwait(false);
+
+        if (_disposed)
+        {
+            return;
+        }
+        _disposed = true;
+
         try
         {
             await _connectionCts.CancelAsync().ConfigureAwait(false);
 
             try
             {
+                // Send DELETE request to terminate the session. Only send if we have a session ID, per MCP spec.
+                if (!string.IsNullOrEmpty(SessionId))
+                {
+                    await SendDeleteRequest();
+                }
+
                 if (_getReceiveTask != null)
                 {
                     await _getReceiveTask.ConfigureAwait(false);
@@ -169,7 +190,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);
 
@@ -232,6 +253,22 @@ message is JsonRpcMessageWithId rpcResponseOrError &&
         return null;
     }
 
+    private async Task SendDeleteRequest()
+    {
+        using var deleteRequest = new HttpRequestMessage(HttpMethod.Delete, _options.Endpoint);
+        CopyAdditionalHeaders(deleteRequest.Headers, _options.AdditionalHeaders, SessionId, _negotiatedProtocolVersion);
+
+        try
+        {
+            // Do not validate we get a successful status code, because server support for the DELETE request is optional
+            (await _httpClient.SendAsync(deleteRequest, CancellationToken.None).ConfigureAwait(false)).Dispose();
+        }
+        catch (Exception ex)
+        {
+            LogTransportShutdownFailed(Name, ex);
+        }
+    }
+
     private void LogJsonException(JsonException ex, string data)
     {
         if (_logger.IsEnabled(LogLevel.Trace))
@@ -244,11 +281,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,
+        string? protocolVersion)
     {
         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/McpSession.cs b/src/ModelContextProtocol.Core/McpSession.cs
@@ -29,12 +29,13 @@ internal sealed partial class McpSession : IDisposable
         "mcp.server.operation.duration", "Measures the duration of inbound message processing.", longBuckets: false);
 
     /// <summary>The latest version of the protocol supported by this implementation.</summary>
-    internal const string LatestProtocolVersion = "2025-03-26";
+    internal const string LatestProtocolVersion = "2025-06-18";
 
     /// <summary>All protocol versions supported by this implementation.</summary>
     internal static readonly string[] SupportedProtocolVersions =
     [
         "2024-11-05",
+        "2025-03-26",
         LatestProtocolVersion,
     ];
 
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
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj b/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpClientConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpClientConformanceTests.cs
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/Utils/KestrelInMemoryConnection.cs b/tests/ModelContextProtocol.AspNetCore.Tests/Utils/KestrelInMemoryConnection.cs
diff --git a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
diff --git a/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs b/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ static void PromptForInput()`
`88`	`88`	`{`
`89`	`89`	`[var script] when script.EndsWith(".py") => ("python", args),`
`90`	`90`	`[var script] when script.EndsWith(".js") => ("node", args),`
`91`		`- [var script] when Directory.Exists(script) \|\| (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", ["run", "--project", script, "--no-build"]),`
`92`		`- _ => ("dotnet", ["run", "--project", "../../../../QuickstartWeatherServer", "--no-build"])`
	`91`	`+ [var script] when Directory.Exists(script) \|\| (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", ["run", "--project", script]),`
	`92`	`+ _ => ("dotnet", ["run", "--project", "../QuickstartWeatherServer"])`
`93`	`93`	`};`
`94`	`94`	`}`
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
`@@ -15,7 +15,7 @@ public static class McpEndpointRouteBuilderExtensions`
`15`	`15`	`{`
`16`	`16`	`/// <summary>`
`17`	`17`	`/// Sets up endpoints for handling MCP Streamable HTTP transport.`
`18`		`- /// See <see href="https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http">the 2025-03-26 protocol specification</see> for details about the Streamable HTTP transport.`
	`18`	`+ /// See <see href="https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http">the 2025-06-18 protocol specification</see> for details about the Streamable HTTP transport.`
`19`	`19`	`/// Also maps legacy SSE endpoints for backward compatibility at the path "/sse" and "/message". <see href="https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse">the 2024-11-05 protocol specification</see> for details about the HTTP with SSE transport.`
`20`	`20`	`/// </summary>`
`21`	`21`	`/// <param name="endpoints">The web application to attach MCP HTTP endpoints.</param>`
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`	`};`