fix: log notification errors instead of forwarding raw exceptions

For notification connection errors, log a warning and continue rather
than forwarding a raw Exception to the read stream (where it would be
silently ignored by _handle_incoming anyway). This keeps the post_writer
loop alive and achieves 100% coverage.

Also move contextlib.suppress inside the request branch — we only need
to suppress errors from the JSONRPCError construction/send, not from
the isinstance check itself.

Author: omar-y-abdi

src/mcp/client/streamable_http.py

@@ -475,8 +475,8 @@ async def handle_request_async() -> None:
                         except anyio.get_cancelled_exc_class():
                             raise
                         except Exception as exc:
-                            with contextlib.suppress(Exception):
-                                if isinstance(message, JSONRPCRequest):
+                            if isinstance(message, JSONRPCRequest):
+                                with contextlib.suppress(Exception):
                                     error_data = ErrorData(
                                         code=INTERNAL_ERROR,
                                         message=str(exc) or "Connection error",
@@ -485,8 +485,8 @@ async def handle_request_async() -> None:
                                         JSONRPCError(jsonrpc="2.0", id=message.id, error=error_data)
                                     )
                                     await read_stream_writer.send(error_msg)
-                                else:
-                                    await read_stream_writer.send(exc)
+                            else:
+                                logger.warning(f"Failed to send notification: {exc}")
 
                     # If this is a request, start a new task to handle it
                     if isinstance(message, JSONRPCRequest):

tests/shared/test_streamable_http.py

@@ -57,6 +57,7 @@
     CallToolResult,
     InitializeResult,
     JSONRPCError,
+    JSONRPCNotification,
     JSONRPCRequest,
     ListToolsResult,
     PaginatedRequestParams,
@@ -2361,3 +2362,56 @@ async def test_connection_error_forwarded_to_read_stream():
             assert isinstance(result, SessionMessage)
             assert isinstance(result.message, JSONRPCError)
             assert result.message.id == "init-err"
+
+
+@pytest.mark.anyio
+async def test_notification_connection_error_logged_not_forwarded():
+    """Test that notification connection errors are logged and do not crash
+    the post_writer loop.
+
+    Unlike request errors (which must be forwarded as JSONRPCError to unblock
+    send_request), notification errors are simply logged since nothing waits
+    for a notification response.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        _, port = s.getsockname()
+
+    async with streamable_http_client(f"http://127.0.0.1:{port}/mcp") as (
+        read_stream,
+        write_stream,
+    ):
+        async with read_stream, write_stream:
+            # Send a notification — this will fail to connect but should
+            # not crash the post_writer
+            notification = SessionMessage(
+                JSONRPCNotification(
+                    jsonrpc="2.0",
+                    method="notifications/initialized",
+                )
+            )
+            await write_stream.send(notification)
+
+            # Send a request after the notification to verify post_writer
+            # is still alive
+            request = SessionMessage(
+                JSONRPCRequest(
+                    jsonrpc="2.0",
+                    id="after-notif",
+                    method="initialize",
+                    params={
+                        "protocolVersion": types.LATEST_PROTOCOL_VERSION,
+                        "capabilities": {},
+                        "clientInfo": {"name": "test", "version": "1.0"},
+                    },
+                )
+            )
+            await write_stream.send(request)
+
+            # The request error should arrive (proving post_writer survived
+            # the notification error)
+            with anyio.fail_after(5):
+                result = await read_stream.receive()
+            assert isinstance(result, SessionMessage)
+            assert isinstance(result.message, JSONRPCError)
+            assert result.message.id == "after-notif"