ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/models/__init__.py

@@ -0,0 +1,123 @@
+"""Pydantic models for Claude Proxy API Server."""
+
+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,
+)
+
+
+__all__ = [
+    # Type aliases
+    "ContentBlockType",
+    "ErrorType",
+    "ImageSourceType",
+    "MessageRole",
+    "ModalityType",
+    "OpenAIFinishReason",
+    "PermissionBehavior",
+    "ResponseFormatType",
+    "ServiceTier",
+    "StopReason",
+    "StreamEventType",
+    "ToolChoiceType",
+    "ToolType",
+    # 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",
+]

ccproxy/models/errors.py

@@ -0,0 +1,42 @@
+"""Error response models for Anthropic API compatibility."""
+
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class ErrorDetail(BaseModel):
+    """Error detail information."""
+
+    type: Annotated[str, Field(description="Error type identifier")]
+    message: Annotated[str, Field(description="Human-readable error message")]
+
+
+class AnthropicError(BaseModel):
+    """Anthropic API error response format."""
+
+    type: Annotated[Literal["error"], Field(description="Error type")] = "error"
+    error: Annotated[ErrorDetail, Field(description="Error details")]
+
+
+# Note: Specific error model classes were removed as they were unused.
+# Error responses are now forwarded directly from the upstream Claude API
+# to preserve the exact error format and headers.
+
+
+def create_error_response(
+    error_type: str, message: str, status_code: int = 500
+) -> tuple[dict[str, Any], int]:
+    """
+    Create a standardized error response.
+
+    Args:
+        error_type: Type of error (e.g., "invalid_request_error")
+        message: Human-readable error message
+        status_code: HTTP status code
+
+    Returns:
+        Tuple of (error_dict, status_code)
+    """
+    error_response = AnthropicError(error=ErrorDetail(type=error_type, message=message))
+    return error_response.model_dump(), status_code

ccproxy/models/messages.py

@@ -0,0 +1,243 @@
+"""Message models for Anthropic Messages API endpoint."""
+
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from .requests import Message, ToolDefinition, Usage
+from .types import ContentBlockType, ServiceTier, StopReason, ToolChoiceType
+
+
+class SystemMessage(BaseModel):
+    """System message content block."""
+
+    type: Annotated[Literal["text"], Field(description="Content type")] = "text"
+    text: Annotated[str, Field(description="System message text")]
+
+
+class ThinkingConfig(BaseModel):
+    """Configuration for extended thinking process."""
+
+    type: Annotated[Literal["enabled"], Field(description="Enable thinking mode")] = (
+        "enabled"
+    )
+    budget_tokens: Annotated[
+        int, Field(description="Token budget for thinking process", ge=1024)
+    ]
+
+
+class MetadataParams(BaseModel):
+    """Metadata about the request."""
+
+    user_id: Annotated[
+        str | None,
+        Field(description="External identifier for the user", max_length=256),
+    ] = None
+
+    class Config:
+        extra = "allow"  # Allow additional fields in metadata
+
+
+class ToolChoiceParams(BaseModel):
+    """Tool choice configuration."""
+
+    type: Annotated[ToolChoiceType, Field(description="How the model should use tools")]
+    name: Annotated[
+        str | None, Field(description="Specific tool name (when type is 'tool')")
+    ] = None
+    disable_parallel_tool_use: Annotated[
+        bool, Field(description="Disable parallel tool use")
+    ] = False
+
+
+class MessageCreateParams(BaseModel):
+    """Request parameters for creating messages via Anthropic Messages API."""
+
+    # Required fields
+    model: Annotated[
+        str,
+        Field(
+            description="The model to use for the message",
+            pattern=r"^claude-.*",
+        ),
+    ]
+    messages: Annotated[
+        list[Message],
+        Field(
+            description="Array of messages in the conversation",
+            min_length=1,
+        ),
+    ]
+    max_tokens: Annotated[
+        int,
+        Field(
+            description="Maximum number of tokens to generate",
+            ge=1,
+            le=200000,
+        ),
+    ]
+
+    # Optional Anthropic API fields
+    system: Annotated[
+        str | list[SystemMessage] | None,
+        Field(description="System prompt to provide context and instructions"),
+    ] = None
+    temperature: Annotated[
+        float | None,
+        Field(
+            description="Sampling temperature between 0.0 and 1.0",
+            ge=0.0,
+            le=1.0,
+        ),
+    ] = None
+    top_p: Annotated[
+        float | None,
+        Field(
+            description="Nucleus sampling parameter",
+            ge=0.0,
+            le=1.0,
+        ),
+    ] = None
+    top_k: Annotated[
+        int | None,
+        Field(
+            description="Top-k sampling parameter",
+            ge=0,
+        ),
+    ] = None
+    stop_sequences: Annotated[
+        list[str] | None,
+        Field(
+            description="Custom sequences where the model should stop generating",
+            max_length=4,
+        ),
+    ] = None
+    stream: Annotated[
+        bool | None,
+        Field(description="Whether to stream the response"),
+    ] = False
+    metadata: Annotated[
+        MetadataParams | None,
+        Field(description="Metadata about the request, including optional user_id"),
+    ] = None
+    tools: Annotated[
+        list[ToolDefinition] | None,
+        Field(description="Available tools/functions for the model to use"),
+    ] = None
+    tool_choice: Annotated[
+        ToolChoiceParams | None,
+        Field(description="How the model should use the provided tools"),
+    ] = None
+    service_tier: Annotated[
+        ServiceTier | None,
+        Field(description="Request priority level"),
+    ] = None
+    thinking: Annotated[
+        ThinkingConfig | None,
+        Field(description="Configuration for extended thinking process"),
+    ] = None
+
+    @field_validator("model")
+    @classmethod
+    def validate_model(cls, v: str) -> str:
+        """Validate that the model is a supported Claude model."""
+        supported_models = {
+            "claude-opus-4-20250514",
+            "claude-sonnet-4-20250514",
+            "claude-3-7-sonnet-20250219",
+            "claude-3-5-sonnet-20241022",
+            "claude-3-5-sonnet-20240620",
+            "claude-3-5-haiku-20241022",
+            "claude-3-opus-20240229",
+            "claude-3-sonnet-20240229",
+            "claude-3-haiku-20240307",
+            "claude-3-5-sonnet",
+            "claude-3-5-haiku",
+            "claude-3-opus",
+            "claude-3-sonnet",
+            "claude-3-haiku",
+        }
+
+        if v not in supported_models and not v.startswith("claude-"):
+            raise ValueError(f"Model {v} is not supported")
+
+        return v
+
+    @field_validator("messages")
+    @classmethod
+    def validate_messages(cls, v: list[Message]) -> list[Message]:
+        """Validate message alternation and content."""
+        if not v:
+            raise ValueError("At least one message is required")
+
+        # First message must be from user
+        if v[0].role != "user":
+            raise ValueError("First message must be from user")
+
+        # Check for proper alternation
+        for i in range(1, len(v)):
+            if v[i].role == v[i - 1].role:
+                raise ValueError("Messages must alternate between user and assistant")
+
+        return v
+
+    @field_validator("stop_sequences")
+    @classmethod
+    def validate_stop_sequences(cls, v: list[str] | None) -> list[str] | None:
+        """Validate stop sequences."""
+        if v is not None:
+            if len(v) > 4:
+                raise ValueError("Maximum 4 stop sequences allowed")
+            for seq in v:
+                if len(seq) > 100:
+                    raise ValueError("Stop sequences must be 100 characters or less")
+        return v
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True)
+
+
+class MessageContentBlock(BaseModel):
+    """Content block in a message response."""
+
+    type: Annotated[ContentBlockType, Field(description="Type of content block")]
+    text: Annotated[
+        str | None, Field(description="Text content (for text/thinking blocks)")
+    ] = None
+    id: Annotated[str | None, Field(description="Unique ID (for tool_use blocks)")] = (
+        None
+    )
+    name: Annotated[
+        str | None, Field(description="Tool name (for tool_use blocks)")
+    ] = None
+    input: Annotated[
+        dict[str, Any] | None, Field(description="Tool input (for tool_use blocks)")
+    ] = None
+
+
+class MessageResponse(BaseModel):
+    """Response model for Anthropic Messages API endpoint."""
+
+    id: Annotated[str, Field(description="Unique identifier for the message")]
+    type: Annotated[Literal["message"], Field(description="Response type")] = "message"
+    role: Annotated[Literal["assistant"], Field(description="Message role")] = (
+        "assistant"
+    )
+    content: Annotated[
+        list[MessageContentBlock],
+        Field(description="Array of content blocks in the response"),
+    ]
+    model: Annotated[str, Field(description="The model used for the response")]
+    stop_reason: Annotated[
+        StopReason | None, Field(description="Reason why the model stopped generating")
+    ] = None
+    stop_sequence: Annotated[
+        str | None,
+        Field(description="The stop sequence that triggered stopping (if applicable)"),
+    ] = None
+    usage: Annotated[Usage, Field(description="Token usage information")]
+    container: Annotated[
+        dict[str, Any] | None,
+        Field(description="Information about container used in the request"),
+    ] = None
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True)

ccproxy/models/requests.py

@@ -0,0 +1,85 @@
+"""Request models for Claude Proxy API Server compatible with Anthropic's API format."""
+
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, validator
+
+
+class ImageSource(BaseModel):
+    """Image source data."""
+
+    type: Annotated[Literal["base64", "url"], Field(description="Source type")]
+    media_type: Annotated[
+        str, Field(description="Media type (e.g., image/jpeg, image/png)")
+    ]
+    data: Annotated[str | None, Field(description="Base64 encoded image data")] = None
+    url: Annotated[str | None, Field(description="Image URL")] = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ImageContent(BaseModel):
+    """Image content block for multimodal messages."""
+
+    type: Annotated[Literal["image"], Field(description="Content type")] = "image"
+    source: Annotated[
+        ImageSource,
+        Field(description="Image source data with type (base64 or url) and media_type"),
+    ]
+
+
+class TextContent(BaseModel):
+    """Text content block for messages."""
+
+    type: Annotated[Literal["text"], Field(description="Content type")] = "text"
+    text: Annotated[str, Field(description="The text content")]
+
+
+MessageContent = TextContent | ImageContent | str
+
+
+class Message(BaseModel):
+    """Individual message in the conversation."""
+
+    role: Annotated[
+        Literal["user", "assistant"],
+        Field(description="The role of the message sender"),
+    ]
+    content: Annotated[
+        str | list[MessageContent], Field(description="The content of the message")
+    ]
+
+
+class FunctionDefinition(BaseModel):
+    """Function definition for tool calling."""
+
+    name: Annotated[str, Field(description="Function name")]
+    description: Annotated[str, Field(description="Function description")]
+    parameters: Annotated[
+        dict[str, Any], Field(description="JSON Schema for function parameters")
+    ]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ToolDefinition(BaseModel):
+    """Tool definition for function calling."""
+
+    type: Annotated[Literal["function"], Field(description="Tool type")] = "function"
+    function: Annotated[
+        FunctionDefinition,
+        Field(description="Function definition with name, description, and parameters"),
+    ]
+
+
+class Usage(BaseModel):
+    """Token usage information."""
+
+    input_tokens: Annotated[int, Field(description="Number of input tokens")] = 0
+    output_tokens: Annotated[int, Field(description="Number of output tokens")] = 0
+    cache_creation_input_tokens: Annotated[
+        int | None, Field(description="Number of tokens used for cache creation")
+    ] = None
+    cache_read_input_tokens: Annotated[
+        int | None, Field(description="Number of tokens read from cache")
+    ] = None