Remove stateless check from ClientSupportsMrtr and flow protocol version header

ClientSupportsMrtr now purely reflects whether the client negotiated
the MRTR protocol version, independent of server transport mode.
The stateless guard is moved to the call site that gates the high-level
await path (which requires storing continuations).

In stateless mode, each request creates a new McpServerImpl that never
sees the initialize handshake. The Mcp-Protocol-Version header is now
flowed via JsonRpcMessageContext.ProtocolVersion so the MRTR wrapper
can populate _negotiatedProtocolVersion, making IsMrtrSupported return
true when the client sends the experimental protocol version header.

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

Author: halter73

src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs

@@ -480,12 +480,25 @@ internal static string MakeNewSessionId()
         // Implementation for reading a JSON-RPC message from the request body
         var message = await context.Request.ReadFromJsonAsync(s_messageTypeInfo, context.RequestAborted);
 
-        if (context.User?.Identity?.IsAuthenticated == true && message is not null)
+        if (message is not null)
         {
-            message.Context = new()
+            var protocolVersion = context.Request.Headers[McpProtocolVersionHeaderName].ToString();
+            var isAuthenticated = context.User?.Identity?.IsAuthenticated == true;
+
+            if (isAuthenticated || !string.IsNullOrEmpty(protocolVersion))
             {
-                User = context.User,
-            };
+                message.Context ??= new();
+
+                if (isAuthenticated)
+                {
+                    message.Context.User = context.User;
+                }
+
+                if (!string.IsNullOrEmpty(protocolVersion))
+                {
+                    message.Context.ProtocolVersion = protocolVersion;
+                }
+            }
         }
 
         return message;

src/ModelContextProtocol.Core/Protocol/JsonRpcMessageContext.cs

@@ -74,4 +74,15 @@ public sealed class JsonRpcMessageContext
     /// </para>
     /// </remarks>
     public IDictionary<string, object?>? Items { get; set; }
+
+    /// <summary>
+    /// Gets or sets the protocol version from the transport-level header (e.g. <c>Mcp-Protocol-Version</c>)
+    /// that accompanied this JSON-RPC message.
+    /// </summary>
+    /// <remarks>
+    /// In stateless Streamable HTTP mode, the protocol version cannot be negotiated via the <c>initialize</c>
+    /// handshake because each request creates a new server instance. This property allows the transport layer
+    /// to flow the protocol version header so the server can determine client capabilities.
+    /// </remarks>
+    public string? ProtocolVersion { get; set; }
 }

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -1143,11 +1143,9 @@ internal static LoggingLevel ToLoggingLevel(LogLevel level) =>
     private partial void ReadResourceCompleted(string resourceUri);
 
     /// <summary>
-    /// Checks whether the negotiated protocol version enables MRTR and the server
-    /// operates in a mode where MRTR continuations can be stored (i.e., not stateless).
+    /// Checks whether the negotiated protocol version enables MRTR.
     /// </summary>
     internal bool ClientSupportsMrtr() =>
-        _sessionTransport is not StreamableHttpServerTransport { Stateless: true } &&
         _negotiatedProtocolVersion is not null &&
         _negotiatedProtocolVersion == ServerOptions.ExperimentalProtocolVersion;
 
@@ -1177,6 +1175,15 @@ private void WrapHandlerWithMrtr(string method)
 
         _requestHandlers[method] = async (request, cancellationToken) =>
         {
+            // In stateless mode, each request creates a new server instance that never saw the
+            // initialize handshake, so _negotiatedProtocolVersion is null. Pick it up from the
+            // Mcp-Protocol-Version header that the transport layer flowed via JsonRpcMessageContext.
+            if (_negotiatedProtocolVersion is null &&
+                request.Context?.ProtocolVersion is { } headerProtocolVersion)
+            {
+                _negotiatedProtocolVersion = headerProtocolVersion;
+            }
+
             // Check for MRTR retry: if requestState is present, look up the continuation.
             if (request.Params is JsonObject paramsObj &&
                 paramsObj.TryGetPropertyValue("requestState", out var requestStateNode) &&
@@ -1217,8 +1224,9 @@ private void WrapHandlerWithMrtr(string method)
                 // high-level handlers that call ElicitAsync/SampleAsync.
             }
 
-            // Not a retry, or a retry without a continuation - check if the client supports MRTR.
-            if (!ClientSupportsMrtr())
+            // Not a retry, or a retry without a continuation - check if the client supports MRTR
+            // and the server is stateful (the high-level await path requires storing continuations).
+            if (!ClientSupportsMrtr() || _sessionTransport is StreamableHttpServerTransport { Stateless: true })
             {
                 return await InvokeWithIncompleteResultHandlingAsync(originalHandler, request, cancellationToken).ConfigureAwait(false);
             }
@@ -1262,10 +1270,10 @@ private void WrapHandlerWithMrtr(string method)
         }
         catch (IncompleteResultException ex)
         {
-            // In stateless mode, the server has no persistent session or negotiated protocol
-            // version, so it cannot determine client MRTR support. The tool handler has
-            // explicitly chosen to return an IncompleteResult, so we trust that decision.
-            if (_sessionTransport is not StreamableHttpServerTransport { Stateless: true } && !ClientSupportsMrtr())
+            // Allow the IncompleteResult if the client supports MRTR or the server is stateless
+            // (in stateless mode, the tool handler has explicitly chosen to return an IncompleteResult
+            // via the low-level API, so we trust that decision regardless of negotiated version).
+            if (!ClientSupportsMrtr() && _sessionTransport is not StreamableHttpServerTransport { Stateless: true })
             {
                 throw new McpException(
                     "A tool handler returned an incomplete result, but the client does not support Multi Round-Trip Requests (MRTR). " +

tests/ModelContextProtocol.AspNetCore.Tests/StatelessMrtrTests.cs

@@ -25,7 +25,9 @@ public class StatelessMrtrTests(ITestOutputHelper outputHelper) : KestrelInMemor
         TransportMode = HttpTransportMode.StreamableHttp,
     };
 
-    private async Task StartAsync()
+    private Task StartAsync() => StartAsync(configureOptions: null);
+
+    private async Task StartAsync(Action<McpServerOptions>? configureOptions, params McpServerTool[] additionalTools)
     {
         Builder.Services.AddMcpServer(options =>
         {
@@ -34,6 +36,7 @@ private async Task StartAsync()
                 Name = nameof(StatelessMrtrTests),
                 Version = "1",
             };
+            configureOptions?.Invoke(options);
         })
         .WithHttpTransport(httpOptions =>
         {
@@ -228,6 +231,7 @@ static string (RequestContext<CallToolRequestParams> context) =>
                     Name = "stateless-multi-roundtrip",
                     Description = "Stateless tool with multiple MRTR round-trips"
                 }),
+            ..additionalTools,
         ]);
 
         _app = Builder.Build();
@@ -434,4 +438,33 @@ public async Task Stateless_MultiRoundTrip_CompletesAcrossMultipleRetries()
         Assert.Equal(1, samplingCalls);
         Assert.Equal(1, elicitCalls);
     }
+
+    [Fact]
+    public async Task Stateless_IsMrtrSupported_ReturnsTrue_WhenExperimentalProtocolNegotiated()
+    {
+        // Regression test: In stateless mode, each request creates a new McpServerImpl that never
+        // sees the initialize handshake. The Mcp-Protocol-Version header is flowed via
+        // JsonRpcMessageContext.ProtocolVersion so the server can determine MRTR support.
+        var isMrtrSupportedTool = McpServerTool.Create(
+            static string (McpServer server) => server.IsMrtrSupported.ToString(),
+            new McpServerToolCreateOptions
+            {
+                Name = "check-mrtr",
+                Description = "Returns IsMrtrSupported"
+            });
+
+        await StartAsync(
+            options => options.ExperimentalProtocolVersion = "2026-06-XX",
+            isMrtrSupportedTool);
+
+        var clientOptions = new McpClientOptions { ExperimentalProtocolVersion = "2026-06-XX" };
+
+        await using var client = await ConnectAsync(clientOptions);
+
+        var result = await client.CallToolAsync("check-mrtr",
+            cancellationToken: TestContext.Current.CancellationToken);
+
+        var text = Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text;
+        Assert.Equal("True", text);
+    }
 }