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

ccproxy/core/constants.py

@@ -1,4 +1,9 @@
-"""Core constants used across the CCProxy API."""
+"""Core constants for format identifiers and related shared values."""
+
+# Format identifiers
+FORMAT_OPENAI_CHAT = "openai.chat_completions"
+FORMAT_OPENAI_RESPONSES = "openai.responses"
+FORMAT_ANTHROPIC_MESSAGES = "anthropic.messages"
 
 # HTTP headers
 REQUEST_ID_HEADER = "X-Request-ID"
@@ -46,52 +51,13 @@ CONFIG_FILE_NAMES = [
     "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}$"
+# Common upstream endpoint paths (provider APIs)
+UPSTREAM_ENDPOINT_OPENAI_RESPONSES = "/responses"
+UPSTREAM_ENDPOINT_OPENAI_CHAT_COMPLETIONS = "/chat/completions"
+UPSTREAM_ENDPOINT_ANTHROPIC_MESSAGES = "/v1/messages"
+# Additional common OpenAI-style endpoints
+UPSTREAM_ENDPOINT_OPENAI_EMBEDDINGS = "/embeddings"
+UPSTREAM_ENDPOINT_OPENAI_MODELS = "/models"
+# GitHub Copilot internal API endpoints
+UPSTREAM_ENDPOINT_COPILOT_INTERNAL_USER = "/copilot_internal/user"
+UPSTREAM_ENDPOINT_COPILOT_INTERNAL_TOKEN = "/copilot_internal/v2/token"

ccproxy/core/errors.py

@@ -273,6 +273,57 @@ class PermissionAlreadyResolvedError(PermissionRequestError):
         )
 
 
+class PluginResourceError(ProxyError):
+    """Error raised when a plugin resource is unavailable or misconfigured.
+
+    This is a general exception for plugins to use when required resources
+    (like configuration, external services, or dependencies) are not available.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        plugin_name: str | None = None,
+        resource_type: str | None = None,
+        cause: Exception | None = None,
+    ):
+        """Initialize with a message and optional details.
+
+        Args:
+            message: The error message
+            plugin_name: Name of the plugin encountering the error
+            resource_type: Type of resource that's unavailable (e.g., "instructions", "config", "auth")
+            cause: The underlying exception
+        """
+        super().__init__(message, cause)
+        self.plugin_name = plugin_name
+        self.resource_type = resource_type
+
+
+class PluginLoadError(ProxyError):
+    """Error raised when plugin loading fails.
+
+    This exception is used when plugins cannot be loaded due to import errors,
+    missing dependencies, missing classes, or other loading-related issues.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        plugin_name: str | None = None,
+        cause: Exception | None = None,
+    ):
+        """Initialize with a message and optional details.
+
+        Args:
+            message: The error message
+            plugin_name: Name of the plugin that failed to load
+            cause: The underlying exception
+        """
+        super().__init__(message, cause)
+        self.plugin_name = plugin_name
+
+
 __all__ = [
     # Core proxy errors
     "ProxyError",
@@ -281,6 +332,8 @@ __all__ = [
     "ProxyConnectionError",
     "ProxyTimeoutError",
     "ProxyAuthenticationError",
+    "PluginResourceError",
+    "PluginLoadError",
     # API-level errors
     "ClaudeProxyError",
     "ValidationError",

ccproxy/core/id_utils.py

@@ -0,0 +1,20 @@
+"""Utilities for generating short, debug-friendly IDs."""
+
+import uuid
+
+
+# Length of generated IDs - easily adjustable
+ID_LENGTH = 8
+
+
+def generate_short_id() -> str:
+    """Generate a short, debug-friendly ID.
+
+    Creates an 8-character hex string from a UUID4, providing good
+    collision resistance while being much easier to type and remember
+    during debugging.
+
+    Returns:
+        Short hex string (e.g., 'f47ac10b')
+    """
+    return uuid.uuid4().hex[:ID_LENGTH]

ccproxy/core/interfaces.py

@@ -8,7 +8,6 @@ from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator
 from typing import Any, Protocol, TypeVar, runtime_checkable
 
-from ccproxy.auth.models import ClaudeCredentials
 from ccproxy.core.types import TransformContext
 
 
@@ -17,12 +16,12 @@ __all__ = [
     "RequestTransformer",
     "ResponseTransformer",
     "StreamTransformer",
-    "APIAdapter",
     "TransformerProtocol",
     # Storage interfaces
-    "TokenStorage",
     # Metrics interfaces
     "MetricExporter",
+    # Streaming configuration protocol
+    "StreamingConfigurable",
 ]
 
 
@@ -92,65 +91,6 @@ class StreamTransformer(ABC):
         pass
 
 
-class APIAdapter(ABC):
-    """Abstract base class for API format adapters.
-
-    Combines all transformation interfaces to provide a complete adapter
-    for converting between different API formats.
-    """
-
-    @abstractmethod
-    def adapt_request(self, request: dict[str, Any]) -> dict[str, Any]:
-        """Convert a request from one API format to another.
-
-        Args:
-            request: The request data to convert
-
-        Returns:
-            The converted request data
-
-        Raises:
-            ValueError: If the request format is invalid or unsupported
-        """
-        pass
-
-    @abstractmethod
-    def adapt_response(self, response: dict[str, Any]) -> dict[str, Any]:
-        """Convert a response from one API format to another.
-
-        Args:
-            response: The response data to convert
-
-        Returns:
-            The converted response data
-
-        Raises:
-            ValueError: If the response format is invalid or unsupported
-        """
-        pass
-
-    @abstractmethod
-    def adapt_stream(
-        self, stream: AsyncIterator[dict[str, Any]]
-    ) -> AsyncIterator[dict[str, Any]]:
-        """Convert a streaming response from one API format to another.
-
-        Args:
-            stream: The streaming response data to convert
-
-        Yields:
-            The converted streaming response chunks
-
-        Raises:
-            ValueError: If the stream format is invalid or unsupported
-        """
-        # This should be implemented as an async generator
-        # async def adapt_stream(self, stream): ...
-        #     async for item in stream:
-        #         yield transformed_item
-        raise NotImplementedError
-
-
 @runtime_checkable
 class TransformerProtocol(Protocol[T, R]):
     """Protocol defining the transformer interface."""
@@ -160,61 +100,6 @@ class TransformerProtocol(Protocol[T, R]):
         ...
 
 
-# === Storage Interfaces ===
-
-
-class TokenStorage(ABC):
-    """Abstract interface for token storage backends."""
-
-    @abstractmethod
-    async def load(self) -> ClaudeCredentials | None:
-        """Load credentials from storage.
-
-        Returns:
-            Parsed credentials if found and valid, None otherwise
-        """
-        pass
-
-    @abstractmethod
-    async def save(self, credentials: ClaudeCredentials) -> bool:
-        """Save credentials to storage.
-
-        Args:
-            credentials: Credentials to save
-
-        Returns:
-            True if saved successfully, False otherwise
-        """
-        pass
-
-    @abstractmethod
-    async def exists(self) -> bool:
-        """Check if credentials exist in storage.
-
-        Returns:
-            True if credentials exist, False otherwise
-        """
-        pass
-
-    @abstractmethod
-    async def delete(self) -> bool:
-        """Delete credentials from storage.
-
-        Returns:
-            True if deleted successfully, False otherwise
-        """
-        pass
-
-    @abstractmethod
-    def get_location(self) -> str:
-        """Get the storage location description.
-
-        Returns:
-            Human-readable description of where credentials are stored
-        """
-        pass
-
-
 # === Metrics Interfaces ===
 
 
@@ -237,11 +122,19 @@ class MetricExporter(ABC):
         """
         pass
 
-    @abstractmethod
-    async def health_check(self) -> bool:
-        """Check if the metrics export system is healthy.
 
-        Returns:
-            True if the system is healthy, False otherwise
+@runtime_checkable
+class StreamingConfigurable(Protocol):
+    """Protocol for adapters that accept streaming-related configuration.
+
+    Implementers can use this to receive DI-injected toggles such as whether
+    to serialize thinking content as XML in OpenAI streams.
+    """
+
+    def configure_streaming(self, *, openai_thinking_xml: bool | None = None) -> None:
+        """Apply streaming flags.
+
+        Args:
+            openai_thinking_xml: Enable/disable thinking-as-XML in OpenAI streams
         """
-        pass
+        ...