[v1.x] fix(stdio): handle BrokenResourceError in stdout_reader (#1960)

Fix the race condition where `read_stream_writer.aclose()` in the `finally`
block of `stdio_client` can close the stream while `stdout_reader` is
mid-`send`, producing an unhandled `anyio.BrokenResourceError` that
propagates through the task group and surfaces as an `ExceptionGroup` to
the caller.

Root cause: the two `send` sites in `stdout_reader` did not catch
`BrokenResourceError`. The outer `except` only caught `ClosedResourceError`,
which is a distinct anyio exception class raised on already-closed streams.
`BrokenResourceError` is raised when the receiver is closed while a `send`
is in flight, which is the exact shape of this shutdown race.

Fix: wrap each `read_stream_writer.send(...)` call in a `try`/`except` that
catches both `ClosedResourceError` and `BrokenResourceError`, and return
cleanly. Also widen the outer `except` to the same union for defense in
depth.

Verified by driving a stdio MCP server (jules-mcp-server) through mcp2cli,
which previously always surfaced the ExceptionGroup traceback; after the
patch, tool calls return cleanly.

Github-Issue:#1960

Author: BashNetCorp

src/mcp/client/stdio/__init__.py

@@ -155,12 +155,22 @@ async def stdout_reader():
                             message = types.JSONRPCMessage.model_validate_json(line)
                         except Exception as exc:  # pragma: no cover
                             logger.exception("Failed to parse JSONRPC message from server")
-                            await read_stream_writer.send(exc)
+                            try:
+                                await read_stream_writer.send(exc)
+                            except (anyio.ClosedResourceError, anyio.BrokenResourceError):
+                                # Context is closing; exit gracefully (issue #1960).
+                                return
                             continue
 
                         session_message = SessionMessage(message)
-                        await read_stream_writer.send(session_message)
-        except anyio.ClosedResourceError:  # pragma: no cover
+                        try:
+                            await read_stream_writer.send(session_message)
+                        except (anyio.ClosedResourceError, anyio.BrokenResourceError):
+                            # Context is closing; exit gracefully (issue #1960).
+                            # Happens when the caller exits the stdio_client context
+                            # while the subprocess is still writing to stdout.
+                            return
+        except (anyio.ClosedResourceError, anyio.BrokenResourceError):  # pragma: no cover
             await anyio.lowlevel.checkpoint()
 
     async def stdin_writer():