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

ccproxy/utils/cost_calculator.py

@@ -1,210 +0,0 @@
-"""Cost calculation utilities for token-based pricing.
-
-This module provides shared cost calculation functionality that can be used
-across different services to ensure consistent pricing calculations.
-"""
-
-import structlog
-
-
-logger = structlog.get_logger(__name__)
-
-
-def calculate_token_cost(
-    tokens_input: int | None,
-    tokens_output: int | None,
-    model: str | None,
-    cache_read_tokens: int | None = None,
-    cache_write_tokens: int | None = None,
-) -> float | None:
-    """Calculate cost in USD for the given token usage including cache tokens.
-
-    This is a shared utility function that provides consistent cost calculation
-    across all services using the pricing data from the pricing system.
-
-    Args:
-        tokens_input: Number of input tokens
-        tokens_output: Number of output tokens
-        model: Model name for pricing lookup
-        cache_read_tokens: Number of cache read tokens
-        cache_write_tokens: Number of cache write tokens
-
-    Returns:
-        Cost in USD or None if calculation not possible
-    """
-    if not model or (
-        not tokens_input
-        and not tokens_output
-        and not cache_read_tokens
-        and not cache_write_tokens
-    ):
-        return None
-
-    try:
-        # Import pricing system components
-        from ccproxy.config.pricing import PricingSettings
-        from ccproxy.pricing.cache import PricingCache
-        from ccproxy.pricing.loader import PricingLoader
-
-        # Get canonical model name
-        canonical_model = PricingLoader.get_canonical_model_name(model)
-
-        # Create pricing components with dependency injection
-        settings = PricingSettings()
-        cache = PricingCache(settings)
-        cached_data = cache.load_cached_data()
-
-        # If cache is expired, try to use stale cache as fallback
-        if not cached_data:
-            try:
-                import json
-
-                if cache.cache_file.exists():
-                    with cache.cache_file.open(encoding="utf-8") as f:
-                        cached_data = json.load(f)
-                    logger.debug(
-                        "cost_calculation_using_stale_cache",
-                        cache_age_hours=cache.get_cache_info().get("age_hours"),
-                    )
-            except (OSError, json.JSONDecodeError):
-                pass
-
-        if not cached_data:
-            logger.debug("cost_calculation_skipped", reason="no_pricing_data")
-            return None
-
-        # Load pricing data
-        pricing_data = PricingLoader.load_pricing_from_data(cached_data, verbose=False)
-        if not pricing_data or canonical_model not in pricing_data:
-            logger.debug(
-                "cost_calculation_skipped",
-                model=canonical_model,
-                reason="model_not_found",
-            )
-            return None
-
-        model_pricing = pricing_data[canonical_model]
-
-        # Calculate cost (pricing is per 1M tokens)
-        input_cost = ((tokens_input or 0) / 1_000_000) * float(model_pricing.input)
-        output_cost = ((tokens_output or 0) / 1_000_000) * float(model_pricing.output)
-        cache_read_cost = ((cache_read_tokens or 0) / 1_000_000) * float(
-            model_pricing.cache_read
-        )
-        cache_write_cost = ((cache_write_tokens or 0) / 1_000_000) * float(
-            model_pricing.cache_write
-        )
-
-        total_cost = input_cost + output_cost + cache_read_cost + cache_write_cost
-
-        logger.debug(
-            "cost_calculated",
-            model=canonical_model,
-            tokens_input=tokens_input,
-            tokens_output=tokens_output,
-            cache_read_tokens=cache_read_tokens,
-            cache_write_tokens=cache_write_tokens,
-            input_cost=input_cost,
-            output_cost=output_cost,
-            cache_read_cost=cache_read_cost,
-            cache_write_cost=cache_write_cost,
-            cost_usd=total_cost,
-        )
-
-        return total_cost
-
-    except Exception as e:
-        logger.debug("cost_calculation_error", error=str(e), model=model)
-        return None
-
-
-def calculate_cost_breakdown(
-    tokens_input: int | None,
-    tokens_output: int | None,
-    model: str | None,
-    cache_read_tokens: int | None = None,
-    cache_write_tokens: int | None = None,
-) -> dict[str, float | str] | None:
-    """Calculate detailed cost breakdown for the given token usage.
-
-    Args:
-        tokens_input: Number of input tokens
-        tokens_output: Number of output tokens
-        model: Model name for pricing lookup
-        cache_read_tokens: Number of cache read tokens
-        cache_write_tokens: Number of cache write tokens
-
-    Returns:
-        Dictionary with cost breakdown or None if calculation not possible
-    """
-    if not model or (
-        not tokens_input
-        and not tokens_output
-        and not cache_read_tokens
-        and not cache_write_tokens
-    ):
-        return None
-
-    try:
-        # Import pricing system components
-        from ccproxy.config.pricing import PricingSettings
-        from ccproxy.pricing.cache import PricingCache
-        from ccproxy.pricing.loader import PricingLoader
-
-        # Get canonical model name
-        canonical_model = PricingLoader.get_canonical_model_name(model)
-
-        # Create pricing components with dependency injection
-        settings = PricingSettings()
-        cache = PricingCache(settings)
-        cached_data = cache.load_cached_data()
-
-        # If cache is expired, try to use stale cache as fallback
-        if not cached_data:
-            try:
-                import json
-
-                if cache.cache_file.exists():
-                    with cache.cache_file.open(encoding="utf-8") as f:
-                        cached_data = json.load(f)
-                    logger.debug(
-                        "cost_breakdown_using_stale_cache",
-                        cache_age_hours=cache.get_cache_info().get("age_hours"),
-                    )
-            except (OSError, json.JSONDecodeError):
-                pass
-
-        if not cached_data:
-            return None
-
-        # Load pricing data
-        pricing_data = PricingLoader.load_pricing_from_data(cached_data, verbose=False)
-        if not pricing_data or canonical_model not in pricing_data:
-            return None
-
-        model_pricing = pricing_data[canonical_model]
-
-        # Calculate individual costs (pricing is per 1M tokens)
-        input_cost = ((tokens_input or 0) / 1_000_000) * float(model_pricing.input)
-        output_cost = ((tokens_output or 0) / 1_000_000) * float(model_pricing.output)
-        cache_read_cost = ((cache_read_tokens or 0) / 1_000_000) * float(
-            model_pricing.cache_read
-        )
-        cache_write_cost = ((cache_write_tokens or 0) / 1_000_000) * float(
-            model_pricing.cache_write
-        )
-
-        total_cost = input_cost + output_cost + cache_read_cost + cache_write_cost
-
-        return {
-            "input_cost": input_cost,
-            "output_cost": output_cost,
-            "cache_read_cost": cache_read_cost,
-            "cache_write_cost": cache_write_cost,
-            "total_cost": total_cost,
-            "model": canonical_model,
-        }
-
-    except Exception as e:
-        logger.debug("cost_breakdown_error", error=str(e), model=model)
-        return None

ccproxy/utils/disconnection_monitor.py

@@ -1,83 +0,0 @@
-"""Utility functions for monitoring client disconnection and stuck streams during streaming responses."""
-
-import asyncio
-from typing import TYPE_CHECKING
-
-import structlog
-from starlette.requests import Request
-
-
-if TYPE_CHECKING:
-    from ccproxy.services.claude_sdk_service import ClaudeSDKService
-
-logger = structlog.get_logger(__name__)
-
-
-async def monitor_disconnection(
-    request: Request, session_id: str, claude_service: "ClaudeSDKService"
-) -> None:
-    """Monitor for client disconnection and interrupt session if detected.
-
-    Args:
-        request: The incoming HTTP request
-        session_id: The Claude SDK session ID to interrupt if disconnected
-        claude_service: The Claude SDK service instance
-    """
-    try:
-        while True:
-            await asyncio.sleep(1.0)  # Check every second
-            if await request.is_disconnected():
-                logger.info(
-                    "client_disconnected_interrupting_session", session_id=session_id
-                )
-                try:
-                    await claude_service.sdk_client.interrupt_session(session_id)
-                except Exception as e:
-                    logger.error(
-                        "failed_to_interrupt_session",
-                        session_id=session_id,
-                        error=str(e),
-                    )
-                return
-    except asyncio.CancelledError:
-        # Task was cancelled, which is expected when streaming completes normally
-        logger.debug("disconnection_monitor_cancelled", session_id=session_id)
-        raise
-
-
-async def monitor_stuck_stream(
-    session_id: str,
-    claude_service: "ClaudeSDKService",
-    first_chunk_event: asyncio.Event,
-    timeout: float = 10.0,
-) -> None:
-    """Monitor for stuck streams that don't produce a first chunk (SystemMessage).
-
-    Args:
-        session_id: The Claude SDK session ID to monitor
-        claude_service: The Claude SDK service instance
-        first_chunk_event: Event that will be set when first chunk is received
-        timeout: Seconds to wait for first chunk before considering stream stuck
-    """
-    try:
-        # Wait for first chunk with timeout
-        await asyncio.wait_for(first_chunk_event.wait(), timeout=timeout)
-        logger.debug("stuck_stream_first_chunk_received", session_id=session_id)
-    except TimeoutError:
-        logger.error(
-            "streaming_system_message_timeout",
-            session_id=session_id,
-            timeout=timeout,
-            message=f"No SystemMessage received within {timeout}s, interrupting session",
-        )
-        try:
-            await claude_service.sdk_client.interrupt_session(session_id)
-            logger.info("stuck_session_interrupted_successfully", session_id=session_id)
-        except Exception as e:
-            logger.error(
-                "failed_to_interrupt_stuck_session", session_id=session_id, error=str(e)
-            )
-    except asyncio.CancelledError:
-        # Task was cancelled, which is expected when streaming completes normally
-        logger.debug("stuck_stream_monitor_cancelled", session_id=session_id)
-        raise

ccproxy/utils/model_mapping.py

@@ -1,199 +0,0 @@
-"""Unified model mapping utilities for OpenAI and Claude models.
-
-This module provides a single source of truth for all model mappings,
-consolidating OpenAI→Claude mappings and Claude alias resolution.
-"""
-
-from __future__ import annotations
-
-
-# Combined mapping: OpenAI models → Claude models AND Claude aliases → canonical Claude models
-MODEL_MAPPING: dict[str, str] = {
-    "gpt-5": "claude-sonnet-4-20250514",
-    # OpenAI GPT-4 models → Claude 3.5 Sonnet (most comparable)
-    "gpt-4": "claude-3-5-sonnet-20241022",
-    "gpt-4-turbo": "claude-3-5-sonnet-20241022",
-    "gpt-4-turbo-preview": "claude-3-5-sonnet-20241022",
-    "gpt-4-1106-preview": "claude-3-5-sonnet-20241022",
-    "gpt-4-0125-preview": "claude-3-5-sonnet-20241022",
-    "gpt-4-turbo-2024-04-09": "claude-3-5-sonnet-20241022",
-    # OpenAI GPT-4o models → Claude 3.7 Sonnet
-    "gpt-4o": "claude-3-7-sonnet-20250219",
-    "gpt-4o-2024-05-13": "claude-3-7-sonnet-20250219",
-    "gpt-4o-2024-08-06": "claude-3-7-sonnet-20250219",
-    "gpt-4o-2024-11-20": "claude-3-7-sonnet-20250219",
-    # OpenAI GPT-4o-mini models → Claude 3.5 Haiku
-    "gpt-4o-mini": "claude-3-5-haiku-latest",
-    "gpt-4o-mini-2024-07-18": "claude-3-5-haiku-latest",
-    # OpenAI o1 models → Claude models that support thinking
-    "o1": "claude-opus-4-20250514",
-    "o1-preview": "claude-opus-4-20250514",
-    "o1-mini": "claude-sonnet-4-20250514",
-    # OpenAI o3 models → Claude Opus 4
-    "o3-mini": "claude-opus-4-20250514",
-    # OpenAI GPT-3.5 models → Claude 3.5 Haiku (faster, cheaper)
-    "gpt-3.5-turbo": "claude-3-5-haiku-20241022",
-    "gpt-3.5-turbo-16k": "claude-3-5-haiku-20241022",
-    "gpt-3.5-turbo-1106": "claude-3-5-haiku-20241022",
-    "gpt-3.5-turbo-0125": "claude-3-5-haiku-20241022",
-    # OpenAI text models → Claude 3.5 Sonnet
-    "text-davinci-003": "claude-3-5-sonnet-20241022",
-    "text-davinci-002": "claude-3-5-sonnet-20241022",
-    # Claude model aliases → canonical Claude models
-    "claude-3-5-sonnet-latest": "claude-3-5-sonnet-20241022",
-    "claude-3-5-sonnet-20240620": "claude-3-5-sonnet-20240620",
-    "claude-3-5-sonnet-20241022": "claude-3-5-sonnet-20241022",
-    "claude-3-5-haiku-latest": "claude-3-5-haiku-20241022",
-    "claude-3-5-haiku-20241022": "claude-3-5-haiku-20241022",
-    "claude-3-opus": "claude-3-opus-20240229",
-    "claude-3-opus-20240229": "claude-3-opus-20240229",
-    "claude-3-sonnet": "claude-3-sonnet-20240229",
-    "claude-3-sonnet-20240229": "claude-3-sonnet-20240229",
-    "claude-3-haiku": "claude-3-haiku-20240307",
-    "claude-3-haiku-20240307": "claude-3-haiku-20240307",
-}
-
-
-def map_model_to_claude(model_name: str) -> str:
-    """Map any model name to its canonical Claude model name.
-
-    This function handles:
-    - OpenAI model names → Claude equivalents
-    - Claude aliases → canonical Claude names
-    - Pattern matching for versioned models
-    - Pass-through for unknown models
-
-    Args:
-        model_name: Model identifier (OpenAI, Claude, or alias)
-
-    Returns:
-        Canonical Claude model identifier
-    """
-    # Direct mapping first (handles both OpenAI and Claude aliases)
-    claude_model = MODEL_MAPPING.get(model_name)
-    if claude_model:
-        return claude_model
-
-    # Pattern matching for versioned OpenAI models
-    if model_name.startswith("gpt-4o-mini"):
-        return "claude-3-5-haiku-latest"
-    elif model_name.startswith("gpt-4o") or model_name.startswith("gpt-4"):
-        return "claude-3-7-sonnet-20250219"
-    elif model_name.startswith("gpt-3.5"):
-        return "claude-3-5-haiku-latest"
-    elif (
-        model_name.startswith("o1")
-        or model_name.startswith("gpt-5")
-        or model_name.startswith("o3")
-        or model_name.startswith("gpt")
-    ):
-        return "claude-sonnet-4-20250514"
-
-    # If it's already a Claude model, pass through unchanged
-    if model_name.startswith("claude-"):
-        return model_name
-
-    # For unknown models, pass through unchanged
-    return model_name
-
-
-def get_openai_to_claude_mapping() -> dict[str, str]:
-    """Get mapping of OpenAI models to Claude models.
-
-    Returns:
-        Dictionary mapping OpenAI model names to Claude model names
-    """
-    return {k: v for k, v in MODEL_MAPPING.items() if not k.startswith("claude-")}
-
-
-def get_claude_aliases_mapping() -> dict[str, str]:
-    """Get mapping of Claude aliases to canonical Claude names.
-
-    Returns:
-        Dictionary mapping Claude aliases to canonical model names
-    """
-    return {k: v for k, v in MODEL_MAPPING.items() if k.startswith("claude-")}
-
-
-def get_supported_claude_models() -> list[str]:
-    """Get list of supported canonical Claude models.
-
-    Returns:
-        Sorted list of unique canonical Claude model names
-    """
-    return sorted(set(MODEL_MAPPING.values()))
-
-
-def is_openai_model(model_name: str) -> bool:
-    """Check if a model name is an OpenAI model.
-
-    Args:
-        model_name: Model identifier to check
-
-    Returns:
-        True if the model is an OpenAI model, False otherwise
-    """
-    return (
-        model_name.startswith(("gpt-", "o1", "o3", "text-davinci"))
-        or model_name in get_openai_to_claude_mapping()
-    )
-
-
-def is_claude_model(model_name: str) -> bool:
-    """Check if a model name is a Claude model (canonical or alias).
-
-    Args:
-        model_name: Model identifier to check
-
-    Returns:
-        True if the model is a Claude model, False otherwise
-    """
-    return (
-        model_name.startswith("claude-") or model_name in get_claude_aliases_mapping()
-    )
-
-
-# Backward compatibility exports
-OPENAI_TO_CLAUDE_MODEL_MAPPING = get_openai_to_claude_mapping()
-CLAUDE_MODEL_MAPPINGS = get_claude_aliases_mapping()
-
-
-# Legacy function aliases
-def map_openai_model_to_claude(openai_model: str) -> str:
-    """Legacy alias for map_model_to_claude().
-
-    Args:
-        openai_model: OpenAI model identifier
-
-    Returns:
-        Claude model identifier
-    """
-    return map_model_to_claude(openai_model)
-
-
-def get_canonical_model_name(model_name: str) -> str:
-    """Legacy alias for map_model_to_claude().
-
-    Args:
-        model_name: Model name (possibly an alias)
-
-    Returns:
-        Canonical model name
-    """
-    return map_model_to_claude(model_name)
-
-
-__all__ = [
-    "MODEL_MAPPING",
-    "map_model_to_claude",
-    "get_openai_to_claude_mapping",
-    "get_claude_aliases_mapping",
-    "get_supported_claude_models",
-    "is_openai_model",
-    "is_claude_model",
-    # Backward compatibility
-    "OPENAI_TO_CLAUDE_MODEL_MAPPING",
-    "CLAUDE_MODEL_MAPPINGS",
-    "map_openai_model_to_claude",
-    "get_canonical_model_name",
-]

ccproxy/utils/models_provider.py

@@ -1,150 +0,0 @@
-"""Shared models provider for CCProxy API Server.
-
-This module provides a centralized source for all available models,
-combining Claude and OpenAI models in a consistent format.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from ccproxy.utils.model_mapping import get_supported_claude_models
-
-
-def get_anthropic_models() -> list[dict[str, Any]]:
-    """Get list of Anthropic models with metadata.
-
-    Returns:
-        List of Anthropic model entries with type, id, display_name, and created_at fields
-    """
-    # Model display names mapping
-    display_names = {
-        "claude-opus-4-20250514": "Claude Opus 4",
-        "claude-sonnet-4-20250514": "Claude Sonnet 4",
-        "claude-3-7-sonnet-20250219": "Claude Sonnet 3.7",
-        "claude-3-5-sonnet-20241022": "Claude Sonnet 3.5 (New)",
-        "claude-3-5-haiku-20241022": "Claude Haiku 3.5",
-        "claude-3-5-haiku-latest": "Claude Haiku 3.5",
-        "claude-3-5-sonnet-20240620": "Claude Sonnet 3.5 (Old)",
-        "claude-3-haiku-20240307": "Claude Haiku 3",
-        "claude-3-opus-20240229": "Claude Opus 3",
-    }
-
-    # Model creation timestamps
-    timestamps = {
-        "claude-opus-4-20250514": 1747526400,  # 2025-05-22
-        "claude-sonnet-4-20250514": 1747526400,  # 2025-05-22
-        "claude-3-7-sonnet-20250219": 1740268800,  # 2025-02-24
-        "claude-3-5-sonnet-20241022": 1729555200,  # 2024-10-22
-        "claude-3-5-haiku-20241022": 1729555200,  # 2024-10-22
-        "claude-3-5-haiku-latest": 1729555200,  # 2024-10-22
-        "claude-3-5-sonnet-20240620": 1718841600,  # 2024-06-20
-        "claude-3-haiku-20240307": 1709769600,  # 2024-03-07
-        "claude-3-opus-20240229": 1709164800,  # 2024-02-29
-    }
-
-    # Get supported Claude models from existing utility
-    supported_models = get_supported_claude_models()
-
-    # Create Anthropic-style model entries
-    models = []
-    for model_id in supported_models:
-        models.append(
-            {
-                "type": "model",
-                "id": model_id,
-                "display_name": display_names.get(model_id, model_id),
-                "created_at": timestamps.get(model_id, 1677610602),  # Default timestamp
-            }
-        )
-
-    return models
-
-
-def get_openai_models() -> list[dict[str, Any]]:
-    """Get list of recent OpenAI models with metadata.
-
-    Returns:
-        List of OpenAI model entries with id, object, created, and owned_by fields
-    """
-    return [
-        {
-            "id": "gpt-4o",
-            "object": "model",
-            "created": 1715367049,
-            "owned_by": "openai",
-        },
-        {
-            "id": "gpt-4o-mini",
-            "object": "model",
-            "created": 1721172741,
-            "owned_by": "openai",
-        },
-        {
-            "id": "gpt-4-turbo",
-            "object": "model",
-            "created": 1712361441,
-            "owned_by": "openai",
-        },
-        {
-            "id": "gpt-4-turbo-preview",
-            "object": "model",
-            "created": 1706037777,
-            "owned_by": "openai",
-        },
-        {
-            "id": "o1",
-            "object": "model",
-            "created": 1734375816,
-            "owned_by": "openai",
-        },
-        {
-            "id": "o1-mini",
-            "object": "model",
-            "created": 1725649008,
-            "owned_by": "openai",
-        },
-        {
-            "id": "o1-preview",
-            "object": "model",
-            "created": 1725648897,
-            "owned_by": "openai",
-        },
-        {
-            "id": "o3",
-            "object": "model",
-            "created": 1744225308,
-            "owned_by": "openai",
-        },
-        {
-            "id": "o3-mini",
-            "object": "model",
-            "created": 1737146383,
-            "owned_by": "openai",
-        },
-    ]
-
-
-def get_models_list() -> dict[str, Any]:
-    """Get combined list of available Claude and OpenAI models.
-
-    Returns:
-        Dictionary with combined list of models in mixed format compatible with both
-        Anthropic and OpenAI API specifications
-    """
-    anthropic_models = get_anthropic_models()
-    openai_models = get_openai_models()
-
-    # Return combined response in mixed format
-    return {
-        "data": anthropic_models + openai_models,
-        "has_more": False,
-        "object": "list",
-    }
-
-
-__all__ = [
-    "get_anthropic_models",
-    "get_openai_models",
-    "get_models_list",
-]