Consolidate and tighten MRTR test coverage

Refactor MRTR tests to provide extensive coverage with less code, making
it easy for reviewers and other SDK implementers to see edge case
coverage at a glance.

Test consolidation:
- Move MRTR tests into MapMcpTests.Mrtr.cs partial class, which runs
  every test across StreamableHttp, SSE, and Stateless transports
- Use Theory tests with (experimentalServer, experimentalClient) bools
  to cover all 4 MRTR/backcompat protocol combinations
- Delete MrtrBackcompatTests.cs, StatelessMrtrTests.cs, and
  StreamableHttpMrtrTests.cs (coverage subsumed by MapMcpTests)
- Reduce MrtrLowLevelApiTests.cs and MrtrProtocolTests.cs to unique
  protocol-level tests not covered by McpClient-based tests
- Update MrtrIntegrationTests doc to reflect edge-case focus and add
  simple happy-path smoke test for reviewer reference

Test improvements:
- Add ServerMessageTracker with AssertMrtrUsed()/AssertMrtrNotUsed()
  to verify correct protocol mode in every test
- Add NegotiatedProtocolVersion assertions to verify negotiation
- Add result.IsError checks on all success-path tool results
- Add ErrorCode assertions on all error-path tests
- Tighten all version assertions to exact values (no NotEqual)

Helpers:
- ConnectAsync takes Action<McpClientOptions>? to prevent bypassing
  transport config (path/TransportMode defaults)
- ConfigureExperimentalServer/ConfigureDefaultServer with distinct
  Implementation names for clear test output
- ConfigureMrtrHandlers configures elicitation, sampling, and roots
  handlers on an existing McpClientOptions object
- ConnectExperimentalAsync/ConnectDefaultAsync for common patterns
- Move EnablePollingAsync stateless test to MapMcpStatelessTests
- Add client-side warnings for legacy requests on MRTR sessions and
  IncompleteResult on non-MRTR sessions

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

Author: halter73

src/ModelContextProtocol.Core/Client/McpClientImpl.cs

@@ -120,6 +120,8 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not
                     RequestMethods.SamplingCreateMessage,
                     async (request, jsonRpcRequest, cancellationToken) =>
                     {
+                        WarnIfLegacyRequestOnMrtrSession(RequestMethods.SamplingCreateMessage);
+
                         // Check if this is a task-augmented request
                         if (request?.Task is { } taskMetadata)
                         {
@@ -154,10 +156,14 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not
             {
                 requestHandlers.Set(
                     RequestMethods.SamplingCreateMessage,
-                    (request, _, cancellationToken) => samplingHandler(
-                        request,
-                        request?.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance,
-                        cancellationToken),
+                    (request, _, cancellationToken) =>
+                    {
+                        WarnIfLegacyRequestOnMrtrSession(RequestMethods.SamplingCreateMessage);
+                        return samplingHandler(
+                            request,
+                            request?.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance,
+                            cancellationToken);
+                    },
                     McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams,
                     McpJsonUtilities.JsonContext.Default.CreateMessageResult);
             }
@@ -170,7 +176,11 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not
         {
             requestHandlers.Set(
                 RequestMethods.RootsList,
-                (request, _, cancellationToken) => rootsHandler(request, cancellationToken),
+                (request, _, cancellationToken) =>
+                {
+                    WarnIfLegacyRequestOnMrtrSession(RequestMethods.RootsList);
+                    return rootsHandler(request, cancellationToken);
+                },
                 McpJsonUtilities.JsonContext.Default.ListRootsRequestParams,
                 McpJsonUtilities.JsonContext.Default.ListRootsResult);
 
@@ -187,6 +197,8 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not
                     RequestMethods.ElicitationCreate,
                     async (request, jsonRpcRequest, cancellationToken) =>
                     {
+                        WarnIfLegacyRequestOnMrtrSession(RequestMethods.ElicitationCreate);
+
                         // Check if this is a task-augmented request
                         if (request?.Task is { } taskMetadata)
                         {
@@ -219,6 +231,7 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not
                     RequestMethods.ElicitationCreate,
                     async (request, _, cancellationToken) =>
                     {
+                        WarnIfLegacyRequestOnMrtrSession(RequestMethods.ElicitationCreate);
                         var result = await elicitationHandler(request, cancellationToken).ConfigureAwait(false);
                         return ElicitResult.WithDefaults(request, result);
                     },
@@ -718,6 +731,8 @@ public override async Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest requ
                 resultObj.TryGetPropertyValue("result_type", out var resultTypeNode) &&
                 resultTypeNode?.GetValue<string>() is "incomplete")
             {
+                WarnIfIncompleteResultOnNonMrtrSession(request.Method);
+
                 var incompleteResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.JsonContext.Default.IncompleteResult)
                     ?? throw new JsonException("Failed to deserialize IncompleteResult.");
 
@@ -795,6 +810,32 @@ public override async ValueTask DisposeAsync()
         await Completion.ConfigureAwait(false);
     }
 
+    /// <summary>Logs a warning if the session negotiated MRTR but the server sent a legacy JSON-RPC request.</summary>
+    private void WarnIfLegacyRequestOnMrtrSession(string method)
+    {
+        if (_options.ExperimentalProtocolVersion is not null &&
+            _negotiatedProtocolVersion == _options.ExperimentalProtocolVersion)
+        {
+            LogLegacyRequestOnMrtrSession(_endpointName, method);
+        }
+    }
+
+    /// <summary>Logs a warning if the session did not negotiate MRTR but the server sent an IncompleteResult.</summary>
+    private void WarnIfIncompleteResultOnNonMrtrSession(string method)
+    {
+        if (_options.ExperimentalProtocolVersion is null ||
+            _negotiatedProtocolVersion != _options.ExperimentalProtocolVersion)
+        {
+            LogIncompleteResultOnNonMrtrSession(_endpointName, method, _negotiatedProtocolVersion);
+        }
+    }
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} received legacy '{Method}' JSON-RPC request on session that negotiated MRTR. The server should use IncompleteResult instead of sending direct requests.")]
+    private partial void LogLegacyRequestOnMrtrSession(string endpointName, string method);
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} received IncompleteResult for '{Method}' on session that did not negotiate MRTR (protocol version '{ProtocolVersion}'). The server may not be spec-compliant.")]
+    private partial void LogIncompleteResultOnNonMrtrSession(string endpointName, string method, string? protocolVersion);
+
     [LoggerMessage(Level = LogLevel.Information, Message = "{EndpointName} client received server '{ServerInfo}' capabilities: '{Capabilities}'.")]
     private partial void LogServerCapabilitiesReceived(string endpointName, string capabilities, string serverInfo);
 
@@ -812,5 +853,4 @@ public override async ValueTask DisposeAsync()
 
     [LoggerMessage(Level = LogLevel.Information, Message = "{EndpointName} client resumed existing session.")]
     private partial void LogClientSessionResumed(string endpointName);
-
 }

src/ModelContextProtocol.Core/McpSession.cs

@@ -68,7 +68,7 @@ public abstract partial class McpSession : IAsyncDisposable
     /// </param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task that represents the asynchronous send operation.</returns>
-    /// <exception cref="InvalidOperationException">The transport is not connected.</exception>
+    /// <exception cref="InvalidOperationException">The transport is not connected, or <paramref name="message"/> is a <see cref="JsonRpcRequest"/>. Use <see cref="SendRequestAsync"/> for requests.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="message"/> is <see langword="null"/>.</exception>
     /// <remarks>
     /// <para>

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -593,10 +593,7 @@ public async Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest request, Canc
                 LogSendingRequest(EndpointName, request.Method);
             }
 
-            await _outgoingMessageFilter(async (msg, ct) =>
-            {
-                await SendToRelatedTransportAsync(msg, ct).ConfigureAwait(false);
-            })(request, cancellationToken).ConfigureAwait(false);
+            await _outgoingMessageFilter(SendToRelatedTransportAsync)(request, cancellationToken).ConfigureAwait(false);
 
             // Now that the request has been sent, register for cancellation. If we registered before,
             // a cancellation request could arrive before the server knew about that request ID, in which
@@ -654,6 +651,13 @@ public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken can
     {
         Throw.IfNull(message);
 
+        if (message is JsonRpcRequest request)
+        {
+            throw new InvalidOperationException(
+                $"Cannot send '{request.Method}' request via {nameof(SendMessageAsync)}. " +
+                $"Use {nameof(SendRequestAsync)} instead to get a correlated response.");
+        }
+
         cancellationToken.ThrowIfCancellationRequested();
 
         Histogram<double> durationMetric = _isServer ? s_serverOperationDuration : s_clientOperationDuration;

tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStatelessTests.cs

@@ -1,7 +1,45 @@
-namespace ModelContextProtocol.AspNetCore.Tests;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+
+namespace ModelContextProtocol.AspNetCore.Tests;
 
 public class MapMcpStatelessTests(ITestOutputHelper outputHelper) : MapMcpStreamableHttpTests(outputHelper)
 {
     protected override bool UseStreamableHttp => true;
     protected override bool Stateless => true;
+
+    [Fact]
+    public async Task EnablePollingAsync_ThrowsInvalidOperationException_InStatelessMode()
+    {
+        InvalidOperationException? capturedException = null;
+        var pollingTool = McpServerTool.Create(async (RequestContext<CallToolRequestParams> context) =>
+        {
+            try
+            {
+                await context.EnablePollingAsync(retryInterval: TimeSpan.FromSeconds(1));
+            }
+            catch (InvalidOperationException ex)
+            {
+                capturedException = ex;
+            }
+
+            return "Complete";
+        }, options: new() { Name = "polling_tool" });
+
+        Builder.Services.AddMcpServer().WithHttpTransport(ConfigureStateless).WithTools([pollingTool]);
+
+        await using var app = Builder.Build();
+        app.MapMcp();
+
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        await using var mcpClient = await ConnectAsync();
+
+        await mcpClient.CallToolAsync("polling_tool", cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.NotNull(capturedException);
+        Assert.Contains("stateless", capturedException.Message, StringComparison.OrdinalIgnoreCase);
+    }
 }

tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStreamableHttpTests.cs

@@ -178,9 +178,9 @@ public async Task StreamableHttpClient_SendsMcpProtocolVersionHeader_AfterInitia
 
         await app.StartAsync(TestContext.Current.CancellationToken);
 
-        await using var mcpClient = await ConnectAsync(clientOptions: new()
+        await using var mcpClient = await ConnectAsync(configureClient: options =>
         {
-            ProtocolVersion = "2025-06-18",
+            options.ProtocolVersion = "2025-06-18";
         });
 
         Assert.Equal("2025-06-18", mcpClient.NegotiatedProtocolVersion);
@@ -288,41 +288,6 @@ public async Task CanResumeSessionWithMapMcpAndRunSessionHandler()
         Assert.Equal(1, runSessionCount);
     }
 
-    [Fact]
-    public async Task EnablePollingAsync_ThrowsInvalidOperationException_InStatelessMode()
-    {
-        Assert.SkipUnless(Stateless, "This test only applies to stateless mode.");
-
-        InvalidOperationException? capturedException = null;
-        var pollingTool = McpServerTool.Create(async (RequestContext<CallToolRequestParams> context) =>
-        {
-            try
-            {
-                await context.EnablePollingAsync(retryInterval: TimeSpan.FromSeconds(1));
-            }
-            catch (InvalidOperationException ex)
-            {
-                capturedException = ex;
-            }
-
-            return "Complete";
-        }, options: new() { Name = "polling_tool" });
-
-        Builder.Services.AddMcpServer().WithHttpTransport(ConfigureStateless).WithTools([pollingTool]);
-
-        await using var app = Builder.Build();
-        app.MapMcp();
-
-        await app.StartAsync(TestContext.Current.CancellationToken);
-
-        await using var mcpClient = await ConnectAsync();
-
-        await mcpClient.CallToolAsync("polling_tool", cancellationToken: TestContext.Current.CancellationToken);
-
-        Assert.NotNull(capturedException);
-        Assert.Contains("stateless", capturedException.Message, StringComparison.OrdinalIgnoreCase);
-    }
-
     [Fact]
     public async Task EnablePollingAsync_ThrowsInvalidOperationException_WhenNoEventStreamStoreConfigured()
     {