Complete the MRTR core coverage: multi-round, bounds, and the 2026 directionality pins

Ten more tests: the multi-round completion loop, the rounds cap, the
at-least-one-of construction-site rejection, the inputResponses structural
validation and key correspondence, the -32042 emission-ban wire scan, and
the 2026 directionality edges - the push-API loud-fail split (the standalone
leg pins NoBackChannelError green on both 2026 cells; a dedicated in-memory
test pins the request-scoped leg still transmitting the forbidden frame,
recorded as a per-transport, per-leg divergence so the eventual era-gate fix
re-pins mechanically), a wire-trace proof that a 2026 exchange contains no
server-initiated requests and no client-sent responses, and the sampling and
roots embed capability gates (both pinned un-gated with recorded
divergences, completing the embed-gate family).

Five entries flip from deferred, five origin-new entries are minted with
their tests. 859 -> 876 collected cells, every node accounted; suite green
three consecutive runs.

Author: maxisbey

tests/interaction/_requirements.py

@@ -551,6 +551,20 @@ def __post_init__(self) -> None:
             "to a request the client sent or a notification carrying no id."
         ),
     ),
+    "protocol:directionality:no-client-responses": Requirement(
+        source=f"{SPEC_2026_BASE_URL}/basic/patterns",
+        behavior=(
+            "A 2026-07-28 wire trace contains no server-initiated JSON-RPC requests and no "
+            "client-sent JSON-RPC responses: every client-to-server frame is a request and every "
+            "server-to-client frame is a response, even across a multi-round-trip exchange that at "
+            "2025-11-25 was a server-initiated request answered by the client."
+        ),
+        added_in="2026-07-28",
+        note=(
+            "Asserted at the streamable HTTP wire seam: the in-memory 2026 transport dispatches "
+            "typed objects directly with no JSON-RPC framing, so it has no trace to inspect."
+        ),
+    ),
     "protocol:cancel:abort-signal": Requirement(
         source=f"{SPEC_BASE_URL}/basic/utilities/cancellation#cancellation-flow",
         behavior=(
@@ -1250,7 +1264,7 @@ def __post_init__(self) -> None:
         note=(
             "removed in 2026-07-28 (SEP-2322); in-tool elicitation now returns an input_required result from "
             "the tool; the push Context API's 2026 failure mode is pinned separately by "
-            "mrtr:push-api:loud-fail-2026 when the mrtr add-batch lands it."
+            "mrtr:push-api:loud-fail-2026."
         ),
         arm_exclusions=(ArmExclusion(reason="server-initiated-request", transport="streamable-http-stateless"),),
     ),
@@ -2197,17 +2211,22 @@ def __post_init__(self) -> None:
             "requests require sampling.tools; thisServer/allServers context -- itself deprecated -- should "
             "not be used without sampling.context)."
         ),
+        divergence=Divergence(
+            note=(
+                "The embed gate is not implemented: an input_required result carrying a "
+                "sampling/createMessage request for a client that declared no sampling capability is "
+                "transmitted as-is, and the violation surfaces as the client driver's refusal "
+                "(INVALID_REQUEST, 'Sampling not supported') aborting the call. The sub-capability legs "
+                "(sampling.tools, sampling.context) are equally ungated and covered by this divergence "
+                "without separate pins."
+            ),
+        ),
         added_in="2026-07-28",
         supersedes=(
             "sampling:create:not-supported",
             "sampling:tools:server-gated-by-capability",
             "sampling:context:server-gated-by-capability",
         ),
-        deferred=(
-            "Not implemented in the SDK: the server does not gate input_required input requests against the "
-            "client's declared capabilities -- a handler can embed a sampling/createMessage request for a "
-            "client that never declared the matching capability and it is sent as-is."
-        ),
     ),
     # ═══════════════════════════════════════════════════════════════════════════
     # Elicitation (server → client)
@@ -2577,18 +2596,42 @@ def __post_init__(self) -> None:
     # ═══════════════════════════════════════════════════════════════════════════
     # MRTR (multi-round-trip requests, 2026-07-28)
     # ═══════════════════════════════════════════════════════════════════════════
+    "mrtr:input-required-result:at-least-one-of": Requirement(
+        source=f"{SPEC_2026_BASE_URL}/basic/patterns/mrtr#server-requirements-basic-workflow",
+        behavior=(
+            "An InputRequiredResult carries at least one of inputRequests or requestState; a "
+            "handler-built violation fails at construction and surfaces to the client as a JSON-RPC "
+            "error, never as a malformed interim result."
+        ),
+        added_in="2026-07-28",
+        note=(
+            "The at-least-one-of MUST is enforced by construction (mcp_types model validator). Both "
+            "2026 dispatchers map the handler's ValidationError to the shared "
+            "ErrorData(INVALID_PARAMS, 'Invalid request parameters', data='') shape "
+            "(handler_exception_to_error_data); INTERNAL_ERROR is arguably the more apt code for a "
+            "server-side construction bug, but the spec mandates no code for this failure."
+        ),
+    ),
     "mrtr:input-responses:invalid-rejected": Requirement(
         source=f"{SPEC_2026_BASE_URL}/basic/patterns/mrtr#error-handling",
         behavior=(
-            "The server validates that a retry's inputResponses parse as valid results for the requests it "
-            "issued; content that violates the requested schema is rejected rather than silently accepted."
+            "The server validates that a retry's inputResponses parse as a valid InputResponses object; "
+            "a structurally malformed map is rejected with a JSON-RPC error before the handler runs."
         ),
         added_in="2026-07-28",
         supersedes=("elicitation:form:response-validation",),
-        deferred=(
-            "Not yet covered here: 2026-07-28 successor entry registered by the era pass ahead of its test; "
-            "the behaviour is implemented and drivable (phase-4 verdict)."
+        note=(
+            "Elicited content is handed to the handler without requestedSchema re-validation; servers "
+            "validate semantic constraints themselves (spec asks only for structural validation)."
+        ),
+    ),
+    "mrtr:input-responses:key-correspondence": Requirement(
+        source=f"{SPEC_2026_BASE_URL}/basic/patterns/mrtr#inputresponses",
+        behavior=(
+            "A retry's inputResponses map is keyed by the originating inputRequests keys, each value "
+            "the client's typed result for that key's request (e.g. ElicitResult, ListRootsResult)."
         ),
+        added_in="2026-07-28",
     ),
     "mrtr:url-elicitation:no-32042-on-2026": Requirement(
         source=f"{SPEC_2026_BASE_URL}/basic/patterns/mrtr",
@@ -2604,10 +2647,6 @@ def __post_init__(self) -> None:
             "mcpserver:tool:url-elicitation-error",
             "flow:elicitation:url-required-then-retry",
         ),
-        deferred=(
-            "Not yet covered here: 2026-07-28 successor entry registered by the era pass ahead of its test; "
-            "the behaviour is implemented and drivable (phase-4 verdict)."
-        ),
     ),
     "mrtr:tools-call:write-once-roundtrip": Requirement(
         source=f"{SPEC_2026_BASE_URL}/basic/patterns/mrtr#basic-workflow",
@@ -2656,10 +2695,41 @@ def __post_init__(self) -> None:
         ),
         added_in="2026-07-28",
         supersedes=("flow:elicitation:multi-step-form",),
-        deferred=(
-            "Not yet covered here: 2026-07-28 successor entry registered by the era pass ahead of its test; "
-            "the behaviour is implemented and drivable (phase-4 verdict)."
+    ),
+    "mrtr:rounds-cap": Requirement(
+        source="sdk",
+        behavior=(
+            "Client.call_tool / get_prompt / read_resource bound the input_required retry loop at the "
+            "configurable input_required_max_rounds; a server that keeps answering input_required past "
+            "the cap raises InputRequiredRoundsExceededError carrying the configured cap."
         ),
+        added_in="2026-07-28",
+    ),
+    "mrtr:push-api:loud-fail-2026": Requirement(
+        source=f"{SPEC_2026_BASE_URL}/basic/patterns/mrtr",
+        behavior=(
+            "The push-style server-to-client request APIs (ServerSession.elicit_form / elicit_url / "
+            "create_message / list_roots) on a 2026-07-28 connection fail with a typed local error "
+            "(NoBackChannelError, INVALID_REQUEST) before any request reaches the client; a handler "
+            "can catch it and fall back, and the originating call still completes."
+        ),
+        divergence=Divergence(
+            note=(
+                "The prohibition is enforced by each transport's missing back-channel, not by an "
+                "era gate on the send path, and the enforcement splits per transport and per leg. "
+                "Standalone sends (no related_request_id) raise NoBackChannelError locally on both "
+                "2026 transports because the per-request Connection has no outbound channel. "
+                "Request-scoped sends (related_request_id=...) ride the per-request dispatch "
+                "context, whose can_send_request the modern HTTP entry hard-codes to False but the "
+                "in-memory direct-dispatcher pair leaves at its True default -- so in-memory the "
+                "forbidden elicitation/create frame IS transmitted, and the failure comes back from "
+                "the client's 2026 version gate (METHOD_NOT_FOUND) instead of arising locally. An "
+                "era-aware gate on the send path would loud-fail both legs on every transport; when "
+                "it lands, re-pin the request-scoped in-memory test to the local NoBackChannelError "
+                "and delete this divergence."
+            ),
+        ),
+        added_in="2026-07-28",
     ),
     # ═══════════════════════════════════════════════════════════════════════════
     # Roots (server → client)
@@ -2759,13 +2829,16 @@ def __post_init__(self) -> None:
             "The server does not place a roots/list request in an input_required result's inputRequests "
             "for a client that did not declare the roots capability."
         ),
+        divergence=Divergence(
+            note=(
+                "The embed gate is not implemented: an input_required result carrying a roots/list "
+                "request for a client that did not declare the roots capability is transmitted as-is, "
+                "and the violation surfaces as the client driver's refusal (INVALID_REQUEST, 'List "
+                "roots not supported') aborting the call."
+            ),
+        ),
         added_in="2026-07-28",
         supersedes=("roots:list:not-supported",),
-        deferred=(
-            "Not implemented in the SDK: the server does not gate input_required input requests against the "
-            "client's declared capabilities -- a handler can embed a roots/list request for a client that "
-            "never declared the roots capability and it is sent as-is."
-        ),
     ),
     "roots:uri:file-scheme": Requirement(
         source=f"{SPEC_BASE_URL}/client/roots#root",

tests/interaction/lowlevel/test_elicitation.py

@@ -9,6 +9,7 @@
 import pytest
 from inline_snapshot import snapshot
 from mcp_types import (
+    URL_ELICITATION_REQUIRED,
     CallToolResult,
     ElicitCompleteNotification,
     ElicitCompleteNotificationParams,
@@ -28,14 +29,17 @@
     ServerCapabilities,
     TextContent,
 )
+from mcp_types.version import LATEST_MODERN_VERSION
 
 from mcp import MCPError, UrlElicitationRequiredError
 from mcp.client import ClientRequestContext, ClientSession
+from mcp.client.client import Client
+from mcp.client.streamable_http import streamable_http_client
 from mcp.server import Server, ServerRequestContext
 from mcp.shared.memory import MessageStream, create_client_server_memory_streams
 from mcp.shared.message import SessionMessage
-from tests.interaction._connect import Connect
-from tests.interaction._helpers import IncomingMessage
+from tests.interaction._connect import BASE_URL, Connect, mounted_app
+from tests.interaction._helpers import IncomingMessage, RecordingTransport
 from tests.interaction._requirements import requirement
 
 pytestmark = pytest.mark.anyio
@@ -943,3 +947,88 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara
             }
         )
     )
+
+
+@requirement("mrtr:url-elicitation:no-32042-on-2026")
+async def test_url_elicitation_rides_mrtr_and_no_32042_error_crosses_the_wire() -> None:
+    """URL-mode elicitation rides the MRTR loop at 2026-07-28: the embedded URL request reaches the
+    callback, accepting it fulfils the loop, the retried call completes, and the retired -32042
+    urlElicitationRequired code never appears in any frame of the exchange.
+
+    Spec-mandated (-32042 is reserved-never-reused at 2026). Asserted at the client transport seam
+    over the modern streamable HTTP entry, the only transport serving 2026 JSON-RPC frames; the
+    post-exchange scan needs no waiting because the exchange is POST request/response pairs only,
+    each response fully consumed before its await returns.
+    """
+    received: list[types.ElicitRequestParams] = []
+
+    async def list_tools(
+        ctx: ServerRequestContext, params: types.PaginatedRequestParams | None
+    ) -> types.ListToolsResult:
+        # Live (not NotImplementedError): the client's output-schema cache refresh invokes
+        # tools/list right after the first successful tools/call result.
+        return types.ListToolsResult(
+            tools=[types.Tool(name="protected", description="Needs a sign-in.", input_schema={"type": "object"})]
+        )
+
+    async def call_tool(
+        ctx: ServerRequestContext, params: types.CallToolRequestParams
+    ) -> CallToolResult | InputRequiredResult:
+        assert params.name == "protected"
+        if not params.input_responses:
+            return InputRequiredResult(
+                input_requests={
+                    "link": ElicitRequest(
+                        params=ElicitRequestURLParams(message="Sign in to continue.", url="https://example.com/auth")
+                    )
+                }
+            )
+        answer = params.input_responses["link"]
+        assert isinstance(answer, ElicitResult)
+        return CallToolResult(content=[TextContent(text=f"{answer.action} content={answer.content}")])
+
+    server = Server("guard", on_list_tools=list_tools, on_call_tool=call_tool)
+
+    async def answer_url(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult:
+        received.append(params)
+        # Accept means the user agreed to visit the URL; there is never content to carry.
+        return ElicitResult(action="accept")
+
+    with anyio.fail_after(5):
+        # One combined async-with, the recorder bound via := -- a separately nested `async with`
+        # line mis-traces its exit arcs under branch coverage on 3.11+.
+        async with (
+            mounted_app(server) as (http, _),
+            Client(
+                recording := RecordingTransport(streamable_http_client(f"{BASE_URL}/mcp", http_client=http)),
+                mode=LATEST_MODERN_VERSION,
+                elicitation_callback=answer_url,
+            ) as client,
+        ):
+            result = await client.call_tool("protected", {})
+
+    # The URL params crossed the real wire intact; elicitation_id rides its None default at 2026.
+    assert received == snapshot(
+        [ElicitRequestURLParams(message="Sign in to continue.", url="https://example.com/auth")]
+    )
+    assert result == snapshot(CallToolResult(content=[TextContent(text="accept content=None")]))
+    # Positive control: the recording demonstrably captured the MRTR interim leg, so the scan
+    # below covers a conversation that contained the input_required round, not an empty log.
+    interim = [
+        message.message
+        for message in recording.received
+        if isinstance(message, SessionMessage)
+        and isinstance(message.message, JSONRPCResponse)
+        and message.message.result.get("resultType") == "input_required"
+    ]
+    assert len(interim) == 1
+    # The negative: no serialized frame in either direction carries the retired code. A substring
+    # scan also catches the code smuggled inside a result body -- the exact shape the 2025 era
+    # surfaced it in. Test-controlled payloads and single-digit request ids leave no legitimate
+    # occurrence of the digits.
+    frames = [
+        message.message.model_dump_json(by_alias=True, exclude_none=True)
+        for message in [*recording.sent, *recording.received]
+        if isinstance(message, SessionMessage)
+    ]
+    assert all(str(URL_ELICITATION_REQUIRED) not in frame for frame in frames)