Skip to content

ccproxy.models

ccproxy.models

Pydantic models for Claude Proxy API Server.

AssistantMessage

Bases: BaseModel

Assistant message from Claude SDK.

convert_content_blocks classmethod 

convert_content_blocks(v)

Convert Claude SDK dataclass blocks to Pydantic models.

Source code in ccproxy/models/claude_sdk.py 
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
@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

ResultMessage

Bases: BaseModel

Result message from Claude SDK.

stop_reason property 

stop_reason

Get stop reason from result or default to end_turn.

usage_model property 

usage_model

Get usage information as a Usage model for backward compatibility.

ResultMessageBlock

Bases: ResultMessage

Custom content block for result messages with session data.

SDKMessageMode

Bases: SystemMessage

Custom content block for system messages with source attribution.

TextBlock

Bases: BaseModel

Text content block from Claude SDK.

ToolResultBlock

Bases: BaseModel

Tool result content block from Claude SDK.

to_sdk_block 

to_sdk_block()

Convert to ToolResultSDKBlock format for streaming.

Source code in ccproxy/models/claude_sdk.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
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",
    }

ToolResultSDKBlock

Bases: BaseModel

Custom content block for tool results with SDK metadata.

ToolUseBlock

Bases: BaseModel

Tool use content block from Claude SDK.

to_sdk_block 

to_sdk_block()

Convert to ToolUseSDKBlock format for streaming.

Source code in ccproxy/models/claude_sdk.py 
65
66
67
68
69
70
71
72
73
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",
    }

ToolUseSDKBlock

Bases: BaseModel

Custom content block for tool use with SDK metadata.

UserMessage

Bases: BaseModel

User message from Claude SDK.

convert_content_blocks classmethod 

convert_content_blocks(v)

Convert Claude SDK dataclass blocks to Pydantic models.

Source code in ccproxy/models/claude_sdk.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
@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

MessageCreateParams

Bases: BaseModel

Request parameters for creating messages via Anthropic Messages API.

validate_model classmethod 

validate_model(v)

Validate that the model is a supported Claude model.

Source code in ccproxy/models/messages.py 
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
@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

validate_messages classmethod 

validate_messages(v)

Validate message alternation and content.

Source code in ccproxy/models/messages.py 
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
@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

validate_stop_sequences classmethod 

validate_stop_sequences(v)

Validate stop sequences.

Source code in ccproxy/models/messages.py 
195
196
197
198
199
200
201
202
203
204
205
@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

MessageResponse

Bases: BaseModel

Response model for Anthropic Messages API endpoint.

MetadataParams

Bases: BaseModel

Metadata about the request.

SystemMessage

Bases: BaseModel

System message content block.

ThinkingConfig

Bases: BaseModel

Configuration for extended thinking process.

ToolChoiceParams

Bases: BaseModel

Tool choice configuration.

ImageContent

Bases: BaseModel

Image content block for multimodal messages.

Message

Bases: BaseModel

Individual message in the conversation.

TextContent

Bases: BaseModel

Text content block for messages.

ToolDefinition

Bases: BaseModel

Tool definition for function calling.

Usage

Bases: BaseModel

Token usage information.

APIError

Bases: BaseModel

API error details.

AuthenticationError

Bases: APIError

Authentication error.

ChatCompletionResponse

Bases: BaseModel

Response model for Claude chat completions compatible with Anthropic's API.

Choice

Bases: BaseModel

Individual choice in a non-streaming response.

ErrorResponse

Bases: BaseModel

Error response model.

InternalServerError

Bases: APIError

Internal server error.

InvalidRequestError

Bases: APIError

Invalid request error.

NotFoundError

Bases: APIError

Not found error.

OverloadedError

Bases: APIError

Overloaded error.

RateLimitError

Bases: APIError

Rate limit error.

StreamingChatCompletionResponse

Bases: BaseModel

Streaming response model for Claude chat completions.

StreamingChoice

Bases: BaseModel

Individual choice in a streaming response.

TextResponse

Bases: BaseModel

Text response content block.

ToolCall

Bases: BaseModel

Tool call made by the model.

ToolUse

Bases: BaseModel

Tool use content block.

convert_sdk_result_message 

convert_sdk_result_message(
    session_id,
    subtype="",
    duration_ms=0,
    duration_api_ms=0,
    is_error=False,
    num_turns=0,
    usage=None,
    total_cost_usd=None,
    result=None,
)

Convert raw result message data to ResultMessage model.

Source code in ccproxy/models/claude_sdk.py 
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
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,
    )

convert_sdk_system_message 

convert_sdk_system_message(subtype, data)

Convert raw system message data to SystemMessage model.

Source code in ccproxy/models/claude_sdk.py 
416
417
418
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)

convert_sdk_text_block 

convert_sdk_text_block(text_content)

Convert raw text content to TextBlock model.

Source code in ccproxy/models/claude_sdk.py 
395
396
397
def convert_sdk_text_block(text_content: str) -> TextBlock:
    """Convert raw text content to TextBlock model."""
    return TextBlock(text=text_content)

convert_sdk_tool_result_block 

convert_sdk_tool_result_block(
    tool_use_id, content=None, is_error=None
)

Convert raw tool result data to ToolResultBlock model.

Source code in ccproxy/models/claude_sdk.py 
407
408
409
410
411
412
413
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)

convert_sdk_tool_use_block 

convert_sdk_tool_use_block(tool_id, tool_name, tool_input)

Convert raw tool use data to ToolUseBlock model.

Source code in ccproxy/models/claude_sdk.py 
400
401
402
403
404
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)

to_sdk_variant 

to_sdk_variant(base_model, sdk_class)

Convert a base model to its SDK variant using model_validate().

Parameters:

Name Type Description Default
base_model BaseModel

The base model instance to convert

 required
sdk_class type[T]

The target SDK class to convert to

 required

Returns:

Type Description
T

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)

Source code in ccproxy/models/claude_sdk.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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())