Remove MRTR Core tests redundant with MapMcpTests theory rows

Phase 1 of this restoration brought back three Core MRTR happy-path tests
that duplicate scenarios already covered by `MapMcpTests.Mrtr` theory rows
(across StreamableHttp / SSE / Stateless transports with both
`experimentalClient: true` and `experimentalClient: false`):

* `CallToolAsync_BothExperimental_ElicitCompletesViaMrtr`
  → covered by `Mrtr_MultiRoundTrip_Completes(experimentalClient: true)`
* `CallToolAsync_ConcurrentElicitAndSample_PropagatesError`
  → covered by `Mrtr_ParallelAwaits(experimentalClient: true)`
* `CallToolAsync_ElicitThenIncompleteResultException_WorksEndToEnd`
  → covered by `Mrtr_MixedExceptionAndAwaitStyle(experimentalClient: true)`

The MapMcpTests versions assert the same MrtrContext gate ("Concurrent
server-to-client requests are not supported"), the same MrtrUsed message
tracker assertions, and run against multiple transports. The Core stdio
mirrors added no transport-independent coverage.

Also removed two now-unused tool definitions in the test fixture:
`concurrent-tool`, `incomplete-result-tool`, `elicit-then-incomplete-result-tool`.

Retained the rest of MrtrIntegrationTests:
* `ClientHandlerException_DuringMrtrInputResolution_SurfacesToCaller`
  (draft client retry-loop error propagation — not covered by the legacy
  `Mrtr_Backcompat_ClientHandlerThrows_PropagatesError` which exercises
  a different code path)
* `SendMessageAsync_WithJsonRpcRequest_ThrowsAlways` (client API contract)
* `LegacyRequestOnMrtrSession_LogsWarning` (fake-stream protocol-compliance assertion)
* `IncompleteResultOnNonMrtrSession_LogsWarning` (fake-stream protocol-compliance assertion)
* `IncompleteResultRetry_OmittingRequestState_StripsStaleStateFromRetryParams` (regression test)

The server-side lifecycle tests (MrtrHandlerLifecycleTests), message
filter tests (MrtrMessageFilterTests), and per-session limit pattern tests
(MrtrSessionLimitTests) are intentionally kept — they exercise the internal
MRTR machinery (continuation cancellation, handler drain, outgoing filter
visibility) which is not naturally testable at the HTTP transport layer.

Test counts: Core 2024 → 2021 (-3); AspNetCore unchanged at 435.

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

Author: halter73

tests/ModelContextProtocol.Tests/Client/MrtrIntegrationTests.cs

@@ -52,98 +52,10 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer
                     Name = "elicitation-tool",
                     Description = "A tool that requests elicitation from the client"
                 }),
-            McpServerTool.Create(
-                async (McpServer server, CancellationToken ct) =>
-                {
-                    // Attempt concurrent ElicitAsync + SampleAsync ΓÇö MrtrContext prevents this.
-                    var t1 = server.ElicitAsync(new ElicitRequestParams
-                    {
-                        Message = "Concurrent elicit",
-                        RequestedSchema = new()
-                    }, ct).AsTask();
-
-                    var t2 = server.SampleAsync(new CreateMessageRequestParams
-                    {
-                        Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Concurrent sample" }] }],
-                        MaxTokens = 100
-                    }, ct).AsTask();
-
-                    await Task.WhenAll(t1, t2);
-                    return "done";
-                },
-                new McpServerToolCreateOptions
-                {
-                    Name = "concurrent-tool",
-                    Description = "A tool that attempts concurrent elicitation and sampling"
-                }),
-            McpServerTool.Create(
-                (McpServer server) =>
-                {
-                    // Low-level MRTR: throw InputRequiredException directly instead of using ElicitAsync.
-                    // This should NOT be logged at Error level ΓÇö it's normal MRTR control flow.
-                    throw new InputRequiredException(new InputRequiredResult
-                    {
-                        InputRequests = new Dictionary<string, InputRequest>
-                        {
-                            ["input_1"] = InputRequest.ForElicitation(new ElicitRequestParams
-                            {
-                                Message = "low-level elicit",
-                                RequestedSchema = new()
-                            })
-                        }
-                    });
-                },
-                new McpServerToolCreateOptions
-                {
-                    Name = "incomplete-result-tool",
-                    Description = "A tool that throws InputRequiredException for low-level MRTR"
-                }),
-            McpServerTool.Create(
-                async (McpServer server, RequestContext<CallToolRequestParams> context, CancellationToken ct) =>
-                {
-                    var requestState = context.Params!.RequestState;
-                    var inputResponses = context.Params!.InputResponses;
-
-                    // Final round: we have the requestState from the InputRequiredException
-                    if (requestState == "got-name" && inputResponses is not null
-                        && inputResponses.TryGetValue("age", out var ageResponse))
-                    {
-                        var age = ageResponse.Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Content?.FirstOrDefault().Value;
-                        // Decode the name from requestState ΓÇö in a real scenario, requestState
-                        // would carry the accumulated state, but here we just verify the flow works.
-                        return $"age={age}";
-                    }
-
-                    // First round: use high-level ElicitAsync (handler suspends)
-                    var nameResult = await server.ElicitAsync(new ElicitRequestParams
-                    {
-                        Message = "What is your name?",
-                        RequestedSchema = new()
-                    }, ct);
-
-                    var name = nameResult.Content?.FirstOrDefault().Value;
-
-                    // Second round: switch to low-level InputRequiredException (handler dies)
-                    throw new InputRequiredException(
-                        inputRequests: new Dictionary<string, InputRequest>
-                        {
-                            ["age"] = InputRequest.ForElicitation(new ElicitRequestParams
-                            {
-                                Message = $"How old are you, {name}?",
-                                RequestedSchema = new()
-                            })
-                        },
-                        requestState: "got-name");
-                },
-                new McpServerToolCreateOptions
-                {
-                    Name = "elicit-then-incomplete-result-tool",
-                    Description = "A tool that uses high-level ElicitAsync then throws InputRequiredException"
-                }),
             McpServerTool.Create(
                 async (McpServer server) =>
                 {
-                    // Attempt to send a JsonRpcRequest via SendMessageAsync ΓÇö should always throw
+                    // Attempt to send a JsonRpcRequest via SendMessageAsync — should always throw
                     // since requests must go through SendRequestAsync for response correlation.
                     try
                     {
@@ -172,131 +84,6 @@ await server.SendMessageAsync(new JsonRpcRequest
         ]);
     }
 
-    [Fact]
-    public async Task CallToolAsync_BothExperimental_ElicitCompletesViaMrtr()
-    {
-        // Simplest MRTR success: experimental server + experimental client, one elicitation round.
-        StartServer();
-        var clientOptions = new McpClientOptions { ProtocolVersion = "DRAFT-2026-v1" };
-        clientOptions.Handlers.ElicitationHandler = (request, ct) =>
-            new ValueTask<ElicitResult>(new ElicitResult
-            {
-                Action = "accept",
-                Content = new Dictionary<string, JsonElement>
-                {
-                    ["name"] = JsonSerializer.SerializeToElement("Alice", McpJsonUtilities.DefaultOptions)
-                }
-            });
-
-        await using var client = await CreateMcpClientForServer(clientOptions);
-        Assert.Equal("DRAFT-2026-v1", client.NegotiatedProtocolVersion);
-
-        var result = await client.CallToolAsync("elicitation-tool",
-            new Dictionary<string, object?> { ["message"] = "What is your name?" },
-            cancellationToken: TestContext.Current.CancellationToken);
-
-        var text = Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text;
-        Assert.Equal("accept:Alice", text);
-        Assert.True(result.IsError is not true);
-        _messageTracker.AssertMrtrUsed();
-    }
-
-    [Fact]
-    public async Task CallToolAsync_ConcurrentElicitAndSample_PropagatesError()
-    {
-        // MrtrContext only allows one pending request at a time. When a tool handler
-        // calls ElicitAsync and SampleAsync concurrently via Task.WhenAll, the second
-        // call sees the TCS already completed and throws InvalidOperationException.
-        // That exception is caught by the tool error handler and returned as IsError.
-        StartServer();
-        var clientOptions = new McpClientOptions { ProtocolVersion = "DRAFT-2026-v1" };
-
-        // The first concurrent call (ElicitAsync) produces an InputRequiredResult.
-        // The client resolves it via this handler, which unblocks the first task.
-        // Then Task.WhenAll surfaces the InvalidOperationException from the second task.
-        clientOptions.Handlers.ElicitationHandler = (request, ct) =>
-        {
-            return new ValueTask<ElicitResult>(new ElicitResult { Action = "accept" });
-        };
-        clientOptions.Handlers.SamplingHandler = (request, progress, ct) =>
-        {
-            return new ValueTask<CreateMessageResult>(new CreateMessageResult
-            {
-                Content = [new TextContentBlock { Text = "sampled" }],
-                Model = "test-model"
-            });
-        };
-
-        await using var client = await CreateMcpClientForServer(clientOptions);
-
-        var result = await client.CallToolAsync("concurrent-tool",
-            cancellationToken: TestContext.Current.CancellationToken);
-
-        Assert.True(result.IsError);
-        var errorText = Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text;
-        Assert.Contains("concurrent-tool", errorText);
-        _messageTracker.AssertMrtrUsed();
-    }
-
-    [Fact]
-    public async Task CallToolAsync_ElicitThenIncompleteResultException_WorksEndToEnd()
-    {
-        // Verify that a handler can mix high-level MRTR (ElicitAsync) with low-level MRTR
-        // (InputRequiredException) in a single logical flow. The handler:
-        // 1. Calls ElicitAsync (high-level: handler suspends, InputRequiredResult returned)
-        // 2. Gets the response, then throws InputRequiredException (low-level: handler dies)
-        // 3. On the next retry, a fresh handler invocation processes requestState + inputResponses
-        StartServer();
-        int elicitationCallCount = 0;
-
-        var clientOptions = new McpClientOptions { ProtocolVersion = "DRAFT-2026-v1" };
-        clientOptions.Handlers.ElicitationHandler = (request, ct) =>
-        {
-            elicitationCallCount++;
-            if (request?.Message == "What is your name?")
-            {
-                return new ValueTask<ElicitResult>(new ElicitResult
-                {
-                    Action = "accept",
-                    Content = new Dictionary<string, JsonElement>
-                    {
-                        ["name"] = JsonDocument.Parse("\"Alice\"").RootElement.Clone()
-                    }
-                });
-            }
-
-            // Second elicitation from the InputRequiredException path
-            return new ValueTask<ElicitResult>(new ElicitResult
-            {
-                Action = "accept",
-                Content = new Dictionary<string, JsonElement>
-                {
-                    ["age"] = JsonDocument.Parse("\"30\"").RootElement.Clone()
-                }
-            });
-        };
-
-        await using var client = await CreateMcpClientForServer(clientOptions);
-
-        var result = await client.CallToolAsync(
-            "elicit-then-incomplete-result-tool",
-            cancellationToken: TestContext.Current.CancellationToken);
-
-        // Verify the final result came through correctly
-        var content = Assert.Single(result.Content);
-        Assert.Equal("age=30", Assert.IsType<TextContentBlock>(content).Text);
-        Assert.NotEqual(true, result.IsError);
-
-        // Two elicitations: one from ElicitAsync, one from InputRequiredException's inputRequests
-        Assert.Equal(2, elicitationCallCount);
-
-        // Verify no error-level logs for InputRequiredException
-        Assert.DoesNotContain(MockLoggerProvider.LogMessages, m =>
-            m.LogLevel == LogLevel.Error &&
-            m.Exception is InputRequiredException);
-        _messageTracker.AssertMrtrUsed();
-    }
-
     [Fact]
     public async Task ClientHandlerException_DuringMrtrInputResolution_SurfacesToCaller()
     {