@@ -504,38 +504,6 @@ async def on_list_tools(
         assert [t.name for t in result.tools] == ["ok", "dropme"]
 
 
-@pytest.mark.anyio
-async def test_modern_list_tools_evicts_header_map_when_a_tool_turns_invalid() -> None:
-    """A re-list that drops a previously valid tool must also evict its cached `x-mcp-header` map,
-    so a later `tools/call` can't mirror stale `Mcp-Param-*` headers for a now-dropped tool."""
-    valid = types.Tool(
-        name="run",
-        input_schema={"type": "object", "properties": {"a": {"type": "string", "x-mcp-header": "Region"}}},
-    )
-    invalid = types.Tool(
-        name="run",
-        input_schema={"type": "object", "properties": {"a": {"type": "string", "x-mcp-header": "bad name"}}},
-    )
-    listings = iter([valid, invalid])
-
-    async def on_list_tools(
-        ctx: ServerRequestContext, params: types.PaginatedRequestParams | None
-    ) -> types.ListToolsResult:
-        return types.ListToolsResult(tools=[next(listings)])
-
-    server = Server("test", on_list_tools=on_list_tools)
-
-    with anyio.fail_after(5):
-        async with Client(server) as client:
-            session = client.session
-            await client.list_tools()
-            assert session._resolve_param_headers("run", {"a": "x"}) == {"Mcp-Param-Region": "x"}
-
-            result = await client.list_tools()
-            assert [t.name for t in result.tools] == []
-            assert session._resolve_param_headers("run", {"a": "x"}) == {}
-
-
 def test_client_rejects_handshake_era_mode_at_construction() -> None:
     """A handshake-era protocol-version string passed as `mode=` is rejected by
     `__post_init__` with a hint to use `mode='legacy'` — the version-pin path is
 
@@ -38,6 +38,7 @@
 from mcp_types.version import LATEST_MODERN_VERSION
 
 from mcp import MCPError
+from mcp.client.client import Client
 from mcp.client.session import ClientSession
 from mcp.client.streamable_http import streamable_http_client
 from mcp.server import Server, ServerRequestContext
@@ -433,21 +434,22 @@ async def test_modern_client_mirrors_x_mcp_header_args_into_mcp_param_headers()
     async def on_request(request: httpx.Request) -> None:
         requests.append(request)
 
+    discover = DiscoverResult(
+        supported_versions=[LATEST_MODERN_VERSION],
+        capabilities=ServerCapabilities(),
+        server_info=Implementation(name="srv", version="0"),
+    )
     with anyio.fail_after(5):
         async with (
             mounted_app(_custom_header_server(), on_request=on_request) as (http, _),
-            streamable_http_client(f"{BASE_URL}/mcp", http_client=http) as (read, write),
-            ClientSession(read, write) as session,
+            Client(
+                streamable_http_client(f"{BASE_URL}/mcp", http_client=http),
+                mode=LATEST_MODERN_VERSION,
+                prior_discover=discover,
+            ) as client,
         ):
-            session.adopt(
-                DiscoverResult(
-                    supported_versions=[LATEST_MODERN_VERSION],
-                    capabilities=ServerCapabilities(),
-                    server_info=Implementation(name="srv", version="0"),
-                )
-            )
-            await session.list_tools()
-            await session.call_tool("run", {"region": "us-west1", "priority": 42, "verbose": False, "note": "héllo"})
+            await client.list_tools()
+            await client.call_tool("run", {"region": "us-west1", "priority": 42, "verbose": False, "note": "héllo"})
 
     call = next(r for r in requests if json.loads(r.content)["method"] == "tools/call")
     assert {k: v for k, v in call.headers.items() if k.startswith("mcp-param-")} == snapshot(
@@ -478,19 +480,73 @@ async def on_request(request: httpx.Request) -> None:
         if json.loads(request.content)["method"] == "tools/call":
             requests.append(request)
 
+    discover = DiscoverResult(
+        supported_versions=[LATEST_MODERN_VERSION],
+        capabilities=ServerCapabilities(),
+        server_info=Implementation(name="srv", version="0"),
+    )
     with anyio.fail_after(5):
         async with (
             mounted_app(_custom_header_server(), on_request=on_request) as (http, _),
-            streamable_http_client(f"{BASE_URL}/mcp", http_client=http) as (read, write),
-            ClientSession(read, write) as session,
+            Client(
+                streamable_http_client(f"{BASE_URL}/mcp", http_client=http),
+                mode=LATEST_MODERN_VERSION,
+                prior_discover=discover,
+            ) as client,
         ):
-            session.adopt(
-                DiscoverResult(
-                    supported_versions=[LATEST_MODERN_VERSION],
-                    capabilities=ServerCapabilities(),
-                    server_info=Implementation(name="srv", version="0"),
-                )
-            )
-            await session.call_tool("run", {"region": "us-west1"})
+            await client.call_tool("run", {"region": "us-west1"})
 
     assert not any(k.startswith("mcp-param-") for k in requests[0].headers)
+
+
+@requirement("client-transport:http:custom-param-headers")
+async def test_modern_client_stops_mirroring_after_a_re_list_drops_the_tool() -> None:
+    """A re-list that drops a previously valid tool stops mirroring its `x-mcp-header` args.
+
+    The tool is first listed with a valid annotation (so a call mirrors `Mcp-Param-Region`), then re-listed
+    with an invalid annotation -- the modern client drops it and evicts the cached map, so a later `tools/call`
+    by name carries no `Mcp-Param-*` header. Asserted at the wire, where the eviction is observable.
+    """
+    schema = {"type": "object", "properties": {"a": {"type": "string", "x-mcp-header": "Region"}}}
+    bad_schema = {"type": "object", "properties": {"a": {"type": "string", "x-mcp-header": "bad name"}}}
+    valid = Tool(name="run", input_schema=schema)
+    invalid = Tool(name="run", input_schema=bad_schema)
+    listings = iter([valid, invalid])
+
+    async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
+        return ListToolsResult(tools=[next(listings)], ttl_ms=0, cache_scope="public")
+
+    async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
+        return CallToolResult(content=[TextContent(text="ok")])
+
+    server = Server("evict", on_list_tools=list_tools, on_call_tool=call_tool)
+
+    tool_calls: list[httpx.Request] = []
+
+    async def on_request(request: httpx.Request) -> None:
+        if json.loads(request.content)["method"] == "tools/call":
+            tool_calls.append(request)
+
+    discover = DiscoverResult(
+        supported_versions=[LATEST_MODERN_VERSION],
+        capabilities=ServerCapabilities(),
+        server_info=Implementation(name="srv", version="0"),
+    )
+    with anyio.fail_after(5):
+        async with (
+            mounted_app(server, on_request=on_request) as (http, _),
+            Client(
+                streamable_http_client(f"{BASE_URL}/mcp", http_client=http),
+                mode=LATEST_MODERN_VERSION,
+                prior_discover=discover,
+            ) as client,
+        ):
+            assert [t.name for t in (await client.list_tools()).tools] == ["run"]
+            await client.call_tool("run", {"a": "x"})
+
+            assert [t.name for t in (await client.list_tools()).tools] == []
+            await client.call_tool("run", {"a": "x"})
+
+    before, after = tool_calls
+    assert before.headers.get("mcp-param-region") == "x"
+    assert not any(k.startswith("mcp-param-") for k in after.headers)