tests/interaction: add streamable-http-stateless as a connect-matrix arm

The 2025-era unofficial stateless mode (fresh transport per request, no
session id, no standalone GET stream) is now a fourth connectable
transport alongside in-memory, sse, and streamable-http. The factory is
a partial of connect_over_streamable_http with stateless_http=True; the
same shared Server instance backs every request, so no server-factory
widening is needed.

41 requirements that structurally cannot run on the stateless arm are
annotated with arm_exclusions scoped to this transport: 29 because the
server cannot issue requests back to the client (sampling, elicitation,
roots, server-to-client ping/cancel) and 12 because they need persisted
session state or the standalone GET stream (client_params from
initialize, cross-POST cancellation, unsolicited list-changed
notifications).

The connect fixture now pre-binds protocol_version into the returned
factory; the value is still the single SPEC_VERSIONS entry and the
factories ignore it, so this is wiring-only.

504 connect cells (411 existing + 93 stateless), all green;
100% coverage; pyright/ruff clean.

Author: maxisbey

tests/interaction/README.md

@@ -143,6 +143,12 @@ exercises; `SPEC_REVISION = SPEC_VERSIONS[-1]` is the newest. The `connect` fixt
 which intersects the admissible cells across every cited requirement — a cell survives only if
 **all** of the test's requirements admit it.
 
+`streamable-http-stateless` is the fourth connectable transport: the 2025-era unofficial stateless
+mode where each request opens a fresh transport, no session id is issued, and there is no standalone
+GET stream. Requirements that need a server→client back-channel or persisted session state are
+excluded from that arm via `arm_exclusions` (reasons `server-initiated-request` and
+`requires-session`).
+
 What admits or excludes a cell:
 
 - **`added_in` / `removed_in`** gate which spec versions a requirement exists in, as a half-open

tests/interaction/_connect.py

@@ -9,6 +9,7 @@
 
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
 from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from functools import partial
 from typing import Any, Protocol
 
 import httpx
@@ -119,10 +120,11 @@ async def connect_over_streamable_http(
 ) -> AsyncIterator[Client]:
     """Yield a Client connected to the server's streamable HTTP app, entirely in process.
 
-    With the defaults this is the matrix leg (stateful sessions, SSE responses); the
-    transport-specific tests pass `stateless_http` or `json_response` to select the other
-    server modes, and the resumability tests pass an `event_store` (with `retry_interval=0` so
-    the client's reconnection wait is a no-op).
+    With the defaults this is the matrix leg (stateful sessions, SSE responses); the stateless
+    matrix arm binds `stateless_http=True` (see `connect_over_streamable_http_stateless`);
+    transport-specific tests pass `json_response` to select the other server mode, and the
+    resumability tests pass an `event_store` (with `retry_interval=0` so the client's
+    reconnection wait is a no-op).
     """
     app = server.streamable_http_app(
         stateless_http=stateless_http,
@@ -148,6 +150,12 @@ async def connect_over_streamable_http(
         yield client
 
 
+connect_over_streamable_http_stateless: Connect = partial(connect_over_streamable_http, stateless_http=True)
+"""The streamable-http matrix arm with the server in stateless mode (fresh transport per request,
+no session id, no standalone GET stream). The same shared Server instance backs every request --
+stateless mode does not require a server factory."""
+
+
 @asynccontextmanager
 async def mounted_app(
     server: Server | MCPServer,