Gate high-level server-to-client requests on stateless mode, not draft protocol

ElicitAsync/SampleAsync/RequestRootsAsync now throw only when the server is stateless (the existing ThrowIf*Unsupported guards already handled this). Stdio + DRAFT-2026-v1 keeps working via the legacy server-to-client JSON-RPC path; stateless Streamable HTTP throws regardless of protocol revision. A follow-up will force DRAFT-2026-v1 Streamable HTTP to stateless mode.

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

Author: halter73

docs/concepts/elicitation/elicitation.md

@@ -172,10 +172,10 @@ Here's an example implementation of how a console application might handle elici
 
 ### Multi Round-Trip Requests (MRTR)
 
-[MRTR](xref:mrtr) is the SEP-2322 mechanism for server-driven input requests, finalized in protocol revision `DRAFT-2026-v1`. Under the draft protocol, the server-to-client `elicitation/create` request method is removed; the only supported way to ask the user for input from a server handler is to throw <xref:ModelContextProtocol.Protocol.InputRequiredException> and let the SDK emit an <xref:ModelContextProtocol.Protocol.InputRequiredResult> on the wire.
+[MRTR](xref:mrtr) is the SEP-2322 mechanism for server-driven input requests, finalized in protocol revision `DRAFT-2026-v1`. Under the draft protocol, the server-to-client `elicitation/create` request method is removed; the recommended way to ask the user for input from a server handler is to throw <xref:ModelContextProtocol.Protocol.InputRequiredException> and let the SDK emit an <xref:ModelContextProtocol.Protocol.InputRequiredResult> on the wire.
 
 > [!IMPORTANT]
-> Calling `ElicitAsync` after negotiating `DRAFT-2026-v1` throws `InvalidOperationException`. Use `InputRequiredException` from your tool/prompt handler instead — it works under both the current protocol (resolved via legacy JSON-RPC + retry on stateful sessions) and the draft protocol (wire-format `InputRequiredResult`, no server-side handler state required).
+> `ElicitAsync` throws `InvalidOperationException("Elicitation is not supported in stateless mode.")` whenever the server is running stateless — which includes every Streamable HTTP server under `DRAFT-2026-v1` once that revision is forced to stateless-only in a future PR. Stdio servers and current-protocol stateful Streamable HTTP servers continue to work via the legacy server-to-client `elicitation/create` request flow. For code that needs to run on stateless servers — including all `DRAFT-2026-v1` Streamable HTTP servers going forward — throw `InputRequiredException` from your handler instead. It works under both protocols and both session modes.
 
 For example:
 
@@ -188,7 +188,7 @@ public static string ElicitWithMrtr(
     // On retry, process the client's elicitation response
     if (context.Params!.InputResponses?.TryGetValue("user_input", out var response) is true)
     {
-        var elicitResult = response.Deserialize(InputResponse.ElicitResultTypeInfo);
+        var elicitResult = response.Deserialize(InputResponse.ElicitResultJsonTypeInfo);
         return elicitResult?.Action == "accept"
             ? $"User accepted: {elicitResult.Content?.FirstOrDefault().Value}"
             : "User declined.";

docs/concepts/mrtr/mrtr.md

@@ -48,7 +48,7 @@ var clientOptions = new McpClientOptions
 };
 ```
 
-Under `DRAFT-2026-v1`, MRTR is the **only** way to obtain client input from a server handler. The legacy server-to-client `elicitation/create`, `sampling/createMessage`, and `roots/list` request methods are removed; calling <xref:ModelContextProtocol.Server.McpServer.ElicitAsync*>, <xref:ModelContextProtocol.Server.McpServer.SampleAsync*>, or <xref:ModelContextProtocol.Server.McpServer.RequestRootsAsync*> on a server that negotiated `DRAFT-2026-v1` throws `InvalidOperationException`. Tools that need client input must throw <xref:ModelContextProtocol.Protocol.InputRequiredException> instead.
+Under `DRAFT-2026-v1`, MRTR is the recommended way to obtain client input from a server handler. The spec removes the legacy server-to-client `elicitation/create`, `sampling/createMessage`, and `roots/list` request methods, so any code that needs to work on a `DRAFT-2026-v1` Streamable HTTP server (which will be stateless-only in a future revision) must use `InputRequiredException` rather than <xref:ModelContextProtocol.Server.McpServer.ElicitAsync*>, <xref:ModelContextProtocol.Server.McpServer.SampleAsync*>, or <xref:ModelContextProtocol.Server.McpServer.RequestRootsAsync*>. The legacy methods still work on stateful sessions — that's how stdio servers keep working under draft today — but they throw `InvalidOperationException("X is not supported in stateless mode.")` on any stateless session, current or draft.
 
 Under the current protocol revision (`2025-06-18` and earlier), `InputRequiredException` is still supported in stateful sessions via a backward-compatibility resolver — see [Compatibility](#compatibility) below.
 
@@ -96,7 +96,7 @@ public static string AnswerTool(
     // On retry, process the client's responses
     if (requestState is not null && inputResponses is not null)
     {
-        var elicitResult = inputResponses["user_answer"].Deserialize(InputResponse.ElicitResultTypeInfo);
+        var elicitResult = inputResponses["user_answer"].Deserialize(InputResponse.ElicitResultJsonTypeInfo);
         return $"You answered: {elicitResult?.Content?.FirstOrDefault().Value}";
     }
 
@@ -137,9 +137,9 @@ When the client retries a tool call, the retry data is available on the request
 
 Use <xref:ModelContextProtocol.Protocol.InputResponse.Deserialize*> with the `JsonTypeInfo<T>` matching the response type. The expected type follows from the matching <xref:ModelContextProtocol.Protocol.InputRequest.Method> in the original `inputRequests` map — there is no on-the-wire discriminator.
 
-- Elicitation — `response.Deserialize(InputResponse.ElicitResultTypeInfo)`
-- Sampling — `response.Deserialize(InputResponse.SamplingResultTypeInfo)`
-- Roots list — `response.Deserialize(InputResponse.RootsResultTypeInfo)`
+- Elicitation — `response.Deserialize(InputResponse.ElicitResultJsonTypeInfo)`
+- Sampling — `response.Deserialize(InputResponse.CreateMessageResultJsonTypeInfo)`
+- Roots list — `response.Deserialize(InputResponse.ListRootsResultJsonTypeInfo)`
 
 ### Load shedding with requestState-only responses
 
@@ -191,14 +191,14 @@ public static string WizardTool(
 
     if (requestState == "step-2" && inputResponses is not null)
     {
-        var name = inputResponses["name"].Deserialize(InputResponse.ElicitResultTypeInfo)?.Content?.FirstOrDefault().Value;
-        var age = inputResponses["age"].Deserialize(InputResponse.ElicitResultTypeInfo)?.Content?.FirstOrDefault().Value;
+        var name = inputResponses["name"].Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Content?.FirstOrDefault().Value;
+        var age = inputResponses["age"].Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Content?.FirstOrDefault().Value;
         return $"Welcome, {name}! You are {age} years old.";
     }
 
     if (requestState == "step-1" && inputResponses is not null)
     {
-        var name = inputResponses["name"].Deserialize(InputResponse.ElicitResultTypeInfo)?.Content?.FirstOrDefault().Value;
+        var name = inputResponses["name"].Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Content?.FirstOrDefault().Value;
 
         // Second round — ask for age
         throw new InputRequiredException(
@@ -278,14 +278,14 @@ The SDK supports `InputRequiredException` across two protocol revisions and two
 > [!NOTE]
 > The backcompat resolver is intentionally limited to 10 retry rounds. Tools that need more rounds should require `DRAFT-2026-v1` (check `IsMrtrSupported`).
 
-### Why `ElicitAsync` / `SampleAsync` / `RequestRootsAsync` throw under draft
+### Why `ElicitAsync` / `SampleAsync` / `RequestRootsAsync` throw on stateless servers
 
-The `DRAFT-2026-v1` revision removes the server-to-client `elicitation/create`, `sampling/createMessage`, and `roots/list` request methods entirely. Servers cannot use those request methods because clients no longer advertise the corresponding capabilities or implement handlers for them. The SDK fails fast with a clear `InvalidOperationException` so you can fix the call site before it manifests as a wire-level error.
+`ElicitAsync` / `SampleAsync` / `RequestRootsAsync` issue a JSON-RPC request to the client and wait for the response on the same session. Stateless servers don't have a persistent session to wait on, so the SDK fails fast with `InvalidOperationException("X is not supported in stateless mode.")` (the check is `McpServer.ClientCapabilities is null`, which is the SDK's proxy for stateless).
 
-Under the current protocol revision (`2025-06-18` and earlier), these methods continue to work normally and are the recommended way to do simple, one-shot client interactions. `InputRequiredException` is the way to write tools that work the same on both revisions.
+Under the current protocol revision (`2025-06-18` and earlier), stdio and stateful Streamable HTTP keep `ClientCapabilities` populated, so the legacy methods work normally and remain the recommended way to do one-shot client interactions. Under `DRAFT-2026-v1`, the spec removes those request methods from Streamable HTTP entirely; the SDK still allows the legacy methods on draft stdio sessions because stdio is implicitly single-process / stateful and the client handler is wired up regardless of negotiated revision. `InputRequiredException` is the way to write tools that work on every supported configuration.
 
 ### Future direction
 
-The `DRAFT-2026-v1` revision is moving toward a stateless-only model: `Mcp-Session-Id` is being removed, and Streamable HTTP servers will run statelessly by default under the draft revision. When that happens, the `Stateful` row of the compatibility matrix above collapses into the `Stateless` row, and `InputRequiredException` becomes uniformly native across both. The current-protocol resolver path will remain for backward compatibility with older clients and stateful servers.
+The `DRAFT-2026-v1` revision is moving toward a stateless-only model: `Mcp-Session-Id` is being removed, and Streamable HTTP servers will run statelessly by default under the draft revision. When that lands, the `Stateful` row for `DRAFT-2026-v1` in the compatibility matrix above collapses into the `Stateless` row (Streamable HTTP under draft becomes stateless-only), and `InputRequiredException` becomes uniformly required for non-stdio servers. The current-protocol resolver path will remain for backward compatibility with older clients and stateful servers.
 
 This work is a follow-up to the present PR.

docs/concepts/roots/roots.md

@@ -106,10 +106,10 @@ server.RegisterNotificationHandler(
 
 ### Multi Round-Trip Requests (MRTR)
 
-[MRTR](xref:mrtr) is the SEP-2322 mechanism for server-driven input requests, finalized in protocol revision `DRAFT-2026-v1`. Under the draft protocol, the server-to-client `roots/list` request method is removed; the only supported way to ask the client for its roots from a server handler is to throw <xref:ModelContextProtocol.Protocol.InputRequiredException> and let the SDK emit an <xref:ModelContextProtocol.Protocol.InputRequiredResult> on the wire.
+[MRTR](xref:mrtr) is the SEP-2322 mechanism for server-driven input requests, finalized in protocol revision `DRAFT-2026-v1`. Under the draft protocol, the server-to-client `roots/list` request method is removed; the recommended way to ask the client for its roots from a server handler is to throw <xref:ModelContextProtocol.Protocol.InputRequiredException> and let the SDK emit an <xref:ModelContextProtocol.Protocol.InputRequiredResult> on the wire.
 
 > [!IMPORTANT]
-> Calling `RequestRootsAsync` after negotiating `DRAFT-2026-v1` throws `InvalidOperationException`. Use `InputRequiredException` from your tool/prompt handler instead — it works under both the current protocol (resolved via legacy JSON-RPC + retry on stateful sessions) and the draft protocol (wire-format `InputRequiredResult`, no server-side handler state required).
+> `RequestRootsAsync` throws `InvalidOperationException("Roots are not supported in stateless mode.")` whenever the server is running stateless — which includes every Streamable HTTP server under `DRAFT-2026-v1` once that revision is forced to stateless-only in a future PR. Stdio servers and current-protocol stateful Streamable HTTP servers continue to work via the legacy server-to-client `roots/list` request flow. For code that needs to run on stateless servers — including all `DRAFT-2026-v1` Streamable HTTP servers going forward — throw `InputRequiredException` from your handler instead. It works under both protocols and both session modes.
 
 For example:
 
@@ -122,7 +122,7 @@ public static string ListRootsWithMrtr(
     // On retry, process the client's roots response
     if (context.Params!.InputResponses?.TryGetValue("get_roots", out var response) is true)
     {
-        var roots = response.Deserialize(InputResponse.RootsResultTypeInfo)?.Roots ?? [];
+        var roots = response.Deserialize(InputResponse.ListRootsResultJsonTypeInfo)?.Roots ?? [];
         return $"Found {roots.Count} roots: {string.Join(", ", roots.Select(r => r.Uri))}";
     }
 

docs/concepts/sampling/sampling.md

@@ -123,10 +123,10 @@ Sampling requires the client to advertise the `sampling` capability. This is han
 
 ### Multi Round-Trip Requests (MRTR)
 
-[MRTR](xref:mrtr) is the SEP-2322 mechanism for server-driven input requests, finalized in protocol revision `DRAFT-2026-v1`. Under the draft protocol, the server-to-client `sampling/createMessage` request method is removed; the only supported way to ask the client to sample from a server handler is to throw <xref:ModelContextProtocol.Protocol.InputRequiredException> and let the SDK emit an <xref:ModelContextProtocol.Protocol.InputRequiredResult> on the wire.
+[MRTR](xref:mrtr) is the SEP-2322 mechanism for server-driven input requests, finalized in protocol revision `DRAFT-2026-v1`. Under the draft protocol, the server-to-client `sampling/createMessage` request method is removed; the recommended way to ask the client to sample from a server handler is to throw <xref:ModelContextProtocol.Protocol.InputRequiredException> and let the SDK emit an <xref:ModelContextProtocol.Protocol.InputRequiredResult> on the wire.
 
 > [!IMPORTANT]
-> Calling `SampleAsync` or `AsSamplingChatClient` after negotiating `DRAFT-2026-v1` throws `InvalidOperationException`. Use `InputRequiredException` from your tool/prompt handler instead — it works under both the current protocol (resolved via legacy JSON-RPC + retry on stateful sessions) and the draft protocol (wire-format `InputRequiredResult`, no server-side handler state required).
+> `SampleAsync` and `AsSamplingChatClient` throw `InvalidOperationException("Sampling is not supported in stateless mode.")` whenever the server is running stateless — which includes every Streamable HTTP server under `DRAFT-2026-v1` once that revision is forced to stateless-only in a future PR. Stdio servers and current-protocol stateful Streamable HTTP servers continue to work via the legacy server-to-client `sampling/createMessage` request flow. For code that needs to run on stateless servers — including all `DRAFT-2026-v1` Streamable HTTP servers going forward — throw `InputRequiredException` from your handler instead. It works under both protocols and both session modes.
 
 For example:
 
@@ -139,7 +139,7 @@ public static string SampleWithMrtr(
     // On retry, process the client's sampling response
     if (context.Params!.InputResponses?.TryGetValue("llm_call", out var response) is true)
     {
-        var text = response.Deserialize(InputResponse.SamplingResultTypeInfo)?.Content
+        var text = response.Deserialize(InputResponse.CreateMessageResultJsonTypeInfo)?.Content
             .OfType<TextContentBlock>().FirstOrDefault()?.Text;
         return $"LLM said: {text}";
     }

src/ModelContextProtocol.Core/Protocol/InputResponse.cs

@@ -31,8 +31,8 @@ public sealed class InputResponse
     /// <remarks>
     /// Use <see cref="Deserialize{T}"/> with the <c>JsonTypeInfo&lt;T&gt;</c> matching the
     /// associated <see cref="InputRequest.Method"/> — for elicitation, sampling, or roots see
-    /// <see cref="ElicitResultTypeInfo"/>, <see cref="SamplingResultTypeInfo"/>, and
-    /// <see cref="RootsResultTypeInfo"/>.
+    /// <see cref="ElicitResultJsonTypeInfo"/>, <see cref="CreateMessageResultJsonTypeInfo"/>, and
+    /// <see cref="ListRootsResultJsonTypeInfo"/>.
     /// </remarks>
     [JsonIgnore]
     public JsonElement RawValue { get; set; }
@@ -51,21 +51,21 @@ public sealed class InputResponse
     /// <see cref="Deserialize{T}"/> when the corresponding <see cref="InputRequest.Method"/> is
     /// <see cref="RequestMethods.ElicitationCreate"/>.
     /// </summary>
-    public static JsonTypeInfo<ElicitResult> ElicitResultTypeInfo => McpJsonUtilities.JsonContext.Default.ElicitResult;
+    public static JsonTypeInfo<ElicitResult> ElicitResultJsonTypeInfo => McpJsonUtilities.JsonContext.Default.ElicitResult;
 
     /// <summary>
     /// Gets the <see cref="JsonTypeInfo{T}"/> for <see cref="CreateMessageResult"/>, suitable for use with
     /// <see cref="Deserialize{T}"/> when the corresponding <see cref="InputRequest.Method"/> is
     /// <see cref="RequestMethods.SamplingCreateMessage"/>.
     /// </summary>
-    public static JsonTypeInfo<CreateMessageResult> SamplingResultTypeInfo => McpJsonUtilities.JsonContext.Default.CreateMessageResult;
+    public static JsonTypeInfo<CreateMessageResult> CreateMessageResultJsonTypeInfo => McpJsonUtilities.JsonContext.Default.CreateMessageResult;
 
     /// <summary>
     /// Gets the <see cref="JsonTypeInfo{T}"/> for <see cref="ListRootsResult"/>, suitable for use with
     /// <see cref="Deserialize{T}"/> when the corresponding <see cref="InputRequest.Method"/> is
     /// <see cref="RequestMethods.RootsList"/>.
     /// </summary>
-    public static JsonTypeInfo<ListRootsResult> RootsResultTypeInfo => McpJsonUtilities.JsonContext.Default.ListRootsResult;
+    public static JsonTypeInfo<ListRootsResult> ListRootsResultJsonTypeInfo => McpJsonUtilities.JsonContext.Default.ListRootsResult;
 
     /// <summary>
     /// Creates an <see cref="InputResponse"/> from a <see cref="CreateMessageResult"/>.