fix: change _handle_reconnection to return bool and fix infinite recursion

_handle_reconnection previously returned None, making it impossible for
callers to distinguish between a successful response delivery and
exhausted retries. This changes the return type to bool (True on success,
False when max attempts exceeded) and fixes two issues:

- The attempt counter at line 426 was reset to 0 on each reconnection,
  causing infinite recursion when streams kept ending without delivering
  a response. Now increments attempt on each recursion.

- All recursive calls now use `return await` so the result propagates
  back to the original caller.

MAX_RECONNECTION_ATTEMPTS increased from 2 to 5 to accommodate
legitimate multi-reconnection patterns where the server intentionally
closes streams between checkpoints.

Github-Issue: #1401

Author: heyhayes

src/mcp/client/streamable_http.py

@@ -47,7 +47,7 @@
 
 # Reconnection defaults
 DEFAULT_RECONNECTION_DELAY_MS = 1000  # 1 second fallback when server doesn't provide retry
-MAX_RECONNECTION_ATTEMPTS = 2  # Max retry attempts before giving up
+MAX_RECONNECTION_ATTEMPTS = 5  # Max retry attempts before giving up
 
 
 class StreamableHTTPError(Exception):
@@ -377,12 +377,17 @@ async def _handle_reconnection(
         last_event_id: str,
         retry_interval_ms: int | None = None,
         attempt: int = 0,
-    ) -> None:
-        """Reconnect with Last-Event-ID to resume stream after server disconnect."""
+    ) -> bool:
+        """Reconnect with Last-Event-ID to resume stream after server disconnect.
+
+        Returns:
+            True if the response was successfully delivered, False if max
+            reconnection attempts were exceeded without delivering a response.
+        """
         # Bail if max retries exceeded
-        if attempt >= MAX_RECONNECTION_ATTEMPTS:  # pragma: no cover
+        if attempt >= MAX_RECONNECTION_ATTEMPTS:
             logger.debug(f"Max reconnection attempts ({MAX_RECONNECTION_ATTEMPTS}) exceeded")
-            return
+            return False
 
         # Always wait - use server value or default
         delay_ms = retry_interval_ms if retry_interval_ms is not None else DEFAULT_RECONNECTION_DELAY_MS
@@ -419,15 +424,15 @@ async def _handle_reconnection(
                     )
                     if is_complete:
                         await event_source.response.aclose()
-                        return
+                        return True
 
-                # Stream ended again without response - reconnect again (reset attempt counter)
+                # Stream ended again without response - reconnect again
                 logger.info("SSE stream disconnected, reconnecting...")
-                await self._handle_reconnection(ctx, reconnect_last_event_id, reconnect_retry_ms, 0)
+                return await self._handle_reconnection(ctx, reconnect_last_event_id, reconnect_retry_ms, attempt + 1)
         except Exception as e:  # pragma: no cover
             logger.debug(f"Reconnection failed: {e}")
             # Try to reconnect again if we still have an event ID
-            await self._handle_reconnection(ctx, last_event_id, retry_interval_ms, attempt + 1)
+            return await self._handle_reconnection(ctx, last_event_id, retry_interval_ms, attempt + 1)
 
     async def post_writer(
         self,

tests/shared/test_streamable_http.py

@@ -29,7 +29,14 @@
 
 from mcp import MCPError, types
 from mcp.client.session import ClientSession
-from mcp.client.streamable_http import StreamableHTTPTransport, streamable_http_client
+from mcp.client.streamable_http import (
+    MAX_RECONNECTION_ATTEMPTS,
+    StreamableHTTPTransport,
+    streamable_http_client,
+)
+from mcp.client.streamable_http import (
+    RequestContext as TransportRequestContext,
+)
 from mcp.server import Server, ServerRequestContext
 from mcp.server.streamable_http import (
     MCP_PROTOCOL_VERSION_HEADER,
@@ -2247,3 +2254,33 @@ async def test_streamable_http_client_preserves_custom_with_mcp_headers(
 
                 assert "content-type" in headers_data
                 assert headers_data["content-type"] == "application/json"
+
+
+@pytest.mark.anyio
+async def test_handle_reconnection_returns_false_on_max_attempts():
+    """_handle_reconnection returns False when max attempts exceeded."""
+    transport = StreamableHTTPTransport(url="http://localhost:9999/mcp")
+
+    read_stream_writer, read_stream = anyio.create_memory_object_stream[SessionMessage | Exception](1)
+
+    message = JSONRPCRequest(jsonrpc="2.0", id=42, method="tools/call", params={"name": "test"})
+    session_message = SessionMessage(message)
+
+    ctx = TransportRequestContext(
+        client=httpx.AsyncClient(),
+        session_id="test-session",
+        session_message=session_message,
+        metadata=None,
+        read_stream_writer=read_stream_writer,
+    )
+
+    try:
+        with anyio.fail_after(5):
+            result = await transport._handle_reconnection(
+                ctx, last_event_id="evt-1", retry_interval_ms=None, attempt=MAX_RECONNECTION_ATTEMPTS
+            )
+            assert result is False
+    finally:
+        await read_stream_writer.aclose()
+        await read_stream.aclose()
+        await ctx.client.aclose()