ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/models/responses.py

@@ -0,0 +1,227 @@
+"""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 MessageContent, 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")
+
+
+PermissionToolResponse = PermissionToolAllowResponse | PermissionToolDenyResponse
+
+
+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"

ccproxy/models/types.py

@@ -0,0 +1,102 @@
+"""Common type aliases used across the ccproxy models."""
+
+from typing import Literal, TypeAlias
+
+from typing_extensions import TypedDict
+
+
+# Message and content types
+MessageRole: TypeAlias = Literal["user", "assistant", "system", "tool"]
+OpenAIMessageRole: TypeAlias = Literal[
+    "system", "user", "assistant", "tool", "developer"
+]
+ContentBlockType: TypeAlias = Literal[
+    "text", "image", "image_url", "tool_use", "thinking"
+]
+OpenAIContentType: TypeAlias = Literal["text", "image_url"]
+
+# Tool-related types
+ToolChoiceType: TypeAlias = Literal["auto", "any", "tool", "none", "required"]
+OpenAIToolChoiceType: TypeAlias = Literal["none", "auto", "required"]
+ToolType: TypeAlias = Literal["function", "custom"]
+
+# Response format types
+ResponseFormatType: TypeAlias = Literal["text", "json_object", "json_schema"]
+
+# Service tier types
+ServiceTier: TypeAlias = Literal["auto", "standard_only"]
+
+# Stop reasons (re-exported from messages for convenience)
+StopReason: TypeAlias = Literal[
+    "end_turn",
+    "max_tokens",
+    "stop_sequence",
+    "tool_use",
+    "pause_turn",
+    "refusal",
+]
+
+# OpenAI finish reasons
+OpenAIFinishReason: TypeAlias = Literal[
+    "stop", "length", "tool_calls", "content_filter"
+]
+
+# Error types
+ErrorType: TypeAlias = Literal[
+    "error",
+    "rate_limit_error",
+    "invalid_request_error",
+    "authentication_error",
+    "not_found_error",
+    "overloaded_error",
+    "internal_server_error",
+]
+
+# Stream event types
+StreamEventType: TypeAlias = Literal[
+    "message_start",
+    "message_delta",
+    "message_stop",
+    "content_block_start",
+    "content_block_delta",
+    "content_block_stop",
+    "ping",
+]
+
+# Image source types
+ImageSourceType: TypeAlias = Literal["base64", "url"]
+
+# Modality types
+ModalityType: TypeAlias = Literal["text", "audio"]
+
+# Reasoning effort types (OpenAI o1 models)
+ReasoningEffort: TypeAlias = Literal["low", "medium", "high"]
+
+# OpenAI object types
+OpenAIObjectType: TypeAlias = Literal[
+    "chat.completion", "chat.completion.chunk", "model", "list"
+]
+
+# Permission behavior types
+PermissionBehavior: TypeAlias = Literal["allow", "deny"]
+
+
+# Usage and streaming related types
+class UsageData(TypedDict, total=False):
+    """Token usage data extracted from streaming or non-streaming responses."""
+
+    input_tokens: int | None
+    output_tokens: int | None
+    cache_read_input_tokens: int | None
+    cache_creation_input_tokens: int | None
+    event_type: StreamEventType | None
+
+
+class StreamingTokenMetrics(TypedDict, total=False):
+    """Accumulated token metrics during streaming."""
+
+    tokens_input: int | None
+    tokens_output: int | None
+    cache_read_tokens: int | None
+    cache_write_tokens: int | None
+    cost_usd: float | None

ccproxy/observability/__init__.py

@@ -0,0 +1,51 @@
+"""
+Observability module for the CCProxy API.
+
+This module provides comprehensive observability capabilities including metrics collection,
+structured logging, request context tracking, and observability pipeline management.
+
+The observability system follows a hybrid architecture that combines:
+- Real-time metrics collection and aggregation
+- Structured logging with correlation IDs
+- Request context propagation across service boundaries
+- Pluggable pipeline for metrics export and alerting
+
+Components:
+- metrics: Core metrics collection, aggregation, and export functionality
+- logging: Structured logging configuration and context-aware loggers
+- context: Request context tracking and correlation across async operations
+- pipeline: Observability data pipeline for metrics export and alerting
+"""
+
+from .context import (
+    RequestContext,
+    get_context_tracker,
+    request_context,
+    timed_operation,
+    tracked_request_context,
+)
+from .metrics import PrometheusMetrics, get_metrics, reset_metrics
+from .pushgateway import (
+    PushgatewayClient,
+    get_pushgateway_client,
+    reset_pushgateway_client,
+)
+
+
+__all__ = [
+    # Configuration
+    # Context management
+    "RequestContext",
+    "request_context",
+    "tracked_request_context",
+    "timed_operation",
+    "get_context_tracker",
+    # Prometheus metrics
+    "PrometheusMetrics",
+    "get_metrics",
+    "reset_metrics",
+    # Pushgateway
+    "PushgatewayClient",
+    "get_pushgateway_client",
+    "reset_pushgateway_client",
+]