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

ccproxy/models/messages.py

@@ -1,269 +0,0 @@
-"""Message models for Anthropic Messages API endpoint."""
-
-from typing import TYPE_CHECKING, Annotated, Any, Literal
-
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-
-from .claude_sdk import SDKContentBlock
-from .requests import Message, ToolDefinition, Usage
-
-
-if TYPE_CHECKING:
-    pass
-from .types import 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
-
-    model_config = ConfigDict(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
-    stop_reason: 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 TextContentBlock(BaseModel):
-    """Text content block."""
-
-    type: Literal["text"]
-    text: str
-
-
-class ToolUseContentBlock(BaseModel):
-    """Tool use content block."""
-
-    type: Literal["tool_use"]
-    id: str
-    name: str
-    input: dict[str, Any]
-
-
-class ThinkingContentBlock(BaseModel):
-    """Thinking content block."""
-
-    type: Literal["thinking"]
-    thinking: str
-    signature: str | None = None
-
-
-MessageContentBlock = Annotated[
-    TextContentBlock | ToolUseContentBlock | ThinkingContentBlock,
-    Field(discriminator="type"),
-]
-
-
-CCProxyContentBlock = MessageContentBlock | SDKContentBlock
-
-
-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[CCProxyContentBlock],
-        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

@@ -1,107 +0,0 @@
-"""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
-
-
-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
-
-
-class CodexMessage(BaseModel):
-    """Message format for Codex requests."""
-
-    role: Annotated[Literal["user", "assistant"], Field(description="Message role")]
-    content: Annotated[str, Field(description="Message content")]
-
-
-class CodexRequest(BaseModel):
-    """OpenAI Codex completion request model."""
-
-    model: Annotated[str, Field(description="Model name (e.g., gpt-5)")] = "gpt-5"
-    instructions: Annotated[
-        str | None, Field(description="System instructions for the model")
-    ] = None
-    messages: Annotated[list[CodexMessage], Field(description="Conversation messages")]
-    stream: Annotated[bool, Field(description="Whether to stream the response")] = True
-
-    model_config = ConfigDict(
-        extra="allow"
-    )  # Allow additional fields for compatibility

ccproxy/models/responses.py

@@ -1,270 +0,0 @@
-"""Response models for Claude Proxy API Server compatible with Anthropic's API format."""
-
-from typing import Annotated, Any, Literal
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from .requests import Usage
-
-
-class ToolCall(BaseModel):
-    """Tool call made by the model."""
-
-    id: Annotated[str, Field(description="Unique identifier for the tool call")]
-    type: Annotated[Literal["function"], Field(description="Tool call type")] = (
-        "function"
-    )
-    function: Annotated[
-        dict[str, Any],
-        Field(description="Function call details including name and arguments"),
-    ]
-
-
-class ToolUse(BaseModel):
-    """Tool use content block."""
-
-    type: Annotated[Literal["tool_use"], Field(description="Content type")] = "tool_use"
-    id: Annotated[str, Field(description="Unique identifier for the tool use")]
-    name: Annotated[str, Field(description="Name of the tool being used")]
-    input: Annotated[dict[str, Any], Field(description="Input parameters for the tool")]
-
-
-class TextResponse(BaseModel):
-    """Text response content block."""
-
-    type: Annotated[Literal["text"], Field(description="Content type")] = "text"
-    text: Annotated[str, Field(description="The generated text content")]
-
-
-ResponseContent = TextResponse | ToolUse
-
-
-class Choice(BaseModel):
-    """Individual choice in a non-streaming response."""
-
-    index: Annotated[int, Field(description="Index of the choice")]
-    message: Annotated[dict[str, Any], Field(description="The generated message")]
-    finish_reason: Annotated[
-        str | None, Field(description="Reason why the model stopped generating")
-    ] = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class StreamingChoice(BaseModel):
-    """Individual choice in a streaming response."""
-
-    index: Annotated[int, Field(description="Index of the choice")]
-    delta: Annotated[
-        dict[str, Any], Field(description="The incremental message content")
-    ]
-    finish_reason: Annotated[
-        str | None, Field(description="Reason why the model stopped generating")
-    ] = None
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class ChatCompletionResponse(BaseModel):
-    """Response model for Claude chat completions compatible with Anthropic's API."""
-
-    id: Annotated[str, Field(description="Unique identifier for the response")]
-    type: Annotated[Literal["message"], Field(description="Response type")] = "message"
-    role: Annotated[Literal["assistant"], Field(description="Message role")] = (
-        "assistant"
-    )
-    content: Annotated[
-        list[ResponseContent],
-        Field(description="Array of content blocks in the response"),
-    ]
-    model: Annotated[str, Field(description="The model used for the response")]
-    stop_reason: Annotated[
-        str | 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")]
-
-    model_config = ConfigDict(extra="forbid", validate_assignment=True)
-
-
-class StreamingChatCompletionResponse(BaseModel):
-    """Streaming response model for Claude chat completions."""
-
-    id: Annotated[str, Field(description="Unique identifier for the response")]
-    type: Annotated[
-        Literal[
-            "message_start",
-            "message_delta",
-            "message_stop",
-            "content_block_start",
-            "content_block_delta",
-            "content_block_stop",
-            "ping",
-        ],
-        Field(description="Type of streaming event"),
-    ]
-    message: Annotated[
-        dict[str, Any] | None, Field(description="Message data for message events")
-    ] = None
-    index: Annotated[int | None, Field(description="Index of the content block")] = None
-    content_block: Annotated[
-        dict[str, Any] | None, Field(description="Content block data")
-    ] = None
-    delta: Annotated[
-        dict[str, Any] | None, Field(description="Delta data for incremental updates")
-    ] = None
-    usage: Annotated[Usage | None, Field(description="Token usage information")] = None
-
-    model_config = ConfigDict(extra="forbid", validate_assignment=True)
-
-
-class ErrorResponse(BaseModel):
-    """Error response model."""
-
-    type: Annotated[Literal["error"], Field(description="Response type")] = "error"
-    error: Annotated[
-        dict[str, Any], Field(description="Error details including type and message")
-    ]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class APIError(BaseModel):
-    """API error details."""
-
-    type: Annotated[str, Field(description="Error type")]
-    message: Annotated[str, Field(description="Error message")]
-
-    model_config = ConfigDict(
-        extra="forbid", validate_by_alias=True, validate_by_name=True
-    )
-
-
-class PermissionToolAllowResponse(BaseModel):
-    """Response model for allowed permission tool requests."""
-
-    behavior: Annotated[Literal["allow"], Field(description="Permission behavior")] = (
-        "allow"
-    )
-    updated_input: Annotated[
-        dict[str, Any],
-        Field(
-            description="Updated input parameters for the tool, or original input if unchanged",
-            alias="updatedInput",
-        ),
-    ]
-
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-
-class PermissionToolDenyResponse(BaseModel):
-    """Response model for denied permission tool requests."""
-
-    behavior: Annotated[Literal["deny"], Field(description="Permission behavior")] = (
-        "deny"
-    )
-    message: Annotated[
-        str,
-        Field(
-            description="Human-readable explanation of why the permission was denied"
-        ),
-    ]
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class PermissionToolPendingResponse(BaseModel):
-    """Response model for pending permission tool requests requiring user confirmation."""
-
-    behavior: Annotated[
-        Literal["pending"], Field(description="Permission behavior")
-    ] = "pending"
-    confirmation_id: Annotated[
-        str,
-        Field(
-            description="Unique identifier for the confirmation request",
-            alias="confirmationId",
-        ),
-    ]
-    message: Annotated[
-        str,
-        Field(
-            description="Instructions for retrying the request after user confirmation"
-        ),
-    ] = "User confirmation required. Please retry with the same confirmation_id."
-
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-
-PermissionToolResponse = (
-    PermissionToolAllowResponse
-    | PermissionToolDenyResponse
-    | PermissionToolPendingResponse
-)
-
-
-class RateLimitError(APIError):
-    """Rate limit error."""
-
-    type: Annotated[Literal["rate_limit_error"], Field(description="Error type")] = (
-        "rate_limit_error"
-    )
-
-
-class InvalidRequestError(APIError):
-    """Invalid request error."""
-
-    type: Annotated[
-        Literal["invalid_request_error"], Field(description="Error type")
-    ] = "invalid_request_error"
-
-
-class AuthenticationError(APIError):
-    """Authentication error."""
-
-    type: Annotated[
-        Literal["authentication_error"], Field(description="Error type")
-    ] = "authentication_error"
-
-
-class NotFoundError(APIError):
-    """Not found error."""
-
-    type: Annotated[Literal["not_found_error"], Field(description="Error type")] = (
-        "not_found_error"
-    )
-
-
-class OverloadedError(APIError):
-    """Overloaded error."""
-
-    type: Annotated[Literal["overloaded_error"], Field(description="Error type")] = (
-        "overloaded_error"
-    )
-
-
-class InternalServerError(APIError):
-    """Internal server error."""
-
-    type: Annotated[
-        Literal["internal_server_error"], Field(description="Error type")
-    ] = "internal_server_error"
-
-
-class CodexResponse(BaseModel):
-    """OpenAI Codex completion response model."""
-
-    id: Annotated[str, Field(description="Response ID")]
-    model: Annotated[str, Field(description="Model used for completion")]
-    content: Annotated[str, Field(description="Generated content")]
-    finish_reason: Annotated[
-        str | None, Field(description="Reason the response finished")
-    ] = None
-    usage: Annotated[Usage | None, Field(description="Token usage information")] = None
-
-    model_config = ConfigDict(
-        extra="allow"
-    )  # Allow additional fields for compatibility