Tighten the new interaction tests after review

Prove the bare input_required handler actually ran before asserting the
rejection; record listen frames unconditionally in the message handler and
check the subscription-id stamp outside it, so an unstamped frame fails the
test instead of being swallowed by the session's handler guard; run the
path-traversal rejection on every era, since the server applies it on
handshake connections too; fold the two hand-rolled loud-fail twins into a
parametrized fixture test; drop unused client_via_http parameters; say
plainly that the max-total-timeout behaviour has no test yet; and make the
README's example test one that passes as written.

No-Verification-Needed: test-only change

Author: maxisbey

tests/interaction/README.md

@@ -205,22 +205,27 @@ The shortest complete example of the conventions:
 
 ```python
 @requirement("tools:call:content:text")
-async def test_call_tool_returns_text_content() -> None:
+async def test_call_tool_returns_text_content(connect: Connect, unstamped: Unstamp) -> None:
     """Arguments reach the tool handler; its content comes back as the call result."""
 
     async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult:
         assert params.name == "add"
         assert params.arguments is not None
         return CallToolResult(content=[TextContent(text=str(params.arguments["a"] + params.arguments["b"]))])
 
-    server = Server("adder", on_call_tool=call_tool)
+    server = Server("adder", on_list_tools=tool_listing("add"), on_call_tool=call_tool)
 
-    async with Client(server) as client:
+    async with connect(server) as client:
         result = await client.call_tool("add", {"a": 2, "b": 3})
 
-    assert result == snapshot(CallToolResult(content=[TextContent(text="5")]))
+    assert unstamped(result) == snapshot(CallToolResult(content=[TextContent(text="5")]))
 ```
 
+The server needs a tools/list handler even though the test never lists: `Client.call_tool`
+refreshes tools/list once per connection to validate output schemas, so a `Server` without one
+fails the call (`tool_listing` from `_helpers.py` is the one-line handler). `unstamped` strips the
+2026-era serverInfo `_meta` stamp so one expected payload holds on every cell.
+
 - **The server is defined inside the test** (or in a small fixture at the top of the file when
   several tests genuinely share it). The whole observable behaviour fits on one screen.
 - **Test names are behaviour sentences** — they state the observable outcome, not the feature

tests/interaction/_connect.py

@@ -238,8 +238,6 @@ async def client_via_http(
     http_client: httpx2.AsyncClient,
     *,
     mode: ConnectMode = "legacy",
-    sampling_callback: SamplingFnT | None = None,
-    list_roots_callback: ListRootsFnT | None = None,
     logging_callback: LoggingFnT | None = None,
     log_level: LoggingLevel | None = None,
     message_handler: MessageHandlerFnT | None = None,
@@ -259,8 +257,6 @@ async def client_via_http(
     async with Client(
         transport,
         mode=mode,
-        sampling_callback=sampling_callback,
-        list_roots_callback=list_roots_callback,
         logging_callback=logging_callback,
         log_level=log_level,
         message_handler=message_handler,

tests/interaction/_requirements.py

@@ -950,9 +950,9 @@ def __post_init__(self) -> None:
         source=f"{SPEC_BASE_URL}/basic/lifecycle#timeouts",
         behavior="A maximum total timeout is enforced even when progress notifications keep arriving.",
         deferred=(
-            "Not yet covered here: the per-request read timeout is the enforced maximum, since it does not reset "
-            "when progress notifications arrive (reset-on-progress is not offered); the test drives a continuously "
-            "progressing tool against a short read timeout."
+            "Not yet covered here: the per-request read timeout is the enforced maximum and does not reset when "
+            "progress notifications arrive, so a call whose handler keeps reporting progress still fails with "
+            "-32001 once the read timeout elapses; reset-on-progress is not offered. No test drives this yet."
         ),
     ),
     "protocol:timeout:reset-on-progress": Requirement(
@@ -1630,12 +1630,11 @@ def __post_init__(self) -> None:
             "parameter is rejected with a JSON-RPC error and the resource function is never "
             "invoked."
         ),
-        added_in="2026-07-28",
         note=(
             "New security MUST in 2026-07-28. MCPServer's default resource-security policy rejects traversal, "
             "absolute-path and null-byte parameter values when matching the template and reports the same -32602 "
             "'Unknown resource' error as a non-match, so the wire offers no probing oracle; the SDK applies the "
-            "policy on 2025-11-25 connections too."
+            "policy on 2025-11-25 connections too, so the entry carries no version window."
         ),
     ),
     "resources:read:template-vars": Requirement(

tests/interaction/lowlevel/test_mrtr.py

@@ -277,8 +277,10 @@ async def test_input_required_result_with_neither_field_cannot_reach_the_client(
     ValidationError to the same SDK-defined invalid-params error, so one snapshot serves both cells.
     """
 
+    calls: list[str] = []
+
     async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> InputRequiredResult:
-        assert params.name == "bare"
+        calls.append(params.name)
         # Statically legal (both fields default None); raises pydantic's ValidationError here.
         return InputRequiredResult()
 
@@ -291,6 +293,8 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara
     assert exc_info.value.error == snapshot(
         ErrorData(code=INVALID_PARAMS, message="Invalid request parameters", data="")
     )
+    # The handler ran: the error is its ValidationError, not a pre-dispatch params rejection.
+    assert calls == ["bare"]
 
 
 @requirement("mrtr:input-responses:key-correspondence")
@@ -446,23 +450,30 @@ async def call_tool(
 
 
 @requirement("mrtr:push-api:loud-fail-2026")
+@pytest.mark.parametrize("request_scoped", [False, True], ids=["no-related-request-id", "related-request-id"])
 async def test_push_elicit_on_2026_raises_typed_local_error_and_call_still_completes(
-    connect: Connect, unstamped: Unstamp
+    connect: Connect, unstamped: Unstamp, request_scoped: bool
 ) -> None:
     """A push API call on a 2026 connection raises a typed local error and the call still completes.
 
     Spec-mandated outcome, era-routed enforcement: every modern dispatch path installs a
     channel-less context by construction, so the gate is "no back-channel", never a send-time
     era check. One push API stands for all four: they share ServerSession.send_request's
-    channel selection.
+    channel selection. The request-scoped variant passes the originating request id, which
+    routes the send onto the per-request dispatch channel (the one leg otherwise live in
+    memory), so both channel selections prove local provenance: the typed NoBackChannelError
+    and a callback that never fires.
     """
     caught: list[NoBackChannelError] = []
 
     async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult:
         assert params.name == "ask"
+        assert ctx.request_id is not None
+        related_request_id = ctx.request_id if request_scoped else None
         try:
-            await ctx.session.elicit_form("Need a name", _NAME_SCHEMA)
+            await ctx.session.elicit_form("Need a name", _NAME_SCHEMA, related_request_id=related_request_id)
         except NoBackChannelError as exc:
+            # Narrow on purpose: a peer-answered MCPError would propagate and fail the test.
             caught.append(exc)
         return CallToolResult(content=[TextContent(text="fallback")])
 
@@ -490,53 +501,6 @@ async def never_deliverable(context: ClientRequestContext, params: types.ElicitR
     )
 
 
-@requirement("mrtr:push-api:loud-fail-2026")
-async def test_request_scoped_push_elicit_on_in_memory_2026_loud_fails_locally_and_the_call_still_completes() -> None:
-    """A request-scoped push elicit on in-memory 2026 loud-fails locally and the call still completes.
-
-    The related id routes the send onto the per-request dispatch channel -- the one leg whose
-    channel is otherwise live in-memory -- so this pin proves local provenance: the typed
-    NoBackChannelError (never a peer answer) and a callback that never fires. A delivered frame
-    would raise NotImplementedError in the callback, surface as a non-NoBackChannelError error,
-    escape the narrowed except, and fail the test loudly.
-    """
-    caught: list[NoBackChannelError] = []
-
-    async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult:
-        assert params.name == "ask"
-        assert ctx.request_id is not None
-        try:
-            # The related id routes the send onto the per-request dispatch channel.
-            await ctx.session.elicit_form("Need a name", _NAME_SCHEMA, related_request_id=ctx.request_id)
-        except NoBackChannelError as exc:
-            # Narrow on purpose: a peer-answered MCPError would propagate and fail the test.
-            caught.append(exc)
-        return CallToolResult(content=[TextContent(text="fallback")])
-
-    server = Server("scoped-push", on_list_tools=tool_listing("ask"), on_call_tool=call_tool)
-
-    # Registering the callback declares the elicitation capability; it must never fire.
-    async def never_deliverable(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult:
-        raise NotImplementedError
-
-    async with Client(server, mode=LATEST_MODERN_VERSION, elicitation_callback=never_deliverable) as client:
-        result = await client.call_tool("ask", {})
-
-    # The failed push did not poison the request: the call completes with the handler's fallback.
-    assert strip_stamp(result) == snapshot(CallToolResult(content=[TextContent(text="fallback")]))
-    assert len(caught) == 1
-    assert caught[0].method == "elicitation/create"
-    assert caught[0].error == snapshot(
-        ErrorData(
-            code=INVALID_REQUEST,
-            message=(
-                "Cannot send 'elicitation/create': this transport context has no back-channel "
-                "for server-initiated requests."
-            ),
-        )
-    )
-
-
 @requirement("sampling:mrtr:capability:not-declared")
 async def test_sampling_request_embedded_for_a_non_sampling_client_is_sent_and_refused_client_side(
     connect: Connect,

tests/interaction/lowlevel/test_subscriptions.py

@@ -18,6 +18,16 @@
 pytestmark = pytest.mark.anyio
 
 
+def _stamps(teed: list[IncomingMessage]) -> list[tuple[str, object]]:
+    """(method, subscriptionId stamp) per teed frame, checked here because the session swallows a raising handler."""
+    stamps: list[tuple[str, object]] = []
+    for message in teed:
+        assert isinstance(message, types.ServerNotification)
+        assert message.params is not None
+        stamps.append((message.method, (message.params.meta or {}).get(SUBSCRIPTION_ID_META_KEY)))
+    return stamps
+
+
 @requirement("subscriptions:listen:graceful-close")
 async def test_a_graceful_server_close_ends_iteration_after_buffered_events(connect: Connect) -> None:
     """`ListenHandler.close()` sends the result last; iteration drains published events, then ends cleanly."""
@@ -157,12 +167,10 @@ async def test_every_event_frame_on_a_listen_stream_is_stamped_with_the_listen_r
     bus = InMemorySubscriptionBus()
     handler = ListenHandler(bus)
     server = Server("subs", on_subscriptions_listen=handler)
-    stamped: list[tuple[str, object]] = []
+    teed: list[IncomingMessage] = []
 
     async def record(message: IncomingMessage) -> None:
-        assert isinstance(message, types.ServerNotification)
-        assert message.params is not None
-        stamped.append((message.method, (message.params.meta or {})[SUBSCRIPTION_ID_META_KEY]))
+        teed.append(message)
 
     async with connect(server, message_handler=record) as client:
         with anyio.fail_after(5):
@@ -173,7 +181,7 @@ async def record(message: IncomingMessage) -> None:
                 events = [event async for event in sub]
             assert events == [ToolsListChanged(), PromptsListChanged()]
 
-    assert stamped == [
+    assert _stamps(teed) == [
         ("notifications/tools/list_changed", sub.subscription_id),
         ("notifications/prompts/list_changed", sub.subscription_id),
     ]
@@ -192,12 +200,10 @@ async def test_concurrent_streams_each_yield_only_the_kinds_their_own_filter_req
     bus = InMemorySubscriptionBus()
     handler = ListenHandler(bus)
     server = Server("subs", on_subscriptions_listen=handler)
-    stamped: list[tuple[str, object]] = []
+    teed: list[IncomingMessage] = []
 
     async def record(message: IncomingMessage) -> None:
-        assert isinstance(message, types.ServerNotification)
-        assert message.params is not None
-        stamped.append((message.method, (message.params.meta or {})[SUBSCRIPTION_ID_META_KEY]))
+        teed.append(message)
 
     async with connect(server, message_handler=record) as client:
         with anyio.fail_after(5):
@@ -213,6 +219,7 @@ async def record(message: IncomingMessage) -> None:
             assert tools_events == [ToolsListChanged()]
             assert prompts_events == [PromptsListChanged()]
 
+    stamped = _stamps(teed)
     assert len(stamped) == 2
     assert set(stamped) == {
         ("notifications/prompts/list_changed", prompts_sub.subscription_id),

tests/interaction/transports/test_hosting_http_modern.py

@@ -28,8 +28,6 @@
     CallToolRequestParams,
     CallToolResult,
     DiscoverResult,
-    ElicitRequestParams,
-    ElicitResult,
     EmptyResult,
     ErrorData,
     GetPromptRequestParams,
@@ -61,11 +59,9 @@
 from starlette.requests import Request as StarletteRequest
 
 from mcp import MCPError
-from mcp.client import ClientRequestContext
 from mcp.client.session import ClientSession
 from mcp.client.streamable_http import streamable_http_client
 from mcp.server import Server, ServerRequestContext
-from mcp.shared.exceptions import NoBackChannelError
 from tests._stamp import unstamped as strip_stamp
 from tests.interaction._connect import (
     BASE_URL,
@@ -1108,54 +1104,3 @@ async def get_prompt(ctx: ServerRequestContext, params: GetPromptRequestParams)
     assert strip_stamp(result) == snapshot(
         GetPromptResult(messages=[PromptMessage(role="user", content=TextContent(text="bonjour"))])
     )
-
-
-@requirement("mrtr:push-api:loud-fail-2026")
-async def test_modern_request_scoped_push_elicit_loud_fails_locally_and_the_call_still_completes() -> None:
-    """A request-scoped push elicit over the modern HTTP entry loud-fails locally and the call still completes.
-
-    Spec-mandated outcome: the modern HTTP entry builds its per-request channel with no
-    back-channel, so the refusal is local by construction. The in-memory twin of this leg is
-    pinned in lowlevel/test_mrtr.py; this pin keeps the HTTP entry's own gate regression-covered.
-    """
-    caught: list[NoBackChannelError] = []
-
-    async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
-        assert params.name == "ask"
-        assert ctx.request_id is not None
-        try:
-            # The related id selects the per-request dispatch channel.
-            await ctx.session.elicit_form(
-                "Need a name",
-                {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]},
-                related_request_id=ctx.request_id,
-            )
-        except NoBackChannelError as exc:
-            caught.append(exc)
-        return CallToolResult(content=[TextContent(text="fallback")])
-
-    server = Server("scoped-push", on_list_tools=tool_listing("ask"), on_call_tool=call_tool)
-
-    # Declares the elicitation capability, isolating the failure to the missing back-channel.
-    async def never_deliverable(context: ClientRequestContext, params: ElicitRequestParams) -> ElicitResult:
-        raise NotImplementedError
-
-    with anyio.fail_after(5):
-        async with (
-            mounted_app(server) as (http, _),
-            client_via_http(http, mode=LATEST_MODERN_VERSION, elicitation_callback=never_deliverable) as client,
-        ):
-            result = await client.call_tool("ask", {})
-
-    assert strip_stamp(result) == snapshot(CallToolResult(content=[TextContent(text="fallback")]))
-    assert len(caught) == 1
-    assert caught[0].method == "elicitation/create"
-    assert caught[0].error == snapshot(
-        ErrorData(
-            code=INVALID_REQUEST,
-            message=(
-                "Cannot send 'elicitation/create': this transport context has no back-channel "
-                "for server-initiated requests."
-            ),
-        )
-    )