Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
"""Pydantic models for the Anthropic Messages protocol."""
from typing import Any, Literal
from pydantic import BaseModel, ConfigDict, Field, field_validator
class _AnthropicBlockBase(BaseModel):
"""Pass through protocol extensions such as ``cache_control``."""
model_config = ConfigDict(extra="allow")
class ContentBlockText(_AnthropicBlockBase):
type: Literal["text"]
text: str
class ContentBlockImage(_AnthropicBlockBase):
type: Literal["image"]
source: dict[str, Any]
class ContentBlockDocument(_AnthropicBlockBase):
"""Anthropic document block (e.g. PDF files via the Files API)."""
type: Literal["document"]
source: dict[str, Any]
class ContentBlockToolUse(_AnthropicBlockBase):
type: Literal["tool_use"]
id: str
name: str
input: dict[str, Any]
class ContentBlockToolResult(_AnthropicBlockBase):
type: Literal["tool_result"]
tool_use_id: str
content: str | list[Any] | dict[str, Any]
class ContentBlockThinking(_AnthropicBlockBase):
type: Literal["thinking"]
thinking: str
signature: str | None = None
class ContentBlockRedactedThinking(_AnthropicBlockBase):
type: Literal["redacted_thinking"]
data: str
class ContentBlockServerToolUse(_AnthropicBlockBase):
"""Anthropic server-side tool invocation (e.g. ``web_search``, ``web_fetch``)."""
type: Literal["server_tool_use"]
id: str
name: str
input: dict[str, Any]
class ContentBlockWebSearchToolResult(_AnthropicBlockBase):
type: Literal["web_search_tool_result"]
tool_use_id: str
content: Any
class ContentBlockWebFetchToolResult(_AnthropicBlockBase):
type: Literal["web_fetch_tool_result"]
tool_use_id: str
content: Any
class SystemContent(_AnthropicBlockBase):
type: Literal["text"]
text: str
class Message(BaseModel):
role: Literal["user", "assistant", "system"]
content: (
str
| list[
ContentBlockText
| ContentBlockImage
| ContentBlockDocument
| ContentBlockToolUse
| ContentBlockToolResult
| ContentBlockThinking
| ContentBlockRedactedThinking
| ContentBlockServerToolUse
| ContentBlockWebSearchToolResult
| ContentBlockWebFetchToolResult
]
)
reasoning_content: str | None = None
class Tool(_AnthropicBlockBase):
name: str
type: str | None = None
description: str | None = None
input_schema: dict[str, Any] | None = None
class ThinkingConfig(BaseModel):
model_config = ConfigDict(extra="allow")
enabled: bool | None = True
type: str | None = None
budget_tokens: int | None = None
display: Literal["summarized", "omitted", "updates"] | None = None
class MessagesRequest(BaseModel):
model_config = ConfigDict(extra="allow")
model: str
original_model: str | None = Field(default=None, exclude=True)
resolved_provider_model: str | None = Field(default=None, exclude=True)
max_tokens: int | None = None
messages: list[Message]
system: str | list[SystemContent] | None = None
stop_sequences: list[str] | None = None
stream: bool = False
temperature: float | None = None
top_p: float | None = None
top_k: int | None = None
metadata: dict[str, Any] | None = None
tools: list[Tool] | None = None
tool_choice: dict[str, Any] | None = None
thinking: ThinkingConfig | None = None
context_management: dict[str, Any] | None = None
output_config: dict[str, Any] | None = None
mcp_servers: list[dict[str, Any]] | None = None
extra_body: dict[str, Any] | None = None
betas: list[str] | None = Field(default=None, exclude=True)
@field_validator("max_tokens", mode="before")
@classmethod
def _reject_boolean_output_limit(cls, value: object) -> object:
if isinstance(value, bool):
raise ValueError("max_tokens must not be a boolean")
return value
class TokenCountRequest(BaseModel):
model_config = ConfigDict(extra="allow")
model: str
original_model: str | None = Field(default=None, exclude=True)
resolved_provider_model: str | None = Field(default=None, exclude=True)
messages: list[Message]
system: str | list[SystemContent] | None = None
tools: list[Tool] | None = None
thinking: ThinkingConfig | None = None
tool_choice: dict[str, Any] | None = None
context_management: dict[str, Any] | None = None
output_config: dict[str, Any] | None = None
mcp_servers: list[dict[str, Any]] | None = None
betas: list[str] | None = Field(default=None, exclude=True)
class TokenCountResponse(BaseModel):
input_tokens: int
class NativeTokenCountMessage(BaseModel):
"""The outer message shape needed by local estimation, with opaque blocks."""
model_config = ConfigDict(extra="allow", strict=True)
role: str
content: str | list[dict[str, Any]]
class NativeTokenCountRequest(BaseModel):
"""Count native inputs without applying compatibility protocol validation."""
model_config = ConfigDict(extra="allow", strict=True)
model: str = Field(min_length=1)
messages: list[NativeTokenCountMessage]
system: str | list[dict[str, Any]] | None = None
tools: list[dict[str, Any]] | None = None
class Usage(BaseModel):
input_tokens: int
output_tokens: int
cache_creation_input_tokens: int = 0
cache_read_input_tokens: int = 0
class MessagesResponse(BaseModel):
id: str
model: str
role: Literal["assistant"] = "assistant"
content: list[
ContentBlockText
| ContentBlockToolUse
| ContentBlockThinking
| ContentBlockRedactedThinking
| dict[str, Any]
]
type: Literal["message"] = "message"
stop_reason: (
Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None
) = None
stop_sequence: str | None = None
usage: Usage