fix(client): unwrap ExceptionGroup in transport clients

ROOT CAUSE:
Transport clients propagate ExceptionGroup wrapping real errors.

CHANGES:
- Added exception unwrapping in streamable_http_client
- Added exception unwrapping in websocket_client
- Added exception unwrapping in sse_client
- Added exception unwrapping in stdio_client

IMPACT:
- Callers can catch specific exceptions directly

FILES MODIFIED:
- src/mcp/client/streamable_http.py
- src/mcp/client/websocket.py
- src/mcp/client/sse.py
- src/mcp/client/stdio.py

Author: peter-luminova

src/mcp/client/sse.py

@@ -157,6 +157,12 @@ async def post_writer(endpoint_url: str):
                         yield read_stream, write_stream
                     finally:
                         tg.cancel_scope.cancel()
+        except BaseExceptionGroup as e:
+            from mcp.shared.exceptions import unwrap_task_group_exception
+
+            real_exc = unwrap_task_group_exception(e)
+            if real_exc is not e:
+                raise real_exc
         finally:
             await read_stream_writer.aclose()
             await write_stream.aclose()

src/mcp/client/stdio.py

@@ -178,37 +178,44 @@ async def stdin_writer():
             await anyio.lowlevel.checkpoint()
 
     async with anyio.create_task_group() as tg, process:
-        tg.start_soon(stdout_reader)
-        tg.start_soon(stdin_writer)
         try:
-            yield read_stream, write_stream
-        finally:
-            # MCP spec: stdio shutdown sequence
-            # 1. Close input stream to server
-            # 2. Wait for server to exit, or send SIGTERM if it doesn't exit in time
-            # 3. Send SIGKILL if still not exited
-            if process.stdin:  # pragma: no branch
+            tg.start_soon(stdout_reader)
+            tg.start_soon(stdin_writer)
+            try:
+                yield read_stream, write_stream
+            finally:
+                # MCP spec: stdio shutdown sequence
+                # 1. Close input stream to server
+                # 2. Wait for server to exit, or send SIGTERM if it doesn't exit in time
+                # 3. Send SIGKILL if still not exited
+                if process.stdin:  # pragma: no branch
+                    try:
+                        await process.stdin.aclose()
+                    except Exception:  # pragma: no cover
+                        # stdin might already be closed, which is fine
+                        pass
+
                 try:
-                    await process.stdin.aclose()
-                except Exception:  # pragma: no cover
-                    # stdin might already be closed, which is fine
+                    # Give the process time to exit gracefully after stdin closes
+                    with anyio.fail_after(PROCESS_TERMINATION_TIMEOUT):
+                        await process.wait()
+                except TimeoutError:
+                    # Process didn't exit from stdin closure, use platform-specific termination
+                    # which handles SIGTERM -> SIGKILL escalation
+                    await _terminate_process_tree(process)
+                except ProcessLookupError:  # pragma: no cover
+                    # Process already exited, which is fine
                     pass
-
-            try:
-                # Give the process time to exit gracefully after stdin closes
-                with anyio.fail_after(PROCESS_TERMINATION_TIMEOUT):
-                    await process.wait()
-            except TimeoutError:
-                # Process didn't exit from stdin closure, use platform-specific termination
-                # which handles SIGTERM -> SIGKILL escalation
-                await _terminate_process_tree(process)
-            except ProcessLookupError:  # pragma: no cover
-                # Process already exited, which is fine
-                pass
-            await read_stream.aclose()
-            await write_stream.aclose()
-            await read_stream_writer.aclose()
-            await write_stream_reader.aclose()
+                await read_stream.aclose()
+                await write_stream.aclose()
+                await read_stream_writer.aclose()
+                await write_stream_reader.aclose()
+        except BaseExceptionGroup as e:
+            from mcp.shared.exceptions import unwrap_task_group_exception
+
+            real_exc = unwrap_task_group_exception(e)
+            if real_exc is not e:
+                raise real_exc
 
 
 def _get_executable_command(command: str) -> str:

src/mcp/client/streamable_http.py

@@ -574,6 +574,13 @@ def start_get_stream() -> None:
                     if transport.session_id and terminate_on_close:
                         await transport.terminate_session(client)
                     tg.cancel_scope.cancel()
+        except BaseExceptionGroup as e:
+            # Unwrap ExceptionGroup to get only the real error
+            from mcp.shared.exceptions import unwrap_task_group_exception
+
+            real_exc = unwrap_task_group_exception(e)
+            if real_exc is not e:
+                raise real_exc
         finally:
             await read_stream_writer.aclose()
             await write_stream.aclose()

src/mcp/client/websocket.py

@@ -69,12 +69,19 @@ async def ws_writer():
                     await ws.send(json.dumps(msg_dict))
 
         async with anyio.create_task_group() as tg:
-            # Start reader and writer tasks
-            tg.start_soon(ws_reader)
-            tg.start_soon(ws_writer)
+            try:
+                # Start reader and writer tasks
+                tg.start_soon(ws_reader)
+                tg.start_soon(ws_writer)
 
-            # Yield the receive/send streams
-            yield (read_stream, write_stream)
+                # Yield the receive/send streams
+                yield (read_stream, write_stream)
 
-            # Once the caller's 'async with' block exits, we shut down
-            tg.cancel_scope.cancel()
+                # Once the caller's 'async with' block exits, we shut down
+                tg.cancel_scope.cancel()
+            except BaseExceptionGroup as e:
+                from mcp.shared.exceptions import unwrap_task_group_exception
+
+                real_exc = unwrap_task_group_exception(e)
+                if real_exc is not e:
+                    raise real_exc