ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/core/constants.py

@@ -0,0 +1,97 @@
+"""Core constants used across the CCProxy API."""
+
+# HTTP headers
+REQUEST_ID_HEADER = "X-Request-ID"
+AUTH_HEADER = "Authorization"
+CONTENT_TYPE_HEADER = "Content-Type"
+
+# API endpoints
+ANTHROPIC_API_BASE_PATH = "/v1"
+OPENAI_API_BASE_PATH = "/openai/v1"
+CHAT_COMPLETIONS_ENDPOINT = "/chat/completions"
+MESSAGES_ENDPOINT = "/messages"
+MODELS_ENDPOINT = "/models"
+
+# Default values
+DEFAULT_MODEL = "claude-3-5-sonnet-20241022"
+DEFAULT_MAX_TOKENS = 4096
+DEFAULT_TEMPERATURE = 1.0
+DEFAULT_TOP_P = 1.0
+DEFAULT_STREAM = False
+
+# Timeouts (in seconds)
+DEFAULT_TIMEOUT = 30
+DEFAULT_CONNECT_TIMEOUT = 10
+DEFAULT_READ_TIMEOUT = 300
+
+# Rate limiting
+DEFAULT_RATE_LIMIT = 100  # requests per minute
+DEFAULT_BURST_LIMIT = 10  # burst capacity
+
+# Docker defaults
+DEFAULT_DOCKER_IMAGE = "ghcr.io/anthropics/claude-cli:latest"
+DEFAULT_DOCKER_TIMEOUT = 300
+
+# File extensions
+TOML_EXTENSIONS = [".toml"]
+JSON_EXTENSIONS = [".json"]
+YAML_EXTENSIONS = [".yaml", ".yml"]
+
+# Configuration file names
+CONFIG_FILE_NAMES = [
+    ".ccproxy.toml",
+    "ccproxy.toml",
+    "config.toml",
+    "config.json",
+    "config.yaml",
+    "config.yml",
+]
+
+# Environment variable prefixes
+ENV_PREFIX = "CCPROXY_"
+CLAUDE_ENV_PREFIX = "CLAUDE_"
+
+# Logging levels
+LOG_LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+# Error messages
+ERROR_MSG_INVALID_TOKEN = "Invalid or expired authentication token"
+ERROR_MSG_MODEL_NOT_FOUND = "Model not found or not available"
+ERROR_MSG_RATE_LIMIT_EXCEEDED = "Rate limit exceeded"
+ERROR_MSG_INVALID_REQUEST = "Invalid request format"
+ERROR_MSG_INTERNAL_ERROR = "Internal server error"
+
+# Status codes
+STATUS_OK = 200
+STATUS_CREATED = 201
+STATUS_BAD_REQUEST = 400
+STATUS_UNAUTHORIZED = 401
+STATUS_FORBIDDEN = 403
+STATUS_NOT_FOUND = 404
+STATUS_RATE_LIMITED = 429
+STATUS_INTERNAL_ERROR = 500
+STATUS_BAD_GATEWAY = 502
+STATUS_SERVICE_UNAVAILABLE = 503
+
+# Stream event types
+STREAM_EVENT_MESSAGE_START = "message_start"
+STREAM_EVENT_MESSAGE_DELTA = "message_delta"
+STREAM_EVENT_MESSAGE_STOP = "message_stop"
+STREAM_EVENT_CONTENT_BLOCK_START = "content_block_start"
+STREAM_EVENT_CONTENT_BLOCK_DELTA = "content_block_delta"
+STREAM_EVENT_CONTENT_BLOCK_STOP = "content_block_stop"
+
+# Content types
+CONTENT_TYPE_JSON = "application/json"
+CONTENT_TYPE_STREAM = "text/event-stream"
+CONTENT_TYPE_TEXT = "text/plain"
+
+# Character limits
+MAX_PROMPT_LENGTH = 200_000  # Maximum prompt length in characters
+MAX_MESSAGE_LENGTH = 100_000  # Maximum message length
+MAX_TOOL_CALLS = 100  # Maximum number of tool calls per request
+
+# Validation patterns
+EMAIL_PATTERN = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+URL_PATTERN = r"^https?://[^\s/$.?#].[^\s]*$"
+UUID_PATTERN = r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"

ccproxy/core/errors.py

@@ -0,0 +1,256 @@
+"""Core error types for the proxy system."""
+
+from typing import Any, Optional
+
+from fastapi import HTTPException
+
+
+class ProxyHTTPException(HTTPException):
+    pass
+
+
+class ProxyError(Exception):
+    """Base exception for all proxy-related errors."""
+
+    def __init__(self, message: str, cause: Exception | None = None):
+        """Initialize with a message and optional cause.
+
+        Args:
+            message: The error message
+            cause: The underlying exception that caused this error
+        """
+        super().__init__(message)
+        self.cause = cause
+        if cause:
+            # Use Python's exception chaining
+            self.__cause__ = cause
+
+
+class TransformationError(ProxyError):
+    """Error raised during data transformation."""
+
+    def __init__(self, message: str, data: Any = None, cause: Exception | None = None):
+        """Initialize with a message, optional data, and cause.
+
+        Args:
+            message: The error message
+            data: The data that failed to transform
+            cause: The underlying exception
+        """
+        super().__init__(message, cause)
+        self.data = data
+
+
+class MiddlewareError(ProxyError):
+    """Error raised during middleware execution."""
+
+    def __init__(
+        self,
+        message: str,
+        middleware_name: str | None = None,
+        cause: Exception | None = None,
+    ):
+        """Initialize with a message, middleware name, and cause.
+
+        Args:
+            message: The error message
+            middleware_name: The name of the middleware that failed
+            cause: The underlying exception
+        """
+        super().__init__(message, cause)
+        self.middleware_name = middleware_name
+
+
+class ProxyConnectionError(ProxyError):
+    """Error raised when proxy connection fails."""
+
+    def __init__(
+        self, message: str, url: str | None = None, cause: Exception | None = None
+    ):
+        """Initialize with a message, URL, and cause.
+
+        Args:
+            message: The error message
+            url: The URL that failed to connect
+            cause: The underlying exception
+        """
+        super().__init__(message, cause)
+        self.url = url
+
+
+class ProxyTimeoutError(ProxyError):
+    """Error raised when proxy operation times out."""
+
+    def __init__(
+        self,
+        message: str,
+        timeout: float | None = None,
+        cause: Exception | None = None,
+    ):
+        """Initialize with a message, timeout value, and cause.
+
+        Args:
+            message: The error message
+            timeout: The timeout value in seconds
+            cause: The underlying exception
+        """
+        super().__init__(message, cause)
+        self.timeout = timeout
+
+
+class ProxyAuthenticationError(ProxyError):
+    """Error raised when proxy authentication fails."""
+
+    def __init__(
+        self,
+        message: str,
+        auth_type: str | None = None,
+        cause: Exception | None = None,
+    ):
+        """Initialize with a message, auth type, and cause.
+
+        Args:
+            message: The error message
+            auth_type: The type of authentication that failed
+            cause: The underlying exception
+        """
+        super().__init__(message, cause)
+        self.auth_type = auth_type
+
+
+# API-level exceptions (consolidated from exceptions.py)
+class ClaudeProxyError(Exception):
+    """Base exception for Claude Proxy errors."""
+
+    def __init__(
+        self,
+        message: str,
+        error_type: str = "internal_server_error",
+        status_code: int = 500,
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.error_type = error_type
+        self.status_code = status_code
+        self.details = details or {}
+
+
+class ValidationError(ClaudeProxyError):
+    """Validation error (400)."""
+
+    def __init__(self, message: str, details: dict[str, Any] | None = None) -> None:
+        super().__init__(
+            message=message,
+            error_type="invalid_request_error",
+            status_code=400,
+            details=details,
+        )
+
+
+class AuthenticationError(ClaudeProxyError):
+    """Authentication error (401)."""
+
+    def __init__(self, message: str = "Authentication failed") -> None:
+        super().__init__(
+            message=message, error_type="authentication_error", status_code=401
+        )
+
+
+class PermissionError(ClaudeProxyError):
+    """Permission error (403)."""
+
+    def __init__(self, message: str = "Permission denied") -> None:
+        super().__init__(
+            message=message, error_type="permission_error", status_code=403
+        )
+
+
+class NotFoundError(ClaudeProxyError):
+    """Not found error (404)."""
+
+    def __init__(self, message: str = "Resource not found") -> None:
+        super().__init__(message=message, error_type="not_found_error", status_code=404)
+
+
+class RateLimitError(ClaudeProxyError):
+    """Rate limit error (429)."""
+
+    def __init__(self, message: str = "Rate limit exceeded") -> None:
+        super().__init__(
+            message=message, error_type="rate_limit_error", status_code=429
+        )
+
+
+class ModelNotFoundError(ClaudeProxyError):
+    """Model not found error (404)."""
+
+    def __init__(self, model: str) -> None:
+        super().__init__(
+            message=f"Model '{model}' not found",
+            error_type="not_found_error",
+            status_code=404,
+        )
+
+
+class TimeoutError(ClaudeProxyError):
+    """Request timeout error (408)."""
+
+    def __init__(self, message: str = "Request timeout") -> None:
+        super().__init__(message=message, error_type="timeout_error", status_code=408)
+
+
+class ServiceUnavailableError(ClaudeProxyError):
+    """Service unavailable error (503)."""
+
+    def __init__(self, message: str = "Service temporarily unavailable") -> None:
+        super().__init__(
+            message=message, error_type="service_unavailable_error", status_code=503
+        )
+
+
+class DockerError(ClaudeProxyError):
+    """Docker operation error."""
+
+    def __init__(
+        self,
+        message: str,
+        command: str | None = None,
+        cause: Exception | None = None,
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        error_details = details or {}
+        if command:
+            error_details["command"] = command
+        if cause:
+            error_details["cause"] = str(cause)
+            error_details["cause_type"] = type(cause).__name__
+
+        super().__init__(
+            message=message,
+            error_type="docker_error",
+            status_code=500,
+            details=error_details,
+        )
+
+
+__all__ = [
+    # Core proxy errors
+    "ProxyError",
+    "TransformationError",
+    "MiddlewareError",
+    "ProxyConnectionError",
+    "ProxyTimeoutError",
+    "ProxyAuthenticationError",
+    # API-level errors
+    "ClaudeProxyError",
+    "ValidationError",
+    "AuthenticationError",
+    "PermissionError",
+    "NotFoundError",
+    "RateLimitError",
+    "ModelNotFoundError",
+    "TimeoutError",
+    "ServiceUnavailableError",
+    "DockerError",
+]

ccproxy/core/http.py

@@ -0,0 +1,328 @@
+"""Generic HTTP client abstractions for pure forwarding without business logic."""
+
+import os
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import structlog
+
+
+logger = structlog.get_logger(__name__)
+
+
+if TYPE_CHECKING:
+    import httpx
+
+
+class HTTPClient(ABC):
+    """Abstract HTTP client interface for generic HTTP operations."""
+
+    @abstractmethod
+    async def request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: bytes | None = None,
+        timeout: float | None = None,
+    ) -> tuple[int, dict[str, str], bytes]:
+        """Make an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            url: Target URL
+            headers: HTTP headers
+            body: Request body (optional)
+            timeout: Request timeout in seconds (optional)
+
+        Returns:
+            Tuple of (status_code, response_headers, response_body)
+
+        Raises:
+            HTTPError: If the request fails
+        """
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close any resources held by the HTTP client."""
+        pass
+
+
+class BaseProxyClient:
+    """Generic proxy client with no business logic - pure forwarding."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        """Initialize with an HTTP client.
+
+        Args:
+            http_client: The HTTP client to use for requests
+        """
+        self.http_client = http_client
+
+    async def forward(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: bytes | None = None,
+        timeout: float | None = None,
+    ) -> tuple[int, dict[str, str], bytes]:
+        """Forward an HTTP request without any transformations.
+
+        Args:
+            method: HTTP method
+            url: Target URL
+            headers: HTTP headers
+            body: Request body (optional)
+            timeout: Request timeout in seconds (optional)
+
+        Returns:
+            Tuple of (status_code, response_headers, response_body)
+
+        Raises:
+            HTTPError: If the request fails
+        """
+        return await self.http_client.request(method, url, headers, body, timeout)
+
+    async def close(self) -> None:
+        """Close any resources held by the proxy client."""
+        await self.http_client.close()
+
+
+class HTTPError(Exception):
+    """Base exception for HTTP client errors."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        """Initialize HTTP error.
+
+        Args:
+            message: Error message
+            status_code: HTTP status code (optional)
+        """
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class HTTPTimeoutError(HTTPError):
+    """Exception raised when HTTP request times out."""
+
+    def __init__(self, message: str = "Request timed out") -> None:
+        """Initialize timeout error.
+
+        Args:
+            message: Error message
+        """
+        super().__init__(message, status_code=408)
+
+
+class HTTPConnectionError(HTTPError):
+    """Exception raised when HTTP connection fails."""
+
+    def __init__(self, message: str = "Connection failed") -> None:
+        """Initialize connection error.
+
+        Args:
+            message: Error message
+        """
+        super().__init__(message, status_code=503)
+
+
+class HTTPXClient(HTTPClient):
+    """HTTPX-based HTTP client implementation."""
+
+    def __init__(
+        self,
+        timeout: float = 240.0,
+        proxy: str | None = None,
+        verify: bool | str = True,
+    ) -> None:
+        """Initialize HTTPX client.
+
+        Args:
+            timeout: Request timeout in seconds
+            proxy: HTTP proxy URL (optional)
+            verify: SSL verification (True/False or path to CA bundle)
+        """
+        import httpx
+
+        self.timeout = timeout
+        self.proxy = proxy
+        self.verify = verify
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> "httpx.AsyncClient":
+        """Get or create the HTTPX client."""
+        if self._client is None:
+            import httpx
+
+            self._client = httpx.AsyncClient(
+                timeout=self.timeout,
+                proxy=self.proxy,
+                verify=self.verify,
+            )
+        return self._client
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: bytes | None = None,
+        timeout: float | None = None,
+    ) -> tuple[int, dict[str, str], bytes]:
+        """Make an HTTP request using HTTPX.
+
+        Args:
+            method: HTTP method
+            url: Target URL
+            headers: HTTP headers
+            body: Request body (optional)
+            timeout: Request timeout in seconds (optional)
+
+        Returns:
+            Tuple of (status_code, response_headers, response_body)
+
+        Raises:
+            HTTPError: If the request fails
+        """
+        import httpx
+
+        try:
+            client = await self._get_client()
+
+            # Use provided timeout if available
+            if timeout is not None:
+                # Create a new client with different timeout if needed
+                import httpx
+
+                client = httpx.AsyncClient(
+                    timeout=timeout,
+                    proxy=self.proxy,
+                    verify=self.verify,
+                )
+
+            response = await client.request(
+                method=method,
+                url=url,
+                headers=headers,
+                content=body,
+            )
+
+            # Always return the response, even for error status codes
+            # This allows the proxy to forward upstream errors directly
+            return (
+                response.status_code,
+                dict(response.headers),
+                response.content,
+            )
+
+        except httpx.TimeoutException as e:
+            raise HTTPTimeoutError(f"Request timed out: {e}") from e
+        except httpx.ConnectError as e:
+            raise HTTPConnectionError(f"Connection failed: {e}") from e
+        except httpx.HTTPStatusError as e:
+            # This shouldn't happen with the default raise_for_status=False
+            # but keep it just in case
+            raise HTTPError(
+                f"HTTP {e.response.status_code}: {e.response.reason_phrase}",
+                status_code=e.response.status_code,
+            ) from e
+        except Exception as e:
+            raise HTTPError(f"HTTP request failed: {e}") from e
+
+    async def stream(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        content: bytes | None = None,
+    ) -> Any:
+        """Create a streaming HTTP request.
+
+        Args:
+            method: HTTP method
+            url: Target URL
+            headers: HTTP headers
+            content: Request body (optional)
+
+        Returns:
+            HTTPX streaming response context manager
+        """
+        client = await self._get_client()
+        return client.stream(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+        )
+
+    async def close(self) -> None:
+        """Close the HTTPX client."""
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+
+def get_proxy_url() -> str | None:
+    """Get proxy URL from environment variables.
+
+    Returns:
+        str or None: Proxy URL if any proxy is set
+    """
+    # Check for standard proxy environment variables
+    # For HTTPS requests, prioritize HTTPS_PROXY
+    https_proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+    all_proxy = os.environ.get("ALL_PROXY")
+    http_proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+
+    proxy_url = https_proxy or all_proxy or http_proxy
+
+    if proxy_url:
+        logger.debug(
+            "proxy_configured",
+            proxy_url=proxy_url,
+            operation="get_proxy_url",
+        )
+
+    return proxy_url
+
+
+def get_ssl_context() -> str | bool:
+    """Get SSL context configuration from environment variables.
+
+    Returns:
+        SSL verification configuration:
+        - Path to CA bundle file
+        - True for default verification
+        - False to disable verification (insecure)
+    """
+    # Check for custom CA bundle
+    ca_bundle = os.environ.get("REQUESTS_CA_BUNDLE") or os.environ.get("SSL_CERT_FILE")
+
+    # Check if SSL verification should be disabled (NOT RECOMMENDED)
+    ssl_verify = os.environ.get("SSL_VERIFY", "true").lower()
+
+    if ca_bundle and Path(ca_bundle).exists():
+        logger.info(
+            "ssl_ca_bundle_configured",
+            ca_bundle_path=ca_bundle,
+            operation="get_ssl_context",
+        )
+        return ca_bundle
+    elif ssl_verify in ("false", "0", "no"):
+        logger.warning(
+            "ssl_verification_disabled",
+            ssl_verify_value=ssl_verify,
+            operation="get_ssl_context",
+            security_warning=True,
+        )
+        return False
+    else:
+        logger.debug(
+            "ssl_default_verification",
+            ssl_verify_value=ssl_verify,
+            operation="get_ssl_context",
+        )
+        return True