Add edge-case tests for MRTR backward compatibility and experimental mode

Backcompat tests (McpClientMrtrCompatTests):
- 10-retry limit enforcement (tool that never completes)
- Empty inputRequests dictionary triggers immediate error
- Error propagation when client handler throws during resolve

Experimental mode test (McpClientMrtrTests):
- Client handler throws during MRTR input resolution: exception
  surfaces to caller, server logs cancelled MRTR continuation on
  disposal. This exercises a fundamental MRTR limitation where the
  client has no channel to communicate input resolution failures
  back to the server.

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

Author: halter73

tests/ModelContextProtocol.Tests/Client/McpClientMrtrCompatTests.cs

@@ -219,6 +219,67 @@ static string (RequestContext<CallToolRequestParams> context) =>
                     Name = "native-roots",
                     Description = "MRTR-native tool requesting roots/list"
                 }),
+            McpServerTool.Create(
+                static string (RequestContext<CallToolRequestParams> context) =>
+                {
+                    // Always throws IncompleteResultException, never completes.
+                    throw new IncompleteResultException(
+                        inputRequests: new Dictionary<string, InputRequest>
+                        {
+                            ["input"] = InputRequest.ForElicitation(new ElicitRequestParams
+                            {
+                                Message = "Infinite loop",
+                                RequestedSchema = new()
+                            })
+                        },
+                        requestState: $"attempt-{context.Params!.RequestState ?? "0"}");
+                },
+                new McpServerToolCreateOptions
+                {
+                    Name = "native-always-incomplete",
+                    Description = "MRTR-native tool that never completes"
+                }),
+            McpServerTool.Create(
+                static string (RequestContext<CallToolRequestParams> context) =>
+                {
+                    // Throws IncompleteResultException with empty inputRequests dict.
+                    throw new IncompleteResultException(new IncompleteResult
+                    {
+                        InputRequests = new Dictionary<string, InputRequest>(),
+                        RequestState = "some-state",
+                    });
+                },
+                new McpServerToolCreateOptions
+                {
+                    Name = "native-empty-inputs",
+                    Description = "MRTR-native tool with empty inputRequests"
+                }),
+            McpServerTool.Create(
+                static string (RequestContext<CallToolRequestParams> context) =>
+                {
+                    var inputResponses = context.Params!.InputResponses;
+
+                    if (inputResponses is not null)
+                    {
+                        return "should-not-reach";
+                    }
+
+                    throw new IncompleteResultException(
+                        inputRequests: new Dictionary<string, InputRequest>
+                        {
+                            ["user_input"] = InputRequest.ForElicitation(new ElicitRequestParams
+                            {
+                                Message = "Will fail",
+                                RequestedSchema = new()
+                            })
+                        },
+                        requestState: "error-test");
+                },
+                new McpServerToolCreateOptions
+                {
+                    Name = "native-elicit-for-error",
+                    Description = "MRTR-native tool for testing error propagation"
+                }),
         ]);
     }
 
@@ -457,4 +518,79 @@ public async Task CallToolAsync_MrtrNativeRootsList_ResolvedViaLegacyJsonRpc()
         var content = Assert.Single(result.Content);
         Assert.Equal("roots:MyProject", Assert.IsType<TextContentBlock>(content).Text);
     }
+
+    [Fact]
+    public async Task CallToolAsync_MrtrNativeAlwaysIncomplete_FailsAfterMaxRetries()
+    {
+        // Tool always throws IncompleteResultException. The backcompat layer should
+        // give up after 10 retry rounds and throw McpException.
+        int elicitCallCount = 0;
+        StartServer();
+        var clientOptions = new McpClientOptions();
+        clientOptions.Handlers.ElicitationHandler = (request, ct) =>
+        {
+            elicitCallCount++;
+            return new ValueTask<ElicitResult>(new ElicitResult
+            {
+                Action = "accept",
+                Content = new Dictionary<string, JsonElement>
+                {
+                    ["value"] = JsonDocument.Parse($"\"{elicitCallCount}\"").RootElement.Clone()
+                }
+            });
+        };
+
+        await using var client = await CreateMcpClientForServer(clientOptions);
+        Assert.NotEqual("2026-06-XX", client.NegotiatedProtocolVersion);
+
+        var ex = await Assert.ThrowsAsync<McpProtocolException>(async () =>
+            await client.CallToolAsync("native-always-incomplete",
+                cancellationToken: TestContext.Current.CancellationToken));
+
+        Assert.Contains("exceeded", ex.Message, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("10", ex.Message);
+        Assert.Equal(10, elicitCallCount);
+    }
+
+    [Fact]
+    public async Task CallToolAsync_MrtrNativeEmptyInputRequests_FailsWithMcpException()
+    {
+        // Tool throws IncompleteResultException with an empty inputRequests dictionary.
+        // The backcompat layer should detect this and throw McpException immediately.
+        StartServer();
+        var clientOptions = new McpClientOptions();
+
+        await using var client = await CreateMcpClientForServer(clientOptions);
+        Assert.NotEqual("2026-06-XX", client.NegotiatedProtocolVersion);
+
+        var ex = await Assert.ThrowsAsync<McpProtocolException>(async () =>
+            await client.CallToolAsync("native-empty-inputs",
+                cancellationToken: TestContext.Current.CancellationToken));
+
+        Assert.Contains("without input requests", ex.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task CallToolAsync_MrtrNativeElicitation_ClientHandlerThrows_PropagatesError()
+    {
+        // Client's elicitation handler throws. The error should propagate through
+        // ResolveInputRequestAsync and surface as an McpException on the client.
+        StartServer();
+        var clientOptions = new McpClientOptions();
+        clientOptions.Handlers.ElicitationHandler = (request, ct) =>
+        {
+            throw new InvalidOperationException("Client-side elicitation failure");
+        };
+
+        await using var client = await CreateMcpClientForServer(clientOptions);
+        Assert.NotEqual("2026-06-XX", client.NegotiatedProtocolVersion);
+
+        // The client handler's exception message doesn't survive the JSON-RPC round-trip.
+        // The server sends elicitation → client handler throws → client returns JSON-RPC error
+        // → server receives it as McpProtocolException → server re-throws → becomes JSON-RPC
+        // error to the original call → client sees a double-wrapped error.
+        var ex = await Assert.ThrowsAsync<McpProtocolException>(async () =>
+            await client.CallToolAsync("native-elicit-for-error",
+                cancellationToken: TestContext.Current.CancellationToken));
+    }
 }

tests/ModelContextProtocol.Tests/Client/McpClientMrtrTests.cs

@@ -29,6 +29,7 @@ public McpClientMrtrTests(ITestOutputHelper testOutputHelper)
 
     protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder)
     {
+        services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Debug));
         services.Configure<McpServerOptions>(options =>
         {
             options.ExperimentalProtocolVersion = "2026-06-XX";
@@ -851,4 +852,44 @@ public async Task CallToolAsync_ElicitThenIncompleteResultException_WorksEndToEn
             m.LogLevel == LogLevel.Error &&
             m.Exception is IncompleteResultException);
     }
+
+    [Fact]
+    public async Task ClientHandlerException_DuringMrtrInputResolution_SurfacesToCaller()
+    {
+        // When the CLIENT's elicitation handler throws during MRTR input resolution,
+        // the retry never reaches the server — the server's handler remains suspended
+        // on ElicitAsync(). The exception should surface to the CallToolAsync caller,
+        // and the server's orphaned handler should be cleaned up on disposal.
+        // This is a fundamental MRTR limitation: the client has no channel to communicate
+        // input resolution failures back to the server.
+        StartServer();
+
+        var clientOptions = new McpClientOptions { ExperimentalProtocolVersion = "2026-06-XX" };
+        clientOptions.Handlers.ElicitationHandler = (request, ct) =>
+        {
+            throw new InvalidOperationException("Client-side elicitation failure");
+        };
+
+        await using var client = await CreateMcpClientForServer(clientOptions);
+        Assert.Equal("2026-06-XX", client.NegotiatedProtocolVersion);
+
+        // The client handler throws during input resolution, so the exception
+        // escapes ResolveInputRequestAsync and surfaces directly to the caller.
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await client.CallToolAsync("elicitation-tool",
+                new Dictionary<string, object?> { ["message"] = "Will fail" },
+                cancellationToken: TestContext.Current.CancellationToken));
+
+        Assert.Equal("Client-side elicitation failure", ex.Message);
+
+        // Dispose the server to trigger cleanup of the orphaned MRTR continuation.
+        // The server should cancel the handler suspended on ElicitAsync() and log
+        // the cancelled continuation at Debug level.
+        await Server.DisposeAsync();
+
+        Assert.Contains(MockLoggerProvider.LogMessages, m =>
+            m.LogLevel == LogLevel.Debug &&
+            m.Message.Contains("Cancelled") &&
+            m.Message.Contains("MRTR continuation"));
+    }
 }