claude · Aug 11, 2026 · Aug 11, 2026 · Aug 11, 2026 · Aug 11, 2026 · Aug 11, 2026
diff --git a/src/mcp/client/sse.py b/src/mcp/client/sse.py
@@ -118,19 +118,33 @@
            async def post_writer(endpoint_url: str):
                try:
                    async with write_stream_reader, write_stream:
 
                         async def _send_message(session_message: SessionMessage) -> None:
                             logger.debug(f"Sending client message: {session_message}")
+                            message = session_message.message
                             response = await client.post(
                                 endpoint_url,
-                                json=session_message.message.model_dump(
+                                json=message.model_dump(
                                     by_alias=True,
                                     mode="json",
                                     exclude_unset=True,
                                 ),
                             )
-                            response.raise_for_status()
+                            if response.status_code >= 400:
+                                # Resolve the waiting caller with an error correlated to its
+                                # request id, mirroring the streamable-HTTP transport: raising
+                                # here would be swallowed by the post_writer handler below and
+                                # the caller would hang forever (#2110). A notification has no
+                                # waiter to resolve, so the failure is only logged.
+                                logger.error(f"Message POST returned HTTP status {response.status_code}")
+                                if isinstance(message, types.JSONRPCRequest):
+                                    error_data = types.ErrorData(
+                                        code=types.INTERNAL_ERROR, message="Server returned an error response"
+                                    )
+                                    reply = types.JSONRPCError(jsonrpc="2.0", id=message.id, error=error_data)
+                                    await read_stream_writer.send(SessionMessage(reply))
+                                return
                             logger.debug(f"Client message sent successfully: {response.status_code}")
 
                         async for session_message in write_stream_reader:
                            sender_ctx = write_stream_reader.last_context

diff --git a/src/mcp/client/streamable_http.py b/src/mcp/client/streamable_http.py
@@ -248,13 +248,20 @@
         else:
             raise ResumptionError("Resumption request requires a resumption token")  # pragma: no cover
 
-        # Extract original request ID to map responses
-        original_request_id = None
-        if isinstance(ctx.session_message.message, JSONRPCRequest):  # pragma: no branch
-            original_request_id = ctx.session_message.message.id
+        # Only requests resume: a resumption token is only ever attached by a
+        # request's metadata, so the original id is always available to map responses.
+        assert isinstance(ctx.session_message.message, JSONRPCRequest)
+        original_request_id = ctx.session_message.message.id
 
         async with ctx.client.sse(self.url, headers=headers) as event_source:
-            event_source.response.raise_for_status()
+            if event_source.response.status_code >= 400:
+                # Resolve the waiting caller with an error correlated to its request,
+                # mirroring `_handle_post_request`: an escaping `HTTPStatusError` would
+                # tear down the transport's task group and every stream with it (#2110).
+                error_data = ErrorData(code=INTERNAL_ERROR, message="Server returned an error response")
+                reply = JSONRPCError(jsonrpc="2.0", id=original_request_id, error=error_data)
+                await ctx.read_stream_writer.send(SessionMessage(reply))
+                return
             logger.debug("Resumption GET SSE connection established")
 
             async for sse in event_source:  # pragma: no branch

diff --git a/tests/client/test_streamable_http.py b/tests/client/test_streamable_http.py
@@ -19,6 +19,7 @@
     CLIENT_CAPABILITIES_META_KEY,
     CLIENT_INFO_META_KEY,
     CONNECTION_CLOSED,
+    INTERNAL_ERROR,
     INVALID_REQUEST,
     METHOD_NOT_FOUND,
     PROTOCOL_VERSION_META_KEY,
@@ -31,6 +32,7 @@
 from starlette.types import Receive, Scope, Send
 
 from mcp.client.streamable_http import (
+    LAST_EVENT_ID,
     MAX_RECONNECTION_ATTEMPTS,
     RequestContext,
     StreamableHTTPTransport,
@@ -132,6 +134,46 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     assert reply.message.error.code == METHOD_NOT_FOUND
 
 
+@pytest.mark.anyio
+@pytest.mark.parametrize("status", [401, 403, 500])
+async def test_resumption_get_http_error_resolves_caller_and_transport_survives(status: int) -> None:
+    """A non-2xx on the resumption GET resolves the waiting request with a JSON-RPC error
+    correlated to its id, and the transport stays usable for follow-up requests (SDK-defined;
+    #2110 — the status error used to escape into the task group and tear down every stream).
+    """
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        if request.method == "GET" and LAST_EVENT_ID in request.headers:
+            return httpx2.Response(status)
+        body = json.loads(request.content)
+        return httpx2.Response(200, json={"jsonrpc": "2.0", "id": body["id"], "result": {}})
+
+    with anyio.fail_after(5):
+        async with (
+            httpx2.AsyncClient(transport=httpx2.MockTransport(handler)) as http,
+            streamable_http_client("http://test/mcp", http_client=http) as (read, write),
+        ):
+            await write.send(
+                SessionMessage(
+                    message=JSONRPCRequest(jsonrpc="2.0", id=1, method="tools/call", params={}),
+                    metadata=ClientMessageMetadata(resumption_token="token-1"),
+                )
+            )
+            reply = await read.receive()
+            assert isinstance(reply, SessionMessage)
+            assert isinstance(reply.message, JSONRPCError)
+            assert reply.message.id == 1
+            assert reply.message.error.code == INTERNAL_ERROR
+            assert reply.message.error.message == snapshot("Server returned an error response")
+
+            # The transport survived: a plain follow-up request still round-trips.
+            await write.send(SessionMessage(JSONRPCRequest(jsonrpc="2.0", id=2, method="tools/list", params={})))
+            follow_up = await read.receive()
+    assert isinstance(follow_up, SessionMessage)
+    assert isinstance(follow_up.message, JSONRPCResponse)
+    assert follow_up.message.id == 2
+
+
 @pytest.mark.anyio
 async def test_initialize_post_clears_cached_pv_header_and_unstamped_posts_read_it() -> None:
     """``initialize`` discards the cached protocol-version header; every other POST reads it.

diff --git a/tests/shared/test_sse.py b/tests/shared/test_sse.py
@@ -32,6 +32,7 @@
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.routing import Mount, Route
+from starlette.types import Receive, Scope, Send
 
 import mcp.client.sse
 from mcp.client.session import ClientSession
@@ -108,6 +109,39 @@
     return make_app(Server(SERVER_NAME, on_read_resource=_handle_read_resource))
 
 
+def make_app_rejecting_posts(reject: dict[str, int]) -> Starlette:
+    """Like `make_server_app`, but the message POST is answered with a bare HTTP error
+    for JSON-RPC messages whose method appears in `reject` (they never reach the server)."""
+    server = Server(SERVER_NAME, on_read_resource=_handle_read_resource)
+    sse = SseServerTransport(
+        "/messages/", security_settings=TransportSecuritySettings(enable_dns_rebinding_protection=False)
+    )
+
+    async def handle_sse(request: Request) -> Response:
+        async with sse.connect_sse(request.scope, request.receive, request._send) as (read_stream, write_stream):
+            await server.run(read_stream, write_stream, server.create_initialization_options())
+        return Response()
+
+    async def handle_post(scope: Scope, receive: Receive, send: Send) -> None:
+        body = await Request(scope, receive).body()
+        status = reject.get(json.loads(body).get("method"))
+        if status is not None:
+            await Response(status_code=status)(scope, receive, send)
+            return
+
+        async def replay() -> dict[str, Any]:
+            return {"type": "http.request", "body": body, "more_body": False}
+
+        await sse.handle_post_message(scope, replay, send)
+
+    return Starlette(
+        routes=[
+            Route("/sse", endpoint=handle_sse),
+            Mount("/messages/", app=handle_post),
+        ]
+    )
+
+
 @pytest.mark.anyio
 async def test_raw_sse_connection() -> None:
     """The SSE GET responds 200 with an event-stream content type, announcing the session
@@ -224,6 +258,48 @@
         await session.read_resource(uri="xxx://will-not-work")
 
 
+@pytest.mark.anyio
+@pytest.mark.parametrize("status_code", [401, 403, 500])
+async def test_sse_client_request_post_http_error_reaches_caller_and_session_survives(status_code: int) -> None:
+    """A non-2xx on a request's message POST reaches the waiting caller promptly as a JSON-RPC
+    error correlated to the request, and the session stays usable (SDK-defined; #2110 — the
+    status error used to be swallowed inside post_writer, hanging the caller forever).
+    """
+    factory = in_process_client_factory(make_app_rejecting_posts({"resources/read": status_code}))
+    with anyio.fail_after(5):
+        async with sse_client(f"{BASE_URL}/sse", httpx_client_factory=factory) as streams:
+            async with ClientSession(*streams) as session:
+                await session.initialize()
+
+                with pytest.raises(MCPError) as exc_info:
+                    await session.read_resource(uri="foobar://should-work")
+                assert exc_info.value.error.code == types.INTERNAL_ERROR
+                assert exc_info.value.error.message == snapshot("Server returned an error response")
+
+                # The session survived the failed POST: the next request round-trips.
+                assert isinstance(await session.send_ping(), EmptyResult)
+
+
+@pytest.mark.anyio
+async def test_sse_client_notification_post_http_error_leaves_session_usable() -> None:
+    """A non-2xx on a notification's message POST resolves no caller (a notification has no
+    waiter) and leaves the session usable for subsequent requests (SDK-defined; #2110)."""
+    factory = in_process_client_factory(make_app_rejecting_posts({"notifications/cancelled": 500}))
+    with anyio.fail_after(5):
+        async with sse_client(f"{BASE_URL}/sse", httpx_client_factory=factory) as streams:
+            async with ClientSession(*streams) as session:
+                await session.initialize()
+
+                # Fire-and-forget: the rejected POST must neither raise nor stall the writer.
+                await session.send_notification(
+                    types.CancelledNotification(params=types.CancelledNotificationParams(request_id=999))
+                )
+
+                # The write loop is serialized, so this request's POST happens strictly after
+                # the rejected one; its success proves the failure was contained.
+                assert isinstance(await session.send_ping(), EmptyResult)
+
+
 @pytest.mark.anyio
 async def test_sse_client_basic_connection_mounted_app() -> None:
     """The SSE transport works unchanged when its app is mounted under a sub-path."""