Tighten the consolidated 2026-07-28 interaction tests

- Prove the envelope is stamped when the caller passes no _meta by
  snapshotting the implicit tools/list body in the capstone
- Give _server() an on_meta hook so the capstone reuses it instead of
  duplicating its handlers
- Restore the wire-emptiness check on the pinned-initialize-raises unit
  test (buffer-used == 0 after the raise)
- Restore lifecycle:stateless:unpinned-legacy-wire (deferred) and
  client-transport:http:body-derived-headers (stacked on the capstone)
  in the requirements ledger
- Drop the redundant strip(" ") arg in _encode_header_value

Author: maxisbey

src/mcp/client/streamable_http.py

@@ -61,7 +61,7 @@
 
 
 def _encode_header_value(value: str) -> str:
-    if _HEADER_SAFE.fullmatch(value) and value == value.strip(" ") and not _B64_SENTINEL.fullmatch(value):
+    if _HEADER_SAFE.fullmatch(value) and value == value.strip() and not _B64_SENTINEL.fullmatch(value):
         return value
     return f"=?base64?{base64.b64encode(value.encode('utf-8')).decode('ascii')}?="
 

tests/client/test_session.py

@@ -1408,9 +1408,10 @@ async def test_initialize_on_a_pinned_session_raises_before_any_frame_is_sent():
     envelope, so calling ``initialize()`` on a pinned session is a programmer error and raises
     immediately rather than reaching the wire.
     """
-    async with raw_client_session(protocol_version="2026-07-28") as (session, _send, _recv):
+    async with raw_client_session(protocol_version="2026-07-28") as (session, _send, from_client):
         with pytest.raises(RuntimeError, match="pinned to a stateless"):
             await session.initialize()
+        assert from_client.statistics().current_buffer_used == 0
 
 
 @pytest.mark.anyio

tests/interaction/_requirements.py

@@ -341,6 +341,17 @@ def __post_init__(self) -> None:
         ),
         added_in="2026-07-28",
     ),
+    "lifecycle:stateless:unpinned-legacy-wire": Requirement(
+        source=f"{SPEC_2026_BASE_URL}/basic/versioning",
+        behavior=(
+            "An unpinned session that negotiates an earlier protocol version emits no 2026-07-28 "
+            "vocabulary on any JSON-RPC frame in either direction."
+        ),
+        deferred=(
+            "bare-ClientSession seam; the high-level Client + HTTP-seam scan in "
+            "hosting:http:legacy-no-modern-vocabulary covers the same vocabulary set"
+        ),
+    ),
     # ═══════════════════════════════════════════════════════════════════════════
     # Protocol primitives: cancellation, timeout, progress, errors, _meta
     # ═══════════════════════════════════════════════════════════════════════════
@@ -3131,6 +3142,16 @@ def __post_init__(self) -> None:
         removed_in="2026-07-28",
         note="removed in 2026-07-28 (SEP-2567); session DELETE removed with Mcp-Session-Id, no replacement.",
     ),
+    "client-transport:http:body-derived-headers": Requirement(
+        source=f"{SPEC_2026_BASE_URL}/basic/transports#stateless-request-headers",
+        behavior=(
+            "An envelope-bearing request body yields MCP-Protocol-Version, Mcp-Method, and (for tools/call) "
+            "Mcp-Name headers on the outgoing HTTP request; a body without the envelope yields none."
+        ),
+        added_in="2026-07-28",
+        transports=("streamable-http",),
+        note="Only observable over streamable HTTP: headers are derived from the body envelope at the transport seam.",
+    ),
     "client-transport:http:stateless-ignores-session-id": Requirement(
         source=f"{SPEC_2026_BASE_URL}/basic/transports#stateless-request-headers",
         behavior=(

tests/interaction/transports/test_hosting_http_modern.py

@@ -8,6 +8,8 @@
 """
 
 import json
+from collections.abc import Callable
+from typing import Any
 
 import anyio
 import httpx
@@ -63,15 +65,19 @@ def _meta_envelope() -> dict[str, object]:
     }
 
 
-def _server() -> Server:
+def _server(*, on_meta: Callable[[dict[str, Any]], None] | None = None) -> Server:
     """A low-level server with one ``add`` tool for the raw-httpx tests below."""
 
     async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
-        raise NotImplementedError
+        tool = Tool(name="add", input_schema={"type": "object"})
+        return ListToolsResult(tools=[tool], ttl_ms=0, cache_scope="public")
 
     async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
         assert params.name == "add"
         assert params.arguments is not None
+        if on_meta is not None:
+            assert ctx.meta is not None
+            on_meta(dict(ctx.meta))
         return CallToolResult(content=[TextContent(text=str(params.arguments["a"] + params.arguments["b"]))])
 
     return Server("modern", on_list_tools=list_tools, on_call_tool=call_tool)
@@ -195,6 +201,7 @@ async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) ->
 @requirement("hosting:http:modern:tools-call-stateless")
 @requirement("lifecycle:stateless:request-envelope")
 @requirement("lifecycle:stateless:caller-meta-preserved")
+@requirement("client-transport:http:body-derived-headers")
 async def test_pinned_client_stateless_tools_call_round_trips_against_the_modern_entry() -> None:
     """First end-to-end exercise of the 2026-07-28 stateless request style: SDK client to SDK server.
 
@@ -211,20 +218,8 @@ async def test_pinned_client_stateless_tools_call_round_trips_against_the_modern
     client's implicit ``tools/list`` output-schema fetch (see ``client:output-schema:auto-list``),
     both of which must satisfy the stateless contract.
     """
-    observed_metas: list[dict[str, object]] = []
-
-    async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
-        tool = Tool(name="add", input_schema={"type": "object"})
-        return ListToolsResult(tools=[tool], ttl_ms=0, cache_scope="public")
-
-    async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
-        assert params.name == "add"
-        assert params.arguments is not None
-        assert ctx.meta is not None
-        observed_metas.append(dict(ctx.meta))
-        return CallToolResult(content=[TextContent(text=str(params.arguments["a"] + params.arguments["b"]))])
-
-    server = Server("modern", on_list_tools=list_tools, on_call_tool=call_tool)
+    observed_metas: list[dict[str, Any]] = []
+    server = _server(on_meta=observed_metas.append)
 
     requests: list[httpx.Request] = []
     responses: list[httpx.Response] = []
@@ -273,6 +268,15 @@ async def on_response(response: httpx.Response) -> None:
             "io.modelcontextprotocol/clientCapabilities": {},
         }
     )
+    # The implicit tools/list carries the envelope but no caller meta: proves the envelope is
+    # stamped on every request, not just on requests where the caller passed meta=.
+    assert bodies[1]["params"]["_meta"] == snapshot(
+        {
+            "io.modelcontextprotocol/protocolVersion": "2026-07-28",
+            "io.modelcontextprotocol/clientInfo": {"name": "e2e-client", "version": "1.0.0"},
+            "io.modelcontextprotocol/clientCapabilities": {},
+        }
+    )
 
     # The server handler observed the same merged _meta on ctx.meta.
     assert observed_metas == [bodies[0]["params"]["_meta"]]