auto mode: legacy-only discover advertisement falls back to initialize

A server that answers server/discover but advertises no modern version
in supportedVersions (go-sdk's default stateful streamable server does
this) previously made adopt() raise 'No mutually supported modern
protocol version'. On the old schema this path was unreachable by
accident: the reply lacked the then-required body serverInfo, failed
validation, and fell into the unparseable-result fallback. Making
serverInfo optional exposed the raise.

Treat the reply as what it is, an explicit legacy advertisement, and
run the initialize handshake, matching the -32022-with-legacy-versions
branch directly above and the behavior of both the typescript and go
clients. adopt() itself stays strict for direct prior_discover use.

Author: maxisbey

src/mcp/client/_probe.py

@@ -9,8 +9,13 @@
 ``supported`` list. The streamable-HTTP transport already maps HTTP-layer
 4xx rejections (no JSON-RPC body) into ``MCPError`` codes, so those reach
 the same path. Any non-``MCPError`` exception (network/connection errors,
-anyio cancellation, the ``RuntimeError`` from ``adopt()`` on no-mutual)
-propagates to the caller; an outage or in-process bug is never an era verdict.
+anyio cancellation) propagates to the caller; an outage or in-process bug
+is never an era verdict.
+
+A successful ``DiscoverResult`` whose ``supportedVersions`` shares no modern
+version with this client is treated the same way: the server speaks discover
+but advertises only handshake-era versions, which is a legacy advertisement,
+not an incompatibility.
 
 The fallback handshake itself can be answered with ``-32022`` — e.g. a probe
 that timed out client-side but succeeded on a slow-starting server locked the
@@ -89,13 +94,21 @@ async def negotiate_auto(session: ClientSession) -> None:
                 version = mutual[-1]
                 continue
             return
-        # any other exception (httpx2.TransportError, ConnectionError, anyio errors,
-        # RuntimeError from adopt) → propagate
+        # any other exception (httpx2.TransportError, ConnectionError,
+        # anyio errors) → propagate
         try:
             result = types.DiscoverResult.model_validate(raw)
         except ValidationError:
             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
+            # (go-sdk's stateful streamable default does this) is an explicit
+            # legacy advertisement: fall back like the -32022 branch above
+            # instead of letting `adopt()` raise. The ts and go clients fall
+            # back here too.
+            await session.initialize()
+            return
         session.adopt(result)
         return
     raise AssertionError("unreachable")  # pragma: no cover — loop body always returns or raises

tests/client/test_probe.py

@@ -121,6 +121,16 @@ async def test_an_unparseable_discover_result_falls_back_to_initialize() -> None
     assert session.adopted is None
 
 
+async def test_a_discover_result_advertising_only_legacy_versions_falls_back_to_initialize() -> None:
+    """A server that answers the probe but lists no modern version has made an
+    explicit legacy advertisement (go-sdk's default stateful streamable server
+    does this), so the policy runs the handshake instead of raising on adopt."""
+    session = _StubSession(_discover_dict(list(HANDSHAKE_PROTOCOL_VERSIONS)))
+    await _negotiate(session)
+    assert session.initialized
+    assert session.adopted is None
+
+
 # --- the denylist: every JSON-RPC error code falls back ---