rohitg00/ai-engineering-from-scratch · error · RuntimeError

{peer.name}: proven-modern discovery retry returned no resul

Error message

{peer.name}: proven-modern discovery retry returned no result

What it means

The versioned discovery retry completed but _send returned a non-dict value, so there is no JSON-RPC message to decode. Parallel to the first-attempt shape check, this guards the retry path against transports that yield None or raw strings.

Source

Thrown at phases/13-tools-and-protocols/08-building-an-mcp-client/code/main.py:459

            data = payload.get("data")
            advertised = data.get("supported", []) if isinstance(data, dict) else []
            selected = self._mutual_version(advertised)
            if selected is None:
                raise RuntimeError(f"{peer.name}: no mutually supported modern version")
            retry_id = self._new_id()
            retry = modern_request(
                retry_id,
                "server/discover",
                {},
                selected,
                self.client_capabilities,
            )
            try:
                retried = self._send(peer, retry, self.discovery_timeout_ms)
            except (TimeoutError, ConnectionError) as exc:
                raise RuntimeError(f"{peer.name}: proven-modern discovery retry failed") from exc
            if not isinstance(retried, dict):
                raise RuntimeError(f"{peer.name}: proven-modern discovery retry returned no result")
            retry_kind, retry_payload = decode_rpc_response(retried, retry_id)
            if retry_kind != "result":
                raise RuntimeError(f"{peer.name}: proven-modern discovery retry returned an error")
            self._activate_modern(peer, retry_payload, selected)
            return

        self._probe_legacy(peer, f"unrecognized discovery error {code}")

    def connect_all(self) -> None:
        for peer_name in sorted(self.peers):
            self._connect_peer(self.peers[peer_name])

    def _request(self, peer: Peer, method: str, params: dict[str, Any]) -> dict[str, Any]:
        request_id = self._new_id()
        if peer.era == "modern":
            message = modern_request(
                request_id,
                method,

View on GitHub (pinned to 39ea8a1c6d)

Solutions

1. Inspect what the transport returned on the retry
2. Fix the transport's read path to return parsed dicts
3. Harden the server so it responds to the versioned discover request
4. Fix test fakes to return dict responses on every call

null

def is_rpc_message(value) -> bool:
    return isinstance(value, dict) and "jsonrpc" in value

try:
    client.connect_all()
except RuntimeError as e:
    if "retry returned no result" in str(e):
        dump_transport_frames(peer)

When it happens

Trigger: retried = self._send(peer, retry, self.discovery_timeout_ms) succeeds but isinstance(retried, dict) is False.

Common situations: Connection closing between write and read so the reader returns None; transport returning serialized text; test doubles with the wrong return shape on the second call.

Related errors

• {peer.name}: malformed discovery response
• {peer.name}: bounded legacy probe returned no result
• {peer.name}: missing response
• server/discover accepts no params beyond _meta
• {peer.name}: malformed modern discovery result

AI-assisted analysis of rohitg00/ai-engineering-from-scratch@39ea8a1c6d (2026-08-26). Data as JSON: /api/errors/973d296026ae7dc9. Report an issue: GitHub.