ccproxy-api 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

ccproxy/models/claude_sdk.py

@@ -0,0 +1,420 @@
+"""Strongly-typed Pydantic models for Claude SDK types.
+
+This module provides Pydantic models that mirror the Claude SDK types from the
+official claude-code-sdk-python repository. These models enable strong typing
+throughout the proxy system and provide runtime validation.
+
+Based on: https://github.com/anthropics/claude-code-sdk-python/blob/main/src/claude_code_sdk/types.py
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any, Literal, TypeVar, cast
+
+# Import Claude SDK types for isinstance checks
+from claude_code_sdk import TextBlock as SDKTextBlock
+from claude_code_sdk import ToolResultBlock as SDKToolResultBlock
+from claude_code_sdk import ToolUseBlock as SDKToolUseBlock
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from ccproxy.models.requests import Usage
+
+
+# Type variables for generic functions
+T = TypeVar("T", bound=BaseModel)
+
+
+# Generic conversion function
+def to_sdk_variant(base_model: BaseModel, sdk_class: type[T]) -> T:
+    """Convert a base model to its SDK variant using model_validate().
+
+    Args:
+        base_model: The base model instance to convert
+        sdk_class: The target SDK class to convert to
+
+    Returns:
+        Instance of the SDK class with data from the base model
+
+    Example:
+        >>> text_block = TextBlock(text="message")
+        >>> text_block_sdk = to_sdk_variant(text_block, TextBlockSDK)
+    """
+    return sdk_class.model_validate(base_model.model_dump())
+
+
+# Core Content Block Types
+class TextBlock(BaseModel):
+    """Text content block from Claude SDK."""
+
+    type: Literal["text"] = "text"
+    text: str = Field(..., description="Text content")
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ToolUseBlock(BaseModel):
+    """Tool use content block from Claude SDK."""
+
+    type: Literal["tool_use"] = "tool_use"
+    id: str = Field(..., description="Unique identifier for the tool use")
+    name: str = Field(..., description="Name of the tool being used")
+    input: dict[str, Any] = Field(..., description="Input parameters for the tool")
+
+    model_config = ConfigDict(extra="allow")
+
+    def to_sdk_block(self) -> dict[str, Any]:
+        """Convert to ToolUseSDKBlock format for streaming."""
+        return {
+            "type": "tool_use_sdk",
+            "id": self.id,
+            "name": self.name,
+            "input": self.input,
+            "source": "claude_code_sdk",
+        }
+
+
+class ToolResultBlock(BaseModel):
+    """Tool result content block from Claude SDK."""
+
+    type: Literal["tool_result"] = "tool_result"
+    tool_use_id: str = Field(
+        ..., description="ID of the tool use this result corresponds to"
+    )
+    content: str | list[dict[str, Any]] | None = Field(
+        None, description="Result content from the tool"
+    )
+    is_error: bool | None = Field(
+        None, description="Whether this result represents an error"
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+    def to_sdk_block(self) -> dict[str, Any]:
+        """Convert to ToolResultSDKBlock format for streaming."""
+        return {
+            "type": "tool_result_sdk",
+            "tool_use_id": self.tool_use_id,
+            "content": self.content,
+            "is_error": self.is_error,
+            "source": "claude_code_sdk",
+        }
+
+
+class ThinkingBlock(BaseModel):
+    """Thinking content block from Claude SDK.
+
+    Note: Thinking blocks are not normally sent by Claude Code SDK, but this model
+    is included for defensive programming to handle any future SDK changes or edge cases
+    where thinking content might be included in SDK responses.
+    """
+
+    type: Literal["thinking"] = "thinking"
+    thinking: str = Field(..., description="Thinking content text")
+    signature: str | None = Field(None, description="Optional thinking signature")
+
+    model_config = ConfigDict(extra="allow")
+
+
+# Union type for basic content blocks
+ContentBlock = Annotated[
+    TextBlock | ToolUseBlock | ToolResultBlock | ThinkingBlock,
+    Field(discriminator="type"),
+]
+
+
+# Message Types
+class UserMessage(BaseModel):
+    """User message from Claude SDK."""
+
+    content: list[ContentBlock] = Field(
+        ..., description="List of content blocks in the message"
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+    @field_validator("content", mode="before")
+    @classmethod
+    def convert_content_blocks(cls, v: Any) -> list[Any]:
+        """Convert Claude SDK dataclass blocks to Pydantic models."""
+        if not isinstance(v, list):
+            return []
+
+        converted_blocks = []
+        for block in v:
+            if isinstance(block, SDKTextBlock | SDKToolUseBlock | SDKToolResultBlock):
+                # Convert Claude SDK dataclass to dict and add type field
+                if isinstance(block, SDKTextBlock):
+                    converted_blocks.append({"type": "text", "text": block.text})
+                elif isinstance(block, SDKToolUseBlock):
+                    converted_blocks.append(
+                        cast(
+                            Any,
+                            {
+                                "type": "tool_use",
+                                "id": str(block.id),
+                                "name": str(block.name),
+                                "input": dict(block.input),
+                            },
+                        )
+                    )
+                elif isinstance(block, SDKToolResultBlock):
+                    converted_blocks.append(
+                        cast(
+                            Any,
+                            {
+                                "type": "tool_result",
+                                "tool_use_id": str(block.tool_use_id),
+                                "content": block.content,
+                                "is_error": block.is_error,
+                            },
+                        )
+                    )
+            else:
+                converted_blocks.append(block)
+
+        return converted_blocks
+
+
+class AssistantMessage(BaseModel):
+    """Assistant message from Claude SDK."""
+
+    content: list[ContentBlock] = Field(
+        ..., description="List of content blocks in the message"
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+    @field_validator("content", mode="before")
+    @classmethod
+    def convert_content_blocks(cls, v: Any) -> list[Any]:
+        """Convert Claude SDK dataclass blocks to Pydantic models."""
+        if not isinstance(v, list):
+            return []
+
+        converted_blocks = []
+        for block in v:
+            if isinstance(block, SDKTextBlock | SDKToolUseBlock | SDKToolResultBlock):
+                # Convert Claude SDK dataclass to dict and add type field
+                if isinstance(block, SDKTextBlock):
+                    converted_blocks.append({"type": "text", "text": block.text})
+                elif isinstance(block, SDKToolUseBlock):
+                    converted_blocks.append(
+                        cast(
+                            Any,
+                            {
+                                "type": "tool_use",
+                                "id": str(block.id),
+                                "name": str(block.name),
+                                "input": dict(block.input),
+                            },
+                        )
+                    )
+                elif isinstance(block, SDKToolResultBlock):
+                    converted_blocks.append(
+                        cast(
+                            Any,
+                            {
+                                "type": "tool_result",
+                                "tool_use_id": str(block.tool_use_id),
+                                "content": block.content,
+                                "is_error": block.is_error,
+                            },
+                        )
+                    )
+            else:
+                converted_blocks.append(block)
+
+        return converted_blocks
+
+
+class SystemMessage(BaseModel):
+    """System message from Claude SDK."""
+
+    type: Literal["system_message"] = "system_message"
+
+    subtype: str = Field(default="", description="Subtype of the system message")
+    data: dict[str, Any] = Field(
+        default_factory=dict, description="System message data"
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ResultMessage(BaseModel):
+    """Result message from Claude SDK."""
+
+    type: Literal["result_message"] = "result_message"
+
+    subtype: str = Field(default="", description="Subtype of the result message")
+    duration_ms: int = Field(default=0, description="Total duration in milliseconds")
+    duration_api_ms: int = Field(default=0, description="API duration in milliseconds")
+    is_error: bool = Field(
+        default=False, description="Whether this result represents an error"
+    )
+    num_turns: int = Field(default=0, description="Number of conversation turns")
+    session_id: str = Field(default="", description="Session ID for the result")
+    total_cost_usd: float | None = Field(None, description="Total cost in USD")
+    usage: dict[str, Any] | None = Field(
+        None, description="Usage information dictionary"
+    )
+    result: str | None = Field(None, description="Result string if available")
+
+    # Add computed properties for backward compatibility
+    @property
+    def stop_reason(self) -> str:
+        """Get stop reason from result or default to end_turn."""
+        if self.is_error:
+            return "error"
+        return "end_turn"
+
+    @property
+    def usage_model(self) -> Usage:
+        """Get usage information as a Usage model for backward compatibility."""
+        if self.usage is None:
+            return Usage()
+        return Usage.model_validate(self.usage)
+
+    model_config = ConfigDict(extra="allow")
+
+
+# Custom Content Block Types for Internal Use
+class SDKMessageMode(SystemMessage):
+    """Custom content block for system messages with source attribution."""
+
+    type: Literal["system_message"] = "system_message"
+    source: str = "claude_code_sdk"
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ToolUseSDKBlock(BaseModel):
+    """Custom content block for tool use with SDK metadata."""
+
+    type: Literal["tool_use_sdk"] = "tool_use_sdk"
+    id: str = Field(..., description="Unique identifier for the tool use")
+    name: str = Field(..., description="Name of the tool being used")
+    input: dict[str, Any] = Field(..., description="Input parameters for the tool")
+    source: str = "claude_code_sdk"
+
+
+class ToolResultSDKBlock(BaseModel):
+    """Custom content block for tool results with SDK metadata."""
+
+    type: Literal["tool_result_sdk"] = "tool_result_sdk"
+    tool_use_id: str = Field(
+        ..., description="ID of the tool use this result corresponds to"
+    )
+    content: str | list[dict[str, Any]] | None = Field(
+        None, description="Result content from the tool"
+    )
+    is_error: bool | None = Field(
+        None, description="Whether this result represents an error"
+    )
+    source: str = "claude_code_sdk"
+
+
+class ResultMessageBlock(ResultMessage):
+    """Custom content block for result messages with session data."""
+
+    type: Literal["result_message"] = "result_message"
+    source: str = "claude_code_sdk"
+
+
+# Union type for all custom content blocks
+SDKContentBlock = Annotated[
+    TextBlock
+    | ToolUseBlock
+    | ToolResultBlock
+    | ThinkingBlock
+    | SDKMessageMode
+    | ToolUseSDKBlock
+    | ToolResultSDKBlock
+    | ResultMessageBlock,
+    Field(discriminator="type"),
+]
+
+
+# Extended content block type that includes both SDK and custom blocks
+ExtendedContentBlock = SDKContentBlock
+
+
+# Conversion Functions
+def convert_sdk_text_block(text_content: str) -> TextBlock:
+    """Convert raw text content to TextBlock model."""
+    return TextBlock(text=text_content)
+
+
+def convert_sdk_tool_use_block(
+    tool_id: str, tool_name: str, tool_input: dict[str, Any]
+) -> ToolUseBlock:
+    """Convert raw tool use data to ToolUseBlock model."""
+    return ToolUseBlock(id=tool_id, name=tool_name, input=tool_input)
+
+
+def convert_sdk_tool_result_block(
+    tool_use_id: str,
+    content: str | list[dict[str, Any]] | None = None,
+    is_error: bool | None = None,
+) -> ToolResultBlock:
+    """Convert raw tool result data to ToolResultBlock model."""
+    return ToolResultBlock(tool_use_id=tool_use_id, content=content, is_error=is_error)
+
+
+def convert_sdk_system_message(subtype: str, data: dict[str, Any]) -> SystemMessage:
+    """Convert raw system message data to SystemMessage model."""
+    return SystemMessage(subtype=subtype, data=data)
+
+
+def convert_sdk_result_message(
+    session_id: str,
+    subtype: str = "",
+    duration_ms: int = 0,
+    duration_api_ms: int = 0,
+    is_error: bool = False,
+    num_turns: int = 0,
+    usage: dict[str, Any] | None = None,
+    total_cost_usd: float | None = None,
+    result: str | None = None,
+) -> ResultMessage:
+    """Convert raw result message data to ResultMessage model."""
+    return ResultMessage(
+        session_id=session_id,
+        subtype=subtype,
+        duration_ms=duration_ms,
+        duration_api_ms=duration_api_ms,
+        is_error=is_error,
+        num_turns=num_turns,
+        usage=usage,
+        total_cost_usd=total_cost_usd,
+        result=result,
+    )
+
+
+__all__ = [
+    # Generic conversion
+    "to_sdk_variant",
+    # Content blocks
+    "TextBlock",
+    "ToolUseBlock",
+    "ToolResultBlock",
+    "ThinkingBlock",
+    "ContentBlock",
+    # Messages
+    "UserMessage",
+    "AssistantMessage",
+    "SystemMessage",
+    "ResultMessage",
+    # Custom content blocks
+    "SDKMessageMode",
+    "ToolUseSDKBlock",
+    "ToolResultSDKBlock",
+    "ResultMessageBlock",
+    "SDKContentBlock",
+    "ExtendedContentBlock",
+    # Conversion functions
+    "convert_sdk_text_block",
+    "convert_sdk_tool_use_block",
+    "convert_sdk_tool_result_block",
+    "convert_sdk_system_message",
+    "convert_sdk_result_message",
+]

ccproxy/models/messages.py

@@ -1,11 +1,16 @@
 """Message models for Anthropic Messages API endpoint."""
 
-from typing import Annotated, Any, Literal
+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
-from .types import ContentBlockType, ServiceTier, StopReason, ToolChoiceType
+
+
+if TYPE_CHECKING:
+    pass
+from .types import ServiceTier, StopReason, ToolChoiceType
 
 
 class SystemMessage(BaseModel):
@@ -111,6 +116,13 @@ class MessageCreateParams(BaseModel):
             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"),
@@ -195,22 +207,37 @@ class MessageCreateParams(BaseModel):
     model_config = ConfigDict(extra="forbid", validate_assignment=True)
 
 
-class MessageContentBlock(BaseModel):
-    """Content block in a message response."""
+class TextContentBlock(BaseModel):
+    """Text content block."""
 
-    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
+    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):
@@ -222,7 +249,7 @@ class MessageResponse(BaseModel):
         "assistant"
     )
     content: Annotated[
-        list[MessageContentBlock],
+        list[CCProxyContentBlock],
         Field(description="Array of content blocks in the response"),
     ]
     model: Annotated[str, Field(description="The model used for the response")]

ccproxy/models/permissions.py

@@ -0,0 +1,115 @@
+"""Pydantic models for permission system."""
+
+import asyncio
+import uuid
+from datetime import UTC, datetime
+from enum import Enum
+
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class PermissionStatus(Enum):
+    """Status of a permission request."""
+
+    PENDING = "pending"
+    ALLOWED = "allowed"
+    DENIED = "denied"
+    EXPIRED = "expired"
+
+
+class EventType(Enum):
+    """Types of permission events."""
+
+    PERMISSION_REQUEST = "permission_request"
+    PERMISSION_RESOLVED = "permission_resolved"
+    PERMISSION_EXPIRED = "permission_expired"
+
+
+class PermissionInput(BaseModel):
+    """Input parameters for a tool permission request."""
+
+    command: str | None = None
+    code: str | None = None
+    path: str | None = None
+    content: str | None = None
+    # Add other common input fields as needed
+
+
+class PermissionRequest(BaseModel):
+    """Represents a tool permission request."""
+
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    tool_name: str
+    input: dict[str, str]  # More specific than Any
+    status: PermissionStatus = PermissionStatus.PENDING
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    expires_at: datetime
+    resolved_at: datetime | None = None
+
+    # Private attribute for event-driven waiting
+    _resolved_event: asyncio.Event = PrivateAttr(default_factory=asyncio.Event)
+
+    def is_expired(self) -> bool:
+        """Check if the request has expired."""
+        if self.status != PermissionStatus.PENDING:
+            return False
+
+        now, expires_at = self._normalize_datetimes(datetime.now(UTC), self.expires_at)
+        return now > expires_at
+
+    def time_remaining(self) -> int:
+        """Get time remaining in seconds."""
+        if self.status != PermissionStatus.PENDING:
+            return 0
+
+        now, expires_at = self._normalize_datetimes(datetime.now(UTC), self.expires_at)
+        remaining = (expires_at - now).total_seconds()
+        return max(0, int(remaining))
+
+    def resolve(self, allowed: bool) -> None:
+        """Resolve the request."""
+        if self.status != PermissionStatus.PENDING:
+            raise ValueError(f"Cannot resolve request in {self.status} status")
+
+        self.status = PermissionStatus.ALLOWED if allowed else PermissionStatus.DENIED
+        self.resolved_at = datetime.now(UTC)
+        # Signal waiting coroutines that resolution is complete
+        self._resolved_event.set()
+
+    def _normalize_datetimes(
+        self, dt1: datetime, dt2: datetime
+    ) -> tuple[datetime, datetime]:
+        """Normalize two datetimes to ensure both are timezone-aware.
+
+        Args:
+            dt1: First datetime to normalize
+            dt2: Second datetime to normalize
+
+        Returns:
+            Tuple of normalized timezone-aware datetimes
+        """
+        # If dt1 is timezone-aware, convert dt2 to timezone-aware if needed
+        if dt1.tzinfo is not None:
+            if dt2.tzinfo is None:
+                dt2 = dt2.replace(tzinfo=UTC)
+        # If dt2 is timezone-aware, convert dt1 to timezone-aware if needed
+        elif dt2.tzinfo is not None:
+            dt1 = dt1.replace(tzinfo=UTC)
+
+        return dt1, dt2
+
+
+class PermissionEvent(BaseModel):
+    """Event emitted by the permission service."""
+
+    type: EventType
+    request_id: str
+    tool_name: str | None = None
+    input: dict[str, str] | None = None
+    created_at: str | None = None
+    expires_at: str | None = None
+    timeout_seconds: int | None = None
+    allowed: bool | None = None
+    resolved_at: str | None = None
+    expired_at: str | None = None
+    message: str | None = None

ccproxy/models/requests.py

@@ -2,7 +2,7 @@
 
 from typing import Annotated, Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator, validator
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class ImageSource(BaseModel):

ccproxy/models/responses.py

@@ -4,7 +4,7 @@ from typing import Annotated, Any, Literal
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from .requests import MessageContent, Usage
+from .requests import Usage
 
 
 class ToolCall(BaseModel):
@@ -176,7 +176,34 @@ class PermissionToolDenyResponse(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
 
-PermissionToolResponse = PermissionToolAllowResponse | PermissionToolDenyResponse
+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):

ccproxy/observability/access_logger.py

@@ -7,9 +7,8 @@ access logs with complete request metadata including token usage and costs.
 
 from __future__ import annotations
 
-import asyncio
 import time
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import structlog