ccproxy-api 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/plugins/codex/streaming_metrics.py

@@ -0,0 +1,324 @@
+"""Codex-specific streaming metrics extraction utilities.
+
+This module provides utilities for extracting token usage from
+OpenAI/Codex streaming responses.
+"""
+
+import json
+from typing import Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.streaming import StreamingMetrics
+
+
+logger = get_plugin_logger(__name__)
+
+
+def extract_usage_from_codex_chunk(chunk_data: Any) -> dict[str, Any] | None:
+    """Extract usage information from OpenAI/Codex streaming response chunk.
+
+    OpenAI/Codex sends usage information in the final streaming chunk where
+    usage is not null. Earlier chunks have usage=null.
+
+    Args:
+        chunk_data: Streaming response chunk dictionary
+
+    Returns:
+        Dictionary with token counts or None if no usage found
+    """
+    if not isinstance(chunk_data, dict):
+        return None
+
+    # Extract model if present
+    model = chunk_data.get("model")
+
+    # Check for different Codex response formats
+    # 1. Standard OpenAI format (chat.completion.chunk)
+    object_type = chunk_data.get("object", "")
+    usage = chunk_data.get("usage")
+
+    if usage and object_type.startswith(("chat.completion", "codex.response")):
+        # Extract basic tokens
+        result = {
+            "input_tokens": usage.get("prompt_tokens") or usage.get("input_tokens", 0),
+            "output_tokens": usage.get("completion_tokens")
+            or usage.get("output_tokens", 0),
+            "total_tokens": usage.get("total_tokens"),
+            "event_type": "openai_completion",
+            "model": model,
+        }
+
+        # Extract detailed token information if available
+        if "input_tokens_details" in usage:
+            result["cache_read_tokens"] = usage["input_tokens_details"].get(
+                "cached_tokens", 0
+            )
+
+        if "output_tokens_details" in usage:
+            result["reasoning_tokens"] = usage["output_tokens_details"].get(
+                "reasoning_tokens", 0
+            )
+
+        return result
+
+    # 2. Codex CLI response format (response.completed event)
+    event_type = chunk_data.get("type", "")
+    if event_type == "response.completed" and "response" in chunk_data:
+        response_data = chunk_data["response"]
+        if isinstance(response_data, dict) and "usage" in response_data:
+            usage = response_data["usage"]
+            if usage:
+                # Codex CLI uses various formats
+                result = {
+                    "input_tokens": usage.get("input_tokens")
+                    or usage.get("prompt_tokens", 0),
+                    "output_tokens": usage.get("output_tokens")
+                    or usage.get("completion_tokens", 0),
+                    "total_tokens": usage.get("total_tokens"),
+                    "event_type": "codex_cli_response",
+                    "model": response_data.get("model") or model,
+                }
+
+                # Check for detailed tokens
+                if "input_tokens_details" in usage:
+                    result["cache_read_tokens"] = usage["input_tokens_details"].get(
+                        "cached_tokens", 0
+                    )
+
+                if "output_tokens_details" in usage:
+                    result["reasoning_tokens"] = usage["output_tokens_details"].get(
+                        "reasoning_tokens", 0
+                    )
+
+                return result
+
+    return None
+
+
+class CodexStreamingMetricsCollector:
+    """Collects and manages token metrics during Codex streaming responses.
+
+    Implements IStreamingMetricsCollector interface for Codex/OpenAI.
+    """
+
+    def __init__(
+        self,
+        request_id: str | None = None,
+        pricing_service: Any = None,
+        model: str | None = None,
+    ) -> None:
+        """Initialize the metrics collector.
+
+        Args:
+            request_id: Optional request ID for logging context
+            pricing_service: Optional pricing service for cost calculation
+            model: Optional model name for cost calculation (can also be extracted from chunks)
+        """
+        self.request_id = request_id
+        self.pricing_service = pricing_service
+        self.model = model
+        self.reasoning_tokens: int | None = None  # Store reasoning tokens separately
+        self.metrics: StreamingMetrics = {
+            "tokens_input": None,
+            "tokens_output": None,
+            "cache_read_tokens": None,  # OpenAI might support in the future
+            "cache_write_tokens": None,
+            "cost_usd": None,
+        }
+
+    def process_raw_chunk(self, chunk_str: str) -> bool:
+        """Process raw Codex format chunk before any conversion.
+
+        This handles Codex's native response.completed event format.
+        """
+        return self.process_chunk(chunk_str)
+
+    def process_converted_chunk(self, chunk_str: str) -> bool:
+        """Process chunk after conversion to OpenAI format.
+
+        When Codex responses are converted to OpenAI chat completion format,
+        this method extracts metrics from the converted OpenAI format.
+        """
+        # After conversion, we'd see standard OpenAI format
+        # For now, delegate to main process_chunk which handles both
+        return self.process_chunk(chunk_str)
+
+    def process_chunk(self, chunk_str: str) -> bool:
+        """Process a streaming chunk to extract OpenAI/Codex token metrics.
+
+        Args:
+            chunk_str: Raw chunk string from streaming response
+
+        Returns:
+            True if this was the final chunk with complete metrics, False otherwise
+        """
+        # Check if this chunk contains usage information
+        if "usage" not in chunk_str:
+            return False
+
+        logger.debug(
+            "processing_chunk",
+            chunk_preview=chunk_str[:300],
+            request_id=self.request_id,
+        )
+
+        try:
+            # Parse SSE data lines to find usage information
+            # Codex sends complete JSON on a single line after "data: "
+            for line in chunk_str.split("\n"):
+                if line.startswith("data: "):
+                    data_str = line[6:].strip()
+                    if data_str and data_str != "[DONE]":
+                        event_data = json.loads(data_str)
+
+                        # Log event type for debugging
+                        event_type = event_data.get("type", "")
+                        if event_type == "response.completed":
+                            logger.debug(
+                                "completed_event_found",
+                                has_response=("response" in event_data),
+                                has_usage=("usage" in event_data.get("response", {}))
+                                if "response" in event_data
+                                else False,
+                                request_id=self.request_id,
+                            )
+
+                        usage_data = extract_usage_from_codex_chunk(event_data)
+
+                        if usage_data:
+                            # Store token counts from the event
+                            self.metrics["tokens_input"] = usage_data.get(
+                                "input_tokens"
+                            )
+                            self.metrics["tokens_output"] = usage_data.get(
+                                "output_tokens"
+                            )
+                            self.metrics["cache_read_tokens"] = usage_data.get(
+                                "cache_read_tokens", 0
+                            )
+                            self.reasoning_tokens = usage_data.get(
+                                "reasoning_tokens", 0
+                            )
+
+                            # Extract model from the chunk if we don't have it yet
+                            if not self.model and usage_data.get("model"):
+                                self.model = usage_data.get("model")
+                                logger.debug(
+                                    "model_extracted_from_stream",
+                                    plugin="codex",
+                                    model=self.model,
+                                    request_id=self.request_id,
+                                )
+
+                            # Calculate cost synchronously when we have complete metrics
+                            if self.pricing_service:
+                                if self.model:
+                                    try:
+                                        # Import pricing exceptions
+                                        from ccproxy.plugins.pricing.exceptions import (
+                                            ModelPricingNotFoundError,
+                                            PricingDataNotLoadedError,
+                                            PricingServiceDisabledError,
+                                        )
+
+                                        cost_decimal = self.pricing_service.calculate_cost_sync(
+                                            model_name=self.model,
+                                            input_tokens=self.metrics["tokens_input"]
+                                            or 0,
+                                            output_tokens=self.metrics["tokens_output"]
+                                            or 0,
+                                            cache_read_tokens=self.metrics[
+                                                "cache_read_tokens"
+                                            ]
+                                            or 0,
+                                            cache_write_tokens=0,  # OpenAI doesn't have cache write
+                                        )
+                                        self.metrics["cost_usd"] = float(cost_decimal)
+                                        logger.debug(
+                                            "streaming_cost_calculated",
+                                            model=self.model,
+                                            cost_usd=self.metrics["cost_usd"],
+                                            tokens_input=self.metrics["tokens_input"],
+                                            tokens_output=self.metrics["tokens_output"],
+                                            request_id=self.request_id,
+                                        )
+                                    except ModelPricingNotFoundError as e:
+                                        logger.warning(
+                                            "model_pricing_not_found",
+                                            model=self.model,
+                                            message=str(e),
+                                            tokens_input=self.metrics["tokens_input"],
+                                            tokens_output=self.metrics["tokens_output"],
+                                            request_id=self.request_id,
+                                        )
+                                    except PricingDataNotLoadedError as e:
+                                        logger.warning(
+                                            "pricing_data_not_loaded",
+                                            model=self.model,
+                                            message=str(e),
+                                            request_id=self.request_id,
+                                        )
+                                    except PricingServiceDisabledError as e:
+                                        logger.debug(
+                                            "pricing_service_disabled",
+                                            message=str(e),
+                                            request_id=self.request_id,
+                                        )
+                                    except Exception as e:
+                                        logger.debug(
+                                            "streaming_cost_calculation_failed",
+                                            error=str(e),
+                                            model=self.model,
+                                            request_id=self.request_id,
+                                        )
+                                else:
+                                    logger.warning(
+                                        "streaming_cost_calculation_skipped_no_model",
+                                        plugin="codex",
+                                        request_id=self.request_id,
+                                        tokens_input=self.metrics["tokens_input"],
+                                        tokens_output=self.metrics["tokens_output"],
+                                        message="Model not found in streaming response, cannot calculate cost",
+                                    )
+
+                            logger.debug(
+                                "token_metrics_extracted",
+                                plugin="codex",
+                                tokens_input=self.metrics["tokens_input"],
+                                tokens_output=self.metrics["tokens_output"],
+                                cache_read_tokens=self.metrics["cache_read_tokens"],
+                                reasoning_tokens=self.reasoning_tokens,
+                                total_tokens=usage_data.get("total_tokens"),
+                                event_type=usage_data.get("event_type"),
+                                cost_usd=self.metrics.get("cost_usd"),
+                                request_id=self.request_id,
+                            )
+                            return True  # This is the final event with complete metrics
+
+                        break  # Only process first valid data line
+
+        except (json.JSONDecodeError, KeyError) as e:
+            logger.debug(
+                "metrics_parse_failed",
+                plugin="codex",
+                error=str(e),
+                request_id=self.request_id,
+            )
+
+        return False
+
+    def get_metrics(self) -> StreamingMetrics:
+        """Get the current collected metrics.
+
+        Returns:
+            Current token metrics
+        """
+        return self.metrics.copy()
+
+    def get_reasoning_tokens(self) -> int | None:
+        """Get reasoning tokens if available (for o1 models).
+
+        Returns:
+            Reasoning tokens count or None
+        """
+        return self.reasoning_tokens

ccproxy/plugins/codex/tasks.py

@@ -0,0 +1,106 @@
+"""Scheduled tasks for Codex 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 CodexDetectionService
+
+
+logger = get_plugin_logger()
+
+
+class CodexDetectionRefreshTask(BaseScheduledTask):
+    """Task to periodically refresh Codex CLI detection headers."""
+
+    def __init__(
+        self,
+        name: str,
+        interval_seconds: float,
+        detection_service: "CodexDetectionService",
+        enabled: bool = True,
+        skip_initial_run: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the Codex detection refresh task.
+
+        Args:
+            name: Task name
+            interval_seconds: Interval between refreshes
+            detection_service: The Codex detection service to refresh
+            enabled: Whether the task is enabled
+            skip_initial_run: Whether to skip the initial run at startup
+            **kwargs: Additional arguments for BaseScheduledTask
+        """
+        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 detection refresh.
+
+        Returns:
+            True if refresh was successful, False otherwise
+        """
+        # Skip the first run if configured to do so
+        if self._first_run and self.skip_initial_run:
+            self._first_run = False
+            logger.debug(
+                "codex_detection_refresh_skipped_initial",
+                task_name=self.name,
+                reason="Initial run skipped to avoid duplicate detection at startup",
+            )
+            return True  # Return success to avoid triggering backoff
+
+        self._first_run = False
+
+        try:
+            logger.info(
+                "codex_detection_refresh_starting",
+                task_name=self.name,
+            )
+
+            # Refresh the detection data
+            detection_data = await self.detection_service.initialize_detection()
+
+            logger.info(
+                "codex_detection_refresh_completed",
+                task_name=self.name,
+                version=detection_data.codex_version if detection_data else "unknown",
+                has_cached_data=detection_data is not None,
+            )
+
+            return True
+
+        except Exception as e:
+            logger.error(
+                "codex_detection_refresh_failed",
+                task_name=self.name,
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            return False
+
+    async def setup(self) -> None:
+        """Perform any setup required before task execution starts."""
+        logger.debug(
+            "codex_detection_refresh_setup",
+            task_name=self.name,
+            interval_seconds=self.interval_seconds,
+        )
+
+    async def cleanup(self) -> None:
+        """Perform any cleanup required after task execution stops."""
+        logger.info(
+            "codex_detection_refresh_cleanup",
+            task_name=self.name,
+        )

ccproxy/plugins/codex/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for Codex plugin."""

ccproxy/plugins/codex/utils/sse_parser.py

@@ -0,0 +1,106 @@
+"""SSE (Server-Sent Events) parser for Codex responses."""
+
+import json
+from typing import Any
+
+
+def parse_sse_line(line: str) -> tuple[str | None, Any | None]:
+    """Parse a single SSE line.
+
+    Args:
+        line: SSE line to parse
+
+    Returns:
+        Tuple of (event_type, data) or (None, None) if not parseable
+    """
+    line = line.strip()
+
+    if not line:
+        return None, None
+
+    if line.startswith("event:"):
+        return line[6:].strip(), None
+
+    if line.startswith("data:"):
+        data_str = line[5:].strip()
+
+        if data_str == "[DONE]":
+            return "done", None
+
+        try:
+            return "data", json.loads(data_str)
+        except json.JSONDecodeError:
+            return None, None
+
+    return None, None
+
+
+def extract_final_response(sse_content: str) -> dict[str, Any] | None:
+    """Extract the final response from SSE content.
+
+    Looks for the response.completed event in SSE stream.
+
+    Args:
+        sse_content: Complete SSE response content
+
+    Returns:
+        Final response data or None if not found
+    """
+    lines = sse_content.strip().split("\n")
+    final_response = None
+
+    for line in lines:
+        event_type, data = parse_sse_line(line)
+
+        if event_type == "data" and data and isinstance(data, dict):
+            # Check for response.completed event
+            if data.get("type") == "response.completed":
+                # Found the completed response
+                if "response" in data:
+                    final_response = data["response"]
+                else:
+                    final_response = data
+            elif data.get("type") == "response.in_progress" and "response" in data:
+                # Update with in-progress data, but keep looking
+                final_response = data["response"]
+
+    return final_response
+
+
+def parse_sse_stream(chunks: list[bytes]) -> dict[str, Any] | None:
+    """Parse SSE stream chunks to extract final response.
+
+    Args:
+        chunks: List of byte chunks from SSE stream
+
+    Returns:
+        Final response data or None if not found
+    """
+    # Combine all chunks
+    full_content = b"".join(chunks).decode("utf-8", errors="replace")
+    return extract_final_response(full_content)
+
+
+def is_sse_response(content: bytes | str) -> bool:
+    """Check if content appears to be SSE format.
+
+    Args:
+        content: Response content to check
+
+    Returns:
+        True if content appears to be SSE format
+    """
+    if isinstance(content, bytes):
+        try:
+            content = content.decode("utf-8", errors="replace")
+        except Exception:
+            return False
+
+    # Check for SSE markers
+    content_start = content[:100].strip()
+    return (
+        content_start.startswith("event:")
+        or content_start.startswith("data:")
+        or "\nevent:" in content_start
+        or "\ndata:" in content_start
+    )

ccproxy/plugins/command_replay/README.md

@@ -0,0 +1,34 @@
+# Command Replay Plugin
+
+Generates reproducible `curl` and `xh` commands for captured provider requests.
+
+## Highlights
+- Subscribes to provider hook events to snapshot raw HTTP payloads
+- Emits commands to stdout or disk with configurable file layout
+- Supports URL include/exclude filters and provider-only logging
+
+## Configuration
+- `CommandReplayConfig` toggles command types, log directory, and filters
+- Enable via `plugins.command_replay` settings or matching environment vars
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin command_replay --config-class CommandReplayConfig`
+
+```toml
+[plugins.command_replay]
+# enabled = true
+# generate_curl = true
+# generate_xh = true
+# log_dir = "/tmp/ccproxy/command_replay"
+# write_to_files = true
+# separate_files_per_command = true
+# include_url_patterns = ["api.anthropic.com", "api.openai.com", "claude.ai", "chatgpt.com"]
+# exclude_url_patterns = []
+# log_to_console = false
+# log_level = "TRACE"
+# only_provider_requests = false
+```
+
+## Related Components
+- `hook.py`: assembles commands from hook payloads
+- `formatter.py`: file naming and formatting helpers
+- `plugin.py`: runtime wiring and hook registration

ccproxy/plugins/command_replay/__init__.py

@@ -0,0 +1,17 @@
+"""Command Replay Plugin - Generate curl and xh commands for provider requests."""
+
+from .config import CommandReplayConfig
+from .hook import CommandReplayHook
+from .plugin import CommandReplayFactory, CommandReplayRuntime
+
+
+# Export the factory for auto-discovery
+factory = CommandReplayFactory()
+
+__all__ = [
+    "CommandReplayConfig",
+    "CommandReplayHook",
+    "CommandReplayRuntime",
+    "CommandReplayFactory",
+    "factory",
+]