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

ccproxy/plugins/claude_api/hooks.py

@@ -0,0 +1,284 @@
+"""Claude API 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_streaming_chunk
+
+
+logger = get_plugin_logger()
+
+
+class ClaudeAPIStreamingMetricsHook(Hook):
+    """Hook to extract and accumulate metrics from Claude API streaming responses."""
+
+    name = "claude_api_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="claude_api",
+                    )
+            except Exception as e:
+                logger.debug(
+                    "lazy_pricing_service_failed",
+                    plugin="claude_api",
+                    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 claude_api provider events
+        if context.provider != "claude_api":
+            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
+
+        # Debug: Log chunk type and sample
+        logger.debug(
+            "chunk_received",
+            plugin="claude_api",
+            request_id=request_id,
+            chunk_type=type(chunk_data).__name__,
+            chunk_sample=str(chunk_data)[:200] if chunk_data else None,
+        )
+
+        # 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,
+                "cache_write_tokens": None,
+                "cost_usd": None,
+                "model": None,
+            }
+
+        try:
+            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="claude_api",
+                        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.debug(
+                "chunk_metrics_parse_failed",
+                plugin="claude_api",
+                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_streaming_chunk(event_data)
+
+        if not usage_data:
+            return
+
+        cache = self._metrics_cache[request_id]
+        event_type = usage_data.get("event_type")
+
+        # Handle message_start: get input tokens and initial cache tokens
+        if event_type == "message_start":
+            cache["tokens_input"] = usage_data.get("input_tokens")
+            cache["cache_read_tokens"] = (
+                usage_data.get("cache_read_input_tokens") or cache["cache_read_tokens"]
+            )
+            cache["cache_write_tokens"] = (
+                usage_data.get("cache_creation_input_tokens")
+                or cache["cache_write_tokens"]
+            )
+
+            # Extract model from the message_start event
+            if not cache["model"] and usage_data.get("model"):
+                cache["model"] = usage_data.get("model")
+
+            logger.debug(
+                "hook_metrics_extracted",
+                plugin="claude_api",
+                event_type="message_start",
+                tokens_input=cache["tokens_input"],
+                cache_read_tokens=cache["cache_read_tokens"],
+                cache_write_tokens=cache["cache_write_tokens"],
+                model=cache["model"],
+                request_id=request_id,
+            )
+
+        # Handle message_delta: get final output tokens
+        elif event_type == "message_delta":
+            cache["tokens_output"] = usage_data.get("output_tokens")
+
+            # Calculate cost if we have all required data
+            pricing_service = self._get_pricing_service()
+            logger.debug(
+                "hook_calculating_cost",
+                plugin="claude_api",
+                request_id=request_id,
+                pricing_service=bool(pricing_service is not None),
+                model=cache["model"],
+            )
+            if pricing_service and cache["model"]:
+                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=cache["cache_write_tokens"] or 0,
+                    )
+                    cache["cost_usd"] = float(cost_decimal)
+
+                    logger.debug(
+                        "hook_cost_calculated",
+                        plugin="claude_api",
+                        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="claude_api",
+                        reason=str(e),
+                        request_id=request_id,
+                    )
+                except Exception as e:
+                    logger.debug(
+                        "hook_cost_calculation_failed",
+                        plugin="claude_api",
+                        error=str(e),
+                        request_id=request_id,
+                    )
+
+            logger.debug(
+                "hook_metrics_extracted",
+                plugin="claude_api",
+                event_type="message_delta",
+                tokens_output=cache["tokens_output"],
+                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."""
+        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="claude_api",
+                    request_id=request_id,
+                    error=str(error),
+                    event_preview=raw_event[:200],
+                )
+
+        if request_id not in self._metrics_cache:
+            return
+
+        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
+        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["cache_write_tokens"] is not None:
+            context.data["usage_metrics"]["cache_creation_input_tokens"] = metrics[
+                "cache_write_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="claude_api",
+            request_id=request_id,
+            usage_metrics=context.data.get("usage_metrics", {}),
+            context_data_keys=list(context.data.keys()) if context.data else [],
+        )

ccproxy/plugins/claude_api/models.py

@@ -0,0 +1,256 @@
+"""Claude API plugin local CLI health models and detection models."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Annotated, Any, TypedDict
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_serializer,
+    field_validator,
+    model_validator,
+)
+
+from ccproxy.models.detection import DetectedHeaders, DetectedPrompts
+
+
+class ClaudeCliStatus(str, Enum):
+    AVAILABLE = "available"
+    NOT_INSTALLED = "not_installed"
+    BINARY_FOUND_BUT_ERRORS = "binary_found_but_errors"
+    TIMEOUT = "timeout"
+    ERROR = "error"
+
+
+class ClaudeCliInfo(BaseModel):
+    status: ClaudeCliStatus
+    version: str | None = None
+    binary_path: str | None = None
+    version_output: str | None = None
+    error: str | None = None
+    return_code: str | None = None
+
+
+class ClaudeAgentHeaders(BaseModel):
+    """Pydantic model for Claude CLI headers extraction with field aliases."""
+
+    anthropic_beta: str = Field(
+        alias="anthropic-beta",
+        description="Anthropic beta features",
+        default="claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
+    )
+    anthropic_version: str = Field(
+        alias="anthropic-version",
+        description="Anthropic API version",
+        default="2023-06-01",
+    )
+    anthropic_dangerous_direct_browser_access: str = Field(
+        alias="anthropic-dangerous-direct-browser-access",
+        description="Browser access flag",
+        default="true",
+    )
+    x_app: str = Field(
+        alias="x-app", description="Application identifier", default="cli"
+    )
+    user_agent: str = Field(
+        alias="user-agent",
+        description="User agent string",
+        default="claude-cli/1.0.60 (external, cli)",
+    )
+    x_stainless_lang: str = Field(
+        alias="x-stainless-lang", description="SDK language", default="js"
+    )
+    x_stainless_retry_count: str = Field(
+        alias="x-stainless-retry-count", description="Retry count", default="0"
+    )
+    x_stainless_timeout: str = Field(
+        alias="x-stainless-timeout", description="Request timeout", default="60"
+    )
+    x_stainless_package_version: str = Field(
+        alias="x-stainless-package-version",
+        description="Package version",
+        default="0.55.1",
+    )
+    x_stainless_os: str = Field(
+        alias="x-stainless-os", description="Operating system", default="Linux"
+    )
+    x_stainless_arch: str = Field(
+        alias="x-stainless-arch", description="Architecture", default="x64"
+    )
+    x_stainless_runtime: str = Field(
+        alias="x-stainless-runtime", description="Runtime", default="node"
+    )
+    x_stainless_runtime_version: str = Field(
+        alias="x-stainless-runtime-version",
+        description="Runtime version",
+        default="v24.3.0",
+    )
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    def to_headers_dict(self) -> dict[str, str]:
+        """Convert to headers dictionary for HTTP forwarding with proper case."""
+        headers = {}
+
+        # Map field names to proper HTTP header names
+        header_mapping = {
+            "anthropic_beta": "anthropic-beta",
+            "anthropic_version": "anthropic-version",
+            "anthropic_dangerous_direct_browser_access": "anthropic-dangerous-direct-browser-access",
+            "x_app": "x-app",
+            "user_agent": "User-Agent",
+            "x_stainless_lang": "X-Stainless-Lang",
+            "x_stainless_retry_count": "X-Stainless-Retry-Count",
+            "x_stainless_timeout": "X-Stainless-Timeout",
+            "x_stainless_package_version": "X-Stainless-Package-Version",
+            "x_stainless_os": "X-Stainless-OS",
+            "x_stainless_arch": "X-Stainless-Arch",
+            "x_stainless_runtime": "X-Stainless-Runtime",
+            "x_stainless_runtime_version": "X-Stainless-Runtime-Version",
+        }
+
+        for field_name, header_name in header_mapping.items():
+            value = getattr(self, field_name, None)
+            if value is not None:
+                headers[header_name] = value
+
+        return headers
+
+
+class SystemPromptData(BaseModel):
+    """Extracted system prompt information."""
+
+    system_field: Annotated[
+        str | list[dict[str, Any]],
+        Field(
+            description="Complete system field as detected from Claude CLI, preserving exact structure including type, text, and cache_control"
+        ),
+    ]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ClaudeCacheData(BaseModel):
+    """Cached Claude CLI detection data with version tracking."""
+
+    claude_version: Annotated[str, Field(description="Claude CLI version")]
+    headers: Annotated[
+        DetectedHeaders,
+        Field(
+            description="Captured headers (lowercase keys) in insertion order",
+            default_factory=DetectedHeaders,
+        ),
+    ]
+    prompts: Annotated[
+        DetectedPrompts,
+        Field(description="Captured prompt metadata", default_factory=DetectedPrompts),
+    ]
+    body_json: Annotated[
+        dict[str, Any] | None,
+        Field(
+            description="Legacy captured request body (deprecated)",
+            default=None,
+            exclude=True,
+        ),
+    ] = None
+    method: Annotated[
+        str | None, Field(description="Captured HTTP method", default=None)
+    ] = None
+    url: Annotated[str | None, Field(description="Captured full URL", default=None)] = (
+        None
+    )
+    path: Annotated[
+        str | None, Field(description="Captured request path", default=None)
+    ] = None
+    query_params: Annotated[
+        dict[str, str] | None,
+        Field(description="Captured query parameters", default=None),
+    ] = None
+    cached_at: datetime = Field(
+        description="Cache timestamp",
+        default_factory=lambda: datetime.now(UTC),
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="before")
+    @classmethod
+    def _coerce_legacy_format(cls, values: dict[str, Any]) -> dict[str, Any]:
+        if not isinstance(values, dict):
+            return values
+
+        if "prompts" not in values:
+            legacy_body = values.get("body_json")
+            if legacy_body is not None:
+                values["prompts"] = DetectedPrompts.from_body(legacy_body)
+                cls._log_legacy_usage("body_json")
+
+        return values
+
+    @field_validator("headers", mode="before")
+    @classmethod
+    def _validate_headers(cls, value: Any) -> DetectedHeaders:
+        if isinstance(value, DetectedHeaders):
+            return value
+        if isinstance(value, dict):
+            return DetectedHeaders(value)
+        if value is None:
+            cls._log_legacy_usage("missing_headers")
+            return DetectedHeaders()
+        raise TypeError("headers must be a mapping of strings")
+
+    @field_validator("prompts", mode="before")
+    @classmethod
+    def _validate_prompts(cls, value: Any) -> DetectedPrompts:
+        if isinstance(value, DetectedPrompts):
+            return value
+        if isinstance(value, dict):
+            return DetectedPrompts.from_body(value)
+        if value is None:
+            return DetectedPrompts()
+        raise TypeError("prompts must be derived from a mapping")
+
+    @field_serializer("headers")
+    def _serialize_headers(self, headers: DetectedHeaders) -> dict[str, str]:
+        return headers.as_dict()
+
+    @field_serializer("prompts")
+    def _serialize_prompts(self, prompts: DetectedPrompts) -> dict[str, Any]:
+        raw = prompts.raw or {}
+        if not isinstance(raw, dict):
+            raw = {}
+        if prompts.instructions and "instructions" not in raw:
+            raw = dict(raw)
+            raw["instructions"] = prompts.instructions
+        if prompts.system is not None and "system" not in raw:
+            raw = dict(raw)
+            raw["system"] = prompts.system
+        return raw
+
+    @staticmethod
+    def _log_legacy_usage(reason: str) -> None:
+        try:
+            from ccproxy.core.logging import get_plugin_logger
+
+            logger = get_plugin_logger()
+            logger.debug(
+                "legacy_detection_cache_format",
+                plugin="claude_api",
+                reason=reason,
+            )
+        except Exception:  # pragma: no cover - logging best-effort only
+            pass
+
+
+class ClaudeAPIAuthData(TypedDict, total=False):
+    """Authentication data for Claude API provider.
+
+    Attributes:
+        access_token: Bearer token for Anthropic Claude API authentication
+    """
+
+    access_token: str | None