Use MODERN_PROTOCOL_VERSIONS membership instead of a threshold constant

The stateless-era predicate is set membership, not an ordering threshold;
drop FIRST_MODERN_VERSION and is_version_at_least at the four call sites.
The modern entry now takes the protocol_version that matched (threaded
from the manager) instead of hard-coding it.

Author: maxisbey

src/mcp/client/session.py

@@ -21,7 +21,7 @@
 from mcp.shared.message import ClientMessageMetadata, SessionMessage
 from mcp.shared.session import RequestResponder
 from mcp.shared.transport_context import TransportContext
-from mcp.shared.version import FIRST_MODERN_VERSION, SUPPORTED_PROTOCOL_VERSIONS, is_version_at_least
+from mcp.shared.version import MODERN_PROTOCOL_VERSIONS, SUPPORTED_PROTOCOL_VERSIONS
 from mcp.types import (
     CLIENT_CAPABILITIES_META_KEY,
     CLIENT_INFO_META_KEY,
@@ -156,9 +156,7 @@ def __init__(
         self._session_read_timeout_seconds = read_timeout_seconds
         self._client_info = client_info or DEFAULT_CLIENT_INFO
         self._pinned_version = protocol_version
-        self._stateless_pinned = protocol_version is not None and is_version_at_least(
-            protocol_version, FIRST_MODERN_VERSION
-        )
+        self._stateless_pinned = protocol_version in MODERN_PROTOCOL_VERSIONS
         self._sampling_callback = sampling_callback or _default_sampling_callback
         self._sampling_capabilities = sampling_capabilities
         self._elicitation_callback = elicitation_callback or _default_elicitation_callback

src/mcp/client/streamable_http.py

@@ -21,7 +21,7 @@
 from mcp.shared._context_streams import ContextReceiveStream, ContextSendStream, create_context_streams
 from mcp.shared._httpx_utils import create_mcp_http_client
 from mcp.shared.message import ClientMessageMetadata, SessionMessage
-from mcp.shared.version import FIRST_MODERN_VERSION, is_version_at_least
+from mcp.shared.version import MODERN_PROTOCOL_VERSIONS
 from mcp.types import (
     INTERNAL_ERROR,
     INVALID_REQUEST,
@@ -107,7 +107,7 @@ def _per_message_headers(self, message: JSONRPCMessage) -> dict[str, str]:
         MCP-Protocol-Version is not emitted here — `_prepare_headers()` already adds it
         from `self.protocol_version` for every request.
         """
-        if self.protocol_version is None or not is_version_at_least(self.protocol_version, FIRST_MODERN_VERSION):
+        if self.protocol_version not in MODERN_PROTOCOL_VERSIONS:
             return {}
         if not isinstance(message, JSONRPCRequest | JSONRPCNotification):
             return {}

src/mcp/server/_streamable_http_modern.py

@@ -34,7 +34,6 @@
 from mcp.shared.exceptions import MCPError, NoBackChannelError
 from mcp.shared.message import MessageMetadata, ServerMessageMetadata
 from mcp.shared.transport_context import TransportContext
-from mcp.shared.version import FIRST_MODERN_VERSION as MODERN_PROTOCOL_VERSION
 from mcp.types import (
     INTERNAL_ERROR,
     INVALID_PARAMS,
@@ -160,14 +159,16 @@ async def handle(self, req: JSONRPCRequest, on_request: OnRequest) -> JSONRPCRes
 async def handle_modern_request(
     app: Server[Any],
     security_settings: TransportSecuritySettings | None,
+    protocol_version: str,
     scope: Scope,
     receive: Receive,
     send: Send,
 ) -> None:
-    """ASGI handler for a single 2026-07-28 POST.
+    """ASGI handler for a single stateless-era POST.
 
     Called from `StreamableHTTPSessionManager.handle_request` when the
-    `MCP-Protocol-Version` header is `2026-07-28`. Never sets `Mcp-Session-Id`.
+    `MCP-Protocol-Version` header is in `MODERN_PROTOCOL_VERSIONS`; the header
+    value is passed as `protocol_version`. Never sets `Mcp-Session-Id`.
     """
     request = Request(scope, receive)
 
@@ -207,7 +208,7 @@ async def handle_modern_request(
             stateless=True,
             dispatch_middleware=[otel_middleware],
         )
-        runner.connection.protocol_version = MODERN_PROTOCOL_VERSION
+        runner.connection.protocol_version = protocol_version
         try:
             msg = await dispatcher.handle(req, runner._compose_on_request())  # type: ignore[reportPrivateUsage]
         finally:

src/mcp/server/streamable_http_manager.py

@@ -156,7 +156,7 @@ async def handle_request(self, scope: Scope, receive: Receive, send: Send) -> No
         # (per SEP-2575) is a follow-up. 2025 paths below remain unchanged.
         pv = next((v.decode("latin-1") for k, v in scope["headers"] if k == b"mcp-protocol-version"), None)
         if pv in MODERN_PROTOCOL_VERSIONS:
-            await handle_modern_request(self.app, self.security_settings, scope, receive, send)
+            await handle_modern_request(self.app, self.security_settings, pv, scope, receive, send)
             return
 
         # Dispatch to the appropriate handler

src/mcp/shared/version.py

@@ -20,9 +20,6 @@
 )
 """Every released protocol revision, oldest to newest."""
 
-FIRST_MODERN_VERSION: Final[str] = "2026-07-28"
-"""First protocol revision with the stateless per-request envelope (no `initialize`)."""
-
 MODERN_PROTOCOL_VERSIONS: Final[tuple[str, ...]] = ("2026-07-28",)
 """Protocol revisions that use the stateless per-request envelope."""
 

tests/server/test_streamable_http_modern.py

@@ -91,7 +91,7 @@ async def on_request(ctx: DispatchContext[Any], method: str, params: Mapping[str
 
 def _asgi_client(server: Server[Any], security_settings: TransportSecuritySettings | None = None) -> httpx.AsyncClient:
     async def app(scope: Scope, receive: Receive, send: Send) -> None:
-        await handle_modern_request(server, security_settings, scope, receive, send)
+        await handle_modern_request(server, security_settings, "2026-07-28", scope, receive, send)
 
     return httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver")