fix(client): catch read failures on the non-2xx body

`httpx.StreamError` derives from `RuntimeError`, not `httpx.HTTPError`, so it
does not cover a body that stalls or truncates while being read: `aread()`
raises `ReadTimeout`/`RemoteProtocolError` there. Those escaped into the POST's
background task and stranded the caller — the bug this path exists to prevent.

Github-Issue: #3091

Author: himanshu-commits

src/mcp/client/streamable_http.py

@@ -542,8 +542,12 @@ async def _send_http_status_error(
                     reply = JSONRPCError(jsonrpc="2.0", id=request_id, error=parsed.root.error)
                     await read_stream_writer.send(SessionMessage(JSONRPCMessage(reply)))
                     return
-            except (httpx.StreamError, ValidationError):
-                logger.debug("Non-2xx body was not a JSON-RPC error; using the status-derived fallback")
+            # `httpx.HTTPError` covers reading the body as much as parsing it: a stalled or
+            # truncated error body raises `ReadTimeout`/`RemoteProtocolError` here, and letting
+            # that escape would strand the caller exactly as the bug this method exists to fix.
+            # `StreamError` is not one of its subclasses (it derives from `RuntimeError`).
+            except (httpx.HTTPError, httpx.StreamError, ValidationError):
+                logger.debug("Could not read a JSON-RPC error from the non-2xx body; using the fallback")
 
         error_data = ErrorData(code=INTERNAL_ERROR, message="Server returned an error response")
         jsonrpc_error = JSONRPCError(jsonrpc="2.0", id=request_id, error=error_data)

tests/shared/test_streamable_http.py

@@ -8,7 +8,7 @@
 import multiprocessing
 import socket
 import time
-from collections.abc import Generator
+from collections.abc import AsyncIterator, Generator
 from datetime import timedelta
 from typing import Any
 from unittest.mock import MagicMock
@@ -2543,3 +2543,39 @@ def handler(request: httpx.Request) -> httpx.Response:
             assert reply.message.root.error == types.ErrorData(
                 code=types.INTERNAL_ERROR, message="Server returned an error response"
             )
+
+
+@pytest.mark.anyio
+async def test_a_non_2xx_body_that_fails_to_read_still_resolves_the_caller() -> None:
+    """A stalled or truncated error body must not strand the caller.
+
+    `aread()` on the non-2xx body raises `ReadTimeout`/`RemoteProtocolError` when the connection
+    dies mid-body. Those derive from `httpx.HTTPError`, not `httpx.StreamError`, so letting the
+    body-parsing `except` miss them would put the escaping exception right back into the POST's
+    background task — the very bug this path exists to fix.
+    """
+
+    class _DyingStream(httpx.AsyncByteStream):
+        async def __aiter__(self) -> AsyncIterator[bytes]:
+            raise httpx.ReadTimeout("connection died mid-body")
+            yield b""  # pragma: no cover
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(500, headers={"content-type": "application/json"}, stream=_DyingStream())
+
+    with anyio.fail_after(5):
+        async with (
+            httpx.AsyncClient(transport=httpx.MockTransport(handler)) as http_client,
+            streamable_http_client("http://test/mcp", http_client=http_client) as (read, write, _),
+            read,
+            write,
+        ):
+            request = types.JSONRPCRequest(jsonrpc="2.0", id=1, method="tools/list", params={})
+            await write.send(SessionMessage(types.JSONRPCMessage(request)))
+            reply = await read.receive()
+
+            assert isinstance(reply, SessionMessage)
+            assert isinstance(reply.message.root, types.JSONRPCError)
+            assert reply.message.root.error == types.ErrorData(
+                code=types.INTERNAL_ERROR, message="Server returned an error response"
+            )