ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

ccproxy/{claude_sdk → plugins/claude_sdk}/session_client.py

@@ -7,18 +7,19 @@ import time
 from enum import Enum
 from typing import Any
 
-import structlog
-from claude_code_sdk import ClaudeCodeOptions
+from claude_agent_sdk import ClaudeAgentOptions
 from pydantic import BaseModel
 
+from ccproxy.core.async_task_manager import create_managed_task
 from ccproxy.core.async_utils import patched_typing
+from ccproxy.core.logging import get_plugin_logger
 from ccproxy.utils.id_generator import generate_client_id
 
 
 with patched_typing():
-    from claude_code_sdk import ClaudeSDKClient as ImportedClaudeSDKClient
+    from claude_agent_sdk import ClaudeSDKClient as ImportedClaudeSDKClient
 
-logger = structlog.get_logger(__name__)
+logger = get_plugin_logger()
 
 
 class SessionStatus(str, Enum):
@@ -57,7 +58,7 @@ class SessionClient:
     def __init__(
         self,
         session_id: str,
-        options: ClaudeCodeOptions,
+        options: ClaudeAgentOptions,
         client_id: str | None = None,
         ttl_seconds: int = 3600,
     ):
@@ -129,6 +130,39 @@ class SessionClient:
 
                 return True
 
+            except ConnectionError as e:
+                self.status = SessionStatus.ERROR
+                self.last_error = e
+                self.metrics.error_count += 1
+
+                logger.error(
+                    "session_connection_network_error",
+                    session_id=self.session_id,
+                    attempt=self.connection_attempts,
+                    error=str(e),
+                    exc_info=e,
+                )
+            except TimeoutError as e:
+                self.status = SessionStatus.ERROR
+                self.last_error = e
+                self.metrics.error_count += 1
+
+                logger.error(
+                    "session_connection_timeout",
+                    session_id=self.session_id,
+                    attempt=self.connection_attempts,
+                    error=str(e),
+                    exc_info=e,
+                )
+
+                if self.connection_attempts >= self.max_connection_attempts:
+                    logger.error(
+                        "session_connection_exhausted",
+                        session_id=self.session_id,
+                        max_attempts=self.max_connection_attempts,
+                    )
+
+                return False
             except Exception as e:
                 self.status = SessionStatus.ERROR
                 self.last_error = e
@@ -139,7 +173,7 @@ class SessionClient:
                     session_id=self.session_id,
                     attempt=self.connection_attempts,
                     error=str(e),
-                    exc_info=True,
+                    exc_info=e,
                 )
 
                 if self.connection_attempts >= self.max_connection_attempts:
@@ -151,14 +185,21 @@ class SessionClient:
 
                 return False
 
-    def connect_background(self) -> asyncio.Task[bool]:
+            # This should never be reached, but mypy needs it
+            return False
+
+    async def connect_background(self) -> asyncio.Task[bool]:
         """Start connection in background without blocking.
 
         Returns:
             Task that completes when connection is established
         """
         if self._connection_task is None or self._connection_task.done():
-            self._connection_task = asyncio.create_task(self._connect_async())
+            self._connection_task = await create_managed_task(
+                self._connect_async(),
+                name=f"session_connect_{self.session_id}",
+                creator="SessionClient",
+            )
             logger.debug(
                 "session_background_connection_started",
                 session_id=self.session_id,
@@ -174,6 +215,7 @@ class SessionClient:
                 "session_background_connection_failed",
                 session_id=self.session_id,
                 error=str(e),
+                exc_info=e,
             )
             return False
 
@@ -191,11 +233,19 @@ class SessionClient:
                 try:
                     await self.claude_client.disconnect()
                     logger.debug("session_disconnected", session_id=self.session_id)
+                except TimeoutError as e:
+                    logger.warning(
+                        "session_disconnect_timeout",
+                        session_id=self.session_id,
+                        error=str(e),
+                        exc_info=e,
+                    )
                 except Exception as e:
                     logger.warning(
                         "session_disconnect_error",
                         session_id=self.session_id,
                         error=str(e),
+                        exc_info=False,
                     )
                 finally:
                     self.claude_client = None
@@ -256,11 +306,28 @@ class SessionClient:
                         )
                         # Clear the handle reference
                         self.active_stream_handle = None
+                except asyncio.CancelledError as e:
+                    logger.warning(
+                        "session_stream_handle_interrupt_cancelled",
+                        session_id=self.session_id,
+                        error=str(e),
+                        exc_info=e,
+                        message="Stream handle interrupt was cancelled, continuing with SDK interrupt",
+                    )
+                except TimeoutError as e:
+                    logger.warning(
+                        "session_stream_handle_interrupt_timeout",
+                        session_id=self.session_id,
+                        error=str(e),
+                        exc_info=e,
+                        message="Stream handle interrupt timed out, continuing with SDK interrupt",
+                    )
                 except Exception as e:
                     logger.warning(
                         "session_stream_handle_interrupt_error",
                         session_id=self.session_id,
                         error=str(e),
+                        exc_info=e,
                         message="Failed to interrupt stream handle, continuing with SDK interrupt",
                     )
 
@@ -299,12 +366,33 @@ class SessionClient:
             # Force disconnect if interrupt hangs
             await self._force_disconnect()
 
+        except asyncio.CancelledError as e:
+            logger.warning(
+                "session_interrupt_cancelled",
+                session_id=self.session_id,
+                error=str(e),
+                exc_info=e,
+            )
+            # If interrupt fails, try force disconnect as fallback
+            try:
+                logger.debug(
+                    "session_interrupt_fallback_disconnect",
+                    session_id=self.session_id,
+                )
+                await self._force_disconnect()
+            except Exception as disconnect_error:
+                logger.error(
+                    "session_force_disconnect_failed",
+                    session_id=self.session_id,
+                    error=str(disconnect_error),
+                    exc_info=disconnect_error,
+                )
         except Exception as e:
             logger.warning(
                 "session_interrupt_error",
                 session_id=self.session_id,
                 error=str(e),
-                error_type=type(e).__name__,
+                exc_info=e,
             )
 
             # If interrupt fails, try force disconnect as fallback
@@ -319,7 +407,7 @@ class SessionClient:
                     "session_force_disconnect_failed",
                     session_id=self.session_id,
                     error=str(disconnect_error),
-                    error_type=type(disconnect_error).__name__,
+                    exc_info=disconnect_error,
                 )
         finally:
             # Final safety check - ensure we don't hang forever
@@ -373,11 +461,19 @@ class SessionClient:
                     self.claude_client.disconnect(),
                     timeout=3.0,  # 3 second timeout for disconnect
                 )
+        except TimeoutError as e:
+            logger.warning(
+                "session_force_disconnect_timeout",
+                session_id=self.session_id,
+                error=str(e),
+                exc_info=e,
+            )
         except Exception as e:
             logger.warning(
                 "session_force_disconnect_error",
                 session_id=self.session_id,
                 error=str(e),
+                exc_info=e,
             )
         finally:
             # Always clean up the client reference and mark as disconnected
@@ -435,13 +531,29 @@ class SessionClient:
                         handle_id=self.active_stream_handle.handle_id,
                         message="Stream drain timed out after 30 seconds",
                     )
+            except TimeoutError as e:
+                logger.error(
+                    "session_stream_drain_timeout_via_handle",
+                    session_id=self.session_id,
+                    handle_id=self.active_stream_handle.handle_id,
+                    error=str(e),
+                    exc_info=e,
+                )
+            except asyncio.CancelledError as e:
+                logger.warning(
+                    "session_stream_drain_cancelled_via_handle",
+                    session_id=self.session_id,
+                    handle_id=self.active_stream_handle.handle_id,
+                    error=str(e),
+                    exc_info=e,
+                )
             except Exception as e:
                 logger.error(
                     "session_stream_drain_error_via_handle",
                     session_id=self.session_id,
                     handle_id=self.active_stream_handle.handle_id,
                     error=str(e),
-                    error_type=type(e).__name__,
+                    exc_info=e,
                 )
             finally:
                 self.active_stream_handle = None
@@ -450,7 +562,7 @@ class SessionClient:
 
             return
 
-        # Legacy path - should not happen with queue-based architecture
+        # Should not happen with queue-based architecture
         logger.warning(
             "session_no_handle_for_drain",
             session_id=self.session_id,