Remove stateless check from ClientSupportsMrtr

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). This makes
IsMrtrSupported return true in stateless mode when the protocol matches,
which is correct for the low-level IncompleteResultException API.

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

Author: halter73

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;
 
@@ -1217,8 +1215,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 +1261,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,36 @@ public async Task Stateless_MultiRoundTrip_CompletesAcrossMultipleRetries()
         Assert.Equal(1, samplingCalls);
         Assert.Equal(1, elicitCalls);
     }
+
+    [Fact]
+    public async Task Stateless_IsMrtrSupported_ReturnsFalse_BecauseProtocolIsNotNegotiatedPerRequest()
+    {
+        // In stateless mode, each HTTP request creates a new McpServerImpl. The initialize
+        // request negotiates the protocol version on one instance, but subsequent tool calls
+        // run on different instances that never saw the initialize. So IsMrtrSupported is
+        // always false. The low-level IncompleteResultException API still works because it
+        // bypasses the IsMrtrSupported check — the developer takes responsibility for MRTR
+        // compatibility when using the exception-based API.
+        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("False", text);
+    }
 }