fix: honor protocol_version_override on the auto-mode success path

negotiate_auto only consulted protocol_version in its initialize()
fallback calls, so mode="auto" (the default) silently dropped the
override whenever the server/discover probe succeeded first - the
override only ever took effect when the probe failed. Since the whole
point of protocol_version_override is to let a caller pin an older or
custom protocol version, an override must always win: when set, skip
the discover probe entirely and go straight to the legacy handshake at
that version.

Regression tests: a unit test on negotiate_auto proving the probe is
skipped even when the stub's discover script would otherwise succeed,
and an e2e test over a real streamable-HTTP server (mode="auto" +
override) proving only `initialize` is sent and `server/discover`
never is.

Reported by a static review pass on this PR; verified independently by
tracing the actual control flow before applying this fix.

Author: STiFLeR7

src/mcp/client/_probe.py

@@ -58,12 +58,21 @@ async def negotiate_auto(session: ClientSession, protocol_version: str | None =
     ``session.discover_result`` / ``session.initialize_result`` is set on
     return.
 
+    ``protocol_version`` pins the legacy handshake to a specific version. A
+    caller supplying it wants that exact version, so this skips the
+    ``server/discover`` probe entirely and goes straight to the handshake —
+    otherwise a server with modern support would win discovery and the pin
+    would be silently ignored.
+
     Raises:
         MCPError: The server is modern-only and shares no version with this
             client (-32022 with a disjoint ``supported`` list), or the
             fallback handshake failed and one corrective re-probe did too.
         Exception: Any transport/network error from the probe propagates as-is.
     """
+    if protocol_version is not None:
+        await session.initialize(protocol_version=protocol_version)
+        return
     version = LATEST_MODERN_VERSION
     for attempt in range(2):
         try:
@@ -78,10 +87,7 @@ async def negotiate_auto(session: ClientSession, protocol_version: str | None =
                 if supported is not None and not any(v in HANDSHAKE_PROTOCOL_VERSIONS for v in supported):
                     raise  # server is modern-only and disjoint — real incompatibility
             try:
-                if protocol_version is not None:
-                    await session.initialize(protocol_version=protocol_version)
-                else:
-                    await session.initialize()  # every other rpc-error → legacy (the denylist)
+                await session.initialize()  # every other rpc-error → legacy (the denylist)
             except MCPError as handshake_exc:
                 if handshake_exc.code != UNSUPPORTED_PROTOCOL_VERSION or attempt != 0:
                     raise
@@ -102,10 +108,7 @@ async def negotiate_auto(session: ClientSession, protocol_version: str | None =
         try:
             result = types.DiscoverResult.model_validate(raw)
         except ValidationError:
-            if protocol_version is not None:
-                await session.initialize(protocol_version=protocol_version)
-            else:
-                await session.initialize()  # unparseable result → not modern evidence
+            await session.initialize()  # unparseable result → not modern evidence
             return
         if not any(v in result.supported_versions for v in MODERN_PROTOCOL_VERSIONS):
             # A discover-answering server that advertises no modern version

tests/client/test_probe.py

@@ -335,17 +335,18 @@ def test_parse_supported_returns_none_for_anything_not_shaped_like_the_spec_erro
     assert _parse_supported(data) == expected
 
 
-async def test_negotiate_auto_mcp_error_with_custom_protocol_version() -> None:
-    """Test that negotiate_auto initializes with a custom protocol version when discover returns an MCPError."""
-    session = _StubSession(MCPError(code=METHOD_NOT_FOUND, message="nope"))
-    await _negotiate(session, protocol_version="2024-11-05")
-    assert session.initialized
-    assert session.initialize_version == "2024-11-05"
+# --- protocol_version override forces the legacy handshake, unconditionally ---
 
 
-async def test_negotiate_auto_validation_error_with_custom_protocol_version() -> None:
-    """Test that negotiate_auto initializes with a custom protocol version when discover returns unparseable result."""
-    session = _StubSession({"not": "a discover result"})
+async def test_a_protocol_version_override_skips_discovery_and_forces_the_legacy_handshake() -> None:
+    """`protocol_version` pins an explicit legacy version, so the caller wants exactly that
+    version - the probe is skipped entirely and the handshake runs unconditionally, even
+    though the stub's discover script would otherwise return a valid modern result (regression:
+    the override used to only reach `initialize()` via the fallback paths, so a successful
+    discover silently dropped it)."""
+    session = _StubSession(_discover_dict())
     await _negotiate(session, protocol_version="2024-11-05")
+    assert session.probed_at == []
     assert session.initialized
     assert session.initialize_version == "2024-11-05"
+    assert session.adopted is None

tests/interaction/_requirements.py

@@ -465,6 +465,15 @@ def __post_init__(self) -> None:
         ),
         added_in="2026-07-28",
     ),
+    "lifecycle:mode:auto-override-skips-discover": Requirement(
+        source="sdk",
+        behavior=(
+            "A Client constructed with mode='auto' and protocol_version_override=<version> sends "
+            "initialize at that version as its first request and never sends server/discover, even "
+            "when the server would answer discover successfully."
+        ),
+        added_in="2026-07-28",
+    ),
     # ═══════════════════════════════════════════════════════════════════════════
     # Protocol primitives: cancellation, timeout, progress, errors, _meta
     # ═══════════════════════════════════════════════════════════════════════════

tests/interaction/lowlevel/test_client_connect.py

@@ -178,6 +178,34 @@ async def test_auto_mode_probes_server_discover_and_adopts_the_result() -> None:
     assert "initialize" not in [b["method"] for b in bodies]
 
 
+@requirement("lifecycle:mode:auto-override-skips-discover")
+async def test_auto_mode_with_a_protocol_version_override_skips_discover_and_initializes() -> None:
+    """`Client(..., mode='auto', protocol_version_override=...)` sends `initialize` at the
+    override version and never probes `server/discover`, even though the mounted server answers
+    discover successfully. Regression: the override used to only reach `negotiate_auto`'s
+    `initialize()` fallback calls, so a successful discover silently dropped it and the client
+    ended up modern-negotiated at the server's latest version instead of the pinned one.
+    """
+    requests, on_request = _request_recorder()
+    server = _tools_server("discoverable")
+
+    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="auto",
+                protocol_version_override="2024-11-05",
+            ) as client,
+        ):
+            assert client.protocol_version == "2024-11-05"
+            assert client.server_info.name == "discoverable"
+
+    bodies = [json.loads(r.content)["method"] for r in requests if r.method == "POST"]
+    assert bodies[0] == "initialize"
+    assert "server/discover" not in bodies
+
+
 @requirement("lifecycle:discover:retry-on-32022")
 async def test_auto_mode_retries_discover_once_on_unsupported_protocol_version() -> None:
     """A -32022 from `server/discover` triggers exactly one retry at the highest mutual modern version.