Add MRTR-native backcompat: resolve IncompleteResultException via legacy JSON-RPC

When a tool throws IncompleteResultException and the client doesn't
support MRTR, the server now resolves each InputRequest by sending the
corresponding standard JSON-RPC call (elicitation, sampling, roots) to
the client and retries the handler with the responses. This allows
authors to write a single MRTR-native tool implementation that works
with any client.

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

Author: halter73

docs/concepts/mrtr/mrtr.md

@@ -329,7 +329,45 @@ When a server has MRTR enabled but the connected client does not:
 
 - The high-level API (`ElicitAsync`, `SampleAsync`) automatically falls back to sending standard JSON-RPC requests — no code changes needed.
 - The low-level API reports `IsMrtrSupported == false`, allowing the tool to provide a custom fallback message.
-- Throwing `IncompleteResultException` when MRTR is not supported results in a JSON-RPC error being returned to the client.
+
+### Backward compatibility for MRTR-native tools
+
+Tools written with the low-level MRTR pattern (`IncompleteResultException`) work automatically with clients that don't support MRTR. When a tool throws `IncompleteResultException` and the client hasn't negotiated MRTR, the SDK resolves each `InputRequest` by sending the corresponding standard JSON-RPC call (elicitation, sampling, or roots) to the client, then retries the handler with the resolved responses.
+
+This means you can write a single tool implementation using the MRTR-native pattern and it will work with any client:
+
+```csharp
+[McpServerTool, Description("Get weather with user's preferred units")]
+public static string GetWeather(
+    RequestContext<CallToolRequestParams> context,
+    string location)
+{
+    // On retry, inputResponses and requestState are populated
+    if (context.Params!.InputResponses?.TryGetValue("units", out var response) == true)
+    {
+        var units = response.ElicitationResult?.Content?.FirstOrDefault().Value;
+        return $"Weather for {location} in {units}: 72°";
+    }
+
+    // First call: request the user's preferred units
+    throw new IncompleteResultException(
+        inputRequests: new Dictionary<string, InputRequest>
+        {
+            ["units"] = InputRequest.ForElicitation(new ElicitRequestParams
+            {
+                Message = "Which temperature units?",
+                RequestedSchema = new()
+            })
+        },
+        requestState: "awaiting-units");
+}
+```
+
+- **With an MRTR client**: The `IncompleteResult` is sent over the wire. The client resolves the elicitation and retries with `inputResponses`.
+- **Without MRTR**: The SDK sends a standard `elicitation/create` JSON-RPC request to the client, collects the response, and retries the handler internally. The client never sees the `IncompleteResult`.
+
+> [!NOTE]
+> The backcompat retry loop resolves up to 10 rounds. Tools that need more rounds should use the high-level API (`ElicitAsync`) instead.
 
 ## Transitioning from MRTR to Tasks
 

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -1321,33 +1321,103 @@ private void WrapHandlerWithMrtr(string method)
 
     /// <summary>
     /// Invokes a handler and catches <see cref="IncompleteResultException"/> to convert it to an
-    /// <see cref="IncompleteResult"/> JSON response. In stateless mode, the exception is always
-    /// serialized because the server cannot determine client MRTR support. In stateful mode,
-    /// if MRTR is not supported, the exception is wrapped with a descriptive message.
+    /// <see cref="IncompleteResult"/> JSON response. When MRTR is negotiated or the server is stateless,
+    /// the result is serialized directly. Otherwise, input requests are resolved via standard JSON-RPC
+    /// calls (elicitation, sampling, roots) and the handler is retried with the responses — allowing
+    /// MRTR-native tools to work transparently with clients that don't support MRTR.
     /// </summary>
     private async Task<JsonNode?> InvokeWithIncompleteResultHandlingAsync(
         Func<JsonRpcRequest, CancellationToken, Task<JsonNode?>> handler,
         JsonRpcRequest request,
         CancellationToken cancellationToken)
     {
-        try
-        {
-            return await handler(request, cancellationToken).ConfigureAwait(false);
-        }
-        catch (IncompleteResultException ex)
+        const int MaxRetries = 10;
+
+        for (int retry = 0; ; retry++)
         {
-            // Allow the IncompleteResult if the client supports MRTR or the server is stateless
-            // (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 not StreamableHttpServerTransport { Stateless: true })
+            try
             {
-                throw new McpException(
-                    "A tool handler returned an incomplete result, but the client does not support Multi Round-Trip Requests (MRTR). " +
-                    "Ensure both the server and client have ExperimentalProtocolVersion configured to enable MRTR.",
-                    ex);
+                return await handler(request, cancellationToken).ConfigureAwait(false);
             }
+            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 })
+                {
+                    return SerializeIncompleteResult(ex.IncompleteResult);
+                }
 
-            return SerializeIncompleteResult(ex.IncompleteResult);
+                // Backcompat: resolve input requests via standard JSON-RPC calls and retry the handler.
+                if (ex.IncompleteResult.InputRequests is not { Count: > 0 } inputRequests)
+                {
+                    throw new McpException(
+                        "A tool handler returned an incomplete result without input requests, and the client does not support MRTR.", ex);
+                }
+
+                if (retry >= MaxRetries)
+                {
+                    throw new McpException(
+                        $"MRTR-native tool exceeded {MaxRetries} retry rounds without completing.", ex);
+                }
+
+                // Resolve each input request by sending the corresponding JSON-RPC call to the client.
+                var inputResponses = new Dictionary<string, InputResponse>(inputRequests.Count);
+                foreach (var kvp in inputRequests)
+                {
+                    inputResponses[kvp.Key] = await ResolveInputRequestAsync(kvp.Value, cancellationToken).ConfigureAwait(false);
+                }
+
+                // Reconstruct request params with inputResponses and requestState for the retry.
+                var paramsObj = request.Params?.DeepClone() as JsonObject ?? new JsonObject();
+                paramsObj["inputResponses"] = JsonSerializer.SerializeToNode(
+                    (IDictionary<string, InputResponse>)inputResponses, McpJsonUtilities.JsonContext.Default.IDictionaryStringInputResponse);
+
+                if (ex.IncompleteResult.RequestState is { } requestState)
+                {
+                    paramsObj["requestState"] = requestState;
+                }
+
+                request = new JsonRpcRequest
+                {
+                    Id = request.Id,
+                    Method = request.Method,
+                    Params = paramsObj,
+                    Context = request.Context,
+                };
+            }
+        }
+    }
+
+    /// <summary>
+    /// Resolves a single MRTR <see cref="InputRequest"/> by dispatching it as a standard JSON-RPC
+    /// request to the client. This is the server-side mirror of the client's input resolution logic,
+    /// used for backward compatibility when the client doesn't support MRTR.
+    /// </summary>
+    private async Task<InputResponse> ResolveInputRequestAsync(InputRequest inputRequest, CancellationToken cancellationToken)
+    {
+        switch (inputRequest.Method)
+        {
+            case RequestMethods.ElicitationCreate:
+                var elicitParams = inputRequest.ElicitationParams
+                    ?? throw new McpException("Failed to deserialize elicitation parameters from MRTR input request.");
+                var elicitResult = await ElicitAsync(elicitParams, cancellationToken).ConfigureAwait(false);
+                return InputResponse.FromElicitResult(elicitResult);
+
+            case RequestMethods.SamplingCreateMessage:
+                var samplingParams = inputRequest.SamplingParams
+                    ?? throw new McpException("Failed to deserialize sampling parameters from MRTR input request.");
+                var samplingResult = await SampleAsync(samplingParams, cancellationToken).ConfigureAwait(false);
+                return InputResponse.FromSamplingResult(samplingResult);
+
+            case RequestMethods.RootsList:
+                var rootsParams = inputRequest.RootsParams ?? new ListRootsRequestParams();
+                var rootsResult = await RequestRootsAsync(rootsParams, cancellationToken).ConfigureAwait(false);
+                return InputResponse.FromRootsResult(rootsResult);
+
+            default:
+                throw new McpException($"Unsupported input request method: '{inputRequest.Method}'.");
         }
     }