ccproxy-api 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

ccproxy/utils/model_mapping.py

@@ -0,0 +1,197 @@
+"""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] = {
+    # 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"):
+        return "claude-sonnet-4-20250514"
+    elif model_name.startswith("o3"):
+        return "claude-opus-4-20250514"
+    elif 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

@@ -0,0 +1,150 @@
+"""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",
+]

ccproxy/utils/simple_request_logger.py

@@ -0,0 +1,284 @@
+"""Simple request logging utility for content logging across all service layers."""
+
+import asyncio
+import json
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import structlog
+
+
+logger = structlog.get_logger(__name__)
+
+# Global batching settings for streaming logs
+_STREAMING_BATCH_SIZE = 8192  # Batch chunks until we have 8KB
+_STREAMING_BATCH_TIMEOUT = 0.1  # Or flush after 100ms
+_streaming_batches: dict[str, dict[str, Any]] = {}  # request_id -> batch info
+
+
+def should_log_requests() -> bool:
+    """Check if request logging is enabled via environment variable.
+
+    Returns:
+        True if CCPROXY_LOG_REQUESTS is set to 'true' (case-insensitive)
+    """
+    return os.environ.get("CCPROXY_LOG_REQUESTS", "false").lower() == "true"
+
+
+def get_request_log_dir() -> Path | None:
+    """Get the request log directory from environment variable.
+
+    Returns:
+        Path object if CCPROXY_REQUEST_LOG_DIR is set and valid, None otherwise
+    """
+    log_dir = os.environ.get("CCPROXY_REQUEST_LOG_DIR")
+    if not log_dir:
+        return None
+
+    path = Path(log_dir)
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+    except Exception as e:
+        logger.error(
+            "failed_to_create_request_log_dir",
+            log_dir=log_dir,
+            error=str(e),
+        )
+        return None
+
+
+def get_timestamp_prefix() -> str:
+    """Generate timestamp prefix in YYYYMMDDhhmmss format.
+
+    Returns:
+        Timestamp string in YYYYMMDDhhmmss format (UTC)
+    """
+    return datetime.now(UTC).strftime("%Y%m%d%H%M%S")
+
+
+async def write_request_log(
+    request_id: str,
+    log_type: str,
+    data: dict[str, Any],
+    timestamp: str | None = None,
+) -> None:
+    """Write request/response data to JSON file.
+
+    Args:
+        request_id: Unique request identifier
+        log_type: Type of log (e.g., 'middleware_request', 'upstream_response')
+        data: Data to log as JSON
+        timestamp: Optional timestamp prefix (defaults to current time)
+    """
+    if not should_log_requests():
+        return
+
+    log_dir = get_request_log_dir()
+    if not log_dir:
+        return
+
+    timestamp = timestamp or get_timestamp_prefix()
+    filename = f"{timestamp}_{request_id}_{log_type}.json"
+    file_path = log_dir / filename
+
+    try:
+        # Write JSON data to file asynchronously
+        def write_file() -> None:
+            with file_path.open("w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, default=str, ensure_ascii=False)
+
+        # Run in thread pool to avoid blocking
+        await asyncio.get_event_loop().run_in_executor(None, write_file)
+
+        logger.debug(
+            "request_log_written",
+            request_id=request_id,
+            log_type=log_type,
+            file_path=str(file_path),
+        )
+
+    except Exception as e:
+        logger.error(
+            "failed_to_write_request_log",
+            request_id=request_id,
+            log_type=log_type,
+            file_path=str(file_path),
+            error=str(e),
+        )
+
+
+async def write_streaming_log(
+    request_id: str,
+    log_type: str,
+    data: bytes,
+    timestamp: str | None = None,
+) -> None:
+    """Write streaming data to raw file.
+
+    Args:
+        request_id: Unique request identifier
+        log_type: Type of log (e.g., 'middleware_streaming', 'upstream_streaming')
+        data: Raw bytes to log
+        timestamp: Optional timestamp prefix (defaults to current time)
+    """
+    if not should_log_requests():
+        return
+
+    log_dir = get_request_log_dir()
+    if not log_dir:
+        return
+
+    timestamp = timestamp or get_timestamp_prefix()
+    filename = f"{timestamp}_{request_id}_{log_type}.raw"
+    file_path = log_dir / filename
+
+    try:
+        # Write raw data to file asynchronously
+        def write_file() -> None:
+            with file_path.open("wb") as f:
+                f.write(data)
+
+        # Run in thread pool to avoid blocking
+        await asyncio.get_event_loop().run_in_executor(None, write_file)
+
+        logger.debug(
+            "streaming_log_written",
+            request_id=request_id,
+            log_type=log_type,
+            file_path=str(file_path),
+            data_size=len(data),
+        )
+
+    except Exception as e:
+        logger.error(
+            "failed_to_write_streaming_log",
+            request_id=request_id,
+            log_type=log_type,
+            file_path=str(file_path),
+            error=str(e),
+        )
+
+
+async def append_streaming_log(
+    request_id: str,
+    log_type: str,
+    data: bytes,
+    timestamp: str | None = None,
+) -> None:
+    """Append streaming data using batching for performance.
+
+    Args:
+        request_id: Unique request identifier
+        log_type: Type of log (e.g., 'middleware_streaming', 'upstream_streaming')
+        data: Raw bytes to append
+        timestamp: Optional timestamp prefix (defaults to current time)
+    """
+    if not should_log_requests():
+        return
+
+    log_dir = get_request_log_dir()
+    if not log_dir:
+        return
+
+    timestamp = timestamp or get_timestamp_prefix()
+    batch_key = f"{request_id}_{log_type}"
+
+    # Get or create batch for this request/log_type combination
+    if batch_key not in _streaming_batches:
+        _streaming_batches[batch_key] = {
+            "request_id": request_id,
+            "log_type": log_type,
+            "timestamp": timestamp,
+            "data": bytearray(),
+            "chunk_count": 0,
+            "first_chunk_time": asyncio.get_event_loop().time(),
+            "last_flush_task": None,
+        }
+
+    batch = _streaming_batches[batch_key]
+    batch["data"].extend(data)
+    batch["chunk_count"] += 1
+
+    # Cancel previous flush task if it exists
+    if batch["last_flush_task"] and not batch["last_flush_task"].done():
+        batch["last_flush_task"].cancel()
+
+    # Check if we should flush now
+    should_flush = (
+        len(batch["data"]) >= _STREAMING_BATCH_SIZE
+        or batch["chunk_count"] >= 50  # Max 50 chunks per batch
+    )
+
+    if should_flush:
+        await _flush_streaming_batch(batch_key)
+    else:
+        # Schedule a delayed flush
+        batch["last_flush_task"] = asyncio.create_task(
+            _delayed_flush_streaming_batch(batch_key, _STREAMING_BATCH_TIMEOUT)
+        )
+
+
+async def _delayed_flush_streaming_batch(batch_key: str, delay: float) -> None:
+    """Flush a streaming batch after a delay."""
+    try:
+        await asyncio.sleep(delay)
+        if batch_key in _streaming_batches:
+            await _flush_streaming_batch(batch_key)
+    except asyncio.CancelledError:
+        # Task was cancelled, don't flush
+        pass
+
+
+async def _flush_streaming_batch(batch_key: str) -> None:
+    """Flush a streaming batch to disk."""
+    if batch_key not in _streaming_batches:
+        return
+
+    batch = _streaming_batches.pop(batch_key)
+
+    if not batch["data"]:
+        return  # Nothing to flush
+
+    log_dir = get_request_log_dir()
+    if not log_dir:
+        return
+
+    filename = f"{batch['timestamp']}_{batch['request_id']}_{batch['log_type']}.raw"
+    file_path = log_dir / filename
+
+    try:
+        # Append batched data to file asynchronously
+        def append_file() -> None:
+            with file_path.open("ab") as f:
+                f.write(batch["data"])
+
+        # Run in thread pool to avoid blocking
+        await asyncio.get_event_loop().run_in_executor(None, append_file)
+
+        logger.debug(
+            "streaming_batch_flushed",
+            request_id=batch["request_id"],
+            log_type=batch["log_type"],
+            file_path=str(file_path),
+            batch_size=len(batch["data"]),
+            chunk_count=batch["chunk_count"],
+        )
+
+    except Exception as e:
+        logger.error(
+            "failed_to_flush_streaming_batch",
+            request_id=batch["request_id"],
+            log_type=batch["log_type"],
+            file_path=str(file_path),
+            error=str(e),
+        )
+
+
+async def flush_all_streaming_batches() -> None:
+    """Flush all pending streaming batches. Call this on shutdown."""
+    batch_keys = list(_streaming_batches.keys())
+    for batch_key in batch_keys:
+        await _flush_streaming_batch(batch_key)