You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2026/08/04 03:07:11 UTC

(juneau) 01/02: MCP 2026-07-28 sampling + elicitation (TODO-328)

This is an automated email from the ASF dual-hosted git repository.

jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git

commit 3c67b8a8e080142c78acffda70efc8db42706f27
Author: James Bognar <ja...@apache.org>
AuthorDate: Mon Aug 3 20:06:20 2026 -0700

    MCP 2026-07-28 sampling + elicitation (TODO-328)
    
    Elicitation (SEP-2322): ElicitRequest/ElicitResult/ElicitAction wire beans
    plus the ElicitSchema restricted-schema builder, riding the existing MRTR
    input_required pause/resume loop with zero mechanism changes. Adds server
    helpers ElicitationRequests/ElicitationResponses and the client helper
    ElicitationAccess for driving the loop over McpClient#callRaw.
    
    Sampling (SEP-2577, deprecated at the protocol level but fully supported
    here): full-fidelity CreateMessageRequest/CreateMessageResult/
    SamplingMessage/ModelPreferences/ModelHint beans plus a typed
    SamplingCapability (replacing the prior free-form sampling map on
    ClientCapabilities). Content gains a new AudioContent member for
    text/image/audio/resource fidelity in sampling messages/results.
    
    Fixes McpClient#postClientResult to route posted duplex results through
    toWireParams(...) so polymorphic Content fields keep their wire type
    discriminator, matching the request-side path.
    
    Removes the Java-level @Deprecated annotations SEP-2577 had prompted on
    Sampling/Roots/Logging-adjacent members - the protocol-level deprecation
    note stands, but this project has not scheduled removal of the Java types.
    
    Adds ELICIT-* characterization/integration fixtures alongside the existing
    MRTR-* set.
    
    Co-authored-by: Cursor <cu...@cursor.com>
---
 .../juneau/bean/mcp/v20260728/AudioContent.java    |  76 +++++
 .../bean/mcp/v20260728/ClientCapabilities.java     |  26 +-
 .../apache/juneau/bean/mcp/v20260728/Content.java  |   5 +-
 .../bean/mcp/v20260728/CreateMessageRequest.java   | 292 ++++++++++++++++
 .../bean/mcp/v20260728/CreateMessageResult.java    | 114 +++++++
 .../v20260728/{Content.java => ElicitAction.java}  |  43 ++-
 .../juneau/bean/mcp/v20260728/ElicitRequest.java   |  81 +++++
 .../juneau/bean/mcp/v20260728/ElicitResult.java    |  95 ++++++
 .../juneau/bean/mcp/v20260728/ElicitSchema.java    | 373 +++++++++++++++++++++
 .../bean/mcp/v20260728/ElicitationCapability.java  |   2 +-
 .../bean/mcp/v20260728/InputRequiredResult.java    |   4 +-
 .../juneau/bean/mcp/v20260728/McpMethods.java      |   6 +
 .../{ElicitationCapability.java => ModelHint.java} |  34 +-
 .../bean/mcp/v20260728/ModelPreferences.java       | 153 +++++++++
 .../{Content.java => SamplingCapability.java}      |  14 +-
 .../juneau/bean/mcp/v20260728/SamplingMessage.java |  71 ++++
 .../bean/mcp/v20260728/ElicitSchema_Test.java      | 342 +++++++++++++++++++
 .../v20260728/McpElicitationIntegration_Test.java  | 234 +++++++++++++
 .../mcp/v20260728/Characterization_Test.java       |  56 ++++
 .../ELICIT-multi-request-pause.headers.properties  |  17 +
 .../ELICIT-multi-request-pause.request.json        |   1 +
 .../ELICIT-multi-request-pause.response.json       |   1 +
 ...LICIT-resume-accept-complete.headers.properties |  17 +
 .../ELICIT-resume-accept-complete.request.json     |   1 +
 .../ELICIT-resume-accept-complete.response.json    |   1 +
 .../ELICIT-resume-cancel.headers.properties        |  17 +
 .../ELICIT-resume-cancel.request.json              |   1 +
 .../ELICIT-resume-cancel.response.json             |   1 +
 .../ELICIT-resume-decline.headers.properties       |  17 +
 .../ELICIT-resume-decline.request.json             |   1 +
 .../ELICIT-resume-decline.response.json            |   1 +
 .../ELICIT-single-request-pause.headers.properties |  17 +
 .../ELICIT-single-request-pause.request.json       |   1 +
 .../ELICIT-single-request-pause.response.json      |   1 +
 .../client/mcp/v20260728/ElicitationAccess.java    | 155 +++++++++
 .../rest/client/mcp/v20260728/McpClient.java       |  14 +-
 .../mcp/v20260728/ElicitationAccess_Test.java      | 176 ++++++++++
 .../mcp/v20260728/McpClient_Capabilities_Test.java |   2 +-
 .../mcp/v20260728/McpDuplexChannel_Test.java       |  68 ++++
 .../rest/client/mcp/McpDuplexDispatcher.java       |   4 +-
 .../rest/client/mcp/McpServerRequestHandler.java   |   4 +-
 .../rest/client/mcp/McpDuplexDispatcher_Test.java  |   2 +-
 .../server/mcp/v20260728/ElicitationRequests.java  |  90 +++++
 .../server/mcp/v20260728/ElicitationResponses.java |  75 +++++
 .../mcp/v20260728/Characterization_Test.java       |  56 ++++
 .../mcp/v20260728/ElicitationRequests_Test.java    |  88 +++++
 .../mcp/v20260728/ElicitationResponses_Test.java   |  95 ++++++
 .../ELICIT-multi-request-pause.headers.properties  |  17 +
 .../ELICIT-multi-request-pause.request.json        |   1 +
 .../ELICIT-multi-request-pause.response.json       |   1 +
 ...LICIT-resume-accept-complete.headers.properties |  17 +
 .../ELICIT-resume-accept-complete.request.json     |   1 +
 .../ELICIT-resume-accept-complete.response.json    |   1 +
 .../ELICIT-resume-cancel.headers.properties        |  17 +
 .../ELICIT-resume-cancel.request.json              |   1 +
 .../ELICIT-resume-cancel.response.json             |   1 +
 .../ELICIT-resume-decline.headers.properties       |  17 +
 .../ELICIT-resume-decline.request.json             |   1 +
 .../ELICIT-resume-decline.response.json            |   1 +
 .../ELICIT-single-request-pause.headers.properties |  17 +
 .../ELICIT-single-request-pause.request.json       |   1 +
 .../ELICIT-single-request-pause.response.json      |   1 +
 62 files changed, 2980 insertions(+), 60 deletions(-)

diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/AudioContent.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/AudioContent.java
new file mode 100644
index 0000000000..af8b1c8294
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/AudioContent.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import org.apache.juneau.marshall.*;
+
+/**
+ * MCP {@code audio} content block (base64 data).
+ *
+ * <p>
+ * Joins the general-purpose {@link Content} dictionary alongside {@link TextContent}/{@link ImageContent}/
+ * {@link EmbeddedResourceContent} — usable anywhere a {@link Content} is accepted, not only in sampling contexts.
+ * Added specifically to give {@code SamplingMessage.content}/{@code CreateMessageResult.content} genuine
+ * {@code text}/{@code image}/{@code audio}/{@code resource} fidelity to the real MCP sampling schema; usable
+ * anywhere a {@link Content} is accepted, not only sampling contexts.
+ */
+@Marshalled(typeName = "audio")
+public class AudioContent implements Content {
+
+	private String data;
+	private String mimeType;
+
+	/**
+	 * Base64-encoded audio bytes.
+	 *
+	 * @return The data, or {@code null} if not set.
+	 */
+	public String getData() {
+		return data;
+	}
+
+	/**
+	 * Sets the base64 payload.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public AudioContent setData(String value) {
+		data = value;
+		return this;
+	}
+
+	/**
+	 * Audio MIME type (for example {@code audio/wav}, {@code audio/mpeg}).
+	 *
+	 * @return The MIME type, or {@code null} if not set.
+	 */
+	public String getMimeType() {
+		return mimeType;
+	}
+
+	/**
+	 * Sets the MIME type.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public AudioContent setMimeType(String value) {
+		mimeType = value;
+		return this;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ClientCapabilities.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ClientCapabilities.java
index a4d9c2b733..8d2a5ff386 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ClientCapabilities.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ClientCapabilities.java
@@ -31,7 +31,7 @@ public class ClientCapabilities {
 
 	private RootsCapability roots;
 	private ElicitationCapability elicitation;
-	private Map<String,Object> sampling;
+	private SamplingCapability sampling;
 	private Map<String,Object> experimental;
 	private Map<String,Object> extensions;
 
@@ -76,12 +76,12 @@ public class ClientCapabilities {
 	}
 
 	/**
-	 * Sampling capability (free-form map for forward compatibility).
+	 * Sampling capability.
 	 *
-	 * @return The sampling map, or {@code null} if not set.
+	 * @return The capability, or {@code null} if not set.
 	 */
-	public Map<String,Object> getSampling() {
-		return u(sampling);
+	public SamplingCapability getSampling() {
+		return sampling;
 	}
 
 	/**
@@ -90,25 +90,11 @@ public class ClientCapabilities {
 	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
 	 * @return This object (for method chaining).
 	 */
-	public ClientCapabilities setSampling(Map<String,Object> value) {
+	public ClientCapabilities setSampling(SamplingCapability value) {
 		sampling = value;
 		return this;
 	}
 
-	/**
-	 * Convenience method to add a single sampling capability entry.
-	 *
-	 * @param name The entry name.  Can be <jk>null</jk> ({@link LinkedHashMap} tolerates a <jk>null</jk> key).
-	 * @param value The entry value.  Can be <jk>null</jk> (stored as <jk>null</jk>).
-	 * @return This object (for method chaining).
-	 */
-	public ClientCapabilities putSampling(String name, Object value) {
-		if (sampling == null)
-			sampling = map();
-		sampling.put(name, value);
-		return this;
-	}
-
 	/**
 	 * Experimental capability extensions.
 	 *
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java
index 0ad0bc11ab..7c45a1e1dd 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java
@@ -22,10 +22,11 @@ import org.apache.juneau.marshall.*;
  * Polymorphic MCP content block (tool results, prompt messages).
  *
  * <p>
- * Wire objects carry a {@code type} discriminator with values {@code text}, {@code image}, or {@code resource}.
+ * Wire objects carry a {@code type} discriminator with values {@code text}, {@code image}, {@code audio}, or
+ * {@code resource}.
  */
 @Marshalled(
 	typePropertyName = "type",
-	dictionary = { TextContent.class, ImageContent.class, EmbeddedResourceContent.class }
+	dictionary = { TextContent.class, ImageContent.class, AudioContent.class, EmbeddedResourceContent.class }
 )
 public interface Content {}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/CreateMessageRequest.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/CreateMessageRequest.java
new file mode 100644
index 0000000000..9a172804b8
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/CreateMessageRequest.java
@@ -0,0 +1,292 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.CollectionUtils.*;
+import static org.apache.juneau.commons.utils.Shorts.*;
+
+import java.util.*;
+
+import org.apache.juneau.marshall.*;
+
+/**
+ * Parameters for {@value McpMethods#SAMPLING_CREATE_MESSAGE}, a server-to-client duplex request (MCP sampling).
+ * Never dispatched through {@code McpRevision} — this is a plain POJO decoded/encoded by
+ * hand (or via the client's typed duplex flow) inside an {@code McpServerRequestHandler} implementation.
+ */
+@Marshalled
+public class CreateMessageRequest {
+
+	private List<SamplingMessage> messages;
+	private ModelPreferences modelPreferences;
+	private String systemPrompt;
+	private String includeContext;
+	private Double temperature;
+	private Integer maxTokens;
+	private List<String> stopSequences;
+	private Map<String,Object> metadata;
+
+	/**
+	 * The conversation history to sample from.
+	 *
+	 * @return The messages list, or {@code null} if not set.
+	 */
+	public List<SamplingMessage> getMessages() {
+		return u(messages);
+	}
+
+	/**
+	 * Sets the messages.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setMessages(List<SamplingMessage> value) {
+		messages = value;
+		return this;
+	}
+
+	/**
+	 * Sets the messages.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setMessages(SamplingMessage...value) {
+		messages = list(value);
+		return this;
+	}
+
+	/**
+	 * Appends to the messages.
+	 *
+	 * @param value The values to append.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest addMessages(SamplingMessage...value) {
+		if (messages == null)
+			messages = list();
+		Collections.addAll(messages, value);
+		return this;
+	}
+
+	/**
+	 * Appends to the messages.
+	 *
+	 * @param value The values to append.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest addMessages(Collection<SamplingMessage> value) {
+		if (messages == null)
+			messages = list();
+		messages.addAll(value);
+		return this;
+	}
+
+	/**
+	 * Model-selection preferences.
+	 *
+	 * @return The preferences, or {@code null} if not set.
+	 */
+	public ModelPreferences getModelPreferences() {
+		return modelPreferences;
+	}
+
+	/**
+	 * Sets the model preferences.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setModelPreferences(ModelPreferences value) {
+		modelPreferences = value;
+		return this;
+	}
+
+	/**
+	 * An optional system prompt.
+	 *
+	 * @return The system prompt, or {@code null} if not set.
+	 */
+	public String getSystemPrompt() {
+		return systemPrompt;
+	}
+
+	/**
+	 * Sets the system prompt.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setSystemPrompt(String value) {
+		systemPrompt = value;
+		return this;
+	}
+
+	/**
+	 * Which MCP context to include ({@code none}/{@code thisServer}/{@code allServers} per the pinned schema).
+	 * Kept as a plain {@code String}, matching this module's existing precedent of not over-modeling
+	 * schema string-enums that do not gate real branching logic in this codebase.
+	 *
+	 * @return The include-context value, or {@code null} if not set.
+	 */
+	public String getIncludeContext() {
+		return includeContext;
+	}
+
+	/**
+	 * Sets the include-context value.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setIncludeContext(String value) {
+		includeContext = value;
+		return this;
+	}
+
+	/**
+	 * Sampling temperature.
+	 *
+	 * @return The temperature, or {@code null} if not set.
+	 */
+	public Double getTemperature() {
+		return temperature;
+	}
+
+	/**
+	 * Sets the temperature.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setTemperature(Double value) {
+		temperature = value;
+		return this;
+	}
+
+	/**
+	 * Maximum tokens to sample.
+	 *
+	 * @return The max tokens, or {@code null} if not set.
+	 */
+	public Integer getMaxTokens() {
+		return maxTokens;
+	}
+
+	/**
+	 * Sets the max tokens.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setMaxTokens(Integer value) {
+		maxTokens = value;
+		return this;
+	}
+
+	/**
+	 * Sequences that stop sampling when generated.
+	 *
+	 * @return The stop sequences, or {@code null} if not set.
+	 */
+	public List<String> getStopSequences() {
+		return u(stopSequences);
+	}
+
+	/**
+	 * Sets the stop sequences.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setStopSequences(List<String> value) {
+		stopSequences = value;
+		return this;
+	}
+
+	/**
+	 * Sets the stop sequences.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setStopSequences(String...value) {
+		stopSequences = list(value);
+		return this;
+	}
+
+	/**
+	 * Appends to the stop sequences.
+	 *
+	 * @param value The values to append.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest addStopSequences(String...value) {
+		if (stopSequences == null)
+			stopSequences = list();
+		Collections.addAll(stopSequences, value);
+		return this;
+	}
+
+	/**
+	 * Appends to the stop sequences.
+	 *
+	 * @param value The values to append.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest addStopSequences(Collection<String> value) {
+		if (stopSequences == null)
+			stopSequences = list();
+		stopSequences.addAll(value);
+		return this;
+	}
+
+	/**
+	 * Free-form server-defined metadata.
+	 *
+	 * @return The metadata map, or {@code null} if not set.
+	 */
+	public Map<String,Object> getMetadata() {
+		return u(metadata);
+	}
+
+	/**
+	 * Sets the metadata.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest setMetadata(Map<String,Object> value) {
+		metadata = value;
+		return this;
+	}
+
+	/**
+	 * Convenience method to add a single metadata entry.
+	 *
+	 * @param name The entry name.  Can be <jk>null</jk> ({@link LinkedHashMap} tolerates a <jk>null</jk> key).
+	 * @param value The entry value.  Can be <jk>null</jk> (stored as <jk>null</jk>).
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageRequest putMetadata(String name, Object value) {
+		if (metadata == null)
+			metadata = map();
+		metadata.put(name, value);
+		return this;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/CreateMessageResult.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/CreateMessageResult.java
new file mode 100644
index 0000000000..ba2bafb56e
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/CreateMessageResult.java
@@ -0,0 +1,114 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import org.apache.juneau.marshall.*;
+
+/**
+ * Result payload for {@value McpMethods#SAMPLING_CREATE_MESSAGE} (MCP sampling). Never
+ * dispatched through {@code McpRevision}; see {@link CreateMessageRequest}'s class Javadoc for the same
+ * plain-POJO/duplex-payload rationale.
+ */
+@Marshalled
+public class CreateMessageResult {
+
+	private Role role;
+	private Content content;
+	private String model;
+	private String stopReason;
+
+	/**
+	 * The generated message's role (real schema restricts this to {@code user}/{@code assistant}).
+	 *
+	 * @return The role, or {@code null} if not set.
+	 */
+	public Role getRole() {
+		return role;
+	}
+
+	/**
+	 * Sets the role.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageResult setRole(Role value) {
+		role = value;
+		return this;
+	}
+
+	/**
+	 * The generated content — a single block ({@code text}/{@code image}/{@code audio}/{@code resource}).
+	 *
+	 * @return The content, or {@code null} if not set.
+	 */
+	public Content getContent() {
+		return content;
+	}
+
+	/**
+	 * Sets the content.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageResult setContent(Content value) {
+		content = value;
+		return this;
+	}
+
+	/**
+	 * The model that generated the content.
+	 *
+	 * @return The model name, or {@code null} if not set.
+	 */
+	public String getModel() {
+		return model;
+	}
+
+	/**
+	 * Sets the model name.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageResult setModel(String value) {
+		model = value;
+		return this;
+	}
+
+	/**
+	 * Why sampling stopped (commonly {@code endTurn}/{@code stopSequence}/{@code maxTokens}, but the schema
+	 * also permits arbitrary server-defined strings, so this stays a plain {@code String}).
+	 *
+	 * @return The stop reason, or {@code null} if not set.
+	 */
+	public String getStopReason() {
+		return stopReason;
+	}
+
+	/**
+	 * Sets the stop reason.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public CreateMessageResult setStopReason(String value) {
+		stopReason = value;
+		return this;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitAction.java
similarity index 57%
copy from juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java
copy to juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitAction.java
index 0ad0bc11ab..a1f28ae731 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitAction.java
@@ -16,16 +16,37 @@
  */
 package org.apache.juneau.bean.mcp.v20260728;
 
-import org.apache.juneau.marshall.*;
-
 /**
- * Polymorphic MCP content block (tool results, prompt messages).
- *
- * <p>
- * Wire objects carry a {@code type} discriminator with values {@code text}, {@code image}, or {@code resource}.
+ * Closed action set for an elicitation answer (MCP {@code 2026-07-28} SEP-2322).
  */
-@Marshalled(
-	typePropertyName = "type",
-	dictionary = { TextContent.class, ImageContent.class, EmbeddedResourceContent.class }
-)
-public interface Content {}
+public enum ElicitAction {
+
+	/** The end user accepted and supplied {@link ElicitResult#getContent()}. */
+	ACCEPT("accept"),
+
+	/** The end user explicitly declined to answer. */
+	DECLINE("decline"),
+
+	/** The end user cancelled the interaction entirely. */
+	CANCEL("cancel");
+
+	private final String wire;
+
+	ElicitAction(String wire) {
+		this.wire = wire;
+	}
+
+	/**
+	 * Wire token for JSON payloads.
+	 *
+	 * @return Lowercase MCP action string.
+	 */
+	public String toWire() {
+		return wire;
+	}
+
+	@Override /* Object */
+	public String toString() {
+		return wire;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitRequest.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitRequest.java
new file mode 100644
index 0000000000..4d3649df83
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitRequest.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.Shorts.*;
+
+import java.util.*;
+
+import org.apache.juneau.marshall.*;
+
+/**
+ * One entry of an {@code input_required} pause's {@code inputRequests} map for an elicitation sub-request (MCP
+ * {@code 2026-07-28} SEP-2322), built by a {@code tools/call}/{@code prompts/get}/{@code resources/read} handler
+ * and placed via {@code org.apache.juneau.rest.server.mcp.v20260728.ElicitationRequests}.
+ *
+ * <p>
+ * {@link #getRequestedSchema()} is a restricted JSON Schema (see
+ * {@code org.apache.juneau.bean.mcp.v20260728.ElicitSchema}) describing the expected shape of the end user's
+ * answer; it permits only primitive-typed, non-nested top-level properties.
+ */
+@Marshalled
+public class ElicitRequest {
+
+	private String message;
+	private Map<String,Object> requestedSchema;
+
+	/**
+	 * The prompt shown to the end user.
+	 *
+	 * @return The message, or {@code null} if not set.
+	 */
+	public String getMessage() {
+		return message;
+	}
+
+	/**
+	 * Sets the prompt shown to the end user.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ElicitRequest setMessage(String value) {
+		message = value;
+		return this;
+	}
+
+	/**
+	 * The restricted JSON Schema describing the expected answer shape.
+	 *
+	 * @return An unmodifiable view of the schema, or {@code null} if not set.
+	 */
+	public Map<String,Object> getRequestedSchema() {
+		return u(requestedSchema);
+	}
+
+	/**
+	 * Sets the restricted JSON Schema describing the expected answer shape.
+	 *
+	 * @param value The new value, typically built via {@code ElicitSchema.create()....build()}.  Can be
+	 * 	<jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ElicitRequest setRequestedSchema(Map<String,Object> value) {
+		requestedSchema = value;
+		return this;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitResult.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitResult.java
new file mode 100644
index 0000000000..6f9349b5ae
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitResult.java
@@ -0,0 +1,95 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.CollectionUtils.*;
+import static org.apache.juneau.commons.utils.Shorts.*;
+
+import java.util.*;
+
+import org.apache.juneau.marshall.*;
+
+/**
+ * The end user's answer to an {@link ElicitRequest} (MCP {@code 2026-07-28} SEP-2322), echoed back keyed by the
+ * same server-assigned id in a follow-up request's {@code inputResponses} and decoded via
+ * {@code org.apache.juneau.rest.server.mcp.v20260728.ElicitationResponses}.
+ *
+ * <p>
+ * {@link #getContent()} is present only when {@link #getAction()} is {@link ElicitAction#ACCEPT}; its shape is
+ * whatever {@link ElicitRequest#getRequestedSchema()} described, which is per-elicitation and unknowable at the
+ * bean-definition level, so it is deliberately left an untyped, dynamic map.
+ */
+@Marshalled
+public class ElicitResult {
+
+	private ElicitAction action;
+	private Map<String,Object> content;
+
+	/**
+	 * The end user's choice.
+	 *
+	 * @return The action, or {@code null} if not set.
+	 */
+	public ElicitAction getAction() {
+		return action;
+	}
+
+	/**
+	 * Sets the end user's choice.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ElicitResult setAction(ElicitAction value) {
+		action = value;
+		return this;
+	}
+
+	/**
+	 * The schema-shaped answer content.  Present only when {@link #getAction()} is {@link ElicitAction#ACCEPT}.
+	 *
+	 * @return The content map, or {@code null} if not set.
+	 */
+	public Map<String,Object> getContent() {
+		return u(content);
+	}
+
+	/**
+	 * Sets the schema-shaped answer content.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ElicitResult setContent(Map<String,Object> value) {
+		content = value;
+		return this;
+	}
+
+	/**
+	 * Convenience method to add a single content entry.
+	 *
+	 * @param name The entry name.  Can be <jk>null</jk> ({@link LinkedHashMap} tolerates a <jk>null</jk> key).
+	 * @param value The entry value.  Can be <jk>null</jk> (stored as <jk>null</jk>).
+	 * @return This object (for method chaining).
+	 */
+	public ElicitResult putContent(String name, Object value) {
+		if (content == null)
+			content = map();
+		content.put(name, value);
+		return this;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitSchema.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitSchema.java
new file mode 100644
index 0000000000..fbfcb7c864
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitSchema.java
@@ -0,0 +1,373 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.AssertionUtils.*;
+import static org.apache.juneau.commons.utils.CollectionUtils.*;
+import static org.apache.juneau.commons.utils.Shorts.*;
+
+import java.util.*;
+
+import org.apache.juneau.marshall.collections.*;
+
+/**
+ * Fluent builder for a restricted elicitation JSON Schema (MCP {@code 2026-07-28} SEP-2322), producing the
+ * {@link JsonMap} consumed by {@link ElicitRequest#setRequestedSchema(java.util.Map)}.
+ *
+ * <p>
+ * The elicitation restricted schema permits only primitive-typed, non-nested top-level properties. There is
+ * deliberately no {@code objectField}/{@code arrayField} method, so a nested/object/array-typed field is a
+ * compile-time impossibility, never a runtime-rejected one. {@link #build()} additionally rejects a handful of
+ * structurally-invalid per-field modifier combinations (for example {@link #format(String)} on a non-string
+ * field) with an {@link IllegalStateException}, so a handler author gets an immediate, in-process failure rather
+ * than a wire-level schema-validation error discovered by the client much later.
+ *
+ * <p>
+ * Each {@code xxxField(name)} call starts a new field and becomes the target of every subsequent modifier call
+ * ({@link #title(String)}, {@link #description(String)}, etc.) until the next {@code xxxField(...)} call.
+ * Re-declaring a field under a {@code name} already used by an earlier {@code xxxField(...)} call replaces that
+ * field's definition entirely, silently discarding any per-field modifiers already applied to it
+ * (last-field-wins). {@link #minLength(int)}/{@link #maxLength(int)} are additional string-only per-field
+ * modifiers, alongside {@link #format(String)}. {@link #required(String...)} is a separate, builder-level (not
+ * per-field) call that marks one or more field names required, emitting a top-level {@code "required":[...]}
+ * array; unlike the per-field modifiers, it is not tied to the most-recently-started field, is order-independent
+ * with respect to {@code xxxField(...)} (a name may be marked required before or after the field it names is
+ * (re)declared, and a redeclaration of that field does not discard the marking), and may be called any time,
+ * with an unknown name validated only at {@link #build()} time.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * 	JsonMap <jv>schema</jv> = ElicitSchema.<jsm>create</jsm>()
+ * 		.booleanField(<js>"confirm"</js>).title(<js>"Confirm"</js>)
+ * 		.build();
+ * </p>
+ */
+public class ElicitSchema {
+
+	private static final String TYPE_STRING = "string";
+	private static final String TYPE_NUMBER = "number";
+	private static final String TYPE_INTEGER = "integer";
+	private static final String TYPE_BOOLEAN = "boolean";
+	private static final String TYPE_OBJECT = "object";
+
+	private static final Set<String> NUMERIC_TYPES = Set.of(TYPE_NUMBER, TYPE_INTEGER);
+
+	private final Map<String,JsonMap> properties = map();
+	private final Set<String> required = new LinkedHashSet<>();
+	private String currentField;
+
+	private ElicitSchema() {}
+
+	/**
+	 * Creates a new, empty schema builder.
+	 *
+	 * @return A new builder. Never <jk>null</jk>.
+	 */
+	public static ElicitSchema create() {
+		return new ElicitSchema();
+	}
+
+	/**
+	 * Starts a {@code string}-typed field.
+	 *
+	 * @param name The property name. Must not be <jk>null</jk> or blank.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code name} is <jk>null</jk> or blank.
+	 */
+	public ElicitSchema stringField(String name) {
+		return field(name, TYPE_STRING);
+	}
+
+	/**
+	 * Starts a {@code number}-typed (floating-point) field.
+	 *
+	 * @param name The property name. Must not be <jk>null</jk> or blank.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code name} is <jk>null</jk> or blank.
+	 */
+	public ElicitSchema numberField(String name) {
+		return field(name, TYPE_NUMBER);
+	}
+
+	/**
+	 * Starts an {@code integer}-typed field.
+	 *
+	 * @param name The property name. Must not be <jk>null</jk> or blank.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code name} is <jk>null</jk> or blank.
+	 */
+	public ElicitSchema integerField(String name) {
+		return field(name, TYPE_INTEGER);
+	}
+
+	/**
+	 * Starts a {@code boolean}-typed field.
+	 *
+	 * @param name The property name. Must not be <jk>null</jk> or blank.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code name} is <jk>null</jk> or blank.
+	 */
+	public ElicitSchema booleanField(String name) {
+		return field(name, TYPE_BOOLEAN);
+	}
+
+	/**
+	 * Starts a closed-choice {@code string}-typed field restricted to {@code values} (wire shape:
+	 * {@code type:"string", enum:[...]}). Pair with {@link #enumNames(String...)} for parallel display labels.
+	 *
+	 * @param name The property name. Must not be <jk>null</jk> or blank.
+	 * @param values The allowed values. Must not be <jk>null</jk> or empty, and must not contain a
+	 * 	<jk>null</jk> element.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code name} is <jk>null</jk> or blank, or {@code values} is
+	 * 	<jk>null</jk>, empty, or contains a <jk>null</jk> element.
+	 */
+	public ElicitSchema enumField(String name, String...values) {
+		assertArgNotNullOrBlank("name", name);
+		if (values == null || values.length == 0)
+			throw iaex("Field ''%s'': enumField values must not be null or empty", name);
+		for (var value : values)
+			if (value == null)
+				throw iaex("Field ''%s'': enumField values must not contain a null element", name);
+		field(name, TYPE_STRING);
+		properties.get(name).put("enum", List.of(values));
+		return this;
+	}
+
+	private ElicitSchema field(String name, String type) {
+		assertArgNotNullOrBlank("name", name);
+		var p = new JsonMap();
+		p.put("type", type);
+		// Last-field-wins: a redeclared field discards its prior per-field modifiers (see class Javadoc).
+		// required(...) marking is a separate, builder-level set and deliberately survives a redeclaration.
+		properties.put(name, p);
+		currentField = name;
+		return this;
+	}
+
+	/**
+	 * Sets the display title of the most-recently-started field.
+	 *
+	 * @param value The title. Must not be <jk>null</jk>.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code value} is <jk>null</jk>.
+	 */
+	public ElicitSchema title(String value) {
+		currentProperty().put("title", assertArgNotNull("value", value));
+		return this;
+	}
+
+	/**
+	 * Sets the description of the most-recently-started field.
+	 *
+	 * @param value The description. Must not be <jk>null</jk>.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code value} is <jk>null</jk>.
+	 */
+	public ElicitSchema description(String value) {
+		currentProperty().put("description", assertArgNotNull("value", value));
+		return this;
+	}
+
+	/**
+	 * Sets the string-subtype format of the most-recently-started field (for example {@code email}, {@code uri},
+	 * {@code date}, {@code date-time}). Applying this to a non-string field is rejected at {@link #build()} time.
+	 *
+	 * @param value The format token. Must not be <jk>null</jk>.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code value} is <jk>null</jk>.
+	 */
+	public ElicitSchema format(String value) {
+		currentProperty().put("format", assertArgNotNull("value", value));
+		return this;
+	}
+
+	/**
+	 * Sets the minimum UTF-16 code-unit length of the most-recently-started string field. Applying this to a
+	 * non-string field, to an {@link #enumField(String, String...)} (a closed-choice field, where a length
+	 * constraint is meaningless), or a value that is negative or exceeds a previously-/subsequently-set
+	 * {@link #maxLength(int)}, is rejected at {@link #build()} time.
+	 *
+	 * @param value The minimum length.
+	 * @return This object (for method chaining).
+	 */
+	public ElicitSchema minLength(int value) {
+		currentProperty().put("minLength", value);
+		return this;
+	}
+
+	/**
+	 * Sets the maximum UTF-16 code-unit length of the most-recently-started string field. Applying this to a
+	 * non-string field, to an {@link #enumField(String, String...)} (a closed-choice field, where a length
+	 * constraint is meaningless), or a value that is negative or less than a previously-/subsequently-set
+	 * {@link #minLength(int)}, is rejected at {@link #build()} time.
+	 *
+	 * @param value The maximum length.
+	 * @return This object (for method chaining).
+	 */
+	public ElicitSchema maxLength(int value) {
+		currentProperty().put("maxLength", value);
+		return this;
+	}
+
+	/**
+	 * Sets the minimum value of the most-recently-started number/integer field. Applying this to a field of any
+	 * other type is rejected at {@link #build()} time.
+	 *
+	 * @param value The minimum. Must not be <jk>null</jk>.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code value} is <jk>null</jk>.
+	 */
+	public ElicitSchema min(Number value) {
+		currentProperty().put("minimum", assertArgNotNull("value", value));
+		return this;
+	}
+
+	/**
+	 * Sets the maximum value of the most-recently-started number/integer field. Applying this to a field of any
+	 * other type is rejected at {@link #build()} time.
+	 *
+	 * @param value The maximum. Must not be <jk>null</jk>.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code value} is <jk>null</jk>.
+	 */
+	public ElicitSchema max(Number value) {
+		currentProperty().put("maximum", assertArgNotNull("value", value));
+		return this;
+	}
+
+	/**
+	 * Sets the default value of the most-recently-started field.
+	 *
+	 * <p>
+	 * Named {@code defaultValue}, not {@code default} (a reserved Java keyword) &mdash; the wire schema property
+	 * this writes is still literally {@code "default"}.
+	 *
+	 * @param value The default value. Can be <jk>null</jk>.
+	 * @return This object (for method chaining).
+	 */
+	public ElicitSchema defaultValue(Object value) {
+		currentProperty().put("default", value);
+		return this;
+	}
+
+	/**
+	 * Sets parallel display labels for the most-recently-started {@link #enumField(String, String...)}'s values.
+	 * Applying this to a field with no {@code enum} values is rejected at {@link #build()} time.
+	 *
+	 * @param values The display labels, parallel in order to the field's {@code enum} values. Must not be
+	 * 	<jk>null</jk> or empty, must not contain a <jk>null</jk> element, and (when the current field already
+	 * 	carries {@code enum} values) must be the same length as those values.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code values} is <jk>null</jk>, empty, or contains a <jk>null</jk>
+	 * 	element, or if its length does not match the current field's existing {@code enum} values' length.
+	 */
+	public ElicitSchema enumNames(String...values) {
+		if (values == null || values.length == 0)
+			throw iaex("enumNames values must not be null or empty");
+		for (var value : values)
+			if (value == null)
+				throw iaex("enumNames values must not contain a null element");
+		var p = currentProperty();
+		var enumValues = (List<?>)p.get("enum");
+		if (enumValues != null && enumValues.size() != values.length)
+			throw iaex("enumNames length (%s) must match enum length (%s)", values.length, enumValues.size());
+		p.put("enumNames", List.of(values));
+		return this;
+	}
+
+	/**
+	 * Marks one or more already-added field names required, contributing to the built schema's top-level
+	 * {@code "required":[...]} array.
+	 *
+	 * <p>
+	 * Unlike the per-field modifiers ({@link #title(String)}, etc.), this is a builder-level, not per-field,
+	 * call &mdash; it is not tied to the most-recently-started field and may name any field(s) already added via
+	 * an earlier {@code xxxField(...)} call, in any order. May be called more than once; each call adds to the
+	 * previously-marked names (not replaced). Naming a field not (yet) added is rejected at {@link #build()}
+	 * time, not here, since a later {@code xxxField(...)} call may still add it.
+	 *
+	 * @param names The field names to mark required. Must not be <jk>null</jk> or empty, and must not contain
+	 * 	a <jk>null</jk> element.
+	 * @return This object (for method chaining).
+	 * @throws IllegalArgumentException If {@code names} is <jk>null</jk>, empty, or contains a <jk>null</jk>
+	 * 	element.
+	 */
+	public ElicitSchema required(String...names) {
+		if (names == null || names.length == 0)
+			throw iaex("required field names must not be null or empty");
+		for (var name : names)
+			if (name == null)
+				throw iaex("required field names must not contain a null element");
+		Collections.addAll(required, names);
+		return this;
+	}
+
+	private JsonMap currentProperty() {
+		if (currentField == null)
+			throw isex("No field has been started yet; call stringField(...)/numberField(...)/etc. first");
+		return properties.get(currentField);
+	}
+
+	/**
+	 * Validates every field's modifier combination (and the builder-level {@link #required(String...)}
+	 * marking) and builds the final restricted-schema {@link JsonMap}
+	 * ({@code {"type":"object","properties":{...},"required":[...]}}, the last member present only if
+	 * {@link #required(String...)} was called at least once).
+	 *
+	 * @return The built schema, ready for {@link ElicitRequest#setRequestedSchema(java.util.Map)}.
+	 * @throws IllegalStateException If no field was ever added, if any field carries a structurally-invalid
+	 * 	modifier combination, or if {@link #required(String...)} named a field that was never added.
+	 */
+	public JsonMap build() {
+		if (properties.isEmpty())
+			throw isex("ElicitSchema requires at least one field (an empty requestedSchema is unanswerable)");
+		properties.forEach((name, p) -> {
+			var type = (String)p.get("type");
+			if (p.containsKey("format") && ! TYPE_STRING.equals(type))
+				throw isex("Field ''%s'': format is only valid on string fields", name);
+			if ((p.containsKey("minimum") || p.containsKey("maximum")) && ! NUMERIC_TYPES.contains(type))
+				throw isex("Field ''%s'': min/max are only valid on number/integer fields", name);
+			if ((p.containsKey("minLength") || p.containsKey("maxLength")) && ! TYPE_STRING.equals(type))
+				throw isex("Field ''%s'': minLength/maxLength are only valid on string fields", name);
+			if ((p.containsKey("minLength") || p.containsKey("maxLength")) && p.containsKey("enum"))
+				throw isex("Field ''%s'': minLength/maxLength are not valid on an enum (closed-choice) field", name);
+			if (p.containsKey("minLength") && (int)p.get("minLength") < 0)
+				throw isex("Field ''%s'': minLength must not be negative", name);
+			if (p.containsKey("maxLength") && (int)p.get("maxLength") < 0)
+				throw isex("Field ''%s'': maxLength must not be negative", name);
+			if (p.containsKey("minLength") && p.containsKey("maxLength") && (int)p.get("minLength") > (int)p.get("maxLength"))
+				throw isex("Field ''%s'': minLength must not exceed maxLength", name);
+			if (p.containsKey("enumNames") && ! p.containsKey("enum"))
+				throw isex("Field ''%s'': enumNames requires enum values (use enumField(...))", name);
+		});
+		required.forEach(name -> {
+			if (! properties.containsKey(name))
+				throw isex("required(...) names field ''%s'', which was never added", name);
+		});
+		var schema = new JsonMap();
+		schema.put("type", TYPE_OBJECT);
+		// Deep-copy each per-field map so a caller who keeps the builder and applies further modifiers after
+		// build() cannot mutate an already-returned schema.
+		var propsCopy = new JsonMap();
+		properties.forEach((name, p) -> propsCopy.put(name, new JsonMap(p)));
+		schema.put("properties", propsCopy);
+		if (! required.isEmpty())
+			schema.put("required", List.copyOf(required));
+		return schema;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitationCapability.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitationCapability.java
index eec19eef9c..c6dc42dfdb 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitationCapability.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitationCapability.java
@@ -26,7 +26,7 @@ import org.apache.juneau.marshall.*;
  * Deliberately empty today &mdash; the pinned schema defines no sub-fields for this capability yet. A future
  * MCP revision (C6 elicitation territory, out of this TODO's scope) may add fields here; this bean exists now so
  * the capability-gate check (see the {@code 2026-07-28} adapter) has a typed, presence-checkable field to test
- * rather than a bare boolean, matching {@link RootsCapability}'s existing shape.
+ * rather than a bare boolean, matching {@link SamplingCapability}'s existing shape.
  */
 @Marshalled
 public class ElicitationCapability {
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/InputRequiredResult.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/InputRequiredResult.java
index 60f413ac2c..5773f681ee 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/InputRequiredResult.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/InputRequiredResult.java
@@ -39,8 +39,8 @@ import org.apache.juneau.marshall.collections.*;
  * models it (a sampling/roots/elicitation sub-request), typed as a raw {@link JsonMap} so a handler-supplied map
  * reaches the wire byte-for-byte &mdash; there is no synthetic {@code {type, payload}} envelope, and no member is
  * relocated or dropped. Concrete sub-request shapes are owned by the eventual consumers of this mechanism (C5
- * sampling, C6 elicitation), both out of this TODO's scope. This mirrors the equally free-form shapes of the
- * request-side {@code inputResponses} and {@link ClientCapabilities#getSampling() sampling} maps.
+ * sampling, C6 elicitation), both out of this TODO's scope. This mirrors the equally free-form shape of the
+ * request-side {@code inputResponses} map.
  */
 @Marshalled
 public class InputRequiredResult extends Result<InputRequiredResult> {
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/McpMethods.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/McpMethods.java
index 2e21715675..c535c0a188 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/McpMethods.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/McpMethods.java
@@ -55,4 +55,10 @@ public final class McpMethods {
 
 	/** Complete a prompt argument or resource-template variable. */
 	public static final String COMPLETION_COMPLETE = "completion/complete";
+
+	/**
+	 * Server-to-client duplex sampling request (MCP sampling). Never dispatched through
+	 * {@code McpRevision} — flows over the {@code McpDuplexDispatcher}/{@code McpServerRequestHandler} seam.
+	 */
+	public static final String SAMPLING_CREATE_MESSAGE = "sampling/createMessage";
 }
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitationCapability.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ModelHint.java
similarity index 58%
copy from juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitationCapability.java
copy to juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ModelHint.java
index eec19eef9c..bed46a1bd8 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ElicitationCapability.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ModelHint.java
@@ -19,15 +19,31 @@ package org.apache.juneau.bean.mcp.v20260728;
 import org.apache.juneau.marshall.*;
 
 /**
- * Client elicitation capability (SEP-2322): presence on {@link ClientCapabilities#getElicitation()} signals the
- * client understands {@code input_required} elicitation-flavored requests.
- *
- * <p>
- * Deliberately empty today &mdash; the pinned schema defines no sub-fields for this capability yet. A future
- * MCP revision (C6 elicitation territory, out of this TODO's scope) may add fields here; this bean exists now so
- * the capability-gate check (see the {@code 2026-07-28} adapter) has a typed, presence-checkable field to test
- * rather than a bare boolean, matching {@link RootsCapability}'s existing shape.
+ * A model family/name hint for {@link ModelPreferences#getHints()} (MCP sampling).
  */
 @Marshalled
-public class ElicitationCapability {
+public class ModelHint {
+
+	private String name;
+
+	/**
+	 * A model family/name substring the server should prefer (fuzzy match; the schema explicitly allows
+	 * partial matches, e.g. {@code "claude"}).
+	 *
+	 * @return The hint name, or {@code null} if not set.
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * Sets the hint name.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ModelHint setName(String value) {
+		name = value;
+		return this;
+	}
 }
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ModelPreferences.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ModelPreferences.java
new file mode 100644
index 0000000000..51b9ab880a
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/ModelPreferences.java
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.CollectionUtils.*;
+import static org.apache.juneau.commons.utils.Shorts.*;
+
+import java.util.*;
+
+import org.apache.juneau.marshall.*;
+
+/**
+ * Model-selection preferences for {@link CreateMessageRequest} (MCP sampling).
+ */
+@Marshalled
+public class ModelPreferences {
+
+	private List<ModelHint> hints;
+	private Double costPriority;
+	private Double speedPriority;
+	private Double intelligencePriority;
+
+	/**
+	 * Ordered model-family/name hints, most-preferred first.
+	 *
+	 * @return The hints list, or {@code null} if not set.
+	 */
+	public List<ModelHint> getHints() {
+		return u(hints);
+	}
+
+	/**
+	 * Sets the hints.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ModelPreferences setHints(List<ModelHint> value) {
+		hints = value;
+		return this;
+	}
+
+	/**
+	 * Sets the hints.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ModelPreferences setHints(ModelHint...value) {
+		hints = list(value);
+		return this;
+	}
+
+	/**
+	 * Appends to the hints.
+	 *
+	 * @param value The values to append.
+	 * @return This object (for method chaining).
+	 */
+	public ModelPreferences addHints(ModelHint...value) {
+		if (hints == null)
+			hints = list();
+		Collections.addAll(hints, value);
+		return this;
+	}
+
+	/**
+	 * Appends to the hints.
+	 *
+	 * @param value The values to append.
+	 * @return This object (for method chaining).
+	 */
+	public ModelPreferences addHints(Collection<ModelHint> value) {
+		if (hints == null)
+			hints = list();
+		hints.addAll(value);
+		return this;
+	}
+
+	/**
+	 * Relative priority (0.0-1.0) placed on minimizing cost.
+	 *
+	 * @return The priority, or {@code null} if not set.
+	 */
+	public Double getCostPriority() {
+		return costPriority;
+	}
+
+	/**
+	 * Sets the cost priority.
+	 *
+	 * @param value The new value, {@code 0.0}-{@code 1.0}.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ModelPreferences setCostPriority(Double value) {
+		costPriority = value;
+		return this;
+	}
+
+	/**
+	 * Relative priority (0.0-1.0) placed on minimizing latency.
+	 *
+	 * @return The priority, or {@code null} if not set.
+	 */
+	public Double getSpeedPriority() {
+		return speedPriority;
+	}
+
+	/**
+	 * Sets the speed priority.
+	 *
+	 * @param value The new value, {@code 0.0}-{@code 1.0}.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ModelPreferences setSpeedPriority(Double value) {
+		speedPriority = value;
+		return this;
+	}
+
+	/**
+	 * Relative priority (0.0-1.0) placed on maximizing capability.
+	 *
+	 * @return The priority, or {@code null} if not set.
+	 */
+	public Double getIntelligencePriority() {
+		return intelligencePriority;
+	}
+
+	/**
+	 * Sets the intelligence priority.
+	 *
+	 * @param value The new value, {@code 0.0}-{@code 1.0}.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public ModelPreferences setIntelligencePriority(Double value) {
+		intelligencePriority = value;
+		return this;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/SamplingCapability.java
similarity index 70%
copy from juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java
copy to juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/SamplingCapability.java
index 0ad0bc11ab..f3b1cabb88 100644
--- a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/Content.java
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/SamplingCapability.java
@@ -19,13 +19,13 @@ package org.apache.juneau.bean.mcp.v20260728;
 import org.apache.juneau.marshall.*;
 
 /**
- * Polymorphic MCP content block (tool results, prompt messages).
+ * Client sampling capability marker (MCP sampling): presence on
+ * {@link ClientCapabilities#getSampling()} signals the client understands {@value McpMethods#SAMPLING_CREATE_MESSAGE}.
  *
  * <p>
- * Wire objects carry a {@code type} discriminator with values {@code text}, {@code image}, or {@code resource}.
+ * Deliberately empty, mirroring {@link ElicitationCapability}'s shape — the pinned schema defines no sub-fields
+ * for this capability.
  */
-@Marshalled(
-	typePropertyName = "type",
-	dictionary = { TextContent.class, ImageContent.class, EmbeddedResourceContent.class }
-)
-public interface Content {}
+@Marshalled
+public class SamplingCapability {
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/SamplingMessage.java b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/SamplingMessage.java
new file mode 100644
index 0000000000..e1c214cf3e
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/main/java/org/apache/juneau/bean/mcp/v20260728/SamplingMessage.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import org.apache.juneau.marshall.*;
+
+/**
+ * One message in {@link CreateMessageRequest#getMessages()} (MCP sampling).
+ */
+@Marshalled
+public class SamplingMessage {
+
+	private Role role;
+	private Content content;
+
+	/**
+	 * The message role. The real schema restricts sampling roles to {@code user}/{@code assistant}, a subset
+	 * this reused {@link Role} enum already covers.
+	 *
+	 * @return The role, or {@code null} if not set.
+	 */
+	public Role getRole() {
+		return role;
+	}
+
+	/**
+	 * Sets the message role.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public SamplingMessage setRole(Role value) {
+		role = value;
+		return this;
+	}
+
+	/**
+	 * The message content — a single block ({@code text}/{@code image}/{@code audio}/{@code resource}), not a
+	 * list, matching the real sampling schema.
+	 *
+	 * @return The content, or {@code null} if not set.
+	 */
+	public Content getContent() {
+		return content;
+	}
+
+	/**
+	 * Sets the message content.
+	 *
+	 * @param value The new value.  Can be <jk>null</jk> to unset the property.
+	 * @return This object (for method chaining).
+	 */
+	public SamplingMessage setContent(Content value) {
+		content = value;
+		return this;
+	}
+}
diff --git a/juneau-bean/juneau-bean-mcp-v20260728/src/test/java/org/apache/juneau/bean/mcp/v20260728/ElicitSchema_Test.java b/juneau-bean/juneau-bean-mcp-v20260728/src/test/java/org/apache/juneau/bean/mcp/v20260728/ElicitSchema_Test.java
new file mode 100644
index 0000000000..b5de2c710d
--- /dev/null
+++ b/juneau-bean/juneau-bean-mcp-v20260728/src/test/java/org/apache/juneau/bean/mcp/v20260728/ElicitSchema_Test.java
@@ -0,0 +1,342 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.bean.mcp.v20260728;
+
+import static org.apache.juneau.BasicTestUtils.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.*;
+import java.util.stream.*;
+
+import org.junit.jupiter.api.*;
+
+/**
+ * Coverage for {@link ElicitSchema}'s fluent builder and build-time restricted-schema validation.
+ */
+class ElicitSchema_Test {
+
+	@Test void a01_stringField_allModifiersRoundTrip() {
+		var schema = ElicitSchema.create()
+			.stringField("name").title("Name").description("Full name").format("email").defaultValue("a@b.com")
+			.build();
+		assertEquals(
+			"{\"type\":\"object\",\"properties\":{\"name\":{\"type\":\"string\",\"title\":\"Name\","
+				+ "\"description\":\"Full name\",\"format\":\"email\",\"default\":\"a@b.com\"}}}",
+			schema.toString());
+	}
+
+	@Test void a02_numberAndIntegerField_minMaxDefaultRoundTrip() {
+		var schema = ElicitSchema.create()
+			.numberField("price").min(0.0).max(100.0).defaultValue(9.99)
+			.integerField("qty").min(1).max(10).defaultValue(1)
+			.build();
+		assertEquals(
+			"{\"type\":\"object\",\"properties\":{\"price\":{\"type\":\"number\",\"minimum\":0.0,"
+				+ "\"maximum\":100.0,\"default\":9.99},\"qty\":{\"type\":\"integer\",\"minimum\":1,"
+				+ "\"maximum\":10,\"default\":1}}}",
+			schema.toString());
+	}
+
+	@Test void a03_booleanField_titleOnly() {
+		var schema = ElicitSchema.create().booleanField("confirm").title("Confirm").build();
+		assertEquals("{\"type\":\"object\",\"properties\":{\"confirm\":{\"type\":\"boolean\",\"title\":\"Confirm\"}}}",
+			schema.toString());
+	}
+
+	@Test void a04_enumField_valuesAndNamesRoundTrip() {
+		var schema = ElicitSchema.create().enumField("color", "r", "g", "b").enumNames("Red", "Green", "Blue").build();
+		var property = schema.getMap("properties").getMap("color");
+		assertEquals(List.of("r", "g", "b"), property.get("enum"));
+		assertEquals(List.of("Red", "Green", "Blue"), property.get("enumNames"));
+	}
+
+	@Test void a05_multipleFields_onOneSchema() {
+		var schema = ElicitSchema.create()
+			.stringField("name").title("Name")
+			.integerField("age").min(0).max(150)
+			.build();
+		var properties = schema.getMap("properties");
+		assertEquals(Map.of("type", "string", "title", "Name"), properties.getMap("name"));
+		assertEquals(Map.of("type", "integer", "minimum", 0, "maximum", 150), properties.getMap("age"));
+	}
+
+	@Test void a06_reDeclaringFieldName_lastFieldWins() {
+		// Re-declaring "name" via a second stringField(...) call must discard the first declaration's
+		// modifiers (title) entirely, leaving only what was applied after the second declaration.
+		var schema = ElicitSchema.create()
+			.stringField("name").title("First").description("first description")
+			.stringField("name").format("email")
+			.build();
+		var property = schema.getMap("properties").getMap("name");
+		assertEquals(Map.of("type", "string", "format", "email"), property);
+	}
+
+	@Test void b01_format_onNonStringField_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''age'': format is only valid on string fields",
+			() -> ElicitSchema.create().integerField("age").format("email").build());
+	}
+
+	@Test void b02_minMax_onNonNumericField_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''name'': min/max are only valid on number/integer fields",
+			() -> ElicitSchema.create().stringField("name").min(0).build());
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''flag'': min/max are only valid on number/integer fields",
+			() -> ElicitSchema.create().booleanField("flag").max(1).build());
+	}
+
+	@Test void b03_enumNames_withoutEnumValues_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''name'': enumNames requires enum values",
+			() -> ElicitSchema.create().stringField("name").enumNames("A").build());
+	}
+
+	@Test void b04_noFieldStarted_modifierThrowsIllegalStateException() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"No field has been started yet; call stringField(...)/numberField(...)/etc. first",
+			() -> ElicitSchema.create().title("x"));
+	}
+
+	@Test void b05_enumField_nullValues_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class,
+			"Field ''color'': enumField values must not be null or empty",
+			() -> ElicitSchema.create().enumField("color", (String[])null));
+	}
+
+	@Test void b06_enumField_emptyValues_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class,
+			"Field ''color'': enumField values must not be null or empty",
+			() -> ElicitSchema.create().enumField("color"));
+	}
+
+	@Test void b07_title_null_throwsIllegalArgumentException() {
+		assertThrows(IllegalArgumentException.class, () -> ElicitSchema.create().stringField("name").title(null));
+	}
+
+	@Test void b08_description_null_throwsIllegalArgumentException() {
+		assertThrows(IllegalArgumentException.class,
+			() -> ElicitSchema.create().stringField("name").description(null));
+	}
+
+	@Test void b09_format_null_throwsIllegalArgumentException() {
+		assertThrows(IllegalArgumentException.class, () -> ElicitSchema.create().stringField("name").format(null));
+	}
+
+	@Test void b10_enumNames_null_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "enumNames values must not be null or empty",
+			() -> ElicitSchema.create().enumField("color", "r", "g").enumNames((String[])null));
+	}
+
+	@Test void b11_enumNames_empty_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "enumNames values must not be null or empty",
+			() -> ElicitSchema.create().enumField("color", "r", "g").enumNames());
+	}
+
+	@Test void b12_enumNames_lengthMismatch_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "enumNames length (1) must match enum length (2)",
+			() -> ElicitSchema.create().enumField("color", "r", "g").enumNames("Red"));
+	}
+
+	@Test void b13_emptyBuilder_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"ElicitSchema requires at least one field (an empty requestedSchema is unanswerable)",
+			() -> ElicitSchema.create().build());
+	}
+
+	@Test void b14_required_unknownFieldName_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"required(...) names field ''age'', which was never added",
+			() -> ElicitSchema.create().stringField("name").required("age").build());
+	}
+
+	@Test void b15_required_nullOrEmptyNames_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "required field names must not be null or empty",
+			() -> ElicitSchema.create().stringField("name").required((String[])null));
+		assertThrowsWithMessage(IllegalArgumentException.class, "required field names must not be null or empty",
+			() -> ElicitSchema.create().stringField("name").required());
+	}
+
+	@Test void b16_minLength_onNonStringField_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''age'': minLength/maxLength are only valid on string fields",
+			() -> ElicitSchema.create().integerField("age").minLength(1).build());
+	}
+
+	@Test void b17_maxLength_onNonStringField_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''age'': minLength/maxLength are only valid on string fields",
+			() -> ElicitSchema.create().integerField("age").maxLength(1).build());
+	}
+
+	@Test void b18_minLength_negative_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''name'': minLength must not be negative",
+			() -> ElicitSchema.create().stringField("name").minLength(-1).build());
+	}
+
+	@Test void b19_maxLength_negative_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''name'': maxLength must not be negative",
+			() -> ElicitSchema.create().stringField("name").maxLength(-1).build());
+	}
+
+	@Test void b20_minLength_exceedsMaxLength_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''name'': minLength must not exceed maxLength",
+			() -> ElicitSchema.create().stringField("name").minLength(5).maxLength(2).build());
+	}
+
+	@Test void b21_stringField_nullName_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "Argument 'name' cannot be null.",
+			() -> ElicitSchema.create().stringField(null));
+	}
+
+	@Test void b22_stringField_emptyName_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "Argument 'name' cannot be blank.",
+			() -> ElicitSchema.create().stringField(""));
+	}
+
+	@Test void b23_enumField_nullName_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "Argument 'name' cannot be null.",
+			() -> ElicitSchema.create().enumField(null, "r", "g"));
+	}
+
+	@Test void b24_enumField_emptyName_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "Argument 'name' cannot be blank.",
+			() -> ElicitSchema.create().enumField("", "r", "g"));
+	}
+
+	@Test void b25_enumField_nullElementValue_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class,
+			"Field ''color'': enumField values must not contain a null element",
+			() -> ElicitSchema.create().enumField("color", "r", null, "g"));
+	}
+
+	@Test void b26_enumNames_nullElementValue_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "enumNames values must not contain a null element",
+			() -> ElicitSchema.create().enumField("color", "r", "g").enumNames("Red", null));
+	}
+
+	@Test void b27_required_nullElementName_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "required field names must not contain a null element",
+			() -> ElicitSchema.create().stringField("a").stringField("b").required("a", (String)null));
+	}
+
+	@Test void b28_min_null_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "Argument 'value' cannot be null.",
+			() -> ElicitSchema.create().integerField("age").min(null));
+	}
+
+	@Test void b29_max_null_throwsIllegalArgumentException() {
+		assertThrowsWithMessage(IllegalArgumentException.class, "Argument 'value' cannot be null.",
+			() -> ElicitSchema.create().integerField("age").max(null));
+	}
+
+	@Test void b30_minLength_onEnumField_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''color'': minLength/maxLength are not valid on an enum (closed-choice) field",
+			() -> ElicitSchema.create().enumField("color", "r", "g").minLength(1).build());
+	}
+
+	@Test void b31_maxLength_onEnumField_throwsAtBuildTime() {
+		assertThrowsWithMessage(IllegalStateException.class,
+			"Field ''color'': minLength/maxLength are not valid on an enum (closed-choice) field",
+			() -> ElicitSchema.create().enumField("color", "r", "g").maxLength(1).build());
+	}
+
+	@Test void c01_noObjectOrArrayFieldMethodExists() {
+		var methodNames = Arrays.stream(ElicitSchema.class.getDeclaredMethods())
+			.map(m -> m.getName().toLowerCase(Locale.ROOT))
+			.collect(Collectors.toSet());
+		for (var forbidden : List.of("objectfield", "arrayfield", "nestedfield"))
+			assertFalse(methodNames.contains(forbidden), () -> "must not declare a " + forbidden + " method");
+	}
+
+	@Test void d01_build_returnsSchemaIndependentOfFurtherBuilderMutation() {
+		// Pins the fix for the shallow-copy aliasing bug: build() must deep-copy each per-field map so that
+		// applying further modifiers to the builder after build() cannot mutate an already-returned schema.
+		var builder = ElicitSchema.create().stringField("name").title("Name");
+		var first = builder.build();
+		builder.description("added after build");
+		builder.integerField("age").min(0);
+		assertEquals("{\"type\":\"object\",\"properties\":{\"name\":{\"type\":\"string\",\"title\":\"Name\"}}}",
+			first.toString());
+	}
+
+	@Test void e01_required_singleField_emitsRequiredArray() {
+		var schema = ElicitSchema.create().stringField("name").required("name").build();
+		assertEquals(List.of("name"), schema.get("required"));
+	}
+
+	@Test void e02_required_multipleFields_preservesInsertionOrder() {
+		var schema = ElicitSchema.create()
+			.stringField("name").integerField("age").booleanField("confirm")
+			.required("confirm", "name")
+			.build();
+		assertEquals(List.of("confirm", "name"), schema.get("required"));
+	}
+
+	@Test void e03_required_notCalled_omitsRequiredKey() {
+		var schema = ElicitSchema.create().stringField("name").build();
+		assertFalse(schema.containsKey("required"));
+	}
+
+	@Test void e04_required_multipleCalls_accumulate() {
+		var schema = ElicitSchema.create()
+			.stringField("name").integerField("age")
+			.required("name")
+			.required("age")
+			.build();
+		assertEquals(List.of("name", "age"), schema.get("required"));
+	}
+
+	@Test void e05_required_reDeclaredField_markingSurvives() {
+		// required(...) is a builder-level, order-independent set (see class Javadoc): redeclaring "name" via
+		// a second stringField(...) call discards its per-field modifiers (last-field-wins) but must NOT
+		// discard its earlier required(...) marking.
+		var schema = ElicitSchema.create()
+			.stringField("name").required("name")
+			.stringField("name")
+			.build();
+		assertEquals(List.of("name"), schema.get("required"));
+	}
+
+	@Test void e06_required_beforeFieldDeclared_survivesToBuild() {
+		// The critical ordering: required(...) named before the field it names is even added must still
+		// emit that name in the built "required" array.
+		var schema = ElicitSchema.create()
+			.required("email")
+			.stringField("email")
+			.build();
+		assertEquals("{\"type\":\"object\",\"properties\":{\"email\":{\"type\":\"string\"}},\"required\":[\"email\"]}",
+			schema.toString());
+	}
+
+	@Test void e07_required_mixedBeforeAndAfterFieldDeclaration_bothSurvive() {
+		var schema = ElicitSchema.create()
+			.stringField("a").required("a", "b").stringField("b")
+			.build();
+		assertEquals(List.of("a", "b"), schema.get("required"));
+	}
+
+	@Test void f01_minLengthAndMaxLength_emitOnStringField() {
+		var schema = ElicitSchema.create().stringField("name").minLength(1).maxLength(10).build();
+		assertEquals(Map.of("type", "string", "minLength", 1, "maxLength", 10),
+			schema.getMap("properties").getMap("name"));
+	}
+}
diff --git a/juneau-integration-tests/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpElicitationIntegration_Test.java b/juneau-integration-tests/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpElicitationIntegration_Test.java
new file mode 100644
index 0000000000..94543a5c8d
--- /dev/null
+++ b/juneau-integration-tests/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpElicitationIntegration_Test.java
@@ -0,0 +1,234 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.rest.client.mcp.v20260728;
+
+import static org.apache.juneau.test.bct.BctAssertions.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.*;
+
+import org.apache.juneau.*;
+import org.apache.juneau.bean.jsonrpc.*;
+import org.apache.juneau.bean.mcp.v20260728.*;
+import org.apache.juneau.commons.inject.*;
+import org.apache.juneau.marshall.json.*;
+import org.apache.juneau.marshall.marshaller.Json;
+import org.apache.juneau.microservice.*;
+import org.apache.juneau.rest.server.*;
+import org.apache.juneau.rest.server.mcp.*;
+import org.apache.juneau.rest.server.mcp.v20260728.*;
+// Single-type import needed to disambiguate from org.apache.juneau.rest.server.mcp.McpRevision (the
+// revision-neutral interface), which the wildcard import above collides with.
+import org.apache.juneau.rest.server.mcp.v20260728.McpRevision;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.extension.*;
+
+import jakarta.servlet.*;
+
+/**
+ * End-to-end coverage for MCP {@code 2026-07-28} SEP-2322 elicitation (C6), driven through the real
+ * {@link McpClient} and its {@link ElicitationAccess} typed helper against a live embedded-Jetty server whose
+ * tools pause/resume via {@link ElicitationRequests}/{@link ElicitationResponses} &mdash; proving the full typed
+ * path works across a real wire boundary, complementing {@link McpMrtrIntegration_Test}'s generic (untyped)
+ * PAUSE/RESUME coverage and Phase 7's {@code Characterization_Test} in-process replay fixtures.
+ */
+@org.apache.juneau.testing.JettyMicroserviceTest
+class McpElicitationIntegration_Test extends TestBase {
+
+	private static ElicitRequest confirmQuestion() {
+		return new ElicitRequest()
+			.setMessage("Proceed with deletion?")
+			.setRequestedSchema(ElicitSchema.create().booleanField("confirm").title("Confirm").build());
+	}
+
+	private static McpToolHandler confirm() {
+		return new McpToolHandler() {
+			@Override public McpToolSpec descriptor() { return new McpToolSpec().setName("confirm").setDescription("Pauses for one confirmation"); }
+			@Override public McpToolOutcome call(Map<String,Object> arguments, BeanStore ctx) {
+				var resume = ctx.getBean(McpMrtrResumeContext.class);
+				if (resume.isEmpty())
+					throw ElicitationRequests.of("confirm", confirmQuestion(), "cont-1");
+				var answer = ElicitationResponses.get(resume.get(), "confirm");
+				// Echoes the answer's content (not just its action) and the continuation this tool paused
+				// with, so the assertions below actually exercise ElicitResult.content marshalling and prove
+				// the continuation round-trips through McpMrtrResumeContext, instead of only the action enum.
+				var confirmValue = answer.getContent() == null ? null : answer.getContent().get("confirm");
+				return McpToolOutcome.text("action:" + answer.getAction() + ",confirm:" + confirmValue
+					+ ",cont:" + resume.get().continuation());
+			}
+		};
+	}
+
+	private static McpToolHandler confirmTwo() {
+		return new McpToolHandler() {
+			@Override public McpToolSpec descriptor() { return new McpToolSpec().setName("confirmTwo").setDescription("Pauses for two confirmations in one round"); }
+			@Override public McpToolOutcome call(Map<String,Object> arguments, BeanStore ctx) {
+				var resume = ctx.getBean(McpMrtrResumeContext.class);
+				if (resume.isEmpty()) {
+					var requests = new LinkedHashMap<String,ElicitRequest>();
+					requests.put("confirm", confirmQuestion());
+					requests.put("reason", new ElicitRequest().setMessage("Why?")
+						.setRequestedSchema(ElicitSchema.create().stringField("reason").build()));
+					throw ElicitationRequests.of(requests, "cont-multi");
+				}
+				var answers = ElicitationResponses.all(resume.get());
+				var confirmAnswer = answers.get("confirm");
+				var reasonAnswer = answers.get("reason");
+				var confirmValue = confirmAnswer.getContent() == null ? null : confirmAnswer.getContent().get("confirm");
+				var reasonValue = reasonAnswer.getContent() == null ? null : reasonAnswer.getContent().get("reason");
+				return McpToolOutcome.text("confirm:" + confirmAnswer.getAction() + "=" + confirmValue
+					+ ",reason:" + reasonAnswer.getAction() + "=" + reasonValue
+					+ ",cont:" + resume.get().continuation());
+			}
+		};
+	}
+
+	@Rest(serializers = JsonSerializer.class, parsers = JsonParser.class, defaultAccept = "application/json")
+	public static class Fixture extends org.apache.juneau.rest.server.mcp.v20260728.McpRestServlet {
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		protected McpServerConfig createMcpConfig() {
+			return new McpServerConfig().setName("it-elicit-fixture").setVersion("1.0.0")
+				.addTool(confirm()).addTool(confirmTwo());
+		}
+	}
+
+	@Configuration
+	public static class FixtureConfig {
+		@Bean public Servlet mcpServlet() { return new Fixture(); }
+	}
+
+	@RegisterExtension
+	static MicroserviceTestFixture fixture = MicroserviceTestFixture.create()
+		.configurations(FixtureConfig.class);
+
+	private static McpClient.Builder clientBuilder(boolean withElicitation) {
+		var caps = new ClientCapabilities();
+		if (withElicitation)
+			caps.setElicitation(new ElicitationCapability());
+		return McpClient.builder().endpoint(fixture.getRootUrl() + "/").clientCapabilities(caps);
+	}
+
+	/**
+	 * Decodes {@code raw} (a {@link McpClient#callRaw} "complete" result) into a {@link CallToolResult} and
+	 * returns its first content block's text, replacing the raw {@code List}/{@code Map} cast chains every test
+	 * below previously repeated inline.
+	 */
+	private static String firstText(Map<String,Object> raw) {
+		var result = Json.to(Json.of(raw), CallToolResult.class);
+		return ((TextContent) result.getContent().get(0)).getText();
+	}
+
+	// =================================================================================================================
+	// A: single-question pause -> resume -> complete, driven entirely through ElicitationAccess.
+	// =================================================================================================================
+
+	@Test void a01_singleQuestion_pauseResumeAccept_fullLoop() throws Exception {
+		try (var client = clientBuilder(true).build()) {
+			var paused = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirm").setArguments(Map.of()));
+			assertTrue(ElicitationAccess.isInputRequired(paused));
+			var requests = ElicitationAccess.requests(paused);
+			assertEquals("Proceed with deletion?", requests.get("confirm").getMessage());
+			// The requestedSchema (built via ElicitSchema.booleanField("confirm").title("Confirm")) must survive
+			// the wire intact, not just the message - otherwise a real client could not render the right input
+			// control for the end user.
+			var confirmProperty = (Map<?,?>) ((Map<?,?>) requests.get("confirm").getRequestedSchema().get("properties")).get("confirm");
+			assertBean(confirmProperty, "type,title", "boolean,Confirm");
+
+			var answer = new ElicitResult().setAction(ElicitAction.ACCEPT).putContent("confirm", true);
+			var completed = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirm")
+				.setRequestState(ElicitationAccess.requestState(paused))
+				.setInputResponses(ElicitationAccess.toInputResponse("confirm", answer)));
+			assertFalse(ElicitationAccess.isInputRequired(completed));
+			assertEquals("complete", completed.get("resultType"));
+			assertEquals("action:accept,confirm:true,cont:cont-1", firstText(completed));
+		}
+	}
+
+	// =================================================================================================================
+	// B: multi-question pause -> resume with both answers in one round.
+	// =================================================================================================================
+
+	@Test void b01_multiQuestion_pauseResumeBoth_singleRoundTrip() throws Exception {
+		try (var client = clientBuilder(true).build()) {
+			var paused = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirmTwo").setArguments(Map.of()));
+			var requests = ElicitationAccess.requests(paused);
+			assertEquals(2, requests.size());
+			assertTrue(requests.containsKey("confirm"));
+			assertTrue(requests.containsKey("reason"));
+
+			var answers = new LinkedHashMap<String,ElicitResult>();
+			answers.put("confirm", new ElicitResult().setAction(ElicitAction.ACCEPT).putContent("confirm", true));
+			answers.put("reason", new ElicitResult().setAction(ElicitAction.ACCEPT).putContent("reason", "cleanup"));
+			var completed = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirmTwo")
+				.setRequestState(ElicitationAccess.requestState(paused))
+				.setInputResponses(ElicitationAccess.toInputResponses(answers)));
+			assertEquals("complete", completed.get("resultType"));
+			assertEquals("confirm:accept=true,reason:accept=cleanup,cont:cont-multi", firstText(completed));
+		}
+	}
+
+	// =================================================================================================================
+	// C: decline and cancel resumes both complete, carrying the correct ElicitAction to the handler.
+	// =================================================================================================================
+
+	@Test void c01_decline_resumeCarriesDeclineAction() throws Exception {
+		try (var client = clientBuilder(true).build()) {
+			var paused = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirm").setArguments(Map.of()));
+			assertTrue(ElicitationAccess.isInputRequired(paused));
+			assertNotNull(ElicitationAccess.requestState(paused));
+			var answer = new ElicitResult().setAction(ElicitAction.DECLINE);
+			var completed = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirm")
+				.setRequestState(ElicitationAccess.requestState(paused))
+				.setInputResponses(ElicitationAccess.toInputResponse("confirm", answer)));
+			assertEquals("complete", completed.get("resultType"));
+			assertEquals("action:decline,confirm:null,cont:cont-1", firstText(completed));
+		}
+	}
+
+	@Test void c02_cancel_resumeCarriesCancelAction() throws Exception {
+		try (var client = clientBuilder(true).build()) {
+			var paused = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirm").setArguments(Map.of()));
+			assertTrue(ElicitationAccess.isInputRequired(paused));
+			assertNotNull(ElicitationAccess.requestState(paused));
+			var answer = new ElicitResult().setAction(ElicitAction.CANCEL);
+			var completed = client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirm")
+				.setRequestState(ElicitationAccess.requestState(paused))
+				.setInputResponses(ElicitationAccess.toInputResponse("confirm", answer)));
+			assertEquals("complete", completed.get("resultType"));
+			assertEquals("action:cancel,confirm:null,cont:cont-1", firstText(completed));
+		}
+	}
+
+	// =================================================================================================================
+	// D: capability gate still fires unmodified when a typed-helper pause is thrown by an unsupported client.
+	// =================================================================================================================
+
+	/**
+	 * Delta vs {@link McpMrtrIntegration_Test#b01_unsupportedCapability_rejectedOverTheWire()}: proves the same
+	 * capability gate fires for a signal built via the typed {@code ElicitationRequests.of(...)} helper (not a
+	 * hand-built {@code McpInputRequiredSignal}) — i.e. the helper yields a gate-recognized signal.
+	 */
+	@Test void d01_unsupportedCapability_typedHelperPauseStillRejectedOverTheWire() throws Exception {
+		try (var client = clientBuilder(false).build()) {
+			var e = assertThrows(McpException.class,
+				() -> client.callRaw(McpMethods.TOOLS_CALL, new CallToolRequest().setName("confirm").setArguments(Map.of())));
+			assertEquals(McpRevision.CODE_MISSING_REQUIRED_CLIENT_CAPABILITY, e.getCode());
+		}
+	}
+}
diff --git a/juneau-integration-tests/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java b/juneau-integration-tests/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java
index 77926b59de..282e32de83 100644
--- a/juneau-integration-tests/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java
+++ b/juneau-integration-tests/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java
@@ -312,6 +312,58 @@ class Characterization_Test {
 		}
 	}
 
+	/**
+	 * Backs every {@code ELICIT-*} fixture (SEP-2322 elicitation, built on the same PAUSE/RESUME mechanism
+	 * {@link F_Mrtr} exercises generically). Unlike {@link F_Mrtr}'s placeholder {@code Map.of("type","elicitation")},
+	 * this servlet's tools pause and resume through the real typed path ({@link ElicitationRequests}/
+	 * {@link ElicitationResponses}, {@link ElicitRequest}/{@link ElicitResult}/{@link ElicitSchema}), so these
+	 * fixtures characterize the actual elicitation wire shape, not just the generic MRTR envelope.
+	 */
+	@Rest(serializers = JsonSerializer.class, parsers = JsonParser.class, defaultAccept = "application/json")
+	public static class F_Elicit extends McpRestServlet {
+		private static final long serialVersionUID = 1L;
+
+		private static ElicitRequest confirmQuestion() {
+			return new ElicitRequest()
+				.setMessage("Proceed with deletion?")
+				.setRequestedSchema(ElicitSchema.create().booleanField("confirm").title("Confirm").build());
+		}
+
+		@Override protected McpServerConfig createMcpConfig() {
+			return new McpServerConfig()
+				.addTool(new McpToolHandler() {
+					@Override public McpToolSpec descriptor() { return new McpToolSpec().setName("confirm").setDescription("desc:confirm"); }
+					@Override public McpToolOutcome call(Map<String,Object> arguments, BeanStore ctx) {
+						var resume = ctx.getBean(McpMrtrResumeContext.class);
+						if (resume.isEmpty())
+							throw ElicitationRequests.of("confirm", confirmQuestion(), "cont-1");
+						var answer = ElicitationResponses.get(resume.get(), "confirm");
+						return McpToolOutcome.text("action:" + answer.getAction());
+					}
+				})
+				.addTool(new McpToolHandler() {
+					@Override public McpToolSpec descriptor() { return new McpToolSpec().setName("confirmTwo").setDescription("desc:confirmTwo"); }
+					@Override public McpToolOutcome call(Map<String,Object> arguments, BeanStore ctx) {
+						var resume = ctx.getBean(McpMrtrResumeContext.class);
+						if (resume.isEmpty()) {
+							var requests = new LinkedHashMap<String,ElicitRequest>();
+							requests.put("confirm", confirmQuestion());
+							requests.put("reason", new ElicitRequest().setMessage("Why?")
+								.setRequestedSchema(ElicitSchema.create().stringField("reason").build()));
+							throw ElicitationRequests.of(requests, "cont-multi");
+						}
+						var answers = ElicitationResponses.all(resume.get());
+						return McpToolOutcome.text("confirm:" + answers.get("confirm").getAction()
+							+ ",reason:" + answers.get("reason").getAction());
+					}
+				});
+		}
+
+		@Override protected McpMrtrConfig createMrtrConfig() {
+			return new McpMrtrConfig().setCodec(new FixedKeyGcmCodec());
+		}
+	}
+
 	/**
 	 * Test-only deterministic {@link RequestStateCodec}: AES-256-GCM with a <b>hardcoded</b> key and nonce.
 	 *
@@ -416,6 +468,8 @@ class Characterization_Test {
 			case "MRTR-input-required-response", "MRTR-resume-complete", "MRTR-resume-input-required-again",
 				"MRTR-tampered-request-state", "MRTR-expired-request-state", "MRTR-unsupported-capability",
 				"MRTR-max-rounds-exceeded" -> F_Mrtr.class;
+			case "ELICIT-single-request-pause", "ELICIT-multi-request-pause", "ELICIT-resume-accept-complete",
+				"ELICIT-resume-decline", "ELICIT-resume-cancel" -> F_Elicit.class;
 			default -> F_Empty.class;
 		};
 	}
@@ -459,6 +513,8 @@ class Characterization_Test {
 			case "MRTR-expired-request-state" -> codec.seal(new McpRequestState("cont-1", "tools/call", 1, PAST_MS), aad("tools/call"));
 			case "MRTR-max-rounds-exceeded" -> codec.seal(new McpRequestState("cont-1", "tools/call", McpMrtrConfig.DEFAULT_MAX_ROUNDS, FAR_FUTURE_MS), aad("tools/call"));
 			case "MRTR-tampered-request-state" -> tamper(codec.seal(new McpRequestState("cont-1", "tools/call", 1, FAR_FUTURE_MS), aad("tools/call")));
+			case "ELICIT-resume-accept-complete", "ELICIT-resume-decline", "ELICIT-resume-cancel" ->
+				codec.seal(new McpRequestState("cont-1", "tools/call", 1, FAR_FUTURE_MS), aad("tools/call"));
 			default -> throw new IllegalArgumentException("No MRTR token mapping for fixture: " + fixture);
 		};
 	}
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.headers.properties b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.headers.properties
new file mode 100644
index 0000000000..dffe187ccb
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirmTwo
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.request.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.request.json
new file mode 100644
index 0000000000..cc69ae4dfe
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirmTwo","arguments":{},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.response.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.response.json
new file mode 100644
index 0000000000..808a18bbf9
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-multi-request-pause.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"inputRequests":{"confirm":{"message":"Proceed with deletion?","requestedSchema":{"type":"object","properties":{"confirm":{"type":"boolean","title":"Confirm"}}}},"reason":{"message":"Why?","requestedSchema":{"type":"object","properties":{"reason":{"type":"string"}}}}},"requestState":"<sealed>","resultType":"input_required"}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.headers.properties b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.request.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.request.json
new file mode 100644
index 0000000000..3fc4aeac40
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","requestState":"__REQUEST_STATE__","inputResponses":{"confirm":{"action":"accept","content":{"confirm":true}}},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.response.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.response.json
new file mode 100644
index 0000000000..17639de560
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-accept-complete.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"content":[{"type":"text","text":"action:accept"}],"resultType":"complete"}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.headers.properties b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.request.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.request.json
new file mode 100644
index 0000000000..d90d60cf57
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","requestState":"__REQUEST_STATE__","inputResponses":{"confirm":{"action":"cancel"}},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.response.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.response.json
new file mode 100644
index 0000000000..1874cbc3cf
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-cancel.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"content":[{"type":"text","text":"action:cancel"}],"resultType":"complete"}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.headers.properties b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.request.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.request.json
new file mode 100644
index 0000000000..87a1394982
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","requestState":"__REQUEST_STATE__","inputResponses":{"confirm":{"action":"decline"}},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.response.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.response.json
new file mode 100644
index 0000000000..95ad0952e2
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-resume-decline.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"content":[{"type":"text","text":"action:decline"}],"resultType":"complete"}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.headers.properties b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.request.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.request.json
new file mode 100644
index 0000000000..8b1ebbeac7
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","arguments":{},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.response.json b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.response.json
new file mode 100644
index 0000000000..3e633eb223
--- /dev/null
+++ b/juneau-integration-tests/src/test/resources/mcp/v20260728/characterization/ELICIT-single-request-pause.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"inputRequests":{"confirm":{"message":"Proceed with deletion?","requestedSchema":{"type":"object","properties":{"confirm":{"type":"boolean","title":"Confirm"}}}}},"requestState":"<sealed>","resultType":"input_required"}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-client-mcp-v20260728/src/main/java/org/apache/juneau/rest/client/mcp/v20260728/ElicitationAccess.java b/juneau-rest/juneau-rest-client-mcp-v20260728/src/main/java/org/apache/juneau/rest/client/mcp/v20260728/ElicitationAccess.java
new file mode 100644
index 0000000000..834f941255
--- /dev/null
+++ b/juneau-rest/juneau-rest-client-mcp-v20260728/src/main/java/org/apache/juneau/rest/client/mcp/v20260728/ElicitationAccess.java
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.rest.client.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.AssertionUtils.*;
+
+import java.util.*;
+
+import org.apache.juneau.bean.mcp.v20260728.*;
+import org.apache.juneau.marshall.collections.*;
+import org.apache.juneau.marshall.marshaller.*;
+
+/**
+ * Static helper for driving MCP {@code 2026-07-28} SEP-2322 elicitation over {@link McpClient#callRaw}'s raw
+ * {@code Map<String,Object>} result (MRTR, TODO-318's Multi-Round-Trip Requests loop, client side).
+ *
+ * <p>
+ * Works at the raw map/JSON level rather than exposing typed overloads per concrete request bean, because
+ * {@code CallToolRequest}/{@code GetPromptRequest}/{@code ReadResourceRequest} share no common
+ * "has-inputResponses-and-requestState" interface (each independently declares its own pair of fields; their
+ * actual common base, {@code RequestParams<T>}, carries only {@code _meta}). A caller resuming, say, a
+ * {@code CallToolRequest} calls {@link #toInputResponses(Map)} for the raw payload, then makes its own
+ * {@code .setInputResponses(...).setRequestState(...)} call on the concrete bean it already knows it holds.
+ *
+ * @since 10.0.0
+ */
+public final class ElicitationAccess {
+
+	private ElicitationAccess() {}
+
+	/**
+	 * Whether a {@link McpClient#callRaw} result represents a paused elicitation (or any other MRTR pause).
+	 *
+	 * @param raw The raw result from {@link McpClient#callRaw}.  Must not be <jk>null</jk>.
+	 * @return <jk>true</jk> if {@code raw.get("resultType")} is {@code "input_required"}.
+	 * @throws IllegalArgumentException If {@code raw} is <jk>null</jk>.
+	 */
+	public static boolean isInputRequired(Map<String,Object> raw) {
+		assertArgNotNull("raw", raw);
+		return "input_required".equals(raw.get("resultType"));
+	}
+
+	/**
+	 * Decodes {@code raw}'s {@code inputRequests} into typed {@link ElicitRequest}s.
+	 *
+	 * <p>
+	 * Each raw value is generic JSON (a {@code Map} after wire deserialization, per {@code InputRequiredResult}'s
+	 * lossless-map contract), converted via the same {@code Json.to(Json.of(value), type)} technique
+	 * {@code McpMrtrResumeContext.continuationAs(Class)} demonstrates server-side. A value that is present but
+	 * <jk>null</jk> decodes to a <jk>null</jk> entry (see the return doc); this mirrors
+	 * {@code ElicitationResponses.all(McpMrtrResumeContext)}'s null-passthrough on the server side.
+	 *
+	 * <p>
+	 * <b>Every</b> entry is decoded as an {@link ElicitRequest}, unconditionally &mdash; per
+	 * {@code InputRequiredResult}'s Javadoc, {@code inputRequests} entries may in principle be arbitrary
+	 * sub-request kinds (sampling/roots/elicitation), not only elicitation. A non-elicitation entry (one that
+	 * shares no field names with {@link ElicitRequest}) simply decodes to an all-<jk>null</jk>-fields
+	 * {@link ElicitRequest}, since the underlying {@code Json.to} conversion tolerates unknown/missing bean
+	 * properties; it is the caller's responsibility to only call this for elicitation-flavored MRTR pauses.
+	 *
+	 * @param raw The raw result from {@link McpClient#callRaw}.  Must not be <jk>null</jk>.
+	 * @return A keyed map of typed requests.  Never <jk>null</jk> (empty if {@code raw} carried none). Values
+	 * 	may be <jk>null</jk> when the corresponding raw entry is absent/<jk>null</jk>.
+	 * @throws IllegalArgumentException If {@code raw} is <jk>null</jk>.
+	 * @throws ClassCastException If {@code raw.get("inputRequests")} is present but is not, at runtime, a
+	 * 	{@code Map} &mdash; which can only happen against a malformed/non-conforming remote response, since a
+	 * 	well-formed one always deserializes {@code inputRequests} to a {@code Map} per JSON semantics.
+	 * @throws RuntimeException If any entry's decoded shape cannot be converted to {@link ElicitRequest}.
+	 */
+	@SuppressWarnings({
+		"unchecked" // raw.get("inputRequests") deserializes to a Map<String,Object> from JSON for any well-formed remote response; a malformed one surfaces as ClassCastException here (see @throws), not a silently-wrong cast.
+	})
+	public static Map<String,ElicitRequest> requests(Map<String,Object> raw) {
+		assertArgNotNull("raw", raw);
+		var rawRequests = (Map<String,Object>) raw.get("inputRequests");
+		Map<String,ElicitRequest> out = new LinkedHashMap<>();
+		if (rawRequests != null)
+			rawRequests.forEach((id, value) -> out.put(id, value == null ? null : Json.to(Json.of(value), ElicitRequest.class)));
+		return out;
+	}
+
+	/**
+	 * Returns {@code raw}'s echoed continuation token.
+	 *
+	 * @param raw The raw result from {@link McpClient#callRaw}.  Must not be <jk>null</jk>.
+	 * @return The token, or <jk>null</jk> if absent.
+	 * @throws IllegalArgumentException If {@code raw} is <jk>null</jk>.
+	 * @throws ClassCastException If {@code raw.get("requestState")} is present but is not, at runtime, a
+	 * 	{@code String} &mdash; only possible against a malformed/non-conforming remote response.
+	 */
+	public static String requestState(Map<String,Object> raw) {
+		assertArgNotNull("raw", raw);
+		return (String) raw.get("requestState");
+	}
+
+	/**
+	 * Encodes a single typed {@link ElicitResult} into the raw {@code inputResponses} payload shape.
+	 *
+	 * @param id The server-assigned id this answer responds to.  Must not be <jk>null</jk>.
+	 * @param result The typed answer.  Must not be <jk>null</jk>.
+	 * @return A single-entry map ready to pass to {@link #toInputResponses(Map)}'s multi-answer form, or to hand
+	 * 	directly to a concrete request bean's {@code setInputResponses(...)} after merging with other answers.
+	 * @throws IllegalArgumentException If {@code id} or {@code result} is <jk>null</jk>.
+	 */
+	public static Map<String,Object> toInputResponse(String id, ElicitResult result) {
+		assertArgNotNull("id", id);
+		assertArgNotNull("result", result);
+		return toInputResponses(Map.of(id, result));
+	}
+
+	/**
+	 * Encodes several typed {@link ElicitResult}s into the raw {@code inputResponses} payload shape a resume
+	 * call's request bean expects (e.g. {@code CallToolRequest.setInputResponses(...)}).
+	 *
+	 * <p>
+	 * Unlike {@code ElicitationRequests.of(Map,Object)} (server side), an empty {@code results} map is accepted (returning
+	 * an empty map), not rejected &mdash; deliberately asymmetric, since a caller may legitimately resume with
+	 * zero elicitation answers if a round only carried non-elicitation MRTR pauses, whereas building a signal
+	 * with zero questions server-side would be a pointless pause.
+	 *
+	 * @param results Server-assigned-id-keyed typed answers.  Must not be <jk>null</jk>, and no value may be
+	 * 	<jk>null</jk>.  Output iteration order mirrors this map's order, so a caller wanting deterministic
+	 * 	ordering should pass a {@link LinkedHashMap}.
+	 * @return A keyed map of raw, wire-shaped answers.  Never <jk>null</jk> (empty if {@code results} was empty).
+	 * @throws IllegalArgumentException If {@code results} is <jk>null</jk>, or any value in it is <jk>null</jk>.
+	 */
+	public static Map<String,Object> toInputResponses(Map<String,ElicitResult> results) {
+		assertArgNotNull("results", results);
+		Map<String,Object> out = new LinkedHashMap<>();
+		results.forEach((id, result) -> {
+			assertArgNotNull("results[" + id + "]", result);
+			// Pre-marshalled to JsonMap here (rather than left as the typed ElicitResult for McpClient.call's
+			// own toWireParams flattening) so that (a) a null-check on the encoded shape is meaningful even
+			// when this helper is used standalone, outside McpClient.call's flow, and (b) the returned map is
+			// immediately wire-ready for a caller who hands it straight to a concrete request bean's
+			// setInputResponses(...) without ever going through McpClient at all.
+			out.put(id, Json.to(Json.of(result), JsonMap.class));
+		});
+		return out;
+	}
+}
diff --git a/juneau-rest/juneau-rest-client-mcp-v20260728/src/main/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient.java b/juneau-rest/juneau-rest-client-mcp-v20260728/src/main/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient.java
index 5c79a3619c..40c986cbe9 100644
--- a/juneau-rest/juneau-rest-client-mcp-v20260728/src/main/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient.java
+++ b/juneau-rest/juneau-rest-client-mcp-v20260728/src/main/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient.java
@@ -307,9 +307,19 @@ public final class McpClient extends AbstractMcpClient {
 	// DUPLEX_RETURN_METHOD has no routing-name mapping in McpRoutingNames. It is unclear whether the real
 	// contract instead wants it to echo the correlated inbound request's tool/prompt/resource name; that
 	// requires spec clarification and is deliberately left open rather than guessed at here.
+	//
+	// payload must be routed through toWireParams(...) exactly like every other outbound envelope (see #call):
+	// AbstractMcpClient.send(...) posts through restClient, whose serializer is JsonSerializer.DEFAULT
+	// (addBeanTypes=false) - handed the payload's typed beans directly, a polymorphic Content field (e.g.
+	// CreateMessageResult.content holding a TextContent) would be serialized without its "type" discriminator,
+	// since addBeanTypes is what drives whether SerializerSession writes bean-dictionary type names at all.
+	// toWireParams(...) pre-flattens through REQUEST_SERIALIZER (addBeanTypes=true) into a generic Map/List
+	// tree with the discriminator already baked in as literal data, so the final JsonSerializer.DEFAULT pass
+	// re-emits it verbatim.
 	private void postClientResult(Object id, JsonRpcResponse payload) throws IOException {
-		var headers = Map.of("Mcp-Method", DUPLEX_RETURN_METHOD, "Mcp-Name", McpRoutingNames.routingName(DUPLEX_RETURN_METHOD, payload));
-		send(new JsonRpcRequest().setJsonrpc("2.0").setId(id).setMethod(DUPLEX_RETURN_METHOD).setParams(payload), headers);
+		var wire = toWireParams(payload);
+		var headers = Map.of("Mcp-Method", DUPLEX_RETURN_METHOD, "Mcp-Name", McpRoutingNames.routingName(DUPLEX_RETURN_METHOD, wire));
+		send(new JsonRpcRequest().setJsonrpc("2.0").setId(id).setMethod(DUPLEX_RETURN_METHOD).setParams(wire), headers);
 	}
 
 	private <T> T call(String method, RequestParams<?> params, Class<T> resultType) throws IOException {
diff --git a/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/ElicitationAccess_Test.java b/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/ElicitationAccess_Test.java
new file mode 100644
index 0000000000..cf0ba044fa
--- /dev/null
+++ b/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/ElicitationAccess_Test.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.rest.client.mcp.v20260728;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.*;
+
+import org.apache.juneau.bean.mcp.v20260728.*;
+import org.apache.juneau.marshall.collections.*;
+import org.junit.jupiter.api.*;
+
+/**
+ * Coverage for {@link ElicitationAccess}.
+ */
+class ElicitationAccess_Test {
+
+	@Test void a01_isInputRequired_trueOnInputRequiredResultType() {
+		assertTrue(ElicitationAccess.isInputRequired(Map.of("resultType", "input_required")));
+	}
+
+	@Test void a02_isInputRequired_falseOnCompleteResultType() {
+		assertFalse(ElicitationAccess.isInputRequired(Map.of("resultType", "complete")));
+	}
+
+	@Test void a03_isInputRequired_nullRawThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationAccess.isInputRequired(null));
+		assertEquals("Argument 'raw' cannot be null.", e.getMessage());
+	}
+
+	@Test void a04_requests_decodesTypedElicitRequestsFromRawMap() {
+		var raw = Map.<String,Object>of(
+			"resultType", "input_required",
+			"inputRequests", JsonMap.of(
+				"q1", JsonMap.of(
+					"message", "Pick",
+					"requestedSchema", JsonMap.of(
+						"type", "object",
+						"properties", JsonMap.of("choice", JsonMap.of("type", "string"))
+					)
+				)
+			)
+		);
+		var requests = ElicitationAccess.requests(raw);
+		var q1 = requests.get("q1");
+		assertEquals("Pick", q1.getMessage());
+		assertNotNull(q1.getRequestedSchema());
+	}
+
+	@Test void a05_requests_missingInputRequestsReturnsEmptyMap() {
+		var requests = ElicitationAccess.requests(Map.of("resultType", "complete"));
+		assertNotNull(requests);
+		assertTrue(requests.isEmpty());
+	}
+
+	@Test void a06_requestState_returnsEchoedToken() {
+		assertEquals("tok-abc", ElicitationAccess.requestState(Map.of("resultType", "input_required", "requestState", "tok-abc")));
+	}
+
+	@Test void a07_requestState_missingReturnsNull() {
+		assertNull(ElicitationAccess.requestState(Map.of("resultType", "complete")));
+	}
+
+	@Test void a08_toInputResponse_singleAnswer_encodesAcceptWithContent() {
+		var result = new ElicitResult().setAction(ElicitAction.ACCEPT).putContent("choice", "red");
+		var encoded = ElicitationAccess.toInputResponse("q1", result);
+		assertEquals(1, encoded.size());
+		var q1 = (JsonMap) encoded.get("q1");
+		assertEquals("accept", q1.getString("action"));
+		assertEquals("red", q1.getMap("content").getString("choice"));
+	}
+
+	@Test void a09_toInputResponses_multipleAnswers_encodesAll() {
+		var results = new LinkedHashMap<String,ElicitResult>();
+		results.put("q1", new ElicitResult().setAction(ElicitAction.ACCEPT).putContent("choice", "red"));
+		results.put("q2", new ElicitResult().setAction(ElicitAction.DECLINE));
+		var encoded = ElicitationAccess.toInputResponses(results);
+		assertEquals(2, encoded.size());
+		var q1 = (JsonMap) encoded.get("q1");
+		assertEquals("accept", q1.getString("action"));
+		assertEquals("red", q1.getMap("content").getString("choice"));
+		var q2 = (JsonMap) encoded.get("q2");
+		assertEquals("decline", q2.getString("action"));
+		assertNull(q2.get("content"));
+	}
+
+	@Test void a10_toInputResponse_nullIdThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationAccess.toInputResponse(null, new ElicitResult()));
+		assertEquals("Argument 'id' cannot be null.", e.getMessage());
+	}
+
+	@Test void a11_toInputResponse_nullResultThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationAccess.toInputResponse("q1", null));
+		assertEquals("Argument 'result' cannot be null.", e.getMessage());
+	}
+
+	@Test void a12_toInputResponses_nullMapThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationAccess.toInputResponses(null));
+		assertEquals("Argument 'results' cannot be null.", e.getMessage());
+	}
+
+	/**
+	 * Documents the wire-shape symmetry between this client module's {@link ElicitationAccess} and the server
+	 * module's {@code ElicitationRequests}/{@code ElicitationResponses} (Phase 4) without introducing an illegal
+	 * cross-module test dependency: {@code juneau-rest-client-mcp-v20260728} must not depend on
+	 * {@code juneau-rest-server-mcp-v20260728}, so the server-side raw shape is hand-built here to match it
+	 * exactly (verified by inspection/spec cross-reference against {@code ElicitationRequests.of}/
+	 * {@code ElicitationResponses.get}, not a live cross-module call).
+	 */
+	@Test void a13_roundTrip_requestsToResponses_matchesServerSideHelpers() {
+		// Mirrors the raw shape ElicitationRequests.of("q1", elicitRequest, ...) would place into
+		// McpInputRequiredSignal.getInputRequests(), which callRaw ultimately surfaces as raw's "inputRequests".
+		var rawInputRequests = JsonMap.of(
+			"q1", JsonMap.of("message", "Pick one", "requestedSchema", JsonMap.of("type", "object"))
+		);
+		var raw = Map.<String,Object>of("resultType", "input_required", "requestState", "tok-abc", "inputRequests", rawInputRequests);
+
+		var decodedRequests = ElicitationAccess.requests(raw);
+		assertEquals("Pick one", decodedRequests.get("q1").getMessage());
+		assertEquals("tok-abc", ElicitationAccess.requestState(raw));
+
+		var answer = new ElicitResult().setAction(ElicitAction.ACCEPT).putContent("choice", "red");
+		var encodedResponses = ElicitationAccess.toInputResponse("q1", answer);
+
+		// This is exactly the shape ElicitationResponses.get(ctx, "q1") decodes via
+		// Json.to(Json.of(ctx.inputResponses().get("q1")), ElicitResult.class).
+		var q1 = (JsonMap) encodedResponses.get("q1");
+		assertEquals("accept", q1.getString("action"));
+		assertEquals("red", q1.getMap("content").getString("choice"));
+	}
+
+	@Test void a14_requests_malformedEntryThrows() {
+		// A JSON-array entry cannot be converted to a bean target: the marshaller throws (which a caller's own
+		// error handling surfaces). Mirrors ElicitationResponses_Test's a09_get_malformedShapeThrows for the
+		// server-side decode direction.
+		var raw = Map.<String,Object>of("resultType", "input_required", "inputRequests", JsonMap.of("q1", JsonList.of(1, 2)));
+		assertThrows(RuntimeException.class, () -> ElicitationAccess.requests(raw));
+	}
+
+	@Test void a15_toInputResponses_nullEntryThrows() {
+		var results = new LinkedHashMap<String,ElicitResult>();
+		results.put("q1", new ElicitResult().setAction(ElicitAction.ACCEPT));
+		results.put("q2", null);
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationAccess.toInputResponses(results));
+		assertEquals("Argument 'results[q2]' cannot be null.", e.getMessage());
+	}
+
+	@Test void a16_isInputRequired_falseOnMissingResultType() {
+		assertFalse(ElicitationAccess.isInputRequired(Map.of("foo", "bar")));
+	}
+
+	@Test void a17_requests_nullEntryDecodesToNull() {
+		// Mirrors ElicitationResponses.get()'s explicit null handling: a null raw value decodes to a null
+		// typed entry rather than round-tripping through the marshaller.
+		var rawInputRequests = new LinkedHashMap<String,Object>();
+		rawInputRequests.put("q1", null);
+		var raw = Map.<String,Object>of("resultType", "input_required", "inputRequests", rawInputRequests);
+		var requests = ElicitationAccess.requests(raw);
+		assertTrue(requests.containsKey("q1"));
+		assertNull(requests.get("q1"));
+	}
+}
diff --git a/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient_Capabilities_Test.java b/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient_Capabilities_Test.java
index 278294815c..8c0facdd3c 100644
--- a/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient_Capabilities_Test.java
+++ b/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpClient_Capabilities_Test.java
@@ -47,7 +47,7 @@ class McpClient_Capabilities_Test {
 		};
 		var caps = new ClientCapabilities()
 			.setRoots(new RootsCapability().setListChanged(true))
-			.putSampling("supported", true)
+			.setSampling(new SamplingCapability())
 			.putExperimental("x-flag", "on")
 			.putExtensions("x-ext", 1);
 		try (var c = McpClient.builder().endpoint("http://x/mcp").transport(transport).clientCapabilities(caps).build()) {
diff --git a/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpDuplexChannel_Test.java b/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpDuplexChannel_Test.java
index 3538c41c9c..943fff05d6 100644
--- a/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpDuplexChannel_Test.java
+++ b/juneau-rest/juneau-rest-client-mcp-v20260728/src/test/java/org/apache/juneau/rest/client/mcp/v20260728/McpDuplexChannel_Test.java
@@ -23,7 +23,10 @@ import java.nio.charset.*;
 import java.util.concurrent.atomic.*;
 
 import org.apache.juneau.bean.jsonrpc.*;
+import org.apache.juneau.bean.mcp.v20260728.*;
 import org.apache.juneau.marshall.collections.*;
+import org.apache.juneau.marshall.json.*;
+import org.apache.juneau.marshall.marshaller.Json;
 import org.apache.juneau.rest.client.*;
 import org.junit.jupiter.api.*;
 
@@ -92,4 +95,69 @@ class McpDuplexChannel_Test {
 		assertTrue(posted.get().contains("\"error\""), posted.get());
 		assertTrue(posted.get().contains("\"code\":-32603"), posted.get());
 	}
+
+	@Test
+	void a03_samplingCreateMessage_typedRequestAndResultRoundTripOverDuplexSeam() throws Exception {
+		var request = new CreateMessageRequest()
+			.addMessages(new SamplingMessage().setRole(Role.USER).setContent(new TextContent().setText("Summarize this")))
+			.setMaxTokens(100);
+		// addBeanTypes() mirrors production McpClient.REQUEST_SERIALIZER's own addBeanTypes() config (and
+		// matches what a real v2 peer's JSON-RPC layer actually emits): a genuine sampling/createMessage
+		// request carries the "type" discriminator on its polymorphic Content field. Without it here, the
+		// handler's Json.to(...) below could not instantiate the abstract Content interface.
+		var wireJson = JsonSerializer.create().addBeanTypes().build().write(request);
+		var inbound = "data: {\"jsonrpc\":\"2.0\",\"id\":\"99\",\"method\":\"" + McpMethods.SAMPLING_CREATE_MESSAGE + "\",\"params\":"
+			+ wireJson + "}\n\n";
+		var posted = new AtomicReference<String>();
+		var first = new AtomicBoolean(true);
+		HttpTransport transport = tReq -> {
+			if (first.getAndSet(false))
+				return TransportResponse.builder().statusCode(200).header("Content-Type", "text/event-stream")
+					.body(new ByteArrayInputStream(inbound.getBytes(StandardCharsets.UTF_8))).build();
+			try {
+				var out = new ByteArrayOutputStream();
+				tReq.getBody().writeTo(out);
+				posted.set(out.toString(StandardCharsets.UTF_8));
+			} catch (IOException e) {
+				throw new TransportException(e.getMessage(), e);
+			}
+			return TransportResponse.builder().statusCode(200).header("Content-Type", "application/json")
+				.body(new ByteArrayInputStream("{\"jsonrpc\":\"2.0\",\"id\":\"99\",\"result\":{\"ok\":true}}".getBytes(StandardCharsets.UTF_8))).build();
+		};
+
+		// Captured rather than asserted inline: McpDuplexDispatcher.dispatch(...) only catches Exception, not
+		// Error, so a JUnit AssertionError thrown here would still surface - but any ordinary decode exception
+		// (e.g. a ParseException/ClassCastException from a real marshalling regression) would be caught, wrapped
+		// into a -32603 McpException, and posted back as an opaque error envelope, leaving the real cause
+		// swallowed. Capturing the decoded values and asserting them after pumpNextServerMessage() returns
+		// guarantees a decode regression fails with a clear assertion instead of a confusing envelope mismatch.
+		var seenText = new AtomicReference<String>();
+		var seenMaxTokens = new AtomicReference<Integer>();
+		var c = McpClient.builder().endpoint("http://x/mcp").transport(transport).build();
+		c.setServerRequestHandler((req, ctx) -> {
+			var typed = Json.to(Json.of(req.getParams()), CreateMessageRequest.class);
+			seenText.set(((TextContent) typed.getMessages().get(0).getContent()).getText());
+			seenMaxTokens.set(typed.getMaxTokens());
+			return new CreateMessageResult().setRole(Role.ASSISTANT).setContent(new TextContent().setText("Summary"))
+				.setModel("test-model").setStopReason("endTurn");
+		});
+
+		c.pumpNextServerMessage();
+
+		assertEquals("Summarize this", seenText.get());
+		assertEquals(100, seenMaxTokens.get());
+		assertTrue(posted.get().contains("\"model\":\"test-model\""), posted.get());
+		assertTrue(posted.get().contains("\"stopReason\":\"endTurn\""), posted.get());
+		assertTrue(posted.get().contains("\"id\":\"99\""), posted.get());
+		// Regression coverage for the polymorphic CreateMessageResult.content field: postClientResult(...) must
+		// route the posted body through the same addBeanTypes-enabled flattening the request path uses (see
+		// McpClient#postClientResult), or the "type" discriminator a real v2 peer needs to decode the abstract
+		// Content field back into a concrete TextContent/ImageContent/etc. is silently dropped.
+		var envelope = Json.to(posted.get(), JsonRpcRequest.class);
+		var response = Json.to(Json.of(envelope.getParams()), JsonRpcResponse.class);
+		var result = Json.to(Json.of(response.getResult()), CreateMessageResult.class);
+		assertTrue(result.getContent() instanceof TextContent, "content did not decode as TextContent (missing wire discriminator?): " + posted.get());
+		assertEquals("Summary", ((TextContent) result.getContent()).getText());
+		assertEquals(Role.ASSISTANT, result.getRole());
+	}
 }
diff --git a/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher.java b/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher.java
index 7272191695..e13524c88b 100644
--- a/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher.java
+++ b/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher.java
@@ -28,8 +28,8 @@ import org.apache.juneau.commons.inject.*;
  * <p>
  * Requests are handed to the registered handler untouched, with their {@code params} left as the generic,
  * revision-neutral wire representation - never projected into a typed request bean - since the set of
- * server-initiated methods (for example {@code sampling/createMessage}, {@code elicitation/create}) is
- * revision- and deployment-specific and this dispatcher has no knowledge of it.
+ * server-initiated methods (for example {@code sampling/createMessage}; illustrative only, as sampling is
+ * deprecated per SEP-2577) is revision- and deployment-specific and this dispatcher has no knowledge of it.
  *
  * @since 10.0.0
  */
diff --git a/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpServerRequestHandler.java b/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpServerRequestHandler.java
index 3196a90841..7b4c214ce0 100644
--- a/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpServerRequestHandler.java
+++ b/juneau-rest/juneau-rest-client-mcp/src/main/java/org/apache/juneau/rest/client/mcp/McpServerRequestHandler.java
@@ -21,8 +21,8 @@ import org.apache.juneau.commons.inject.*;
 
 /**
  * Callback invoked by {@link McpDuplexDispatcher} to handle a single server-initiated JSON-RPC request
- * delivered over an MCP client's duplex event-stream channel (for example {@code sampling/createMessage} or
- * {@code elicitation/create}).
+ * delivered over an MCP client's duplex event-stream channel (for example {@code sampling/createMessage};
+ * illustrative only, as sampling is deprecated per SEP-2577).
  *
  * @since 10.0.0
  */
diff --git a/juneau-rest/juneau-rest-client-mcp/src/test/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher_Test.java b/juneau-rest/juneau-rest-client-mcp/src/test/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher_Test.java
index bf14a66184..9eecbc487a 100644
--- a/juneau-rest/juneau-rest-client-mcp/src/test/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher_Test.java
+++ b/juneau-rest/juneau-rest-client-mcp/src/test/java/org/apache/juneau/rest/client/mcp/McpDuplexDispatcher_Test.java
@@ -60,7 +60,7 @@ class McpDuplexDispatcher_Test {
 			"nested", JsonMap.of("a", 1, "b", JsonList.of(2, 3)),
 			"experimental", JsonMap.of("x-key", "x-value"));
 		var before = params.toString();
-		var req = new JsonRpcRequest().setJsonrpc("2.0").setId("44").setMethod("elicitation/create").setParams(params);
+		var req = new JsonRpcRequest().setJsonrpc("2.0").setId("44").setMethod("sampling/createMessage").setParams(params);
 		d.dispatch(req, BasicBeanStore.INSTANCE);
 		var after = req.getParams().toString();
 
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationRequests.java b/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationRequests.java
new file mode 100644
index 0000000000..334fb739f2
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationRequests.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.rest.server.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.AssertionUtils.*;
+import static org.apache.juneau.commons.utils.Shorts.*;
+
+import java.util.*;
+
+import org.apache.juneau.bean.mcp.v20260728.*;
+import org.apache.juneau.marshall.collections.*;
+import org.apache.juneau.marshall.marshaller.*;
+
+/**
+ * Static helper that builds an {@link McpInputRequiredSignal} from one or more typed {@link ElicitRequest}s (MCP
+ * {@code 2026-07-28} SEP-2322 elicitation, riding TODO-318's Multi-Round-Trip Requests loop).
+ *
+ * <p>
+ * {@link McpInputRequiredSignal}'s constructor takes {@code Map<String,Object>} whose values must be {@code Map}
+ * at runtime (see its own Javadoc); this helper serializes each {@link ElicitRequest} to that shape via Juneau's
+ * JSON marshaller (round-tripped through {@link JsonMap}, the same technique
+ * {@link McpMrtrResumeContext#continuationAs(Class)} already demonstrates for the continuation side) so a
+ * handler never hand-builds the raw map itself. Pure marshalling: no dispatcher-visible state, no new capability
+ * gate — the existing elicitation-specific gate in {@code McpRevision#pause} already covers every signal this
+ * helper produces.
+ */
+public final class ElicitationRequests {
+
+	private ElicitationRequests() {}
+
+	/**
+	 * Builds a single-question {@link McpInputRequiredSignal}.
+	 *
+	 * @param id The server-assigned id for this question.  Must not be <jk>null</jk>.
+	 * @param request The typed elicitation request.  Must not be <jk>null</jk>.
+	 * @param continuation Handler-opaque continuation value.  Can be <jk>null</jk> if the handler needs no
+	 * 	state carried between rounds.
+	 * @return A new signal ready to be thrown.
+	 * @throws IllegalArgumentException If {@code id} or {@code request} is <jk>null</jk>.
+	 */
+	public static McpInputRequiredSignal of(String id, ElicitRequest request, Object continuation) {
+		assertArgNotNull("id", id);
+		assertArgNotNull("request", request);
+		return of(Map.of(id, request), continuation);
+	}
+
+	/**
+	 * Builds a multi-question {@link McpInputRequiredSignal} (MRTR's multi-request-per-round case: several
+	 * elicitations paused on together, resumed together).
+	 *
+	 * <p>
+	 * Unlike {@code ElicitationAccess.toInputResponses(Map)} (client side), an empty {@code requests} map is
+	 * rejected, not accepted &mdash; deliberately asymmetric, since a signal built with zero questions would be
+	 * a pointless pause, whereas a caller resuming may legitimately have zero elicitation answers on hand if
+	 * the round it is resuming only carried non-elicitation MRTR pauses.
+	 *
+	 * @param requests Server-assigned-id-keyed typed elicitation requests.  Must not be <jk>null</jk> or empty,
+	 * 	and no value may be <jk>null</jk>.  Output iteration order mirrors this map's order, so a caller
+	 * 	wanting deterministic ordering should pass a {@link LinkedHashMap}.
+	 * @param continuation Handler-opaque continuation value.  Can be <jk>null</jk>.
+	 * @return A new signal ready to be thrown.
+	 * @throws IllegalArgumentException If {@code requests} is <jk>null</jk> or empty, or any value in it is
+	 * 	<jk>null</jk>.
+	 */
+	public static McpInputRequiredSignal of(Map<String,ElicitRequest> requests, Object continuation) {
+		assertArgNotNull("requests", requests);
+		if (requests.isEmpty())
+			throw iaex("requests must not be empty");
+		Map<String,Object> raw = new LinkedHashMap<>();
+		requests.forEach((id, request) -> {
+			assertArgNotNull("requests[" + id + "]", request);
+			raw.put(id, Json.to(Json.of(request), JsonMap.class));
+		});
+		return new McpInputRequiredSignal(raw, continuation);
+	}
+}
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationResponses.java b/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationResponses.java
new file mode 100644
index 0000000000..6ad90d3659
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationResponses.java
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.rest.server.mcp.v20260728;
+
+import static org.apache.juneau.commons.utils.AssertionUtils.*;
+
+import java.util.*;
+
+import org.apache.juneau.bean.mcp.v20260728.*;
+import org.apache.juneau.marshall.marshaller.*;
+
+/**
+ * Static helper that parses typed {@link ElicitResult}s out of an {@link McpMrtrResumeContext} (MCP
+ * {@code 2026-07-28} SEP-2322 elicitation, riding TODO-318's Multi-Round-Trip Requests loop).
+ *
+ * <p>
+ * {@link McpMrtrResumeContext#inputResponses()} values are generic JSON (a {@code JsonMap}/{@code JsonList}/
+ * boxed primitive/{@code String} after wire deserialization, never a typed bean automatically); this helper
+ * converts each to {@link ElicitResult} via the same {@code Json.to(Json.of(value), type)} technique
+ * {@link McpMrtrResumeContext#continuationAs(Class)} already uses for the continuation side, just applied
+ * per-key across the map instead of to the single continuation value.
+ */
+public final class ElicitationResponses {
+
+	private ElicitationResponses() {}
+
+	/**
+	 * Returns the typed answer for a single question id.
+	 *
+	 * @param ctx The resume context.  Must not be <jk>null</jk>.
+	 * @param id The server-assigned id this question was posed under.  Must not be <jk>null</jk>.
+	 * @return The typed answer, or <jk>null</jk> if {@code id} is absent from {@code ctx}'s responses, or maps
+	 * 	to <jk>null</jk>.
+	 * @throws IllegalArgumentException If {@code ctx} or {@code id} is <jk>null</jk>.
+	 * @throws RuntimeException If the answer's decoded shape cannot be converted to {@link ElicitResult}.
+	 */
+	public static ElicitResult get(McpMrtrResumeContext ctx, String id) {
+		assertArgNotNull("ctx", ctx);
+		assertArgNotNull("id", id);
+		var value = ctx.inputResponses().get(id);
+		if (value == null)
+			return null;
+		return Json.to(Json.of(value), ElicitResult.class);
+	}
+
+	/**
+	 * Returns every answer in {@code ctx}, converted to {@link ElicitResult}.
+	 *
+	 * @param ctx The resume context.  Must not be <jk>null</jk>.
+	 * @return A keyed map of typed answers.  Never <jk>null</jk> (empty if {@code ctx} carried none). Values
+	 * 	may be <jk>null</jk> when the corresponding raw entry is absent/<jk>null</jk> (see {@link #get}).
+	 * @throws IllegalArgumentException If {@code ctx} is <jk>null</jk>.
+	 * @throws RuntimeException If any answer's decoded shape cannot be converted to {@link ElicitResult}.
+	 */
+	public static Map<String,ElicitResult> all(McpMrtrResumeContext ctx) {
+		assertArgNotNull("ctx", ctx);
+		Map<String,ElicitResult> out = new LinkedHashMap<>();
+		ctx.inputResponses().keySet().forEach(id -> out.put(id, get(ctx, id)));
+		return out;
+	}
+}
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java
index da3d05cdb6..8452c4ffe5 100644
--- a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/Characterization_Test.java
@@ -314,6 +314,58 @@ class Characterization_Test {
 		}
 	}
 
+	/**
+	 * Backs every {@code ELICIT-*} fixture (SEP-2322 elicitation, built on the same PAUSE/RESUME mechanism
+	 * {@link F_Mrtr} exercises generically). Unlike {@link F_Mrtr}'s placeholder {@code Map.of("type","elicitation")},
+	 * this servlet's tools pause and resume through the real typed path ({@link ElicitationRequests}/
+	 * {@link ElicitationResponses}, {@link ElicitRequest}/{@link ElicitResult}/{@link ElicitSchema}), so these
+	 * fixtures characterize the actual elicitation wire shape, not just the generic MRTR envelope.
+	 */
+	@Rest(serializers = JsonSerializer.class, parsers = JsonParser.class, defaultAccept = "application/json")
+	public static class F_Elicit extends McpRestServlet {
+		private static final long serialVersionUID = 1L;
+
+		private static ElicitRequest confirmQuestion() {
+			return new ElicitRequest()
+				.setMessage("Proceed with deletion?")
+				.setRequestedSchema(ElicitSchema.create().booleanField("confirm").title("Confirm").build());
+		}
+
+		@Override protected McpServerConfig createMcpConfig() {
+			return new McpServerConfig()
+				.addTool(new McpToolHandler() {
+					@Override public McpToolSpec descriptor() { return new McpToolSpec().setName("confirm").setDescription("desc:confirm"); }
+					@Override public McpToolOutcome call(Map<String,Object> arguments, BeanStore ctx) {
+						var resume = ctx.getBean(McpMrtrResumeContext.class);
+						if (resume.isEmpty())
+							throw ElicitationRequests.of("confirm", confirmQuestion(), "cont-1");
+						var answer = ElicitationResponses.get(resume.get(), "confirm");
+						return McpToolOutcome.text("action:" + answer.getAction());
+					}
+				})
+				.addTool(new McpToolHandler() {
+					@Override public McpToolSpec descriptor() { return new McpToolSpec().setName("confirmTwo").setDescription("desc:confirmTwo"); }
+					@Override public McpToolOutcome call(Map<String,Object> arguments, BeanStore ctx) {
+						var resume = ctx.getBean(McpMrtrResumeContext.class);
+						if (resume.isEmpty()) {
+							var requests = new LinkedHashMap<String,ElicitRequest>();
+							requests.put("confirm", confirmQuestion());
+							requests.put("reason", new ElicitRequest().setMessage("Why?")
+								.setRequestedSchema(ElicitSchema.create().stringField("reason").build()));
+							throw ElicitationRequests.of(requests, "cont-multi");
+						}
+						var answers = ElicitationResponses.all(resume.get());
+						return McpToolOutcome.text("confirm:" + answers.get("confirm").getAction()
+							+ ",reason:" + answers.get("reason").getAction());
+					}
+				});
+		}
+
+		@Override protected McpMrtrConfig createMrtrConfig() {
+			return new McpMrtrConfig().setCodec(new FixedKeyGcmCodec());
+		}
+	}
+
 	/**
 	 * Test-only deterministic {@link RequestStateCodec}: AES-256-GCM with a <b>hardcoded</b> key and nonce.
 	 *
@@ -418,6 +470,8 @@ class Characterization_Test {
 			case "MRTR-input-required-response", "MRTR-resume-complete", "MRTR-resume-input-required-again",
 				"MRTR-tampered-request-state", "MRTR-expired-request-state", "MRTR-unsupported-capability",
 				"MRTR-max-rounds-exceeded" -> F_Mrtr.class;
+			case "ELICIT-single-request-pause", "ELICIT-multi-request-pause", "ELICIT-resume-accept-complete",
+				"ELICIT-resume-decline", "ELICIT-resume-cancel" -> F_Elicit.class;
 			default -> F_Empty.class;
 		};
 	}
@@ -461,6 +515,8 @@ class Characterization_Test {
 			case "MRTR-expired-request-state" -> codec.seal(new McpRequestState("cont-1", "tools/call", 1, PAST_MS), aad("tools/call"));
 			case "MRTR-max-rounds-exceeded" -> codec.seal(new McpRequestState("cont-1", "tools/call", McpMrtrConfig.DEFAULT_MAX_ROUNDS, FAR_FUTURE_MS), aad("tools/call"));
 			case "MRTR-tampered-request-state" -> tamper(codec.seal(new McpRequestState("cont-1", "tools/call", 1, FAR_FUTURE_MS), aad("tools/call")));
+			case "ELICIT-resume-accept-complete", "ELICIT-resume-decline", "ELICIT-resume-cancel" ->
+				codec.seal(new McpRequestState("cont-1", "tools/call", 1, FAR_FUTURE_MS), aad("tools/call"));
 			default -> throw new IllegalArgumentException("No MRTR token mapping for fixture: " + fixture);
 		};
 	}
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationRequests_Test.java b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationRequests_Test.java
new file mode 100644
index 0000000000..ede29b7d93
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationRequests_Test.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.rest.server.mcp.v20260728;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.*;
+
+import org.apache.juneau.bean.mcp.v20260728.*;
+import org.apache.juneau.marshall.collections.*;
+import org.junit.jupiter.api.*;
+
+/**
+ * Coverage for {@link ElicitationRequests}.
+ */
+class ElicitationRequests_Test {
+
+	@Test void a01_of_singleQuestion_buildsMapShapedValue() {
+		var a = new ElicitRequest().setMessage("Pick one").setRequestedSchema(ElicitSchema.create().stringField("choice").build());
+		var signal = ElicitationRequests.of("q1", a, "cont");
+		var raw = (JsonMap)signal.getInputRequests().get("q1");
+		assertEquals("Pick one", raw.getString("message"));
+		var schema = raw.getMap("requestedSchema");
+		var choice = schema.getMap("properties").getMap("choice");
+		assertEquals("string", choice.getString("type"));
+		assertEquals("cont", signal.getContinuation());
+	}
+
+	@Test void a02_of_multiQuestion_preservesAllKeysAndOrder() {
+		var a1 = new ElicitRequest().setMessage("Question 1");
+		var a2 = new ElicitRequest().setMessage("Question 2");
+		var requests = new LinkedHashMap<String,ElicitRequest>();
+		requests.put("q1", a1);
+		requests.put("q2", a2);
+		var signal = ElicitationRequests.of(requests, "cont");
+		var keys = new ArrayList<>(signal.getInputRequests().keySet());
+		assertEquals(List.of("q1", "q2"), keys);
+		assertEquals("Question 1", ((JsonMap)signal.getInputRequests().get("q1")).getString("message"));
+		assertEquals("Question 2", ((JsonMap)signal.getInputRequests().get("q2")).getString("message"));
+	}
+
+	@Test void a03_of_singleQuestion_nullIdThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationRequests.of(null, new ElicitRequest(), "cont"));
+		assertEquals("Argument 'id' cannot be null.", e.getMessage());
+	}
+
+	@Test void a04_of_singleQuestion_nullRequestThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationRequests.of("q1", null, "cont"));
+		assertEquals("Argument 'request' cannot be null.", e.getMessage());
+	}
+
+	@Test void a05_of_multiQuestion_nullMapThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationRequests.of((Map<String,ElicitRequest>)null, "cont"));
+		assertEquals("Argument 'requests' cannot be null.", e.getMessage());
+	}
+
+	@Test void a06_of_multiQuestion_emptyMapThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationRequests.of(Map.of(), "cont"));
+		assertEquals("requests must not be empty", e.getMessage());
+	}
+
+	@Test void a07_of_singleQuestion_nullContinuationAllowed() {
+		var signal = ElicitationRequests.of("q1", new ElicitRequest().setMessage("Pick one"), null);
+		assertNull(signal.getContinuation());
+	}
+
+	@Test void a08_of_multiQuestion_nullValueThrows() {
+		var requests = new LinkedHashMap<String,ElicitRequest>();
+		requests.put("q1", new ElicitRequest().setMessage("Question 1"));
+		requests.put("q2", null);
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationRequests.of(requests, "cont"));
+		assertEquals("Argument 'requests[q2]' cannot be null.", e.getMessage());
+	}
+}
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationResponses_Test.java b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationResponses_Test.java
new file mode 100644
index 0000000000..e0981f57f7
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/ElicitationResponses_Test.java
@@ -0,0 +1,95 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.rest.server.mcp.v20260728;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.*;
+
+import org.apache.juneau.bean.mcp.v20260728.*;
+import org.apache.juneau.marshall.collections.*;
+import org.junit.jupiter.api.*;
+
+/**
+ * Coverage for {@link ElicitationResponses}.
+ */
+class ElicitationResponses_Test {
+
+	@Test void a01_get_presentKey_acceptActionWithContent() {
+		var responses = Map.<String,Object>of("q1", JsonMap.of("action", "accept", "content", JsonMap.of("choice", "red")));
+		var ctx = new McpMrtrResumeContext(null, responses);
+		var a = ElicitationResponses.get(ctx, "q1");
+		assertEquals(ElicitAction.ACCEPT, a.getAction());
+		assertEquals("red", a.getContent().get("choice"));
+	}
+
+	@Test void a02_get_presentKey_declineActionNoContent() {
+		var responses = Map.<String,Object>of("q1", JsonMap.of("action", "decline"));
+		var ctx = new McpMrtrResumeContext(null, responses);
+		var a = ElicitationResponses.get(ctx, "q1");
+		assertEquals(ElicitAction.DECLINE, a.getAction());
+		assertNull(a.getContent());
+	}
+
+	@Test void a03_get_missingKey_returnsNull() {
+		var ctx = new McpMrtrResumeContext(null, Map.of());
+		assertNull(ElicitationResponses.get(ctx, "missing"));
+	}
+
+	@Test void a04_get_nullCtxThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationResponses.get(null, "q1"));
+		assertEquals("Argument 'ctx' cannot be null.", e.getMessage());
+	}
+
+	@Test void a05_get_nullIdThrows() {
+		var ctx = new McpMrtrResumeContext(null, Map.of());
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationResponses.get(ctx, null));
+		assertEquals("Argument 'id' cannot be null.", e.getMessage());
+	}
+
+	@Test void a06_all_multipleKeys_returnsAllTyped() {
+		var responses = new LinkedHashMap<String,Object>();
+		responses.put("q1", JsonMap.of("action", "accept", "content", JsonMap.of("choice", "red")));
+		responses.put("q2", JsonMap.of("action", "decline"));
+		var ctx = new McpMrtrResumeContext(null, responses);
+		var all = ElicitationResponses.all(ctx);
+		assertEquals(2, all.size());
+		assertEquals(ElicitAction.ACCEPT, all.get("q1").getAction());
+		assertEquals("red", all.get("q1").getContent().get("choice"));
+		assertEquals(ElicitAction.DECLINE, all.get("q2").getAction());
+	}
+
+	@Test void a07_all_emptyResponses_returnsEmptyMap() {
+		var all = ElicitationResponses.all(new McpMrtrResumeContext(null, Map.of()));
+		assertNotNull(all);
+		assertTrue(all.isEmpty());
+	}
+
+	@Test void a08_all_nullCtxThrows() {
+		var e = assertThrows(IllegalArgumentException.class, () -> ElicitationResponses.all(null));
+		assertEquals("Argument 'ctx' cannot be null.", e.getMessage());
+	}
+
+	@Test void a09_get_malformedShapeThrows() {
+		// A JSON-array answer cannot be converted to a bean target: the marshaller throws (which the
+		// dispatcher's generic branch surfaces as -32603). Mirrors McpInputRequiredSignal_Test's
+		// b07_continuationAsShapeMismatchThrows for the continuation side.
+		var responses = Map.<String,Object>of("q1", JsonList.of(1, 2));
+		var ctx = new McpMrtrResumeContext(null, responses);
+		assertThrows(RuntimeException.class, () -> ElicitationResponses.get(ctx, "q1"));
+	}
+}
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.headers.properties b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.headers.properties
new file mode 100644
index 0000000000..dffe187ccb
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirmTwo
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.request.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.request.json
new file mode 100644
index 0000000000..cc69ae4dfe
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirmTwo","arguments":{},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.response.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.response.json
new file mode 100644
index 0000000000..808a18bbf9
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-multi-request-pause.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"inputRequests":{"confirm":{"message":"Proceed with deletion?","requestedSchema":{"type":"object","properties":{"confirm":{"type":"boolean","title":"Confirm"}}}},"reason":{"message":"Why?","requestedSchema":{"type":"object","properties":{"reason":{"type":"string"}}}}},"requestState":"<sealed>","resultType":"input_required"}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.headers.properties b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.request.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.request.json
new file mode 100644
index 0000000000..3fc4aeac40
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","requestState":"__REQUEST_STATE__","inputResponses":{"confirm":{"action":"accept","content":{"confirm":true}}},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.response.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.response.json
new file mode 100644
index 0000000000..17639de560
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-accept-complete.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"content":[{"type":"text","text":"action:accept"}],"resultType":"complete"}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.headers.properties b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.request.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.request.json
new file mode 100644
index 0000000000..d90d60cf57
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","requestState":"__REQUEST_STATE__","inputResponses":{"confirm":{"action":"cancel"}},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.response.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.response.json
new file mode 100644
index 0000000000..1874cbc3cf
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-cancel.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"content":[{"type":"text","text":"action:cancel"}],"resultType":"complete"}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.headers.properties b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.request.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.request.json
new file mode 100644
index 0000000000..87a1394982
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","requestState":"__REQUEST_STATE__","inputResponses":{"confirm":{"action":"decline"}},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.response.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.response.json
new file mode 100644
index 0000000000..95ad0952e2
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-resume-decline.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"content":[{"type":"text","text":"action:decline"}],"resultType":"complete"}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.headers.properties b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.headers.properties
new file mode 100644
index 0000000000..c03a2fd89f
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.headers.properties
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Mcp-Method=tools/call
+Mcp-Name=confirm
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.request.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.request.json
new file mode 100644
index 0000000000..8b1ebbeac7
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.request.json
@@ -0,0 +1 @@
+{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"confirm","arguments":{},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"fixture-client","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{"elicitation":{}}}}}
\ No newline at end of file
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.response.json b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.response.json
new file mode 100644
index 0000000000..3e633eb223
--- /dev/null
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/resources/characterization/ELICIT-single-request-pause.response.json
@@ -0,0 +1 @@
+{"id":1,"jsonrpc":"2.0","result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"juneau-rest-server-mcp","version":"unknown"}},"inputRequests":{"confirm":{"message":"Proceed with deletion?","requestedSchema":{"type":"object","properties":{"confirm":{"type":"boolean","title":"Confirm"}}}}},"requestState":"<sealed>","resultType":"input_required"}}
\ No newline at end of file