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

ccproxy/models/__init__.py

@@ -1,164 +1,13 @@
-"""Pydantic models for Claude Proxy API Server."""
+"""Pydantic models for Claude Proxy API Server.
 
-from .claude_sdk import (
-    AssistantMessage,
-    ContentBlock,
-    ExtendedContentBlock,
-    ResultMessage,
-    ResultMessageBlock,
-    SDKContentBlock,
-    SDKMessageMode,
-    TextBlock,
-    ToolResultBlock,
-    ToolResultSDKBlock,
-    ToolUseBlock,
-    ToolUseSDKBlock,
-    UserMessage,
-    convert_sdk_result_message,
-    convert_sdk_system_message,
-    convert_sdk_text_block,
-    convert_sdk_tool_result_block,
-    convert_sdk_tool_use_block,
-    to_sdk_variant,
-)
-from .messages import (
-    MessageContentBlock,
-    MessageCreateParams,
-    MessageResponse,
-    MetadataParams,
-    SystemMessage,
-    ThinkingConfig,
-    ToolChoiceParams,
-)
-from .requests import (
-    ImageContent,
-    Message,
-    MessageContent,
-    TextContent,
-    ToolDefinition,
-    Usage,
-)
-from .responses import (
-    APIError,
-    AuthenticationError,
-    ChatCompletionResponse,
-    Choice,
-    ErrorResponse,
-    InternalServerError,
-    InvalidRequestError,
-    NotFoundError,
-    OverloadedError,
-    RateLimitError,
-    ResponseContent,
-    StreamingChatCompletionResponse,
-    StreamingChoice,
-    TextResponse,
-    ToolCall,
-    ToolUse,
-)
-from .types import (
-    ContentBlockType,
-    ErrorType,
-    ImageSourceType,
-    MessageRole,
-    ModalityType,
-    OpenAIFinishReason,
-    PermissionBehavior,
-    ResponseFormatType,
-    ServiceTier,
-    StopReason,
-    StreamEventType,
-    ToolChoiceType,
-    ToolType,
-)
+This package now re-exports Anthropic models from ccproxy.llms.models.anthropic
+for backward compatibility, while keeping provider-agnostic models here.
+"""
+
+from .provider import ProviderConfig
 
 
 __all__ = [
-    # Type aliases
-    "ContentBlockType",
-    "ErrorType",
-    "ImageSourceType",
-    "MessageRole",
-    "ModalityType",
-    "OpenAIFinishReason",
-    "PermissionBehavior",
-    "ResponseFormatType",
-    "ServiceTier",
-    "StopReason",
-    "StreamEventType",
-    "ToolChoiceType",
-    "ToolType",
-    # Claude SDK models
-    "AssistantMessage",
-    "ContentBlock",
-    "ExtendedContentBlock",
-    "ResultMessage",
-    "ResultMessageBlock",
-    "SDKContentBlock",
-    "SDKMessageMode",
-    "TextBlock",
-    "ToolResultBlock",
-    "ToolResultSDKBlock",
-    "ToolUseBlock",
-    "ToolUseSDKBlock",
-    "UserMessage",
-    "convert_sdk_result_message",
-    "convert_sdk_system_message",
-    "convert_sdk_text_block",
-    "convert_sdk_tool_result_block",
-    "convert_sdk_tool_use_block",
-    "to_sdk_variant",
-    # Message models
-    "MessageContentBlock",
-    "MessageCreateParams",
-    "MessageResponse",
-    "MetadataParams",
-    "SystemMessage",
-    "ThinkingConfig",
-    "ToolChoiceParams",
-    # Request models
-    "ImageContent",
-    "Message",
-    "MessageContent",
-    "TextContent",
-    "ToolDefinition",
-    "Usage",
-    # Response models
-    "APIError",
-    "AuthenticationError",
-    "ChatCompletionResponse",
-    "Choice",
-    "ErrorResponse",
-    "InternalServerError",
-    "InvalidRequestError",
-    "NotFoundError",
-    "OverloadedError",
-    "RateLimitError",
-    "ResponseContent",
-    "StreamingChatCompletionResponse",
-    "StreamingChoice",
-    "TextResponse",
-    "ToolCall",
-    "ToolUse",
-    # OpenAI-compatible models
-    "OpenAIChatCompletionRequest",
-    "OpenAIChatCompletionResponse",
-    "OpenAIChoice",
-    "OpenAIErrorDetail",
-    "OpenAIErrorResponse",
-    "OpenAIFunction",
-    "OpenAILogprobs",
-    "OpenAIMessage",
-    "OpenAIMessageContent",
-    "OpenAIModelInfo",
-    "OpenAIModelsResponse",
-    "OpenAIResponseFormat",
-    "OpenAIResponseMessage",
-    "OpenAIStreamingChatCompletionResponse",
-    "OpenAIStreamingChoice",
-    "OpenAIStreamOptions",
-    "OpenAITool",
-    "OpenAIToolCall",
-    "OpenAIToolChoice",
-    "OpenAIUsage",
+    # Provider models
+    "ProviderConfig",
 ]

ccproxy/models/detection.py

@@ -1,208 +1,107 @@
-"""Detection models for Claude Code CLI headers and system prompt extraction."""
+"""Shared helper dataclasses for plugin detection caches."""
 
 from __future__ import annotations
 
-from datetime import UTC, datetime
-from typing import Annotated, Any
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class ClaudeCodeHeaders(BaseModel):
-    """Pydantic model for Claude CLI headers extraction with field aliases."""
-
-    anthropic_beta: str = Field(
-        alias="anthropic-beta",
-        description="Anthropic beta features",
-        default="claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
-    )
-    anthropic_version: str = Field(
-        alias="anthropic-version",
-        description="Anthropic API version",
-        default="2023-06-01",
-    )
-    anthropic_dangerous_direct_browser_access: str = Field(
-        alias="anthropic-dangerous-direct-browser-access",
-        description="Browser access flag",
-        default="true",
-    )
-    x_app: str = Field(
-        alias="x-app", description="Application identifier", default="cli"
-    )
-    user_agent: str = Field(
-        alias="user-agent",
-        description="User agent string",
-        default="claude-cli/1.0.60 (external, cli)",
-    )
-    x_stainless_lang: str = Field(
-        alias="x-stainless-lang", description="SDK language", default="js"
-    )
-    x_stainless_retry_count: str = Field(
-        alias="x-stainless-retry-count", description="Retry count", default="0"
-    )
-    x_stainless_timeout: str = Field(
-        alias="x-stainless-timeout", description="Request timeout", default="60"
-    )
-    x_stainless_package_version: str = Field(
-        alias="x-stainless-package-version",
-        description="Package version",
-        default="0.55.1",
-    )
-    x_stainless_os: str = Field(
-        alias="x-stainless-os", description="Operating system", default="Linux"
-    )
-    x_stainless_arch: str = Field(
-        alias="x-stainless-arch", description="Architecture", default="x64"
-    )
-    x_stainless_runtime: str = Field(
-        alias="x-stainless-runtime", description="Runtime", default="node"
-    )
-    x_stainless_runtime_version: str = Field(
-        alias="x-stainless-runtime-version",
-        description="Runtime version",
-        default="v24.3.0",
-    )
-
-    model_config = ConfigDict(extra="ignore", populate_by_name=True)
-
-    def to_headers_dict(self) -> dict[str, str]:
-        """Convert to headers dictionary for HTTP forwarding with proper case."""
-        headers = {}
-
-        # Map field names to proper HTTP header names
-        header_mapping = {
-            "anthropic_beta": "anthropic-beta",
-            "anthropic_version": "anthropic-version",
-            "anthropic_dangerous_direct_browser_access": "anthropic-dangerous-direct-browser-access",
-            "x_app": "x-app",
-            "user_agent": "User-Agent",
-            "x_stainless_lang": "X-Stainless-Lang",
-            "x_stainless_retry_count": "X-Stainless-Retry-Count",
-            "x_stainless_timeout": "X-Stainless-Timeout",
-            "x_stainless_package_version": "X-Stainless-Package-Version",
-            "x_stainless_os": "X-Stainless-OS",
-            "x_stainless_arch": "X-Stainless-Arch",
-            "x_stainless_runtime": "X-Stainless-Runtime",
-            "x_stainless_runtime_version": "X-Stainless-Runtime-Version",
+from collections.abc import ItemsView, Iterable
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class DetectedHeaders:
+    """Normalized, lowercase HTTP headers captured during CLI detection."""
+
+    values: dict[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        normalized: dict[str, str] = {}
+        for key, raw_value in (self.values or {}).items():
+            if key is None:
+                continue
+            normalized_key = str(key).lower()
+            normalized[normalized_key] = "" if raw_value is None else str(raw_value)
+        self.values = normalized
+
+    def as_dict(self) -> dict[str, str]:
+        """Return a copy of the detected headers as a plain dict."""
+
+        return dict(self.values)
+
+    def filtered(
+        self,
+        ignores: Iterable[str] | None = None,
+        redacted: Iterable[str] | None = None,
+    ) -> dict[str, str]:
+        """Return headers filtered for safe forwarding."""
+
+        ignore_set = {item.lower() for item in ignores or ()}
+        redacted_set = {item.lower() for item in redacted or ()}
+        return {
+            key: value
+            for key, value in self.values.items()
+            if value and key not in ignore_set and key not in redacted_set
         }
 
-        for field_name, header_name in header_mapping.items():
-            value = getattr(self, field_name, None)
-            if value is not None:
-                headers[header_name] = value
-
-        return headers
-
-
-class SystemPromptData(BaseModel):
-    """Extracted system prompt information."""
-
-    system_field: Annotated[
-        str | list[dict[str, Any]],
-        Field(
-            description="Complete system field as detected from Claude CLI, preserving exact structure including type, text, and cache_control"
-        ),
-    ]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ClaudeCacheData(BaseModel):
-    """Cached Claude CLI detection data with version tracking."""
-
-    claude_version: Annotated[str, Field(description="Claude CLI version")]
-    headers: Annotated[ClaudeCodeHeaders, Field(description="Extracted headers")]
-    system_prompt: Annotated[
-        SystemPromptData, Field(description="Extracted system prompt")
-    ]
-    cached_at: Annotated[
-        datetime,
-        Field(
-            description="Cache timestamp",
-            default_factory=lambda: datetime.now(UTC),
-        ),
-    ] = None  # type: ignore # Pydantic handles this via default_factory
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class CodexHeaders(BaseModel):
-    """Pydantic model for Codex CLI headers extraction with field aliases."""
-
-    session_id: str = Field(
-        alias="session_id",
-        description="Codex session identifier",
-        default="",
-    )
-    originator: str = Field(
-        description="Codex originator identifier",
-        default="codex_cli_rs",
-    )
-    openai_beta: str = Field(
-        alias="openai-beta",
-        description="OpenAI beta features",
-        default="responses=experimental",
-    )
-    version: str = Field(
-        description="Codex CLI version",
-        default="0.21.0",
-    )
-    chatgpt_account_id: str = Field(
-        alias="chatgpt-account-id",
-        description="ChatGPT account identifier",
-        default="",
-    )
-
-    model_config = ConfigDict(extra="ignore", populate_by_name=True)
-
-    def to_headers_dict(self) -> dict[str, str]:
-        """Convert to headers dictionary for HTTP forwarding with proper case."""
-        headers = {}
-
-        # Map field names to proper HTTP header names
-        header_mapping = {
-            "session_id": "session_id",
-            "originator": "originator",
-            "openai_beta": "openai-beta",
-            "version": "version",
-            "chatgpt_account_id": "chatgpt-account-id",
-        }
+    def get(self, key: str, default: str | None = None) -> str | None:
+        """Lookup a header by key (case-insensitive)."""
+
+        return self.values.get(key.lower(), default)
+
+    def items(self) -> ItemsView[str, str]:
+        """Iterate over header key/value pairs."""
+
+        return self.values.items()
+
+    def __bool__(self) -> bool:
+        return bool(self.values)
+
+
+@dataclass(slots=True)
+class DetectedPrompts:
+    """Structured prompt metadata extracted from CLI detection payloads."""
+
+    instructions: str | None = None
+    system: Any | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_body(cls, body: Any | None) -> DetectedPrompts:
+        """Build a DetectedPrompts instance from a captured request body."""
+
+        if not isinstance(body, dict):
+            return cls(raw={} if body is None else {"__raw__": body})
+
+        body_copy = deepcopy(body)
+
+        instructions = body_copy.get("instructions")
+        if not isinstance(instructions, str) or not instructions.strip():
+            instructions = None
 
-        for field_name, header_name in header_mapping.items():
-            value = getattr(self, field_name, None)
-            if value is not None and value != "":
-                headers[header_name] = value
+        system_value = body_copy.get("system")
 
-        return headers
+        return cls(instructions=instructions, system=system_value, raw=body_copy)
 
+    def instructions_payload(self) -> dict[str, Any]:
+        """Return a payload suitable for injecting Codex-style instructions."""
 
-class CodexInstructionsData(BaseModel):
-    """Extracted Codex instructions information."""
+        if self.instructions:
+            return {"instructions": self.instructions}
+        return {}
 
-    instructions_field: Annotated[
-        str,
-        Field(
-            description="Complete instructions field as detected from Codex CLI, preserving exact text content"
-        ),
-    ]
+    def system_payload(self, mode: str = "full") -> dict[str, Any]:
+        """Return anthropic-style system data respecting the requested mode."""
 
-    model_config = ConfigDict(extra="forbid")
+        if self.system is None or mode == "none":
+            return {}
 
+        if mode == "minimal" and isinstance(self.system, list):
+            return {"system": self.system[:1]} if self.system else {}
 
-class CodexCacheData(BaseModel):
-    """Cached Codex CLI detection data with version tracking."""
+        return {"system": self.system}
 
-    codex_version: Annotated[str, Field(description="Codex CLI version")]
-    headers: Annotated[CodexHeaders, Field(description="Extracted headers")]
-    instructions: Annotated[
-        CodexInstructionsData, Field(description="Extracted instructions")
-    ]
-    cached_at: Annotated[
-        datetime,
-        Field(
-            description="Cache timestamp",
-            default_factory=lambda: datetime.now(UTC),
-        ),
-    ] = None  # type: ignore # Pydantic handles this via default_factory
+    def has_system(self) -> bool:
+        return bool(self.system)
 
-    model_config = ConfigDict(extra="forbid")
+    def has_instructions(self) -> bool:
+        return bool(self.instructions)

ccproxy/models/provider.py

@@ -0,0 +1,75 @@
+"""Provider configuration models."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelMappingRule(BaseModel):
+    """Ordered mapping rule for translating client model identifiers."""
+
+    match: str = Field(..., description="Client-facing model identifier or pattern")
+    target: str = Field(..., description="Upstream model identifier to use")
+    kind: Literal["exact", "regex", "prefix", "suffix"] = Field(
+        default="exact",
+        description="Type of match to apply for this rule",
+    )
+    flags: list[Literal["IGNORECASE"]] = Field(
+        default_factory=list,
+        description="Optional regex flags to apply when kind=regex",
+    )
+    notes: str | None = Field(
+        default=None,
+        description="Optional human-readable description of this rule",
+    )
+
+
+class ModelCard(BaseModel):
+    """Representation of a model entry returned by /models."""
+
+    id: str = Field(..., description="Unique model identifier exposed to clients")
+    object: str = Field(default="model", description="OpenAI-compatible object type")
+    created: int | None = Field(
+        default=None, description="Unix timestamp when the model became available"
+    )
+    owned_by: str | None = Field(
+        default=None, description="Provider or organization that owns the model"
+    )
+    permission: list[dict[str, Any]] | None = Field(
+        default=None,
+        description="Optional list of permission descriptors",
+    )
+    root: str | None = Field(
+        default=None, description="Root model identifier for fine-tuned variants"
+    )
+    parent: str | None = Field(
+        default=None, description="Parent model identifier, if any"
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ProviderConfig(BaseModel):
+    """Configuration for a provider plugin."""
+
+    name: str = Field(..., description="Provider name")
+    base_url: str = Field(..., description="Base URL for the provider API")
+    supports_streaming: bool = Field(
+        default=False, description="Whether the provider supports streaming"
+    )
+    requires_auth: bool = Field(
+        default=True, description="Whether the provider requires authentication"
+    )
+    auth_type: str | None = Field(
+        default=None, description="Authentication type (bearer, api_key, etc.)"
+    )
+    model_mappings: list[ModelMappingRule] = Field(
+        default_factory=list,
+        description="Ordered list of client→upstream model mapping rules",
+    )
+    models_endpoint: list[ModelCard] = Field(
+        default_factory=list,
+        description="Model metadata returned by the provider's /models endpoint",
+    )

ccproxy/plugins/access_log/README.md

@@ -0,0 +1,32 @@
+# Access Log Plugin
+
+Captures client and provider traffic and writes structured access logs.
+
+## Highlights
+- Hooks into request lifecycle events to log Common, Combined, or JSON formats
+- Supports per-channel enablement and configurable log destinations
+- Optionally forwards records to the analytics ingest service for persistence
+
+## Configuration
+- `AccessLogConfig` controls enable flags, formats, and file paths
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin access_log`
+
+```toml
+[plugins.access_log]
+# enabled = true
+# client_enabled = true
+# client_format = "structured"
+# client_log_file = "/tmp/ccproxy/access.log"
+# provider_enabled = false
+# provider_format = "structured"
+# provider_log_file = "/tmp/ccproxy/provider_access.log"
+# exclude_paths = ["/health", "/metrics", "/readyz", "/livez"]
+# buffer_size = 100
+# flush_interval = 1.0
+```
+
+## Related Components
+- `plugin.py`: runtime lifecycle and hook registration
+- `hook.py`: event handler that formats and writes log entries
+- `formatter.py` / `writer.py`: formatting helpers and async file writer

ccproxy/plugins/access_log/__init__.py

@@ -0,0 +1,20 @@
+"""Access log plugin for CCProxy.
+
+Provides structured access logging for both client and provider requests
+using the hook system.
+"""
+
+from .config import AccessLogConfig
+from .hook import AccessLogHook
+from .plugin import AccessLogFactory, AccessLogRuntime
+
+
+__all__ = [
+    "AccessLogConfig",
+    "AccessLogFactory",
+    "AccessLogHook",
+    "AccessLogRuntime",
+]
+
+# Export the factory instance for plugin loading
+factory = AccessLogFactory()

ccproxy/plugins/access_log/config.py

@@ -0,0 +1,33 @@
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+
+class AccessLogConfig(BaseModel):
+    """Configuration for access logging.
+
+    Supports logging at both client and provider levels with
+    different formats for each.
+    """
+
+    # Global enable/disable
+    enabled: bool = True
+
+    # Client-level access logging
+    client_enabled: bool = True
+    client_format: Literal["combined", "common", "structured"] = "structured"
+    client_log_file: str = "/tmp/ccproxy/access.log"
+
+    # Provider-level access logging (optional)
+    provider_enabled: bool = False
+    provider_format: Literal["structured"] = "structured"
+    provider_log_file: str = "/tmp/ccproxy/provider_access.log"
+
+    # Path filters (only for client level)
+    exclude_paths: list[str] = ["/health", "/metrics", "/readyz", "/livez"]
+
+    # Performance options
+    buffer_size: int = 100  # Buffer this many log entries before writing
+    flush_interval: float = 1.0  # Flush buffer every N seconds
+
+    model_config = ConfigDict()