Apply SEP-2322 spec renames and remove ExperimentalProtocolVersion

- IncompleteResult/IncompleteResultException -> InputRequiredResult/InputRequiredException
- Wire format: result_type -> resultType, `incomplete` -> `input_required`
- Drop ExperimentalProtocolVersion option; opt in via ProtocolVersion = `DRAFT-2026-v1`
- Add DraftProtocolVersion constant and include in SupportedProtocolVersions
- Restrict implicit MRTR continuation path to legacy stateful sessions; DRAFT-2026-v1
  and stateless sessions always use the exception-based path

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

Author: halter73

docs/concepts/elicitation/elicitation.md

@@ -198,7 +198,7 @@ var result = await server.ElicitAsync(new ElicitRequestParams
 
 #### Low-level API
 
-For stateless servers or scenarios requiring manual control, throw <xref:ModelContextProtocol.Protocol.IncompleteResultException> with an elicitation input request. On retry, read the client's response from <xref:ModelContextProtocol.Protocol.RequestParams.InputResponses>:
+For stateless servers or scenarios requiring manual control, throw <xref:ModelContextProtocol.Protocol.InputRequiredException> with an elicitation input request. On retry, read the client's response from <xref:ModelContextProtocol.Protocol.RequestParams.InputResponses>:
 
 ```csharp
 [McpServerTool, Description("Tool that elicits via low-level MRTR")]
@@ -221,7 +221,7 @@ public static string ElicitWithMrtr(
     }
 
     // First call — request user input
-    throw new IncompleteResultException(
+    throw new InputRequiredException(
         inputRequests: new Dictionary<string, InputRequest>
         {
             ["user_input"] = InputRequest.ForElicitation(new ElicitRequestParams

docs/concepts/mrtr/mrtr.md

@@ -26,10 +26,10 @@ MRTR is useful when:
 ## How MRTR works
 
 1. The client calls a tool on the server via `tools/call`.
-2. The server tool determines it needs client input and returns an `IncompleteResult` containing `inputRequests` and/or `requestState`.
+2. The server tool determines it needs client input and returns an `InputRequiredResult` containing `inputRequests` and/or `requestState`.
 3. The client resolves each input request (e.g., prompts the user for elicitation, calls an LLM for sampling).
 4. The client retries the original `tools/call` with `inputResponses` (keyed to the input requests) and `requestState` echoed back.
-5. The server processes the responses and either returns a final result or another `IncompleteResult` for additional rounds.
+5. The server processes the responses and either returns a final result or another `InputRequiredResult` for additional rounds.
 
 ## Opting in
 
@@ -130,7 +130,7 @@ public static string MyTool(
 
 ### Returning an incomplete result
 
-Throw <xref:ModelContextProtocol.Protocol.IncompleteResultException> to return an incomplete result to the client. The exception carries an <xref:ModelContextProtocol.Protocol.IncompleteResult> containing `inputRequests` and/or `requestState`:
+Throw <xref:ModelContextProtocol.Protocol.InputRequiredException> to return an incomplete result to the client. The exception carries an <xref:ModelContextProtocol.Protocol.InputRequiredResult> containing `inputRequests` and/or `requestState`:
 
 ```csharp
 [McpServerTool, Description("Stateless tool managing its own MRTR flow")]
@@ -155,7 +155,7 @@ public static string StatelessTool(
     }
 
     // First call — request user input
-    throw new IncompleteResultException(
+    throw new InputRequiredException(
         inputRequests: new Dictionary<string, InputRequest>
         {
             ["user_answer"] = InputRequest.ForElicitation(new ElicitRequestParams
@@ -217,7 +217,7 @@ public static string DeferredTool(
 
     // Defer work to a later retry
     var initialState = new MyState { Step = 1 };
-    throw new IncompleteResultException(
+    throw new InputRequiredException(
         requestState: Convert.ToBase64String(
             JsonSerializer.SerializeToUtf8Bytes(initialState)));
 }
@@ -227,7 +227,7 @@ The client automatically retries `requestState`-only incomplete results, echoing
 
 ### Multiple round trips
 
-A tool can perform multiple rounds of interaction by throwing `IncompleteResultException` multiple times across retries:
+A tool can perform multiple rounds of interaction by throwing `InputRequiredException` multiple times across retries:
 
 ```csharp
 [McpServerTool, Description("Multi-step wizard")]
@@ -250,7 +250,7 @@ public static string WizardTool(
         var name = inputResponses["name"].ElicitationResult?.Content?.FirstOrDefault().Value;
 
         // Second round — ask for age
-        throw new IncompleteResultException(
+        throw new InputRequiredException(
             inputRequests: new Dictionary<string, InputRequest>
             {
                 ["age"] = InputRequest.ForElicitation(new ElicitRequestParams
@@ -277,7 +277,7 @@ public static string WizardTool(
     }
 
     // First round — ask for name
-    throw new IncompleteResultException(
+    throw new InputRequiredException(
         inputRequests: new Dictionary<string, InputRequest>
         {
             ["name"] = InputRequest.ForElicitation(new ElicitRequestParams
@@ -332,7 +332,7 @@ When a server has MRTR enabled but the connected client does not:
 
 ### 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.
+Tools written with the low-level MRTR pattern (`InputRequiredException`) work automatically with clients that don't support MRTR. When a tool throws `InputRequiredException` 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:
 
@@ -350,7 +350,7 @@ public static string GetWeather(
     }
 
     // First call: request the user's preferred units
-    throw new IncompleteResultException(
+    throw new InputRequiredException(
         inputRequests: new Dictionary<string, InputRequest>
         {
             ["units"] = InputRequest.ForElicitation(new ElicitRequestParams
@@ -363,8 +363,8 @@ public static string GetWeather(
 }
 ```
 
-- **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`.
+- **With an MRTR client**: The `InputRequiredResult` 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 `InputRequiredResult`.
 
 > [!NOTE]
 > The backcompat retry loop resolves up to 10 rounds. Tools that need more rounds should use the high-level API (`ElicitAsync`) instead.

docs/concepts/roots/roots.md

@@ -123,7 +123,7 @@ foreach (var root in result.Roots)
 
 #### Low-level API
 
-For stateless servers or scenarios requiring manual control, throw <xref:ModelContextProtocol.Protocol.IncompleteResultException> with a roots input request. On retry, read the client's response from <xref:ModelContextProtocol.Protocol.RequestParams.InputResponses>:
+For stateless servers or scenarios requiring manual control, throw <xref:ModelContextProtocol.Protocol.InputRequiredException> with a roots input request. On retry, read the client's response from <xref:ModelContextProtocol.Protocol.RequestParams.InputResponses>:
 
 ```csharp
 [McpServerTool, Description("Tool that requests roots via low-level MRTR")]
@@ -144,7 +144,7 @@ public static string ListRootsWithMrtr(
     }
 
     // First call — request the client's root list
-    throw new IncompleteResultException(
+    throw new InputRequiredException(
         inputRequests: new Dictionary<string, InputRequest>
         {
             ["get_roots"] = InputRequest.ForRootsList(new ListRootsRequestParams())

docs/concepts/sampling/sampling.md

@@ -149,7 +149,7 @@ var result = await server.SampleAsync(
 
 #### Low-level API
 
-For stateless servers or scenarios requiring manual control, throw <xref:ModelContextProtocol.Protocol.IncompleteResultException> with a sampling input request. On retry, read the client's response from <xref:ModelContextProtocol.Protocol.RequestParams.InputResponses>:
+For stateless servers or scenarios requiring manual control, throw <xref:ModelContextProtocol.Protocol.InputRequiredException> with a sampling input request. On retry, read the client's response from <xref:ModelContextProtocol.Protocol.RequestParams.InputResponses>:
 
 ```csharp
 [McpServerTool, Description("Tool that samples via low-level MRTR")]
@@ -171,7 +171,7 @@ public static string SampleWithMrtr(
     }
 
     // First call — request LLM completion from the client
-    throw new IncompleteResultException(
+    throw new InputRequiredException(
         inputRequests: new Dictionary<string, InputRequest>
         {
             ["llm_call"] = InputRequest.ForSampling(new CreateMessageRequestParams

src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs

@@ -552,8 +552,7 @@ private bool ValidateProtocolVersionHeader(HttpContext context, out string? erro
     {
         var protocolVersionHeader = context.Request.Headers[McpProtocolVersionHeaderName].ToString();
         if (!string.IsNullOrEmpty(protocolVersionHeader) &&
-            !s_supportedProtocolVersions.Contains(protocolVersionHeader) &&
-            !(mcpServerOptionsSnapshot.Value.ExperimentalProtocolVersion is { } experimentalVersion && protocolVersionHeader == experimentalVersion))
+            !s_supportedProtocolVersions.Contains(protocolVersionHeader))
         {
             errorMessage = $"Bad Request: The MCP-Protocol-Version header value '{protocolVersionHeader}' is not supported.";
             return false;

src/ModelContextProtocol.Core/Client/McpClientImpl.cs

@@ -650,7 +650,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
             try
             {
                 // Send initialize request
-                string requestProtocol = _options.ProtocolVersion ?? _options.ExperimentalProtocolVersion ?? McpSessionHandler.LatestProtocolVersion;
+                string requestProtocol = _options.ProtocolVersion ?? McpSessionHandler.LatestProtocolVersion;
                 var initializeResponse = await SendRequestAsync(
                     RequestMethods.Initialize,
                     new InitializeRequestParams
@@ -678,8 +678,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
                 // Validate protocol version
                 bool isResponseProtocolValid =
                     _options.ProtocolVersion is { } optionsProtocol ? optionsProtocol == initializeResponse.ProtocolVersion :
-                    McpSessionHandler.SupportedProtocolVersions.Contains(initializeResponse.ProtocolVersion) ||
-                    (_options.ExperimentalProtocolVersion is not null && _options.ExperimentalProtocolVersion == initializeResponse.ProtocolVersion);
+                    McpSessionHandler.SupportedProtocolVersions.Contains(initializeResponse.ProtocolVersion);
                 if (!isResponseProtocolValid)
                 {
                     LogServerProtocolVersionMismatch(_endpointName, requestProtocol, initializeResponse.ProtocolVersion);
@@ -832,17 +831,17 @@ request.Params is System.Text.Json.Nodes.JsonObject paramsObjForHeaders &&
         {
             JsonRpcResponse response = await _sessionHandler.SendRequestAsync(request, cancellationToken).ConfigureAwait(false);
 
-            // Check if the result is an IncompleteResult by looking at result_type.
+            // Check if the result is an InputRequiredResult by looking at result_type.
             if (response.Result is JsonObject resultObj &&
-                resultObj.TryGetPropertyValue("result_type", out var resultTypeNode) &&
-                resultTypeNode?.GetValue<string>() is "incomplete")
+                resultObj.TryGetPropertyValue("resultType", out var resultTypeNode) &&
+                resultTypeNode?.GetValue<string>() is "input_required")
             {
-                WarnIfIncompleteResultOnNonMrtrSession(request.Method);
+                WarnIfInputRequiredResultOnNonMrtrSession(request.Method);
 
-                var incompleteResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.JsonContext.Default.IncompleteResult)
-                    ?? throw new JsonException("Failed to deserialize IncompleteResult.");
+                var InputRequiredResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.JsonContext.Default.InputRequiredResult)
+                    ?? throw new JsonException("Failed to deserialize InputRequiredResult.");
 
-                if (incompleteResult.InputRequests is { Count: > 0 } inputRequests)
+                if (InputRequiredResult.InputRequests is { Count: > 0 } inputRequests)
                 {
                     IDictionary<string, InputResponse> inputResponses =
                         await ResolveInputRequestsAsync(inputRequests, cancellationToken).ConfigureAwait(false);
@@ -853,25 +852,25 @@ request.Params is System.Text.Json.Nodes.JsonObject paramsObjForHeaders &&
                     paramsObj["inputResponses"] = JsonSerializer.SerializeToNode(
                         inputResponses, McpJsonUtilities.JsonContext.Default.IDictionaryStringInputResponse);
 
-                    if (incompleteResult.RequestState is { } requestState)
+                    if (InputRequiredResult.RequestState is { } requestState)
                     {
                         paramsObj["requestState"] = requestState;
                     }
 
                     request = new JsonRpcRequest { Method = request.Method, Params = paramsObj, Context = request.Context };
                 }
-                else if (incompleteResult.RequestState is not null)
+                else if (InputRequiredResult.RequestState is not null)
                 {
                     // No input requests but has requestState (e.g., load shedding) — just retry with state.
                     var paramsObj = request.Params?.DeepClone() as JsonObject ?? new JsonObject();
-                    paramsObj["requestState"] = incompleteResult.RequestState;
+                    paramsObj["requestState"] = InputRequiredResult.RequestState;
                     paramsObj.Remove("inputResponses");
 
                     request = new JsonRpcRequest { Method = request.Method, Params = paramsObj, Context = request.Context };
                 }
                 else
                 {
-                    throw new McpException("Server returned an IncompleteResult without inputRequests or requestState.");
+                    throw new McpException("Server returned an InputRequiredResult without inputRequests or requestState.");
                 }
 
                 continue; // retry with the updated request
@@ -880,7 +879,7 @@ request.Params is System.Text.Json.Nodes.JsonObject paramsObjForHeaders &&
             return response;
         }
 
-        throw new McpException($"Server returned IncompleteResult more than {maxRetries} times.");
+        throw new McpException($"Server returned InputRequiredResult more than {maxRetries} times.");
     }
 
     /// <inheritdoc/>
@@ -919,28 +918,26 @@ public override async ValueTask DisposeAsync()
     /// <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)
+        if (_negotiatedProtocolVersion == McpSessionHandler.DraftProtocolVersion)
         {
             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)
+    /// <summary>Logs a warning if the session did not negotiate MRTR but the server sent an InputRequiredResult.</summary>
+    private void WarnIfInputRequiredResultOnNonMrtrSession(string method)
     {
-        if (_options.ExperimentalProtocolVersion is null ||
-            _negotiatedProtocolVersion != _options.ExperimentalProtocolVersion)
+        if (_negotiatedProtocolVersion != McpSessionHandler.DraftProtocolVersion)
         {
-            LogIncompleteResultOnNonMrtrSession(_endpointName, method, _negotiatedProtocolVersion);
+            LogInputRequiredResultOnNonMrtrSession(_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.")]
+    [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} received legacy '{Method}' JSON-RPC request on session that negotiated MRTR. The server should use InputRequiredResult 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.Warning, Message = "{EndpointName} received InputRequiredResult for '{Method}' on session that did not negotiate MRTR (protocol version '{ProtocolVersion}'). The server may not be spec-compliant.")]
+    private partial void LogInputRequiredResultOnNonMrtrSession(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);

src/ModelContextProtocol.Core/Client/McpClientOptions.cs

@@ -111,24 +111,4 @@ public McpClientHandlers Handlers
     /// </remarks>
     [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)]
     public bool SendTaskStatusNotifications { get; set; } = true;
-
-    /// <summary>
-    /// Gets or sets an experimental protocol version that enables draft protocol features such as
-    /// Multi Round-Trip Requests (MRTR).
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// When set, this version is used as the requested protocol version during initialization instead of
-    /// the latest stable version. The server must also have a matching <c>ExperimentalProtocolVersion</c>
-    /// configured for the experimental features to activate. If the server does not recognize the
-    /// experimental version, it will negotiate to the latest stable version and the client will work
-    /// normally without experimental features.
-    /// </para>
-    /// <para>
-    /// This property is intended for proof-of-concept and testing of draft MCP specification features
-    /// that have not yet been ratified.
-    /// </para>
-    /// </remarks>
-    [Experimental(Experimentals.Mrtr_DiagnosticId, UrlFormat = Experimentals.Mrtr_Url)]
-    public string? ExperimentalProtocolVersion { get; set; }
 }

src/ModelContextProtocol.Core/McpJsonUtilities.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.AI;
+using Microsoft.Extensions.AI;
 using ModelContextProtocol.Authentication;
 using ModelContextProtocol.Protocol;
 using System.Diagnostics.CodeAnalysis;
@@ -145,7 +145,7 @@ internal static bool IsValidMcpToolSchema(JsonElement element)
     [JsonSerializable(typeof(UnsubscribeRequestParams))]
 
     // MCP MRTR (Multi Round-Trip Requests)
-    [JsonSerializable(typeof(IncompleteResult))]
+    [JsonSerializable(typeof(InputRequiredResult))]
     [JsonSerializable(typeof(InputRequest))]
     [JsonSerializable(typeof(InputResponse))]
     [JsonSerializable(typeof(IDictionary<string, InputRequest>))]