Pre-undraft cleanup: revert unrelated noise, drop low-level/high-level framing, restore lost theory coverage

- Revert BOM-only diffs on AIFunctionMcpServerTool.cs and DelegatingMcpServerTool.cs.
- Drop the unused System.Diagnostics.CodeAnalysis using in McpServerTool.cs.
- Restore the trailing newline in McpServerToolAttribute.cs.
- Revert the NegotiatedProtocolVersion stub change in McpServerTests.cs (only the deleted ThrowIfDraftProtocol gate needed it).
- Drop the stray blank line in MapMcpTests.cs.
- Inline IsLowLevelMrtrAvailable into a public override IsMrtrSupported on McpServerImpl; DestinationBoundMcpServer.IsMrtrSupported is now a simple proxy.
- Rewrite the stale IsStatefulSession XML doc.
- Rename MrtrLowLevelApiTests -> MrtrInputRequiredExceptionTests, and drop low-level/high-level adjectives from MRTR tests + docs.
- Restore InlineData(true) on Mrtr_MixedExceptionAndAwaitStyle (covers draft+stateful mixed mode); add AssertMrtrUsedAtLeastOnce helper.
- Collapse Mrtr_ParallelAwaits to a Fact (under the new contract draft+stateful behaves the same as legacy+stateful).

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

Author: halter73

src/ModelContextProtocol.Core/Protocol/InputRequiredException.cs

@@ -8,7 +8,7 @@ namespace ModelContextProtocol.Protocol;
 /// </summary>
 /// <remarks>
 /// <para>
-/// This exception is part of the low-level Multi Round-Trip Requests (MRTR) API. Tool handlers
+/// This exception is part of the Multi Round-Trip Requests (MRTR) API. Tool handlers
 /// throw this exception to directly control the input-required result payload, including
 /// <see cref="Protocol.InputRequiredResult.InputRequests"/> and <see cref="Protocol.InputRequiredResult.RequestState"/>.
 /// </para>
@@ -30,7 +30,7 @@ namespace ModelContextProtocol.Protocol;
 /// </remarks>
 /// <example>
 /// <code>
-/// [McpServerTool, Description("A stateless tool using low-level MRTR")]
+/// [McpServerTool, Description("A stateless tool using MRTR")]
 /// public static string MyTool(McpServer server, RequestContext&lt;CallToolRequestParams&gt; context)
 /// {
 ///     if (context.Params.RequestState is { } state)

src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.AI;
+using Microsoft.Extensions.AI;
 using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol.Protocol;
 using System.ComponentModel;

src/ModelContextProtocol.Core/Server/DelegatingMcpServerTool.cs

@@ -1,4 +1,4 @@
-using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Protocol;
 
 namespace ModelContextProtocol.Server;
 

src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs

@@ -14,7 +14,7 @@ internal sealed class DestinationBoundMcpServer(McpServerImpl server, ITransport
     public override IServiceProvider? Services => server.Services;
     public override LoggingLevel? LoggingLevel => server.LoggingLevel;
 
-    public override bool IsMrtrSupported => server.IsLowLevelMrtrAvailable();
+    public override bool IsMrtrSupported => server.IsMrtrSupported;
 
     public override ValueTask DisposeAsync() => server.DisposeAsync();
 

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -781,7 +781,7 @@ await originalListToolsHandler(request, cancellationToken).ConfigureAwait(false)
                     // (client request cancellation, session shutdown, MRTR teardown), not a
                     // tool error.
                     // Skip logging for InputRequiredException — it's normal MRTR control flow,
-                    // not an error (the low-level API uses it to signal an InputRequiredResult).
+                    // not an error (tools throw it to signal an InputRequiredResult).
                     if (!(e is OperationCanceledException && cancellationToken.IsCancellationRequested) && e is not InputRequiredException)
                     {
                         ToolCallError(request.Params?.Name ?? string.Empty, e);
@@ -1134,26 +1134,17 @@ internal bool ClientSupportsMrtr() =>
         _negotiatedProtocolVersion == McpSessionHandler.DraftProtocolVersion;
 
     /// <summary>
-    /// Returns <see langword="true"/> when the session is stateful (i.e., the same server instance
-    /// will handle subsequent requests). The implicit MRTR path — where a handler can call
-    /// <c>ElicitAsync</c>/<c>SampleAsync</c> and the SDK suspends/resumes the handler across an
-    /// <see cref="InputRequiredResult"/> round trip — requires the continuation map to outlive the
-    /// initial response, so it is only available on stateful sessions. Stateless transports always
-    /// go through the exception-based path.
+    /// Returns <see langword="true"/> when the session is stateful — the same server instance handles
+    /// subsequent requests on the same session. The legacy backcompat resolver in
+    /// <see cref="InvokeWithInputRequiredResultHandlingAsync"/> needs a stateful session so it can send
+    /// <c>elicitation/create</c> / <c>sampling/createMessage</c> / <c>roots/list</c> to the client and
+    /// retry the handler with the responses.
     /// </summary>
     internal bool IsStatefulSession() =>
         _sessionTransport is not StreamableHttpServerTransport { Stateless: true };
 
-    /// <summary>
-    /// Checks whether the low-level MRTR API (<see cref="InputRequiredException"/>) 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>InputRequiredResult</c>).
-    /// </summary>
-    internal bool IsLowLevelMrtrAvailable() =>
-        ClientSupportsMrtr() ||
-        _sessionTransport is not StreamableHttpServerTransport { Stateless: true };
+    /// <inheritdoc />
+    public override bool IsMrtrSupported => ClientSupportsMrtr() || IsStatefulSession();
 
     /// <summary>
     /// Invokes a handler and catches <see cref="InputRequiredException"/> to convert it to an

src/ModelContextProtocol.Core/Server/McpServerTool.cs

@@ -2,7 +2,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol;
-using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Text.Json;
 

src/ModelContextProtocol.Core/Server/McpServerToolAttribute.cs

@@ -325,5 +325,4 @@ public ToolTaskSupport TaskSupport
         get => _taskSupport ?? ToolTaskSupport.Forbidden;
         set => _taskSupport = value;
     }
-
-}
+}

tests/Common/Utils/ServerMessageTracker.cs

@@ -72,6 +72,16 @@ public void AssertMrtrUsed()
         Assert.Empty(_legacyRequestMethods);
     }
 
+    /// <summary>
+    /// Asserts that MRTR was used at least once (at least one InputRequiredResult response was sent),
+    /// independent of whether the session also issued any legacy server-to-client requests.
+    /// </summary>
+    public void AssertMrtrUsedAtLeastOnce()
+    {
+        Assert.True(_incompleteResultCount > 0,
+            "Expected at least one InputRequiredResult response (MRTR mode), but none were detected.");
+    }
+
     /// <summary>
     /// Asserts that legacy mode was used: at least one legacy JSON-RPC request was sent
     /// and no MRTR retries or InputRequiredResult responses were detected.

tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.Mrtr.cs

@@ -153,6 +153,7 @@ private static async Task<string> MrtrMixed(McpServer server, RequestContext<Cal
 
     [Theory]
     [InlineData(false)]
+    [InlineData(true)]
     public async Task Mrtr_MixedExceptionAndAwaitStyle(bool experimentalClient)
     {
         // The server always supports DRAFT-2026-v1 (it's in SupportedProtocolVersions). The
@@ -217,7 +218,10 @@ public async Task Mrtr_MixedExceptionAndAwaitStyle(bool experimentalClient)
 
         if (experimentalClient)
         {
-            messageTracker.AssertMrtrUsed();
+            // Rounds 1-2 use wire-format MRTR (InputRequiredResult), but round 3's await calls
+            // still issue legacy elicitation/create + sampling/createMessage requests, so this
+            // configuration is mixed-mode.
+            messageTracker.AssertMrtrUsedAtLeastOnce();
         }
         else
         {
@@ -228,75 +232,45 @@ public async Task Mrtr_MixedExceptionAndAwaitStyle(bool experimentalClient)
     [McpServerTool(Name = "mrtr-parallel-await")]
     private static async Task<string> MrtrParallelAwait(McpServer server, CancellationToken ct)
     {
-        // Start the first await — succeeds with MRTR (creates exchange)
         var elicitTask = server.ElicitAsync(new ElicitRequestParams
         {
             Message = "Parallel elicit",
             RequestedSchema = new()
         }, ct);
 
-        // Start the second await. This path is only exercised for legacy clients now
-        // that draft clients must use InputRequiredException instead of await-style requests.
-        try
+        var sampleTask = server.SampleAsync(new CreateMessageRequestParams
         {
-            var sampleTask = server.SampleAsync(new CreateMessageRequestParams
-            {
-                Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Parallel sample" }] }],
-                MaxTokens = 100
-            }, ct);
+            Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Parallel sample" }] }],
+            MaxTokens = 100
+        }, ct);
 
-            // If we get here, both calls succeeded (non-MRTR path)
-            var sampleResult = await sampleTask;
-            var elicitResult = await elicitTask;
-            return $"parallel-ok:{elicitResult.Action}:{sampleResult.Content.OfType<TextContentBlock>().First().Text}";
-        }
-        catch (InvalidOperationException ex)
-        {
-            return ex.Message;
-        }
+        var sampleResult = await sampleTask;
+        var elicitResult = await elicitTask;
+        return $"parallel-ok:{elicitResult.Action}:{sampleResult.Content.OfType<TextContentBlock>().First().Text}";
     }
 
-    [Theory]
-    [InlineData(false)]
-    public async Task Mrtr_ParallelAwaits(bool experimentalClient)
+    [Fact]
+    public async Task Mrtr_ParallelAwaits()
     {
-        // Parallel awaits work with regular JSON-RPC for legacy clients.
-        Assert.SkipWhen(Stateless, "Await-style API requires handler suspension (stateful only).");
+        // Server-side parallel ElicitAsync + SampleAsync awaits use the legacy server-to-client
+        // request path on stateful sessions, which works the same under either negotiated revision
+        // (the spec only removes those request methods from Streamable HTTP under draft, which is
+        // stateless-only territory). Stateless servers can't issue server-to-client requests at all.
+        Assert.SkipWhen(Stateless, "Server-side awaits require stateful server-to-client requests.");
 
-        var messageTracker = ConfigureServer(MrtrParallelAwait);
+        ConfigureServer(MrtrParallelAwait);
         await using var app = Builder.Build();
         app.MapMcp();
         await app.StartAsync(TestContext.Current.CancellationToken);
 
-        Action<McpClientOptions> configureClient = experimentalClient
-            ? options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "DRAFT-2026-v1"; }
-            : ConfigureMrtrHandlers;
-        await using var client = await ConnectAsync(configureClient: configureClient);
-
-        if (experimentalClient)
-        {
-            // Draft clients must use InputRequiredException instead of await-style requests.
-            Assert.Equal("DRAFT-2026-v1", client.NegotiatedProtocolVersion);
-
-            var result = await client.CallToolAsync("mrtr-parallel-await",
-                cancellationToken: TestContext.Current.CancellationToken);
+        await using var client = await ConnectAsync(configureClient: ConfigureMrtrHandlers);
 
-            var text = Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text;
-            Assert.Contains("Concurrent server-to-client requests are not supported", text);
-            Assert.True(result.IsError is not true);
-        }
-        else
-        {
-            // Non-MRTR: awaits go through regular JSON-RPC — concurrent calls work.
-            Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion);
-
-            var result = await client.CallToolAsync("mrtr-parallel-await",
-                cancellationToken: TestContext.Current.CancellationToken);
+        var result = await client.CallToolAsync("mrtr-parallel-await",
+            cancellationToken: TestContext.Current.CancellationToken);
 
-            var text = Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text;
-            Assert.StartsWith("parallel-ok:", text);
-            Assert.True(result.IsError is not true);
-        }
+        var text = Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text;
+        Assert.StartsWith("parallel-ok:", text);
+        Assert.True(result.IsError is not true);
     }
 
     [McpServerTool(Name = "mrtr-elicit")]
@@ -321,7 +295,7 @@ private static string MrtrElicit(RequestContext<CallToolRequestParams> context)
     }
 
     [Fact]
-    public async Task Mrtr_LowLevel_Roots_CompletesViaMrtr()
+    public async Task Mrtr_Roots_CompletesViaMrtr()
     {
         var messageTracker = ConfigureServer(
             [McpServerTool(Name = "mrtr-roots")] (RequestContext<CallToolRequestParams> context) =>
@@ -558,7 +532,7 @@ public async Task Mrtr_ConcurrentThreeInputs_ResolvedSimultaneously()
     }
 
     [Fact]
-    public async Task Mrtr_Experimental_LoadShedding_RequestStateOnly_CompletesViaMrtr()
+    public async Task Mrtr_LoadShedding_RequestStateOnly_CompletesViaMrtr()
     {
         var messageTracker = ConfigureServer(
             [McpServerTool(Name = "mrtr-loadshed")] (RequestContext<CallToolRequestParams> context) =>

tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs

@@ -288,7 +288,6 @@ public async Task LongRunningToolCall_DoesNotTimeout_WhenNoEventStreamStore()
 
     }
 
-
     [Fact]
     public async Task IncomingFilter_SeesClientRequests()
     {