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

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

@@ -8,15 +8,16 @@ import uuid
 from collections.abc import AsyncIterator
 from typing import Any
 
-import structlog
+from ccproxy.core.async_task_manager import create_managed_task
+from ccproxy.core.logging import get_plugin_logger
 
-from ccproxy.claude_sdk.message_queue import QueueListener
-from ccproxy.claude_sdk.session_client import SessionClient
-from ccproxy.claude_sdk.stream_worker import StreamWorker, WorkerStatus
-from ccproxy.config.claude import SessionPoolSettings
+from .config import SessionPoolSettings
+from .message_queue import QueueListener
+from .session_client import SessionClient
+from .stream_worker import StreamWorker, WorkerStatus
 
 
-logger = structlog.get_logger(__name__)
+logger = get_plugin_logger()
 
 
 class StreamHandle:
@@ -73,19 +74,39 @@ class StreamHandle:
     async def create_listener(self) -> AsyncIterator[Any]:
         """Create a new listener for this stream.
 
-        This method starts the worker on first listener and returns
-        an async iterator for consuming messages.
+        This method creates the worker if needed, pre-registers the listener,
+        then starts the worker. This ordering prevents race conditions where
+        fast STDIO tools could return results before the listener was ready.
 
         Yields:
             Messages from the stream
         """
-        # Start worker if needed
-        await self._ensure_worker_started()
+        # Create worker if needed (but don't start yet)
+        async with self._worker_lock:
+            if self._worker is None:
+                worker_id = f"{self.handle_id}-worker"
+                self._worker = StreamWorker(
+                    worker_id=worker_id,
+                    message_iterator=self._message_iterator,
+                    session_id=self.session_id,
+                    request_id=self.request_id,
+                    session_client=self._session_client,
+                    stream_handle=self,
+                )
+                logger.debug(
+                    "stream_handle_worker_created",
+                    handle_id=self.handle_id,
+                    worker_id=worker_id,
+                    session_id=self.session_id,
+                    category="streaming",
+                )
 
         if not self._worker:
-            raise RuntimeError("Failed to start stream worker")
+            raise RuntimeError("Failed to create stream worker")
 
-        # Create listener
+        # Pre-register listener BEFORE starting worker
+        # This fixes the race condition where fast STDIO tools could
+        # return results before the listener was ready
         queue = self._worker.get_message_queue()
         listener = await queue.create_listener()
         self._listeners[listener.listener_id] = listener
@@ -93,12 +114,16 @@ class StreamHandle:
         if self._first_listener_at is None:
             self._first_listener_at = time.time()
 
+        # NOW start the worker (after listener is registered)
+        await self._worker.start()
+
         logger.debug(
             "stream_handle_listener_created",
             handle_id=self.handle_id,
             listener_id=listener.listener_id,
             total_listeners=len(self._listeners),
             worker_status=self._worker.status.value,
+            category="streaming",
         )
 
         try:
@@ -133,31 +158,6 @@ class StreamHandle:
             # Check if we should trigger cleanup
             await self._check_cleanup()
 
-    async def _ensure_worker_started(self) -> None:
-        """Ensure the worker is started, creating it if needed."""
-        async with self._worker_lock:
-            if self._worker is None:
-                # Create worker
-                worker_id = f"{self.handle_id}-worker"
-                self._worker = StreamWorker(
-                    worker_id=worker_id,
-                    message_iterator=self._message_iterator,
-                    session_id=self.session_id,
-                    request_id=self.request_id,
-                    session_client=self._session_client,
-                    stream_handle=self,  # Pass self for message tracking
-                )
-
-                # Start worker
-                await self._worker.start()
-
-                logger.debug(
-                    "stream_handle_worker_created",
-                    handle_id=self.handle_id,
-                    worker_id=worker_id,
-                    session_id=self.session_id,
-                )
-
     async def _remove_listener(self, listener_id: str) -> None:
         """Remove a listener and clean it up.
 
@@ -177,6 +177,7 @@ class StreamHandle:
                 handle_id=self.handle_id,
                 listener_id=listener_id,
                 remaining_listeners=len(self._listeners),
+                category="streaming",
             )
 
     async def _check_cleanup(self) -> None:
@@ -220,7 +221,7 @@ class StreamHandle:
                         )
                         # Still stop the worker to ensure cleanup
                         if self._worker:
-                            logger.info(
+                            logger.trace(
                                 "stream_handle_stopping_worker_direct",
                                 handle_id=self.handle_id,
                                 message="Stopping worker directly since SDK interrupt not needed",
@@ -245,7 +246,11 @@ class StreamHandle:
                         # Schedule interrupt using a background task with timeout control
                         try:
                             # Create a background task with proper timeout and error handling
-                            asyncio.create_task(self._safe_interrupt_with_timeout())
+                            await create_managed_task(
+                                self._safe_interrupt_with_timeout(),
+                                name=f"stream_interrupt_{self.handle_id}",
+                                creator="StreamHandle",
+                            )
                             logger.debug(
                                 "stream_handle_interrupt_scheduled",
                                 handle_id=self.handle_id,
@@ -295,7 +300,7 @@ class StreamHandle:
 
             # Stop our worker after SDK interrupt to ensure it's not blocking the session
             if self._worker:
-                logger.info(
+                logger.trace(
                     "stream_handle_stopping_worker_after_interrupt",
                     handle_id=self.handle_id,
                     message="Stopping worker to free up session for reuse",
@@ -319,7 +324,7 @@ class StreamHandle:
 
             # Fallback: Stop our worker manually if SDK interrupt timed out
             if self._worker:
-                logger.info(
+                logger.trace(
                     "stream_handle_fallback_worker_stop",
                     handle_id=self.handle_id,
                     message="SDK interrupt timed out, stopping worker as fallback",
@@ -345,7 +350,7 @@ class StreamHandle:
 
             # Fallback: Stop our worker manually if SDK interrupt failed
             if self._worker:
-                logger.info(
+                logger.trace(
                     "stream_handle_fallback_worker_stop_after_error",
                     handle_id=self.handle_id,
                     message="SDK interrupt failed, stopping worker as fallback",
@@ -389,7 +394,7 @@ class StreamHandle:
                 listener.close()
             self._listeners.clear()
 
-            logger.info(
+            logger.trace(
                 "stream_handle_interrupted",
                 handle_id=self.handle_id,
             )

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

@@ -8,18 +8,19 @@ from collections.abc import AsyncIterator
 from enum import Enum
 from typing import TYPE_CHECKING, Any
 
-import structlog
+from ccproxy.core.async_task_manager import create_managed_task
+from ccproxy.core.logging import get_plugin_logger
 
-from ccproxy.claude_sdk.exceptions import StreamTimeoutError
-from ccproxy.claude_sdk.message_queue import MessageQueue
-from ccproxy.models import claude_sdk as sdk_models
+from . import models as sdk_models
+from .exceptions import StreamTimeoutError
+from .message_queue import MessageQueue
 
 
 if TYPE_CHECKING:
-    from ccproxy.claude_sdk.session_client import SessionClient
-    from ccproxy.claude_sdk.stream_handle import StreamHandle
+    from .session_client import SessionClient
+    from .stream_handle import StreamHandle
 
-logger = structlog.get_logger(__name__)
+logger = get_plugin_logger()
 
 
 class WorkerStatus(str, Enum):
@@ -35,7 +36,7 @@ class WorkerStatus(str, Enum):
 
 
 class StreamWorker:
-    """Worker that consumes messages from Claude SDK and distributes via queue."""
+    """Worker that consumes messa`es from Claude SDK and distributes via queue."""
 
     def __init__(
         self,
@@ -90,7 +91,11 @@ class StreamWorker:
         self._started_at = time.time()
 
         # Create worker task
-        self._worker_task = asyncio.create_task(self._run_worker())
+        self._worker_task = await create_managed_task(
+            self._run_worker(),
+            name=f"stream_worker_{self.worker_id}",
+            creator="StreamWorker",
+        )
 
         logger.debug(
             "stream_worker_started",
@@ -189,13 +194,13 @@ class StreamWorker:
                 self._total_messages += 1
                 self._last_message_time = time.time()
 
-                # Check if we have listeners
-                if await self._message_queue.has_listeners():
-                    # Broadcast to all listeners
-                    delivered_count = await self._message_queue.broadcast(message)
-                    self._messages_delivered += delivered_count
+                # Always broadcast - the queue handles no-listeners case atomically
+                # Previous bug: Separate has_listeners() check was racy with fast STDIO tools
+                delivered_count = await self._message_queue.broadcast(message)
 
-                    logger.debug(
+                if delivered_count > 0:
+                    self._messages_delivered += delivered_count
+                    logger.trace(
                         "stream_worker_message_delivered",
                         worker_id=self.worker_id,
                         message_type=type(message).__name__,
@@ -203,10 +208,9 @@ class StreamWorker:
                         total_messages=self._total_messages,
                     )
                 else:
-                    # No listeners - discard message
+                    # No listeners at broadcast time - message discarded
                     self._messages_discarded += 1
-
-                    logger.debug(
+                    logger.trace(
                         "stream_worker_message_discarded",
                         worker_id=self.worker_id,
                         message_type=type(message).__name__,

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

@@ -4,16 +4,17 @@ from collections.abc import AsyncIterator
 from typing import Any
 from uuid import uuid4
 
-import structlog
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.request_context import RequestContext
 
-from ccproxy.claude_sdk.converter import MessageConverter
-from ccproxy.config.claude import SDKMessageMode
-from ccproxy.models import claude_sdk as sdk_models
-from ccproxy.observability.context import RequestContext
-from ccproxy.observability.metrics import PrometheusMetrics
+# from ccproxy.observability.metrics import  # Metrics moved to plugin PrometheusMetrics
+from . import models as sdk_models
+from .config import SDKMessageMode
+from .converter import MessageConverter
+from .hooks import ClaudeSDKStreamingHook
 
 
-logger = structlog.get_logger(__name__)
+logger = get_plugin_logger()
 
 
 class ClaudeStreamProcessor:
@@ -22,16 +23,19 @@ class ClaudeStreamProcessor:
     def __init__(
         self,
         message_converter: MessageConverter,
-        metrics: PrometheusMetrics | None = None,
+        metrics: Any | None = None,  # Metrics now handled by metrics plugin
+        streaming_hook: ClaudeSDKStreamingHook | None = None,
     ) -> None:
         """Initialize the stream processor.
 
         Args:
             message_converter: Converter for message formats.
-            metrics: Prometheus metrics instance.
+            metrics: Optional metrics handler.
+            streaming_hook: Hook for emitting streaming events.
         """
         self.message_converter = message_converter
         self.metrics = metrics
+        self.streaming_hook = streaming_hook
 
     async def process_stream(
         self,
@@ -72,7 +76,7 @@ class ClaudeStreamProcessor:
             yield chunk
 
         async for message in sdk_stream:
-            logger.debug(
+            logger.trace(
                 "sdk_message_received",
                 message_type=type(message).__name__,
                 request_id=request_id,
@@ -82,7 +86,7 @@ class ClaudeStreamProcessor:
             )
 
             if isinstance(message, sdk_models.SystemMessage):
-                logger.debug(
+                logger.trace(
                     "sdk_system_message_processing",
                     mode=sdk_message_mode.value,
                     subtype=message.subtype,
@@ -109,7 +113,7 @@ class ClaudeStreamProcessor:
                 )
                 for block in message.content:
                     if isinstance(block, sdk_models.TextBlock):
-                        logger.debug(
+                        logger.trace(
                             "sdk_text_block_processing",
                             text_length=len(block.text),
                             text_preview=block.text[:50],
@@ -139,7 +143,7 @@ class ClaudeStreamProcessor:
                             mode=sdk_message_mode.value,
                             request_id=request_id,
                         )
-                        logger.info(
+                        logger.debug(
                             "sdk_tool_use_block",
                             tool_id=block.id,
                             tool_name=block.name,
@@ -176,7 +180,7 @@ class ClaudeStreamProcessor:
                             mode=sdk_message_mode.value,
                             request_id=request_id,
                         )
-                        logger.info(
+                        logger.debug(
                             "sdk_tool_result_block",
                             tool_use_id=block.tool_use_id,
                             is_error=block.is_error,
@@ -287,6 +291,32 @@ class ClaudeStreamProcessor:
                             num_turns=message.num_turns,
                         )
 
+                # Emit PROVIDER_STREAM_END hook with usage metrics
+                if self.streaming_hook and message.usage:
+                    usage_metrics = {
+                        "tokens_input": message.usage_model.input_tokens,
+                        "tokens_output": message.usage_model.output_tokens,
+                        "cache_read_tokens": message.usage_model.cache_read_input_tokens,
+                        "cache_write_tokens": message.usage_model.cache_creation_input_tokens,
+                        "cost_usd": message.total_cost_usd,
+                        "model": getattr(
+                            message, "model", "claude-3-5-sonnet-20241022"
+                        ),
+                    }
+
+                    # Emit the hook asynchronously
+                    import asyncio
+
+                    asyncio.create_task(
+                        self.streaming_hook.emit_stream_end(
+                            request_id=str(request_id or ""),
+                            usage_metrics=usage_metrics,
+                            provider="claude_sdk",
+                            url="claude-sdk://direct",
+                            method="POST",
+                        )
+                    )
+
                 end_chunks = self.message_converter.create_streaming_end_chunks(
                     stop_reason=message.stop_reason
                 )
@@ -300,7 +330,7 @@ class ClaudeStreamProcessor:
                 yield end_chunks[1][1]  # message_stop
                 break  # End of stream
             else:
-                logger.warning(  # type: ignore[unreachable]
+                logger.warning(
                     "sdk_unknown_message_type",
                     message_type=type(message).__name__,
                     message_content=str(message)[:200],
@@ -325,4 +355,8 @@ class ClaudeStreamProcessor:
         # NOTE: Access logging is now handled by StreamingResponseWithLogging
         # No need for manual access logging here anymore
 
-        logger.debug("claude_sdk_stream_processing_completed", request_id=request_id)
+        logger.info(
+            "streaming_complete",
+            plugin="claude_sdk",
+            request_id=request_id,
+        )

ccproxy/plugins/claude_sdk/tasks.py

@@ -0,0 +1,97 @@
+"""Scheduled tasks for Claude SDK plugin."""
+
+from typing import TYPE_CHECKING, Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.scheduler.tasks import BaseScheduledTask
+
+
+if TYPE_CHECKING:
+    from .detection_service import ClaudeSDKDetectionService
+
+
+logger = get_plugin_logger()
+
+
+class ClaudeSDKDetectionRefreshTask(BaseScheduledTask):
+    """Task to periodically refresh Claude CLI detection."""
+
+    def __init__(
+        self,
+        name: str,
+        interval_seconds: float,
+        detection_service: "ClaudeSDKDetectionService",
+        enabled: bool = True,
+        skip_initial_run: bool = True,
+        **kwargs: Any,
+    ):
+        """Initialize the detection refresh task.
+
+        Args:
+            name: Task name
+            interval_seconds: How often to run the task
+            detection_service: Claude CLI detection service
+            enabled: Whether the task is enabled
+            skip_initial_run: Whether to skip the first run
+            **kwargs: Additional task arguments
+        """
+        super().__init__(
+            name=name,
+            interval_seconds=interval_seconds,
+            enabled=enabled,
+            **kwargs,
+        )
+        self.detection_service = detection_service
+        self.skip_initial_run = skip_initial_run
+        self._first_run = True
+
+    async def run(self) -> bool:
+        """Execute the Claude CLI detection refresh.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if self._first_run and self.skip_initial_run:
+            self._first_run = False
+            logger.debug(
+                "claude_sdk_detection_refresh_skipped_initial",
+                task_name=self.name,
+            )
+            return True
+
+        self._first_run = False
+
+        try:
+            logger.debug(
+                "claude_sdk_detection_refresh_starting",
+                task_name=self.name,
+            )
+
+            # Refresh Claude CLI detection
+            detection_data = await self.detection_service.initialize_detection()
+
+            logger.debug(
+                "claude_sdk_detection_refresh_completed",
+                task_name=self.name,
+                version=detection_data.claude_version or "unknown",
+                cli_command=detection_data.cli_command,
+                is_available=detection_data.is_available,
+            )
+            return True
+
+        except Exception as e:
+            logger.error(
+                "claude_sdk_detection_refresh_failed",
+                task_name=self.name,
+                error=str(e),
+                exc_info=e,
+            )
+            return False
+
+    async def setup(self) -> None:
+        """Setup before task execution starts."""
+        pass
+
+    async def cleanup(self) -> None:
+        """Cleanup after task execution stops."""
+        pass

ccproxy/plugins/claude_shared/README.md

@@ -0,0 +1,18 @@
+# Claude Shared Utilities
+
+Shared metadata consumed by Claude provider plugins.
+
+## Highlights
+- Defines default `ModelCard` entries for common Claude model releases
+- Declares mapping rules that translate OpenAI-style aliases to Claude IDs
+
+## Configuration
+- No standalone plugin configuration; these helpers are imported by
+  `claude_api` and `claude_sdk` settings modules.
+
+## Usage
+- Imported during Claude plugin configuration to seed model catalogs
+- Extend by editing `DEFAULT_CLAUDE_MODEL_CARDS` or mapping rules
+
+## Related Components
+- `model_defaults.py`: source of cards and alias mapping helpers

ccproxy/plugins/claude_shared/__init__.py

@@ -0,0 +1,12 @@
+"""Shared Claude plugin defaults."""
+
+from .model_defaults import (
+    DEFAULT_CLAUDE_MODEL_CARDS,
+    DEFAULT_CLAUDE_MODEL_MAPPINGS,
+)
+
+
+__all__ = [
+    "DEFAULT_CLAUDE_MODEL_CARDS",
+    "DEFAULT_CLAUDE_MODEL_MAPPINGS",
+]