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

ccproxy/observability/storage/models.py

@@ -1,70 +0,0 @@
-"""
-SQLModel schema definitions for observability storage.
-
-This module provides the centralized schema definitions for access logs and metrics
-using SQLModel to ensure type safety and eliminate column name repetition.
-"""
-
-from datetime import datetime
-
-from sqlmodel import Field, SQLModel
-
-
-class AccessLog(SQLModel, table=True):
-    """Access log model for storing request/response data."""
-
-    __tablename__ = "access_logs"
-
-    # Core request identification
-    request_id: str = Field(primary_key=True)
-    timestamp: datetime = Field(default_factory=datetime.now, index=True)
-
-    # Request details
-    method: str
-    endpoint: str
-    path: str
-    query: str = Field(default="")
-    client_ip: str
-    user_agent: str
-
-    # Service and model info
-    service_type: str
-    model: str
-    streaming: bool = Field(default=False)
-
-    # Response details
-    status_code: int
-    duration_ms: float
-    duration_seconds: float
-
-    # Token and cost tracking
-    tokens_input: int = Field(default=0)
-    tokens_output: int = Field(default=0)
-    cache_read_tokens: int = Field(default=0)
-    cache_write_tokens: int = Field(default=0)
-    cost_usd: float = Field(default=0.0)
-    cost_sdk_usd: float = Field(default=0.0)
-    num_turns: int = Field(default=0)  # number of conversation turns
-
-    # Session context metadata
-    session_type: str = Field(default="")  # "session_pool" or "direct"
-    session_status: str = Field(default="")  # active, idle, connecting, etc.
-    session_age_seconds: float = Field(default=0.0)  # how long session has been alive
-    session_message_count: int = Field(default=0)  # number of messages in session
-    session_client_id: str = Field(default="")  # unique session client identifier
-    session_pool_enabled: bool = Field(
-        default=False
-    )  # whether session pooling is enabled
-    session_idle_seconds: float = Field(default=0.0)  # how long since last activity
-    session_error_count: int = Field(default=0)  # number of errors in this session
-    session_is_new: bool = Field(
-        default=True
-    )  # whether this is a newly created session
-
-    class Config:
-        """SQLModel configuration."""
-
-        # Enable automatic conversion from dict
-        from_attributes = True
-        # Use enum values
-        use_enum_values = True

ccproxy/observability/streaming_response.py

@@ -1,107 +0,0 @@
-"""FastAPI StreamingResponse with automatic access logging on completion.
-
-This module provides a reusable StreamingResponseWithLogging class that wraps
-any async generator and handles access logging when the stream completes,
-eliminating code duplication between different streaming endpoints.
-"""
-
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator, AsyncIterator
-from typing import TYPE_CHECKING, Any
-
-import structlog
-from fastapi.responses import StreamingResponse
-
-from ccproxy.observability.access_logger import log_request_access
-
-
-if TYPE_CHECKING:
-    from ccproxy.observability.context import RequestContext
-    from ccproxy.observability.metrics import PrometheusMetrics
-
-logger = structlog.get_logger(__name__)
-
-
-class StreamingResponseWithLogging(StreamingResponse):
-    """FastAPI StreamingResponse that triggers access logging on completion.
-
-    This class wraps a streaming response generator to automatically trigger
-    access logging when the stream completes (either successfully or with an error).
-    This eliminates the need for manual access logging in individual stream processors.
-    """
-
-    def __init__(
-        self,
-        content: AsyncGenerator[bytes, None] | AsyncIterator[bytes],
-        request_context: RequestContext,
-        metrics: PrometheusMetrics | None = None,
-        status_code: int = 200,
-        **kwargs: Any,
-    ) -> None:
-        """Initialize streaming response with logging capability.
-
-        Args:
-            content: The async generator producing streaming content
-            request_context: The request context for access logging
-            metrics: Optional PrometheusMetrics instance for recording metrics
-            status_code: HTTP status code for the response
-            **kwargs: Additional arguments passed to StreamingResponse
-        """
-        # Wrap the content generator to add logging
-        logged_content = self._wrap_with_logging(
-            content, request_context, metrics, status_code
-        )
-        super().__init__(logged_content, status_code=status_code, **kwargs)
-
-    async def _wrap_with_logging(
-        self,
-        content: AsyncGenerator[bytes, None] | AsyncIterator[bytes],
-        context: RequestContext,
-        metrics: PrometheusMetrics | None,
-        status_code: int,
-    ) -> AsyncGenerator[bytes, None]:
-        """Wrap content generator with access logging on completion.
-
-        Args:
-            content: The original content generator
-            context: Request context for logging
-            metrics: Optional metrics instance
-            status_code: HTTP status code
-
-        Yields:
-            bytes: Content chunks from the original generator
-        """
-        try:
-            # Stream all content from the original generator
-            async for chunk in content:
-                yield chunk
-        except GeneratorExit:
-            # Client disconnected - log this and re-raise to propagate to underlying generators
-            logger.info(
-                "streaming_response_client_disconnected",
-                request_id=context.request_id,
-                message="Client disconnected from streaming response, propagating GeneratorExit",
-            )
-            # CRITICAL: Re-raise GeneratorExit to propagate disconnect to create_listener()
-            raise
-        finally:
-            # Log access when stream completes (success or error)
-            try:
-                # Add streaming completion event type to context
-                context.add_metadata(event_type="streaming_complete")
-
-                # Check if status_code was updated in context metadata (e.g., due to error)
-                final_status_code = context.metadata.get("status_code", status_code)
-
-                await log_request_access(
-                    context=context,
-                    status_code=final_status_code,
-                    metrics=metrics,
-                )
-            except Exception as e:
-                logger.warning(
-                    "streaming_access_log_failed",
-                    error=str(e),
-                    request_id=context.request_id,
-                )

ccproxy/pricing/__init__.py

@@ -1,19 +0,0 @@
-"""Dynamic pricing system for Claude models.
-
-This module provides dynamic pricing capabilities by downloading and caching
-pricing information from external sources like LiteLLM.
-"""
-
-from .cache import PricingCache
-from .loader import PricingLoader
-from .models import ModelPricing, PricingData
-from .updater import PricingUpdater
-
-
-__all__ = [
-    "PricingCache",
-    "PricingLoader",
-    "PricingUpdater",
-    "ModelPricing",
-    "PricingData",
-]

ccproxy/pricing/loader.py

@@ -1,251 +0,0 @@
-"""Pricing data loader and format converter for LiteLLM pricing data."""
-
-from decimal import Decimal
-from typing import Any
-
-from pydantic import ValidationError
-from structlog import get_logger
-
-from ccproxy.utils.model_mapping import get_claude_aliases_mapping, map_model_to_claude
-
-from .models import PricingData
-
-
-logger = get_logger(__name__)
-
-
-class PricingLoader:
-    """Loads and converts pricing data from LiteLLM format to internal format."""
-
-    @staticmethod
-    def extract_claude_models(
-        litellm_data: dict[str, Any], verbose: bool = True
-    ) -> dict[str, Any]:
-        """Extract Claude model entries from LiteLLM data.
-
-        Args:
-            litellm_data: Raw LiteLLM pricing data
-            verbose: Whether to log individual model discoveries
-
-        Returns:
-            Dictionary with only Claude models
-        """
-        claude_models = {}
-
-        for model_name, model_data in litellm_data.items():
-            # Check if this is a Claude model
-            if (
-                isinstance(model_data, dict)
-                and model_data.get("litellm_provider") == "anthropic"
-                and "claude" in model_name.lower()
-            ):
-                claude_models[model_name] = model_data
-                if verbose:
-                    logger.debug("claude_model_found", model_name=model_name)
-
-        if verbose:
-            logger.info(
-                "claude_models_extracted",
-                model_count=len(claude_models),
-                source="LiteLLM",
-            )
-        return claude_models
-
-    @staticmethod
-    def convert_to_internal_format(
-        claude_models: dict[str, Any], verbose: bool = True
-    ) -> dict[str, dict[str, Decimal]]:
-        """Convert LiteLLM pricing format to internal format.
-
-        LiteLLM format uses cost per token, we use cost per 1M tokens as Decimal.
-
-        Args:
-            claude_models: Claude models in LiteLLM format
-            verbose: Whether to log individual model conversions
-
-        Returns:
-            Dictionary in internal pricing format
-        """
-        internal_format = {}
-
-        for model_name, model_data in claude_models.items():
-            try:
-                # Extract pricing fields
-                input_cost_per_token = model_data.get("input_cost_per_token")
-                output_cost_per_token = model_data.get("output_cost_per_token")
-                cache_creation_cost = model_data.get("cache_creation_input_token_cost")
-                cache_read_cost = model_data.get("cache_read_input_token_cost")
-
-                # Skip models without pricing info
-                if input_cost_per_token is None or output_cost_per_token is None:
-                    if verbose:
-                        logger.warning("model_pricing_missing", model_name=model_name)
-                    continue
-
-                # Convert to per-1M-token pricing (multiply by 1,000,000)
-                pricing = {
-                    "input": Decimal(str(input_cost_per_token * 1_000_000)),
-                    "output": Decimal(str(output_cost_per_token * 1_000_000)),
-                }
-
-                # Add cache pricing if available
-                if cache_creation_cost is not None:
-                    pricing["cache_write"] = Decimal(
-                        str(cache_creation_cost * 1_000_000)
-                    )
-
-                if cache_read_cost is not None:
-                    pricing["cache_read"] = Decimal(str(cache_read_cost * 1_000_000))
-
-                # Map to canonical model name if needed
-                canonical_name = map_model_to_claude(model_name)
-                internal_format[canonical_name] = pricing
-
-                if verbose:
-                    logger.debug(
-                        "model_pricing_converted",
-                        original_name=model_name,
-                        canonical_name=canonical_name,
-                        input_cost=str(pricing["input"]),
-                        output_cost=str(pricing["output"]),
-                    )
-
-            except (ValueError, TypeError) as e:
-                if verbose:
-                    logger.error(
-                        "pricing_conversion_failed", model_name=model_name, error=str(e)
-                    )
-                continue
-
-        if verbose:
-            logger.info("models_converted", model_count=len(internal_format))
-        return internal_format
-
-    @staticmethod
-    def load_pricing_from_data(
-        litellm_data: dict[str, Any], verbose: bool = True
-    ) -> PricingData | None:
-        """Load and convert pricing data from LiteLLM format.
-
-        Args:
-            litellm_data: Raw LiteLLM pricing data
-            verbose: Whether to enable verbose logging
-
-        Returns:
-            Validated pricing data as PricingData model, or None if invalid
-        """
-        try:
-            # Extract Claude models
-            claude_models = PricingLoader.extract_claude_models(
-                litellm_data, verbose=verbose
-            )
-
-            if not claude_models:
-                if verbose:
-                    logger.warning("claude_models_not_found", source="LiteLLM")
-                return None
-
-            # Convert to internal format
-            internal_pricing = PricingLoader.convert_to_internal_format(
-                claude_models, verbose=verbose
-            )
-
-            if not internal_pricing:
-                if verbose:
-                    logger.warning("pricing_data_invalid")
-                return None
-
-            # Validate and create PricingData model
-            pricing_data = PricingData.from_dict(internal_pricing)
-
-            if verbose:
-                logger.info("pricing_data_loaded", model_count=len(pricing_data))
-
-            return pricing_data
-
-        except ValidationError as e:
-            if verbose:
-                logger.error("pricing_validation_failed", error=str(e))
-            return None
-        except Exception as e:
-            if verbose:
-                logger.error("pricing_load_failed", source="LiteLLM", error=str(e))
-            return None
-
-    @staticmethod
-    def validate_pricing_data(
-        pricing_data: Any, verbose: bool = True
-    ) -> PricingData | None:
-        """Validate pricing data using Pydantic models.
-
-        Args:
-            pricing_data: Pricing data to validate (dict or PricingData)
-            verbose: Whether to enable verbose logging
-
-        Returns:
-            Valid PricingData model or None if validation fails
-        """
-        try:
-            # If already a PricingData instance, return it
-            if isinstance(pricing_data, PricingData):
-                if verbose:
-                    logger.debug(
-                        "pricing_already_validated", model_count=len(pricing_data)
-                    )
-                return pricing_data
-
-            # If it's a dict, try to create PricingData from it
-            if isinstance(pricing_data, dict):
-                if not pricing_data:
-                    if verbose:
-                        logger.warning("pricing_data_empty")
-                    return None
-
-                # Try to create PricingData model
-                validated_data = PricingData.from_dict(pricing_data)
-
-                if verbose:
-                    logger.debug(
-                        "pricing_data_validated", model_count=len(validated_data)
-                    )
-
-                return validated_data
-
-            # Invalid type
-            if verbose:
-                logger.error(
-                    "pricing_data_invalid_type",
-                    actual_type=type(pricing_data).__name__,
-                    expected_types=["dict", "PricingData"],
-                )
-            return None
-
-        except ValidationError as e:
-            if verbose:
-                logger.error("pricing_validation_failed", error=str(e))
-            return None
-        except Exception as e:
-            if verbose:
-                logger.error("pricing_validation_unexpected_error", error=str(e))
-            return None
-
-    @staticmethod
-    def get_model_aliases() -> dict[str, str]:
-        """Get mapping of model aliases to canonical names.
-
-        Returns:
-            Dictionary mapping aliases to canonical model names
-        """
-        return get_claude_aliases_mapping()
-
-    @staticmethod
-    def get_canonical_model_name(model_name: str) -> str:
-        """Get canonical model name for a given model name.
-
-        Args:
-            model_name: Model name (possibly an alias)
-
-        Returns:
-            Canonical model name
-        """
-        return map_model_to_claude(model_name)

ccproxy/services/claude_detection_service.py

@@ -1,243 +0,0 @@
-"""Service for automatically detecting Claude CLI headers at startup."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-import socket
-import subprocess
-from pathlib import Path
-from typing import Any
-
-import structlog
-from fastapi import FastAPI, Request, Response
-
-from ccproxy.config.discovery import get_ccproxy_cache_dir
-from ccproxy.config.settings import Settings
-from ccproxy.models.detection import (
-    ClaudeCacheData,
-    ClaudeCodeHeaders,
-    SystemPromptData,
-)
-
-
-logger = structlog.get_logger(__name__)
-
-
-class ClaudeDetectionService:
-    """Service for automatically detecting Claude CLI headers at startup."""
-
-    def __init__(self, settings: Settings) -> None:
-        """Initialize Claude detection service."""
-        self.settings = settings
-        self.cache_dir = get_ccproxy_cache_dir()
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self._cached_data: ClaudeCacheData | None = None
-
-    async def initialize_detection(self) -> ClaudeCacheData:
-        """Initialize Claude detection at startup."""
-        try:
-            # Get current Claude version
-            current_version = await self._get_claude_version()
-
-            # Try to load from cache first
-            detected_data = self._load_from_cache(current_version)
-            cached = detected_data is not None
-            if cached:
-                logger.debug("detection_claude_headers_debug", version=current_version)
-            else:
-                # No cache or version changed - detect fresh
-                detected_data = await self._detect_claude_headers(current_version)
-                # Cache the results
-                self._save_to_cache(detected_data)
-
-            self._cached_data = detected_data
-
-            logger.info(
-                "detection_claude_headers_completed",
-                version=current_version,
-                cached=cached,
-            )
-
-            # TODO: add proper testing without claude cli installed
-            if detected_data is None:
-                raise ValueError("Claude detection failed")
-            return detected_data
-
-        except Exception as e:
-            logger.warning("detection_claude_headers_failed", fallback=True, error=e)
-            # Return fallback data
-            fallback_data = self._get_fallback_data()
-            self._cached_data = fallback_data
-            return fallback_data
-
-    def get_cached_data(self) -> ClaudeCacheData | None:
-        """Get currently cached detection data."""
-        return self._cached_data
-
-    async def _get_claude_version(self) -> str:
-        """Get Claude CLI version."""
-        try:
-            result = subprocess.run(
-                ["claude", "--version"],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            if result.returncode == 0:
-                # Extract version from output like "1.0.60 (Claude Code)"
-                version_line = result.stdout.strip()
-                if "/" in version_line:
-                    # Handle "claude-cli/1.0.60" format
-                    version_line = version_line.split("/")[-1]
-                if "(" in version_line:
-                    # Handle "1.0.60 (Claude Code)" format - extract just the version number
-                    return version_line.split("(")[0].strip()
-                return version_line
-            else:
-                raise RuntimeError(f"Claude version command failed: {result.stderr}")
-
-        except (subprocess.TimeoutExpired, FileNotFoundError, RuntimeError) as e:
-            logger.warning("claude_version_detection_failed", error=str(e))
-            return "unknown"
-
-    async def _detect_claude_headers(self, version: str) -> ClaudeCacheData:
-        """Execute Claude CLI with proxy to capture headers and system prompt."""
-        # Data captured from the request
-        captured_data: dict[str, Any] = {}
-
-        async def capture_handler(request: Request) -> Response:
-            """Capture the Claude CLI request."""
-            captured_data["headers"] = dict(request.headers)
-            captured_data["body"] = await request.body()
-            # Return a mock response to satisfy Claude CLI
-            return Response(
-                content='{"type": "message", "content": [{"type": "text", "text": "Test response"}]}',
-                media_type="application/json",
-                status_code=200,
-            )
-
-        # Create temporary FastAPI app
-        temp_app = FastAPI()
-        temp_app.post("/v1/messages")(capture_handler)
-
-        # Find available port
-        sock = socket.socket()
-        sock.bind(("", 0))
-        port = sock.getsockname()[1]
-        sock.close()
-
-        # Start server in background
-        from uvicorn import Config, Server
-
-        config = Config(temp_app, host="127.0.0.1", port=port, log_level="error")
-        server = Server(config)
-
-        server_task = asyncio.create_task(server.serve())
-
-        try:
-            # Wait for server to start
-            await asyncio.sleep(0.5)
-
-            # Execute Claude CLI with proxy
-            env = {**dict(os.environ), "ANTHROPIC_BASE_URL": f"http://127.0.0.1:{port}"}
-
-            process = await asyncio.create_subprocess_exec(
-                "claude",
-                "test",
-                env=env,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-            )
-
-            # Wait for process with timeout
-            try:
-                await asyncio.wait_for(process.wait(), timeout=30)
-            except TimeoutError:
-                process.kill()
-                await process.wait()
-
-            # Stop server
-            server.should_exit = True
-            await server_task
-
-            if not captured_data:
-                raise RuntimeError("Failed to capture Claude CLI request")
-
-            # Extract headers and system prompt
-            headers = self._extract_headers(captured_data["headers"])
-            system_prompt = self._extract_system_prompt(captured_data["body"])
-
-            return ClaudeCacheData(
-                claude_version=version, headers=headers, system_prompt=system_prompt
-            )
-
-        except Exception as e:
-            # Ensure server is stopped
-            server.should_exit = True
-            if not server_task.done():
-                await server_task
-            raise
-
-    def _load_from_cache(self, version: str) -> ClaudeCacheData | None:
-        """Load cached data for specific Claude version."""
-        cache_file = self.cache_dir / f"claude_headers_{version}.json"
-
-        if not cache_file.exists():
-            return None
-
-        try:
-            with cache_file.open("r") as f:
-                data = json.load(f)
-                return ClaudeCacheData.model_validate(data)
-        except Exception:
-            return None
-
-    def _save_to_cache(self, data: ClaudeCacheData) -> None:
-        """Save detection data to cache."""
-        cache_file = self.cache_dir / f"claude_headers_{data.claude_version}.json"
-
-        try:
-            with cache_file.open("w") as f:
-                json.dump(data.model_dump(), f, indent=2, default=str)
-            logger.debug(
-                "cache_saved", file=str(cache_file), version=data.claude_version
-            )
-        except Exception as e:
-            logger.warning("cache_save_failed", file=str(cache_file), error=str(e))
-
-    def _extract_headers(self, headers: dict[str, str]) -> ClaudeCodeHeaders:
-        """Extract Claude CLI headers from captured request."""
-        try:
-            return ClaudeCodeHeaders.model_validate(headers)
-        except Exception as e:
-            logger.error("header_extraction_failed", error=str(e))
-            raise ValueError(f"Failed to extract required headers: {e}") from e
-
-    def _extract_system_prompt(self, body: bytes) -> SystemPromptData:
-        """Extract system prompt from captured request body."""
-        try:
-            data = json.loads(body.decode("utf-8"))
-            system_content = data.get("system")
-
-            if system_content is None:
-                raise ValueError("No system field found in request body")
-
-            return SystemPromptData(system_field=system_content)
-
-        except Exception as e:
-            logger.error("system_prompt_extraction_failed", error=str(e))
-            raise ValueError(f"Failed to extract system prompt: {e}") from e
-
-    def _get_fallback_data(self) -> ClaudeCacheData:
-        """Get fallback data when detection fails."""
-        logger.warning("using_fallback_claude_data")
-
-        # Load fallback data from package data file
-        package_data_file = (
-            Path(__file__).parent.parent / "data" / "claude_headers_fallback.json"
-        )
-        with package_data_file.open("r") as f:
-            fallback_data_dict = json.load(f)
-            return ClaudeCacheData.model_validate(fallback_data_dict)