adcp 2.12.1__py3-none-any.whl → 2.13.0__py3-none-any.whl

adcp/protocols/mcp.py

@@ -9,6 +9,16 @@ from contextlib import AsyncExitStack
 from typing import TYPE_CHECKING, Any
 from urllib.parse import urlparse
 
+# ExceptionGroup and BaseExceptionGroup are available in Python 3.11+
+# In 3.11+, they're built-in types. For 3.10, we need to handle their absence.
+try:
+    _ExceptionGroup: type[BaseException] | None = ExceptionGroup  # type: ignore[name-defined]
+    _BaseExceptionGroup: type[BaseException] | None = BaseExceptionGroup  # type: ignore[name-defined]
+except NameError:
+    # Python 3.10 - ExceptionGroup doesn't exist
+    _ExceptionGroup = None
+    _BaseExceptionGroup = None
+
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
@@ -23,6 +33,14 @@ try:
 except ImportError:
     MCP_AVAILABLE = False
 
+try:
+    from httpx import HTTPStatusError
+
+    HTTPX_AVAILABLE = True
+except ImportError:
+    HTTPX_AVAILABLE = False
+    HTTPStatusError = None  # type: ignore[assignment, misc]
+
 from adcp.exceptions import ADCPConnectionError, ADCPTimeoutError
 from adcp.protocols.base import ProtocolAdapter
 from adcp.types.core import DebugInfo, TaskResult, TaskStatus
@@ -56,23 +74,80 @@ class MCPAdapter(ProtocolAdapter):
             self._session = None
             try:
                 await old_stack.aclose()
-            except asyncio.CancelledError:
-                logger.debug(f"MCP session cleanup cancelled {context}")
-            except RuntimeError as cleanup_error:
-                # Known anyio task group cleanup issue
-                error_msg = str(cleanup_error).lower()
-                if "cancel scope" in error_msg or "async context" in error_msg:
-                    logger.debug(f"Ignoring anyio cleanup error {context}: {cleanup_error}")
-                else:
-                    logger.warning(
-                        f"Unexpected RuntimeError during cleanup {context}: {cleanup_error}"
-                    )
-            except Exception as cleanup_error:
-                # Log unexpected cleanup errors but don't raise to preserve original error
-                logger.warning(
-                    f"Unexpected error during cleanup {context}: {cleanup_error}", exc_info=True
+            except BaseException as cleanup_error:
+                # Handle all cleanup errors including ExceptionGroup
+                # Re-raise KeyboardInterrupt and SystemExit immediately
+                if isinstance(cleanup_error, (KeyboardInterrupt, SystemExit)):
+                    raise
+
+                if isinstance(cleanup_error, asyncio.CancelledError):
+                    logger.debug(f"MCP session cleanup cancelled {context}")
+                    return
+
+                # Handle ExceptionGroup/BaseExceptionGroup from task group failures (Python 3.11+)
+                # ExceptionGroup: for Exception subclasses (e.g., HTTPStatusError)
+                # BaseExceptionGroup: for BaseException subclasses (e.g., CancelledError)
+                # We need both because CancelledError is a BaseException, not an Exception
+                is_exception_group = (
+                    _ExceptionGroup is not None and isinstance(cleanup_error, _ExceptionGroup)
+                ) or (
+                    _BaseExceptionGroup is not None
+                    and isinstance(cleanup_error, _BaseExceptionGroup)
                 )
 
+                if is_exception_group:
+                    # Check if all exceptions in the group are CancelledError
+                    # If so, treat the entire group as a cancellation
+                    all_cancelled = all(
+                        isinstance(exc, asyncio.CancelledError)
+                        for exc in cleanup_error.exceptions  # type: ignore[attr-defined]
+                    )
+                    if all_cancelled:
+                        logger.debug(f"MCP session cleanup cancelled {context}")
+                        return
+
+                    # Mixed group: skip CancelledErrors and log real errors
+                    exceptions = cleanup_error.exceptions  # type: ignore[attr-defined]
+                    cancelled_errors = [
+                        exc for exc in exceptions if isinstance(exc, asyncio.CancelledError)
+                    ]
+                    cancelled_count = len(cancelled_errors)
+                    if cancelled_count > 0:
+                        logger.debug(
+                            f"Skipping {cancelled_count} CancelledError(s) "
+                            f"in mixed exception group {context}"
+                        )
+
+                    # Log each non-cancelled exception individually
+                    for exc in exceptions:
+                        if not isinstance(exc, asyncio.CancelledError):
+                            self._log_cleanup_error(exc, context)
+                else:
+                    self._log_cleanup_error(cleanup_error, context)
+
+    def _log_cleanup_error(self, exc: BaseException, context: str) -> None:
+        """Log a cleanup error without raising."""
+        # Check for known cleanup error patterns from httpx/anyio
+        exc_str = str(exc).lower()
+
+        # Common cleanup errors that are expected when connection fails
+        is_known_cleanup_error = (
+            isinstance(exc, RuntimeError)
+            and ("cancel scope" in exc_str or "async context" in exc_str)
+        ) or (
+            # HTTP errors during cleanup (if httpx is available)
+            HTTPX_AVAILABLE
+            and HTTPStatusError is not None
+            and isinstance(exc, HTTPStatusError)
+        )
+
+        if is_known_cleanup_error:
+            # Expected cleanup errors - log at debug level without stack trace
+            logger.debug(f"Ignoring expected cleanup error {context}: {exc}")
+        else:
+            # Truly unexpected cleanup errors - log at warning with full context
+            logger.warning(f"Unexpected error during cleanup {context}: {exc}", exc_info=True)
+
     async def _get_session(self) -> ClientSession:
         """
         Get or create MCP client session with URL fallback handling.
@@ -146,7 +221,11 @@ class MCPAdapter(ProtocolAdapter):
                         )
 
                     return self._session  # type: ignore[no-any-return]
-                except Exception as e:
+                except BaseException as e:
+                    # Catch BaseException to handle CancelledError from failed initialization
+                    # Re-raise KeyboardInterrupt and SystemExit immediately
+                    if isinstance(e, (KeyboardInterrupt, SystemExit)):
+                        raise
                     last_error = e
                     # Clean up the exit stack on failure to avoid resource leaks
                     await self._cleanup_failed_connection("during connection attempt")