Require the version header's presence in the classifier's header rung

A null body protocolVersion slipped the header equality check (None ==
None), so the absent-header outcome depended on the body value: an int
gave HEADER_MISMATCH while null fell through to the string guard's
INVALID_PARAMS. The rung now checks presence explicitly, making an
absent version header uniformly HEADER_MISMATCH and the string guard
reachable only on header-less transports. Also updates the public
Server.run docstring to the first-success era-lock wording.

Author: maxisbey

src/mcp/server/lowlevel/server.py

@@ -691,8 +691,8 @@ async def run(
 
         Thin wrapper over `serve_dual_era_loop`: enters the server lifespan,
         then drives the loop, serving the legacy handshake era and the modern
-        per-request-envelope era (the first era-distinctive message locks the
-        connection). Transports with their own lifespan owner (the
+        per-request-envelope era (the first era-distinctive message to succeed
+        locks the connection). Transports with their own lifespan owner (the
         streamable-HTTP manager) call `serve_loop` directly instead.
         """
         async with self.lifespan(self) as lifespan_context:

src/mcp/shared/inbound.py

@@ -415,7 +415,10 @@ def classify_inbound_request(
             "client-capabilities envelope keys",
         )
     if headers is not None:
-        if headers.get(MCP_PROTOCOL_VERSION_HEADER) != protocol_version:
+        version_header = headers.get(MCP_PROTOCOL_VERSION_HEADER)
+        # Presence is checked explicitly: a null body version would otherwise
+        # slip the equality check (None == None) and mask the absent header.
+        if version_header is None or version_header != protocol_version:
             return InboundLadderRejection(
                 code=HEADER_MISMATCH,
                 message=f"{MCP_PROTOCOL_VERSION_HEADER} header does not match the request envelope's protocol version",
@@ -440,9 +443,11 @@ def classify_inbound_request(
         # Rung 3's precondition: a shape defect, not a version-negotiation
         # outcome - -32022 is the one code auto-negotiating clients do NOT
         # fall back from, and the typed rung-3 payload itself requires a
-        # string `requested`. Sits after the header rung so the HTTP wire is
-        # untouched when the version header is present (a string header can
-        # never equal a non-string body value, so rung 2 fires first there).
+        # string `requested`. Sits after the header rung, which fires first
+        # for every header-bearing entry (an absent version header is a
+        # mismatch, and a present one is a string that can never equal a
+        # non-string body value) - so this rejection is reachable only on
+        # header-less transports.
         return InboundLadderRejection(
             code=INVALID_PARAMS,
             message="the protocol-version envelope value must be a string",

tests/shared/test_inbound.py

@@ -151,30 +151,19 @@ def test_non_string_protocol_version_over_http_still_rejects_at_the_header_rung(
     assert_rejected(classify_inbound_request(body, headers=headers), HEADER_MISMATCH)
 
 
-def test_non_string_protocol_version_with_absent_header_is_a_header_mismatch() -> None:
-    """SDK-defined: an absent version header is a header defect first - the
-    same HEADER_MISMATCH a string-bodied request gets - even when the body
-    version is also mis-shaped (a non-string value never equals the absent
-    header's None, so rung 2 owns this cell)."""
+@pytest.mark.parametrize("version", [7, None], ids=["int", "null"])
+def test_absent_version_header_rejects_before_the_string_guard(version: Any) -> None:
+    """SDK-defined: the version header must be PRESENT, not merely equal - a
+    null body version would otherwise slip the equality check (None == None)
+    - so an absent header is HEADER_MISMATCH for every body value and the
+    string guard stays reachable only on header-less transports."""
     body = envelope()
     headers = matching_headers(body)
     del headers[MCP_PROTOCOL_VERSION_HEADER]
-    body["params"]["_meta"][PROTOCOL_VERSION_META_KEY] = 7
+    body["params"]["_meta"][PROTOCOL_VERSION_META_KEY] = version
     assert_rejected(classify_inbound_request(body, headers=headers), HEADER_MISMATCH)
 
 
-def test_non_string_protocol_version_with_no_version_header_hits_the_guard() -> None:
-    """SDK-defined: a null body version with the version header absent slips
-    the header equality check (None == None), so the string guard is the
-    backstop that keeps the version rung's typed payload from raising."""
-    body = envelope()
-    headers = matching_headers(body)
-    del headers[MCP_PROTOCOL_VERSION_HEADER]
-    body["params"]["_meta"][PROTOCOL_VERSION_META_KEY] = None
-    rejection = assert_rejected(classify_inbound_request(body, headers=headers), INVALID_PARAMS)
-    assert "string" in rejection.message
-
-
 # --- rung 2: protocol-version-supported ----------------------------------------