Make IsMrtrSupported reflect low-level API availability

IsMrtrSupported now returns true whenever the low-level MRTR API
(IncompleteResultException) can be used, not just when the client
natively negotiated MRTR. The only case where it returns false is
stateless mode with a non-MRTR client, where nobody can drive the
retry loop.

- Add IsLowLevelMrtrAvailable() to McpServerImpl
- Update DestinationBoundMcpServer.IsMrtrSupported to use it
- Error explicitly for stateless + non-MRTR in the IncompleteResult
  handler instead of silently serializing an unusable response
- Add Stateless_IncompleteResultException_WithoutMrtrClient_ReturnsError
  test verifying the error path
- Fix existing tests: stateless tests now properly negotiate MRTR,
  protocol test verifies IsMrtrSupported=true via backcompat

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

Author: halter73

src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs

@@ -22,7 +22,7 @@ internal sealed class DestinationBoundMcpServer(McpServerImpl server, ITransport
     /// </summary>
     internal MrtrContext? ActiveMrtrContext { get; set; }
 
-    public override bool IsMrtrSupported => server.ClientSupportsMrtr();
+    public override bool IsMrtrSupported => server.IsLowLevelMrtrAvailable();
 
     public override ValueTask DisposeAsync() => server.DisposeAsync();
 

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -1188,6 +1188,17 @@ internal bool ClientSupportsMrtr() =>
         _negotiatedProtocolVersion is not null &&
         _negotiatedProtocolVersion == ServerOptions.ExperimentalProtocolVersion;
 
+    /// <summary>
+    /// Checks whether the low-level MRTR API (<see cref="IncompleteResultException"/>) is available
+    /// for the current request. Returns <see langword="true"/> in all cases except stateless mode
+    /// with a client that hasn't negotiated MRTR — that's the one configuration where nobody can
+    /// drive the retry loop (the server can't send JSON-RPC requests to the client, and the client
+    /// doesn't know about <c>IncompleteResult</c>).
+    /// </summary>
+    internal bool IsLowLevelMrtrAvailable() =>
+        ClientSupportsMrtr() ||
+        _sessionTransport is not StreamableHttpServerTransport { Stateless: true };
+
     /// <summary>
     /// Wraps MRTR-eligible request handlers so that when a handler calls ElicitAsync/SampleAsync,
     /// an IncompleteResult is returned early and the handler is suspended until the retry arrives.
@@ -1341,14 +1352,23 @@ private void WrapHandlerWithMrtr(string method)
             }
             catch (IncompleteResultException ex)
             {
-                // If the client supports MRTR or the server is stateless, serialize and return directly.
-                // 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 StreamableHttpServerTransport { Stateless: true })
+                // If the client natively supports MRTR, serialize and return directly —
+                // the client will drive the retry loop.
+                if (ClientSupportsMrtr())
                 {
                     return SerializeIncompleteResult(ex.IncompleteResult);
                 }
 
+                // In stateless mode without MRTR, the server can't resolve input requests via
+                // JSON-RPC (no persistent session for server-to-client requests), and the client
+                // won't recognize the IncompleteResult. This is the one unsupported configuration.
+                if (_sessionTransport is StreamableHttpServerTransport { Stateless: true })
+                {
+                    throw new McpException(
+                        "A tool handler returned an incomplete result, but the server is stateless and the client does not support MRTR. " +
+                        "MRTR-native tools require either an MRTR-capable client or a stateful server for backward-compatible resolution.", ex);
+                }
+
                 // Backcompat: resolve input requests via standard JSON-RPC calls and retry the handler.
                 if (ex.IncompleteResult.InputRequests is not { Count: > 0 } inputRequests)
                 {

tests/ModelContextProtocol.AspNetCore.Tests/MrtrProtocolTests.cs

@@ -108,6 +108,13 @@ private async Task StartAsync()
                     Name = "simple-tool",
                     Description = "A tool that does not use MRTR"
                 }),
+            McpServerTool.Create(
+                static string (McpServer server) => server.IsMrtrSupported.ToString(),
+                new McpServerToolCreateOptions
+                {
+                    Name = "check-mrtr-tool",
+                    Description = "Returns IsMrtrSupported"
+                }),
             McpServerTool.Create(
                 static string (McpServer _) => throw new McpProtocolException("Tool validation failed", McpErrorCode.InvalidParams),
                 new McpServerToolCreateOptions
@@ -815,19 +822,20 @@ public async Task LowLevel_IncompleteResult_HasCorrectJsonStructure()
     }
 
     [Fact]
-    public async Task LowLevel_ToolFallsBackGracefully_WithoutMrtr()
+    public async Task LowLevel_IsMrtrSupported_ReturnsTrue_WithoutMrtrNegotiation()
     {
         await StartAsync();
         await InitializeWithoutMrtrAsync();
 
-        // Call the lowlevel-tool that checks IsMrtrSupported and returns a fallback message
-        var response = await PostJsonRpcAsync(CallTool("lowlevel-tool"));
+        // On a non-stateless HTTP server, IsMrtrSupported returns true even without
+        // MRTR negotiation because the backcompat layer can resolve IncompleteResultException
+        // via standard JSON-RPC server-to-client requests.
+        var response = await PostJsonRpcAsync(CallTool("check-mrtr-tool"));
         var rpcResponse = await AssertSingleSseResponseAsync(response);
 
         var callToolResult = AssertType<CallToolResult>(rpcResponse.Result);
         var content = Assert.Single(callToolResult.Content);
-        var text = Assert.IsType<TextContentBlock>(content).Text;
-        Assert.Equal("lowlevel-unsupported:MRTR is not available", text);
+        Assert.Equal("True", Assert.IsType<TextContentBlock>(content).Text);
     }
 
     [Fact]

tests/ModelContextProtocol.AspNetCore.Tests/StatelessMrtrTests.cs

@@ -25,7 +25,8 @@ public class StatelessMrtrTests(ITestOutputHelper outputHelper) : KestrelInMemor
         TransportMode = HttpTransportMode.StreamableHttp,
     };
 
-    private Task StartAsync() => StartAsync(configureOptions: null);
+    private Task StartAsync() => StartAsync(
+        options => options.ExperimentalProtocolVersion = "2026-06-XX");
 
     private async Task StartAsync(Action<McpServerOptions>? configureOptions, params McpServerTool[] additionalTools)
     {
@@ -249,7 +250,7 @@ private Task<McpClient> ConnectAsync(McpClientOptions? clientOptions = null)
 
     private McpClientOptions CreateClientOptionsWithAllHandlers()
     {
-        var options = new McpClientOptions();
+        var options = new McpClientOptions { ExperimentalProtocolVersion = "2026-06-XX" };
         options.Handlers.ElicitationHandler = (request, ct) =>
         {
             return new ValueTask<ElicitResult>(new ElicitResult
@@ -353,7 +354,7 @@ public async Task Stateless_AllThreeConcurrent_ClientResolvesAllInputRequests()
         var samplingHandlerCalled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         var rootsHandlerCalled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        var options = new McpClientOptions();
+        var options = new McpClientOptions { ExperimentalProtocolVersion = "2026-06-XX" };
         options.Handlers.ElicitationHandler = async (request, ct) =>
         {
             elicitHandlerCalled.TrySetResult();
@@ -409,7 +410,7 @@ public async Task Stateless_MultiRoundTrip_CompletesAcrossMultipleRetries()
         int samplingCalls = 0;
         int elicitCalls = 0;
 
-        var options = new McpClientOptions();
+        var options = new McpClientOptions { ExperimentalProtocolVersion = "2026-06-XX" };
         options.Handlers.SamplingHandler = (request, progress, ct) =>
         {
             Interlocked.Increment(ref samplingCalls);
@@ -643,4 +644,53 @@ await StartAsync(
         var text = Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text;
         Assert.Equal("resumed:deferred-work", text);
     }
+
+    [Fact]
+    public async Task Stateless_IncompleteResultException_WithoutMrtrClient_ReturnsError()
+    {
+        // When a tool throws IncompleteResultException in stateless mode and the client doesn't
+        // support MRTR, nobody can drive the retry loop: the server can't send JSON-RPC requests
+        // to the client (stateless), and the client doesn't recognize IncompleteResult (no MRTR).
+        // IsMrtrSupported correctly returns false for this configuration.
+        var nativeToolWithoutGuard = McpServerTool.Create(
+            static string (McpServer server, RequestContext<CallToolRequestParams> context) =>
+            {
+                var inputResponses = context.Params!.InputResponses;
+                if (inputResponses is not null)
+                {
+                    return $"resolved:{inputResponses["user_input"].ElicitationResult?.Action}";
+                }
+
+                // IsMrtrSupported is false in stateless + non-MRTR, but tool ignores the check
+                throw new IncompleteResultException(
+                    inputRequests: new Dictionary<string, InputRequest>
+                    {
+                        ["user_input"] = InputRequest.ForElicitation(new ElicitRequestParams
+                        {
+                            Message = "Please confirm",
+                            RequestedSchema = new()
+                        })
+                    },
+                    requestState: "awaiting-confirmation");
+            },
+            new McpServerToolCreateOptions
+            {
+                Name = "native-tool-no-guard",
+                Description = "MRTR-native tool that doesn't check IsMrtrSupported"
+            });
+
+        await StartAsync(
+            options => options.ExperimentalProtocolVersion = "2026-06-XX",
+            nativeToolWithoutGuard);
+
+        // Client does NOT opt in to MRTR
+        await using var client = await ConnectAsync();
+
+        var ex = await Assert.ThrowsAsync<McpProtocolException>(() =>
+            client.CallToolAsync("native-tool-no-guard",
+                cancellationToken: TestContext.Current.CancellationToken).AsTask());
+
+        Assert.Contains("stateless", ex.Message, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("MRTR", ex.Message);
+    }
 }

tests/ModelContextProtocol.Tests/Client/McpClientMrtrLowLevelTests.cs

@@ -255,20 +255,31 @@ public async Task IsMrtrSupported_ReturnsTrue_WhenBothExperimental()
     }
 
     [Fact]
-    public async Task IsMrtrSupported_ReturnsFalse_WhenClientNotExperimental()
+    public async Task IsMrtrSupported_ReturnsTrue_WhenClientNotExperimental_BackcompatAvailable()
     {
         StartServer();
-        // Client does NOT set ExperimentalProtocolVersion
+        // Client does NOT set ExperimentalProtocolVersion, but backcompat resolves the tool
         var clientOptions = new McpClientOptions();
+        clientOptions.Handlers.ElicitationHandler = (request, ct) =>
+        {
+            return new ValueTask<ElicitResult>(new ElicitResult
+            {
+                Action = "accept",
+                Content = new Dictionary<string, JsonElement>
+                {
+                    ["answer"] = JsonDocument.Parse("\"backcompat\"").RootElement.Clone()
+                }
+            });
+        };
 
         await using var client = await CreateMcpClientForServer(clientOptions);
 
-        // The lowlevel-elicit tool checks IsMrtrSupported and returns a fallback message
+        // The lowlevel-elicit tool checks IsMrtrSupported — now true with backcompat
         var result = await client.CallToolAsync("lowlevel-elicit",
             cancellationToken: TestContext.Current.CancellationToken);
 
         var content = Assert.Single(result.Content);
-        Assert.Equal("fallback:MRTR not supported", Assert.IsType<TextContentBlock>(content).Text);
+        Assert.Equal("completed:accept:backcompat", Assert.IsType<TextContentBlock>(content).Text);
     }
 
     [Fact]