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

ccproxy/plugins/codex/health.py

@@ -0,0 +1,162 @@
+"""Codex health check implementation."""
+
+from typing import Any, Literal
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins.protocol import HealthCheckResult
+
+from .config import CodexSettings
+from .detection_service import CodexDetectionService
+
+
+logger = get_plugin_logger()
+
+
+async def codex_health_check(
+    config: CodexSettings | None,
+    detection_service: CodexDetectionService | None = None,
+    auth_manager: Any | None = None,
+    *,
+    version: str,
+) -> HealthCheckResult:
+    """Perform health check for Codex plugin."""
+    try:
+        if not config:
+            return HealthCheckResult(
+                status="fail",
+                componentId="plugin-codex",
+                output="Codex plugin configuration not available",
+                version=version,
+            )
+
+        # Check basic configuration validity
+        if not config.base_url:
+            return HealthCheckResult(
+                status="fail",
+                componentId="plugin-codex",
+                output="Codex base URL not configured",
+                version=version,
+            )
+
+        # Check OAuth configuration
+        if not config.oauth.base_url or not config.oauth.client_id:
+            return HealthCheckResult(
+                status="warn",
+                componentId="plugin-codex",
+                output="Codex OAuth configuration incomplete",
+                version=version,
+            )
+
+        # Standardized details models
+        from ccproxy.core.plugins.models import (
+            AuthHealth,
+            CLIHealth,
+            ConfigHealth,
+            ProviderHealthDetails,
+        )
+
+        cli_info = (
+            detection_service.get_cli_health_info() if detection_service else None
+        )
+        status_val = (
+            cli_info.status.value
+            if (cli_info and hasattr(cli_info, "status"))
+            else "unknown"
+        )
+        available = bool(status_val == "available")
+        cli_health = (
+            CLIHealth(
+                available=available,
+                status=status_val,
+                version=(cli_info.version if cli_info else None),
+                path=(cli_info.binary_path if cli_info else None),
+            )
+            if cli_info
+            else None
+        )
+
+        # Get authentication status if auth manager is available
+        auth_details: dict[str, Any] = {}
+        if auth_manager:
+            try:
+                # Use the new helper method to get auth status
+                auth_details = await auth_manager.get_auth_status()
+            except Exception as e:
+                logger.debug(
+                    "Failed to check auth status", error=str(e), category="auth"
+                )
+                auth_details = {
+                    "authenticated": False,
+                    "reason": str(e),
+                }
+
+        # Determine overall status
+        status: Literal["pass", "warn", "fail"]
+        provider_auth = (
+            AuthHealth(
+                configured=bool(auth_manager),
+                token_available=auth_details.get("authenticated"),
+                token_expired=(
+                    not auth_details.get("authenticated")
+                    and auth_details.get("reason") == "Token expired"
+                ),
+                account_id=auth_details.get("account_id"),
+                expires_at=auth_details.get("expires_at"),
+                error=(
+                    None
+                    if auth_details.get("authenticated")
+                    else auth_details.get("reason")
+                ),
+            )
+            if auth_manager
+            else AuthHealth(configured=False)
+        )
+
+        if (cli_health and cli_health.available) and provider_auth.token_available:
+            output = f"Codex plugin is healthy (CLI v{cli_health.version} available, authenticated)"
+            status = "pass"
+        elif cli_health and cli_health.available:
+            output = f"Codex plugin is functional (CLI v{cli_health.version} available, auth missing)"
+            status = "warn"
+        elif provider_auth.token_available:
+            output = "Codex plugin is functional (authenticated, CLI not found)"
+            status = "warn"
+        else:
+            output = "Codex plugin is functional but CLI and auth missing"
+            status = "warn"
+
+        # Basic health check passes
+        return HealthCheckResult(
+            status=status,
+            componentId="plugin-codex",
+            output=output,
+            version=version,
+            details={
+                **ProviderHealthDetails(
+                    provider="codex",
+                    enabled=True,
+                    base_url=config.base_url,
+                    cli=cli_health,
+                    auth=provider_auth,
+                    config=ConfigHealth(
+                        model_count=None,
+                        supports_openai_format=None,
+                        verbose_logging=config.verbose_logging,
+                        extra={
+                            "oauth_configured": bool(
+                                config.oauth.base_url and config.oauth.client_id
+                            )
+                        },
+                    ),
+                ).model_dump(),
+            },
+        )
+
+    except Exception as e:
+        logger.error("health_check_failed", error=str(e))
+        return HealthCheckResult(
+            status="fail",
+            componentId="plugin-codex",
+            output=f"Codex health check failed: {str(e)}",
+            version=version,
+        )

ccproxy/plugins/codex/hooks.py

@@ -0,0 +1,263 @@
+"""Codex plugin hooks for streaming metrics extraction."""
+
+import json
+from typing import Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins.hooks import Hook, HookContext, HookEvent
+from ccproxy.streaming.sse_parser import SSEStreamParser
+
+from .streaming_metrics import extract_usage_from_codex_chunk
+
+
+logger = get_plugin_logger()
+
+
+class CodexStreamingMetricsHook(Hook):
+    """Hook to extract and accumulate metrics from Codex streaming responses."""
+
+    name = "codex_streaming_metrics"
+    events = [HookEvent.PROVIDER_STREAM_CHUNK, HookEvent.PROVIDER_STREAM_END]
+    priority = 700  # HookLayer.OBSERVATION - Metrics collection layer
+
+    def __init__(
+        self, pricing_service: Any = None, plugin_registry: Any = None
+    ) -> None:
+        """Initialize with optional pricing service for cost calculation.
+
+        Args:
+            pricing_service: Direct pricing service instance (if available at init)
+            plugin_registry: Plugin registry to get pricing service lazily
+        """
+        self.pricing_service = pricing_service
+        self.plugin_registry = plugin_registry
+        # Store metrics per request_id
+        self._metrics_cache: dict[str, dict[str, Any]] = {}
+        # Incremental SSE parsers keyed by request
+        self._sse_parsers: dict[str, SSEStreamParser] = {}
+
+    def _get_pricing_service(self) -> Any:
+        """Get pricing service, trying lazy loading if not already available."""
+        if self.pricing_service:
+            return self.pricing_service
+
+        if self.plugin_registry:
+            try:
+                from ccproxy.plugins.pricing.service import PricingService
+
+                self.pricing_service = self.plugin_registry.get_service(
+                    "pricing", PricingService
+                )
+                if self.pricing_service:
+                    logger.debug(
+                        "pricing_service_obtained_lazily",
+                        plugin="codex",
+                    )
+            except Exception as e:
+                logger.debug(
+                    "lazy_pricing_service_failed",
+                    plugin="codex",
+                    error=str(e),
+                )
+
+        return self.pricing_service
+
+    async def __call__(self, context: HookContext) -> None:
+        """Extract metrics from streaming chunks and add to stream end events."""
+        # Only process codex provider events
+        if context.provider != "codex":
+            return
+
+        request_id = context.metadata.get("request_id")
+        if not request_id:
+            return
+
+        if context.event == HookEvent.PROVIDER_STREAM_CHUNK:
+            await self._process_chunk(context, request_id)
+        elif context.event == HookEvent.PROVIDER_STREAM_END:
+            await self._finalize_metrics(context, request_id)
+
+    async def _process_chunk(self, context: HookContext, request_id: str) -> None:
+        """Process a streaming chunk to extract metrics."""
+        chunk_data = context.data.get("chunk")
+        if not chunk_data:
+            return
+
+        # Initialize metrics cache for this request if needed
+        if request_id not in self._metrics_cache:
+            self._metrics_cache[request_id] = {
+                "tokens_input": None,
+                "tokens_output": None,
+                "cache_read_tokens": None,
+                "reasoning_tokens": None,
+                "cost_usd": None,
+                "model": None,
+            }
+
+        try:
+            # Parse SSE data if it's a string or bytes
+            if isinstance(chunk_data, str | bytes):
+                parser = self._sse_parsers.setdefault(request_id, SSEStreamParser())
+                for payload in parser.feed(chunk_data):
+                    if isinstance(payload, dict):
+                        self._extract_and_accumulate(payload, request_id)
+                for raw_event, error in parser.consume_errors():
+                    logger.debug(
+                        "chunk_metrics_sse_event_skipped",
+                        plugin="codex",
+                        request_id=request_id,
+                        error=str(error),
+                        event_preview=raw_event[:200],
+                    )
+            elif isinstance(chunk_data, dict):
+                # Direct dict chunk
+                self._extract_and_accumulate(chunk_data, request_id)
+
+        except (json.JSONDecodeError, KeyError) as e:
+            logger.error(
+                "chunk_metrics_parse_failed",
+                plugin="codex",
+                error=str(e),
+                request_id=request_id,
+            )
+
+    def _extract_and_accumulate(
+        self, event_data: dict[str, Any], request_id: str
+    ) -> None:
+        """Extract metrics from parsed event data and accumulate."""
+        usage_data = extract_usage_from_codex_chunk(event_data)
+
+        if not usage_data:
+            return
+
+        cache = self._metrics_cache[request_id]
+        event_type = usage_data.get("event_type")
+
+        # Update metrics from usage data
+        if usage_data.get("input_tokens") is not None:
+            cache["tokens_input"] = usage_data.get("input_tokens")
+
+        if usage_data.get("output_tokens") is not None:
+            cache["tokens_output"] = usage_data.get("output_tokens")
+
+        if usage_data.get("cache_read_tokens") is not None:
+            cache["cache_read_tokens"] = usage_data.get("cache_read_tokens")
+
+        if usage_data.get("reasoning_tokens") is not None:
+            cache["reasoning_tokens"] = usage_data.get("reasoning_tokens")
+
+        # Extract model from the event
+        if not cache["model"] and usage_data.get("model"):
+            cache["model"] = usage_data.get("model")
+
+        # Calculate cost if we have all required data
+        pricing_service = self._get_pricing_service()
+        if (
+            pricing_service
+            and cache["model"]
+            and cache["tokens_input"] is not None
+            and cache["tokens_output"] is not None
+        ):
+            try:
+                from ccproxy.plugins.pricing.exceptions import (
+                    ModelPricingNotFoundError,
+                    PricingDataNotLoadedError,
+                    PricingServiceDisabledError,
+                )
+
+                cost_decimal = pricing_service.calculate_cost_sync(
+                    model_name=cache["model"],
+                    input_tokens=cache["tokens_input"] or 0,
+                    output_tokens=cache["tokens_output"] or 0,
+                    cache_read_tokens=cache["cache_read_tokens"] or 0,
+                    cache_write_tokens=0,  # OpenAI/Codex doesn't have cache write
+                )
+                cache["cost_usd"] = float(cost_decimal)
+
+                logger.debug(
+                    "hook_cost_calculated",
+                    plugin="codex",
+                    model=cache["model"],
+                    cost_usd=cache["cost_usd"],
+                    request_id=request_id,
+                )
+            except (
+                ModelPricingNotFoundError,
+                PricingDataNotLoadedError,
+                PricingServiceDisabledError,
+            ) as e:
+                logger.debug(
+                    "hook_cost_calculation_skipped",
+                    plugin="codex",
+                    reason=str(e),
+                    request_id=request_id,
+                )
+            except Exception as e:
+                logger.debug(
+                    "hook_cost_calculation_failed",
+                    plugin="codex",
+                    error=str(e),
+                    request_id=request_id,
+                )
+
+        logger.debug(
+            "hook_metrics_extracted",
+            plugin="codex",
+            event_type=event_type,
+            tokens_input=cache["tokens_input"],
+            tokens_output=cache["tokens_output"],
+            cache_read_tokens=cache.get("cache_read_tokens"),
+            reasoning_tokens=cache.get("reasoning_tokens"),
+            cost_usd=cache.get("cost_usd"),
+            request_id=request_id,
+        )
+
+    async def _finalize_metrics(self, context: HookContext, request_id: str) -> None:
+        """Add accumulated metrics to the PROVIDER_STREAM_END event."""
+        if request_id not in self._metrics_cache:
+            return
+
+        parser = self._sse_parsers.pop(request_id, None)
+        if parser:
+            for payload in parser.flush():
+                if isinstance(payload, dict):
+                    self._extract_and_accumulate(payload, request_id)
+            for raw_event, error in parser.consume_errors():
+                logger.debug(
+                    "chunk_metrics_sse_event_skipped",
+                    plugin="codex",
+                    request_id=request_id,
+                    error=str(error),
+                    event_preview=raw_event[:200],
+                )
+
+        metrics = self._metrics_cache.pop(request_id, {})
+
+        # Add metrics to the event's usage_metrics field
+        if not context.data.get("usage_metrics"):
+            context.data["usage_metrics"] = {}
+
+        # Update with our collected metrics (use standard naming)
+        if metrics["tokens_input"] is not None:
+            context.data["usage_metrics"]["input_tokens"] = metrics["tokens_input"]
+        if metrics["tokens_output"] is not None:
+            context.data["usage_metrics"]["output_tokens"] = metrics["tokens_output"]
+        if metrics["cache_read_tokens"] is not None:
+            context.data["usage_metrics"]["cache_read_input_tokens"] = metrics[
+                "cache_read_tokens"
+            ]
+        if metrics["reasoning_tokens"] is not None:
+            context.data["usage_metrics"]["reasoning_tokens"] = metrics[
+                "reasoning_tokens"
+            ]
+        if metrics["cost_usd"] is not None:
+            context.data["usage_metrics"]["cost_usd"] = metrics["cost_usd"]
+        if metrics["model"]:
+            context.data["model"] = metrics["model"]
+
+        logger.info(
+            "streaming_metrics_finalized",
+            plugin="codex",
+            request_id=request_id,
+            usage_metrics=context.data.get("usage_metrics", {}),
+        )

ccproxy/plugins/codex/model_defaults.py

@@ -0,0 +1,39 @@
+"""Default model metadata and mapping rules for the Codex provider."""
+
+from __future__ import annotations
+
+from ccproxy.models.provider import ModelCard, ModelMappingRule
+
+
+DEFAULT_CODEX_MODEL_CARDS: list[ModelCard] = [
+    ModelCard(
+        id="gpt-5",
+        created=1723075200,
+        owned_by="openai",
+        permission=[],
+        root="gpt-5",
+        parent=None,
+    ),
+    ModelCard(
+        id="gpt-5-codex",
+        created=1726444800,
+        owned_by="openai",
+        permission=[],
+        root="gpt-5-codex",
+        parent=None,
+    ),
+]
+
+
+DEFAULT_CODEX_MODEL_MAPPINGS: list[ModelMappingRule] = [
+    ModelMappingRule(match="gpt-", target="gpt-5", kind="prefix"),
+    ModelMappingRule(match="o3-", target="gpt-5", kind="prefix"),
+    ModelMappingRule(match="o1-", target="gpt-5", kind="prefix"),
+    ModelMappingRule(match="claude-", target="gpt-5", kind="prefix"),
+]
+
+
+__all__ = [
+    "DEFAULT_CODEX_MODEL_CARDS",
+    "DEFAULT_CODEX_MODEL_MAPPINGS",
+]