openai-protocol 1.0.0

//! Anthropic Messages API protocol definitions
//!
//! This module provides Rust types for the Anthropic Messages API.
//! See: https://docs.anthropic.com/en/api/messages

use std::collections::HashMap;

use serde::{Deserialize, Serialize};
use serde_json::Value;

// ============================================================================
// Request Types
// ============================================================================

/// Request to create a message using the Anthropic Messages API.
///
/// This is the main request type for `/v1/messages` endpoint.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateMessageRequest {
    /// The model that will complete your prompt.
    pub model: String,

    /// Input messages for the conversation.
    pub messages: Vec<InputMessage>,

    /// The maximum number of tokens to generate before stopping.
    pub max_tokens: u32,

    /// An object describing metadata about the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<Metadata>,

    /// Service tier for the request (auto or standard_only).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<ServiceTier>,

    /// Custom text sequences that will cause the model to stop generating.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop_sequences: Option<Vec<String>>,

    /// Whether to incrementally stream the response using server-sent events.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stream: Option<bool>,

    /// System prompt for providing context and instructions.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system: Option<SystemContent>,

    /// Amount of randomness injected into the response (0.0 to 1.0).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,

    /// Configuration for extended thinking.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thinking: Option<ThinkingConfig>,

    /// How the model should use the provided tools.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_choice: Option<ToolChoice>,

    /// Definitions of tools that the model may use.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<Tool>>,

    /// Only sample from the top K options for each subsequent token.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_k: Option<u32>,

    /// Use nucleus sampling.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f64>,

    // Beta features
    /// Container configuration for code execution (beta).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container: Option<ContainerConfig>,

    /// MCP servers to be utilized in this request (beta).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mcp_servers: Option<Vec<McpServerConfig>>,
}

impl CreateMessageRequest {
    /// Check if the request is for streaming
    pub fn is_stream(&self) -> bool {
        self.stream.unwrap_or(false)
    }

    /// Get the model name
    pub fn get_model(&self) -> &str {
        &self.model
    }
}

/// Request metadata
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Metadata {
    /// An external identifier for the user who is associated with the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
}

/// Service tier options
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ServiceTier {
    Auto,
    StandardOnly,
}

/// System content can be a string or an array of text blocks
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SystemContent {
    String(String),
    Blocks(Vec<TextBlock>),
}

/// A single input message in a conversation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InputMessage {
    /// The role of the message sender (user or assistant)
    pub role: Role,

    /// The content of the message
    pub content: InputContent,
}

/// Role of a message sender
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum Role {
    User,
    Assistant,
}

/// Input content can be a string or an array of content blocks
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InputContent {
    String(String),
    Blocks(Vec<InputContentBlock>),
}

// ============================================================================
// Input Content Blocks
// ============================================================================

/// Input content block types
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum InputContentBlock {
    /// Text content
    Text(TextBlock),
    /// Image content
    Image(ImageBlock),
    /// Document content
    Document(DocumentBlock),
    /// Tool use block (for assistant messages)
    ToolUse(ToolUseBlock),
    /// Tool result block (for user messages)
    ToolResult(ToolResultBlock),
    /// Thinking block
    Thinking(ThinkingBlock),
    /// Redacted thinking block
    RedactedThinking(RedactedThinkingBlock),
    /// Server tool use block
    ServerToolUse(ServerToolUseBlock),
    /// Search result block
    SearchResult(SearchResultBlock),
    /// Web search tool result block
    WebSearchToolResult(WebSearchToolResultBlock),
}

/// Text content block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextBlock {
    /// The text content
    pub text: String,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,

    /// Citations for this text block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citations: Option<Vec<Citation>>,
}

/// Image content block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageBlock {
    /// The image source
    pub source: ImageSource,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Image source (base64 or URL)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ImageSource {
    Base64 { media_type: String, data: String },
    Url { url: String },
}

/// Document content block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DocumentBlock {
    /// The document source
    pub source: DocumentSource,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,

    /// Optional title for the document
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,

    /// Optional context for the document
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context: Option<String>,

    /// Citations configuration
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citations: Option<CitationsConfig>,
}

/// Document source (base64, text, or URL)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum DocumentSource {
    Base64 { media_type: String, data: String },
    Text { data: String },
    Url { url: String },
    Content { content: Vec<InputContentBlock> },
}

/// Tool use block (in assistant messages)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolUseBlock {
    /// Unique identifier for this tool use
    pub id: String,

    /// Name of the tool being used
    pub name: String,

    /// Input arguments for the tool
    pub input: Value,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Tool result block (in user messages)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolResultBlock {
    /// The ID of the tool use this is a result for
    pub tool_use_id: String,

    /// The result content (string or blocks)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<ToolResultContent>,

    /// Whether this result indicates an error
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_error: Option<bool>,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Tool result content (string or blocks)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ToolResultContent {
    String(String),
    Blocks(Vec<ToolResultContentBlock>),
}

/// Content blocks allowed in tool results
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ToolResultContentBlock {
    Text(TextBlock),
    Image(ImageBlock),
    Document(DocumentBlock),
    SearchResult(SearchResultBlock),
}

/// Thinking block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThinkingBlock {
    /// The thinking content
    pub thinking: String,

    /// Signature for the thinking block
    pub signature: String,
}

/// Redacted thinking block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RedactedThinkingBlock {
    /// The encrypted/redacted data
    pub data: String,
}

/// Server tool use block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerToolUseBlock {
    /// Unique identifier for this tool use
    pub id: String,

    /// Name of the server tool
    pub name: String,

    /// Input arguments for the tool
    pub input: Value,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Search result block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchResultBlock {
    /// Source URL or identifier
    pub source: String,

    /// Title of the search result
    pub title: String,

    /// Content of the search result
    pub content: Vec<TextBlock>,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,

    /// Citations configuration
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citations: Option<CitationsConfig>,
}

/// Web search tool result block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebSearchToolResultBlock {
    /// The tool use ID this result is for
    pub tool_use_id: String,

    /// The search results or error
    pub content: WebSearchToolResultContent,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Web search tool result content
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WebSearchToolResultContent {
    Results(Vec<WebSearchResultBlock>),
    Error(WebSearchToolResultError),
}

/// Web search result block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebSearchResultBlock {
    /// Title of the search result
    pub title: String,

    /// URL of the search result
    pub url: String,

    /// Encrypted content
    pub encrypted_content: String,

    /// Page age (if available)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page_age: Option<String>,
}

/// Web search tool result error
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebSearchToolResultError {
    #[serde(rename = "type")]
    pub error_type: String,
    pub error_code: WebSearchToolResultErrorCode,
}

/// Web search tool result error codes
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum WebSearchToolResultErrorCode {
    InvalidToolInput,
    Unavailable,
    MaxUsesExceeded,
    TooManyRequests,
    QueryTooLong,
}

/// Cache control configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum CacheControl {
    Ephemeral,
}

/// Citations configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CitationsConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// Citation types
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Citation {
    CharLocation(CharLocationCitation),
    PageLocation(PageLocationCitation),
    ContentBlockLocation(ContentBlockLocationCitation),
    WebSearchResultLocation(WebSearchResultLocationCitation),
    SearchResultLocation(SearchResultLocationCitation),
}

/// Character location citation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CharLocationCitation {
    pub cited_text: String,
    pub document_index: u32,
    pub document_title: Option<String>,
    pub start_char_index: u32,
    pub end_char_index: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_id: Option<String>,
}

/// Page location citation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PageLocationCitation {
    pub cited_text: String,
    pub document_index: u32,
    pub document_title: Option<String>,
    pub start_page_number: u32,
    pub end_page_number: u32,
}

/// Content block location citation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContentBlockLocationCitation {
    pub cited_text: String,
    pub document_index: u32,
    pub document_title: Option<String>,
    pub start_block_index: u32,
    pub end_block_index: u32,
}

/// Web search result location citation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebSearchResultLocationCitation {
    pub cited_text: String,
    pub url: String,
    pub title: Option<String>,
    pub encrypted_index: String,
}

/// Search result location citation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchResultLocationCitation {
    pub cited_text: String,
    pub search_result_index: u32,
    pub source: String,
    pub title: Option<String>,
    pub start_block_index: u32,
    pub end_block_index: u32,
}

// ============================================================================
// Tool Definitions
// ============================================================================

/// Tool definition
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Tool {
    /// Custom tool definition
    Custom(CustomTool),
    /// Bash tool (computer use)
    Bash(BashTool),
    /// Text editor tool (computer use)
    TextEditor(TextEditorTool),
    /// Web search tool
    WebSearch(WebSearchTool),
}

/// Custom tool definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CustomTool {
    /// Name of the tool
    pub name: String,

    /// Optional type (defaults to "custom")
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub tool_type: Option<String>,

    /// Description of what this tool does
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// JSON schema for the tool's input
    pub input_schema: InputSchema,

    /// Cache control for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// JSON Schema for tool input
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InputSchema {
    #[serde(rename = "type")]
    pub schema_type: String,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<HashMap<String, Value>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub required: Option<Vec<String>>,

    /// Additional properties can be stored here
    #[serde(flatten)]
    pub additional: HashMap<String, Value>,
}

/// Bash tool for computer use
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BashTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "bash_20250124"

    pub name: String, // "bash"

    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Text editor tool for computer use
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextEditorTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "text_editor_20250124", etc.

    pub name: String, // "str_replace_editor"

    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Web search tool
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebSearchTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "web_search_20250305"

    pub name: String, // "web_search"

    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_domains: Option<Vec<String>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub blocked_domains: Option<Vec<String>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_uses: Option<u32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_location: Option<UserLocation>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// User location for web search
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserLocation {
    #[serde(rename = "type")]
    pub location_type: String, // "approximate"

    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}

// ============================================================================
// Tool Choice
// ============================================================================

/// How the model should use the provided tools
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ToolChoice {
    /// The model will automatically decide whether to use tools
    Auto {
        #[serde(skip_serializing_if = "Option::is_none")]
        disable_parallel_tool_use: Option<bool>,
    },
    /// The model will use any available tools
    Any {
        #[serde(skip_serializing_if = "Option::is_none")]
        disable_parallel_tool_use: Option<bool>,
    },
    /// The model will use the specified tool
    Tool {
        name: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        disable_parallel_tool_use: Option<bool>,
    },
    /// The model will not use tools
    None,
}

// ============================================================================
// Thinking Configuration
// ============================================================================

/// Configuration for extended thinking
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ThinkingConfig {
    /// Enable extended thinking
    Enabled {
        /// Budget in tokens for thinking (minimum 1024)
        budget_tokens: u32,
    },
    /// Disable extended thinking
    Disabled,
}

// ============================================================================
// Response Types
// ============================================================================

/// Response message from the API
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Message {
    /// Unique object identifier
    pub id: String,

    /// Object type (always "message")
    #[serde(rename = "type")]
    pub message_type: String,

    /// Conversational role (always "assistant")
    pub role: String,

    /// Content generated by the model
    pub content: Vec<ContentBlock>,

    /// The model that generated the message
    pub model: String,

    /// The reason the model stopped generating
    pub stop_reason: Option<StopReason>,

    /// Which custom stop sequence was generated (if any)
    pub stop_sequence: Option<String>,

    /// Billing and rate-limit usage
    pub usage: Usage,
}

/// Output content block types
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ContentBlock {
    /// Text content
    Text {
        text: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        citations: Option<Vec<Citation>>,
    },
    /// Tool use by the model
    ToolUse {
        id: String,
        name: String,
        input: Value,
    },
    /// Thinking content
    Thinking { thinking: String, signature: String },
    /// Redacted thinking content
    RedactedThinking { data: String },
    /// Server tool use
    ServerToolUse {
        id: String,
        name: String,
        input: Value,
    },
    /// Web search tool result
    WebSearchToolResult {
        tool_use_id: String,
        content: WebSearchToolResultContent,
    },
}

/// Stop reasons
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum StopReason {
    /// The model reached a natural stopping point
    EndTurn,
    /// We exceeded the requested max_tokens
    MaxTokens,
    /// One of the custom stop_sequences was generated
    StopSequence,
    /// The model invoked one or more tools
    ToolUse,
    /// We paused a long-running turn
    PauseTurn,
    /// Streaming classifiers intervened
    Refusal,
}

/// Billing and rate-limit usage
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Usage {
    /// The number of input tokens used
    pub input_tokens: u32,

    /// The number of output tokens used
    pub output_tokens: u32,

    /// The number of input tokens used to create the cache entry
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_creation_input_tokens: Option<u32>,

    /// The number of input tokens read from the cache
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_read_input_tokens: Option<u32>,

    /// Breakdown of cached tokens by TTL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_creation: Option<CacheCreation>,

    /// Server tool usage information
    #[serde(skip_serializing_if = "Option::is_none")]
    pub server_tool_use: Option<ServerToolUsage>,

    /// Service tier used for the request
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<String>,
}

/// Cache creation breakdown
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CacheCreation {
    #[serde(flatten)]
    pub tokens_by_ttl: HashMap<String, u32>,
}

/// Server tool usage information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerToolUsage {
    pub web_search_requests: u32,
}

// ============================================================================
// Streaming Event Types
// ============================================================================

/// Server-sent event wrapper
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum MessageStreamEvent {
    /// Start of a new message
    MessageStart { message: Message },
    /// Update to a message
    MessageDelta {
        delta: MessageDelta,
        usage: MessageDeltaUsage,
    },
    /// End of a message
    MessageStop,
    /// Start of a content block
    ContentBlockStart {
        index: u32,
        content_block: ContentBlock,
    },
    /// Update to a content block
    ContentBlockDelta {
        index: u32,
        delta: ContentBlockDelta,
    },
    /// End of a content block
    ContentBlockStop { index: u32 },
    /// Ping event (for keep-alive)
    Ping,
    /// Error event
    Error { error: ErrorResponse },
}

/// Message delta for streaming updates
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MessageDelta {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop_reason: Option<StopReason>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop_sequence: Option<String>,
}

/// Usage delta for streaming updates
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MessageDeltaUsage {
    pub output_tokens: u32,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_tokens: Option<u32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_creation_input_tokens: Option<u32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_read_input_tokens: Option<u32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub server_tool_use: Option<ServerToolUsage>,
}

/// Content block delta for streaming updates
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ContentBlockDelta {
    /// Text delta
    TextDelta { text: String },
    /// JSON input delta (for tool use)
    InputJsonDelta { partial_json: String },
    /// Thinking delta
    ThinkingDelta { thinking: String },
    /// Signature delta
    SignatureDelta { signature: String },
    /// Citations delta
    CitationsDelta { citation: Citation },
}

// ============================================================================
// Error Types
// ============================================================================

/// Error response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorResponse {
    #[serde(rename = "type")]
    pub error_type: String,

    pub message: String,
}

/// API error types
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ApiError {
    InvalidRequestError { message: String },
    AuthenticationError { message: String },
    BillingError { message: String },
    PermissionError { message: String },
    NotFoundError { message: String },
    RateLimitError { message: String },
    TimeoutError { message: String },
    ApiError { message: String },
    OverloadedError { message: String },
}

// ============================================================================
// Count Tokens Types
// ============================================================================

/// Request to count tokens in a message
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CountMessageTokensRequest {
    /// The model to use for token counting
    pub model: String,

    /// Input messages
    pub messages: Vec<InputMessage>,

    /// System prompt
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system: Option<SystemContent>,

    /// Thinking configuration
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thinking: Option<ThinkingConfig>,

    /// Tool choice
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_choice: Option<ToolChoice>,

    /// Tool definitions
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<Tool>>,
}

/// Response from token counting
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CountMessageTokensResponse {
    pub input_tokens: u32,
}

// ============================================================================
// Model Info Types
// ============================================================================

/// Model information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelInfo {
    /// Object type (always "model")
    #[serde(rename = "type")]
    pub model_type: String,

    /// Model ID
    pub id: String,

    /// Display name
    pub display_name: String,

    /// When the model was created
    pub created_at: String,
}

/// List of models response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ListModelsResponse {
    pub data: Vec<ModelInfo>,
    pub has_more: bool,
    pub first_id: Option<String>,
    pub last_id: Option<String>,
}

// ============================================================================
// Beta Features - Container & MCP Configuration
// ============================================================================

/// Container configuration for code execution (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContainerConfig {
    /// Container ID for reuse across requests
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,

    /// Skills to be loaded in the container
    #[serde(skip_serializing_if = "Option::is_none")]
    pub skills: Option<Vec<String>>,
}

/// MCP server configuration (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpServerConfig {
    /// Name of the MCP server
    pub name: String,

    /// MCP server URL
    pub url: String,

    /// Authorization token (if required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub authorization_token: Option<String>,

    /// Tool configuration for this server
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_configuration: Option<McpToolConfiguration>,
}

/// MCP tool configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolConfiguration {
    /// Whether to allow all tools
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,

    /// Allowed tool names
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_tools: Option<Vec<String>>,
}

// ============================================================================
// Beta Features - MCP Tool Types
// ============================================================================

/// MCP tool use block (beta) - for assistant messages
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolUseBlock {
    /// Unique identifier for this tool use
    pub id: String,

    /// Name of the tool being used
    pub name: String,

    /// Name of the MCP server
    pub server_name: String,

    /// Input arguments for the tool
    pub input: Value,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// MCP tool result block (beta) - for user messages
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolResultBlock {
    /// The ID of the tool use this is a result for
    pub tool_use_id: String,

    /// The result content
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<ToolResultContent>,

    /// Whether this result indicates an error
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_error: Option<bool>,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// MCP toolset definition (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolset {
    #[serde(rename = "type")]
    pub toolset_type: String, // "mcp_toolset"

    /// Name of the MCP server to configure tools for
    pub mcp_server_name: String,

    /// Default configuration applied to all tools from this server
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_config: Option<McpToolDefaultConfig>,

    /// Configuration overrides for specific tools
    #[serde(skip_serializing_if = "Option::is_none")]
    pub configs: Option<HashMap<String, McpToolConfig>>,

    /// Cache control for this toolset
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Default configuration for MCP tools
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolDefaultConfig {
    /// Whether tools are enabled
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,

    /// Whether to defer loading
    #[serde(skip_serializing_if = "Option::is_none")]
    pub defer_loading: Option<bool>,
}

/// Per-tool MCP configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolConfig {
    /// Whether this tool is enabled
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,

    /// Whether to defer loading
    #[serde(skip_serializing_if = "Option::is_none")]
    pub defer_loading: Option<bool>,
}

// ============================================================================
// Beta Features - Code Execution Types
// ============================================================================

/// Code execution tool (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CodeExecutionTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "code_execution_20250522" or "code_execution_20250825"

    pub name: String, // "code_execution"

    /// Allowed callers for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_callers: Option<Vec<String>>,

    /// Whether to defer loading
    #[serde(skip_serializing_if = "Option::is_none")]
    pub defer_loading: Option<bool>,

    /// Whether to use strict mode
    #[serde(skip_serializing_if = "Option::is_none")]
    pub strict: Option<bool>,

    /// Cache control for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Code execution result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CodeExecutionResultBlock {
    /// Stdout output
    pub stdout: String,

    /// Stderr output
    pub stderr: String,

    /// Return code
    pub return_code: i32,

    /// Output files
    pub content: Vec<CodeExecutionOutputBlock>,
}

/// Code execution output file reference
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CodeExecutionOutputBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "code_execution_output"

    /// File ID
    pub file_id: String,
}

/// Code execution tool result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CodeExecutionToolResultBlock {
    /// The ID of the tool use this is a result for
    pub tool_use_id: String,

    /// The result content (success or error)
    pub content: CodeExecutionToolResultContent,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Code execution tool result content
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CodeExecutionToolResultContent {
    Success(CodeExecutionResultBlock),
    Error(CodeExecutionToolResultError),
}

/// Code execution tool result error
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CodeExecutionToolResultError {
    #[serde(rename = "type")]
    pub error_type: String, // "code_execution_tool_result_error"

    pub error_code: CodeExecutionToolResultErrorCode,
}

/// Code execution error codes
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CodeExecutionToolResultErrorCode {
    Unavailable,
    CodeExecutionExceededTimeout,
    ContainerExpired,
    InvalidToolInput,
}

/// Bash code execution result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BashCodeExecutionResultBlock {
    /// Stdout output
    pub stdout: String,

    /// Stderr output
    pub stderr: String,

    /// Return code
    pub return_code: i32,

    /// Output files
    pub content: Vec<BashCodeExecutionOutputBlock>,
}

/// Bash code execution output file reference
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BashCodeExecutionOutputBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "bash_code_execution_output"

    /// File ID
    pub file_id: String,
}

/// Bash code execution tool result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BashCodeExecutionToolResultBlock {
    /// The ID of the tool use this is a result for
    pub tool_use_id: String,

    /// The result content (success or error)
    pub content: BashCodeExecutionToolResultContent,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Bash code execution tool result content
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BashCodeExecutionToolResultContent {
    Success(BashCodeExecutionResultBlock),
    Error(BashCodeExecutionToolResultError),
}

/// Bash code execution tool result error
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BashCodeExecutionToolResultError {
    #[serde(rename = "type")]
    pub error_type: String, // "bash_code_execution_tool_result_error"

    pub error_code: BashCodeExecutionToolResultErrorCode,
}

/// Bash code execution error codes
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BashCodeExecutionToolResultErrorCode {
    Unavailable,
    CodeExecutionExceededTimeout,
    ContainerExpired,
    InvalidToolInput,
}

/// Text editor code execution tool result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextEditorCodeExecutionToolResultBlock {
    /// The ID of the tool use this is a result for
    pub tool_use_id: String,

    /// The result content
    pub content: TextEditorCodeExecutionToolResultContent,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Text editor code execution result content
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TextEditorCodeExecutionToolResultContent {
    CreateResult(TextEditorCodeExecutionCreateResultBlock),
    StrReplaceResult(TextEditorCodeExecutionStrReplaceResultBlock),
    ViewResult(TextEditorCodeExecutionViewResultBlock),
    Error(TextEditorCodeExecutionToolResultError),
}

/// Text editor create result block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextEditorCodeExecutionCreateResultBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "text_editor_code_execution_create_result"
}

/// Text editor str_replace result block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextEditorCodeExecutionStrReplaceResultBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "text_editor_code_execution_str_replace_result"

    /// Snippet of content around the replacement
    #[serde(skip_serializing_if = "Option::is_none")]
    pub snippet: Option<String>,
}

/// Text editor view result block
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextEditorCodeExecutionViewResultBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "text_editor_code_execution_view_result"

    /// Content of the viewed file
    pub content: String,
}

/// Text editor code execution tool result error
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextEditorCodeExecutionToolResultError {
    #[serde(rename = "type")]
    pub error_type: String,

    pub error_code: TextEditorCodeExecutionToolResultErrorCode,
}

/// Text editor code execution error codes
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TextEditorCodeExecutionToolResultErrorCode {
    Unavailable,
    InvalidToolInput,
    FileNotFound,
    ContainerExpired,
}

// ============================================================================
// Beta Features - Web Fetch Types
// ============================================================================

/// Web fetch tool (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebFetchTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "web_fetch_20250305" or similar

    pub name: String, // "web_fetch"

    /// Allowed callers for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_callers: Option<Vec<String>>,

    /// Maximum number of uses
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_uses: Option<u32>,

    /// Cache control for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Web fetch result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebFetchResultBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "web_fetch_result"

    /// The URL that was fetched
    pub url: String,

    /// The document content
    pub content: DocumentBlock,

    /// When the content was retrieved
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retrieved_at: Option<String>,
}

/// Web fetch tool result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebFetchToolResultBlock {
    /// The ID of the tool use this is a result for
    pub tool_use_id: String,

    /// The result content (success or error)
    pub content: WebFetchToolResultContent,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Web fetch tool result content
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WebFetchToolResultContent {
    Success(WebFetchResultBlock),
    Error(WebFetchToolResultError),
}

/// Web fetch tool result error
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebFetchToolResultError {
    #[serde(rename = "type")]
    pub error_type: String, // "web_fetch_tool_result_error"

    pub error_code: WebFetchToolResultErrorCode,
}

/// Web fetch error codes
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum WebFetchToolResultErrorCode {
    InvalidToolInput,
    Unavailable,
    MaxUsesExceeded,
    TooManyRequests,
    UrlNotAllowed,
    FetchFailed,
    ContentTooLarge,
}

// ============================================================================
// Beta Features - Tool Search Types
// ============================================================================

/// Tool search tool (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolSearchTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "tool_search_tool_regex" or "tool_search_tool_bm25"

    pub name: String,

    /// Allowed callers for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_callers: Option<Vec<String>>,

    /// Cache control for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

/// Tool reference block (beta) - returned by tool search
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolReferenceBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "tool_reference"

    /// Tool name
    pub tool_name: String,

    /// Tool description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

/// Tool search result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolSearchResultBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "tool_search_tool_search_result"

    /// Tool name
    pub tool_name: String,

    /// Relevance score
    #[serde(skip_serializing_if = "Option::is_none")]
    pub score: Option<f64>,
}

/// Tool search tool result block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolSearchToolResultBlock {
    /// The ID of the tool use this is a result for
    pub tool_use_id: String,

    /// The search results
    pub content: Vec<ToolSearchResultBlock>,

    /// Cache control for this block
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

// ============================================================================
// Beta Features - Container Upload Types
// ============================================================================

/// Container upload block (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContainerUploadBlock {
    #[serde(rename = "type")]
    pub block_type: String, // "container_upload"

    /// File ID
    pub file_id: String,

    /// File name
    pub file_name: String,

    /// File path in container
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_path: Option<String>,
}

// ============================================================================
// Beta Features - Memory Tool Types
// ============================================================================

/// Memory tool (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "memory_20250818"

    pub name: String, // "memory"

    /// Allowed callers for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_callers: Option<Vec<String>>,

    /// Whether to defer loading
    #[serde(skip_serializing_if = "Option::is_none")]
    pub defer_loading: Option<bool>,

    /// Whether to use strict mode
    #[serde(skip_serializing_if = "Option::is_none")]
    pub strict: Option<bool>,

    /// Input examples
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_examples: Option<Vec<Value>>,

    /// Cache control for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

// ============================================================================
// Beta Features - Computer Use Tool Types
// ============================================================================

/// Computer use tool (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComputerUseTool {
    #[serde(rename = "type")]
    pub tool_type: String, // "computer_20241022" or "computer_20250124"

    pub name: String, // "computer"

    /// Display width
    pub display_width_px: u32,

    /// Display height
    pub display_height_px: u32,

    /// Display number (optional)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_number: Option<u32>,

    /// Allowed callers for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_callers: Option<Vec<String>>,

    /// Cache control for this tool
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_control: Option<CacheControl>,
}

// ============================================================================
// Beta Features - Extended Input Content Block Enum
// ============================================================================

/// Beta input content block types (extends InputContentBlock)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum BetaInputContentBlock {
    // Standard types
    Text(TextBlock),
    Image(ImageBlock),
    Document(DocumentBlock),
    ToolUse(ToolUseBlock),
    ToolResult(ToolResultBlock),
    Thinking(ThinkingBlock),
    RedactedThinking(RedactedThinkingBlock),
    ServerToolUse(ServerToolUseBlock),
    SearchResult(SearchResultBlock),
    WebSearchToolResult(WebSearchToolResultBlock),

    // Beta MCP types
    McpToolUse(McpToolUseBlock),
    McpToolResult(McpToolResultBlock),

    // Beta code execution types
    CodeExecutionToolResult(CodeExecutionToolResultBlock),
    BashCodeExecutionToolResult(BashCodeExecutionToolResultBlock),
    TextEditorCodeExecutionToolResult(TextEditorCodeExecutionToolResultBlock),

    // Beta web fetch types
    WebFetchToolResult(WebFetchToolResultBlock),

    // Beta tool search types
    ToolSearchToolResult(ToolSearchToolResultBlock),
    ToolReference(ToolReferenceBlock),

    // Beta container types
    ContainerUpload(ContainerUploadBlock),
}

/// Beta output content block types (extends ContentBlock)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum BetaContentBlock {
    // Standard types
    Text {
        text: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        citations: Option<Vec<Citation>>,
    },
    ToolUse {
        id: String,
        name: String,
        input: Value,
    },
    Thinking {
        thinking: String,
        signature: String,
    },
    RedactedThinking {
        data: String,
    },
    ServerToolUse {
        id: String,
        name: String,
        input: Value,
    },
    WebSearchToolResult {
        tool_use_id: String,
        content: WebSearchToolResultContent,
    },

    // Beta MCP types
    McpToolUse {
        id: String,
        name: String,
        server_name: String,
        input: Value,
    },
    McpToolResult {
        tool_use_id: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        content: Option<ToolResultContent>,
        #[serde(skip_serializing_if = "Option::is_none")]
        is_error: Option<bool>,
    },

    // Beta code execution types
    CodeExecutionToolResult {
        tool_use_id: String,
        content: CodeExecutionToolResultContent,
    },
    BashCodeExecutionToolResult {
        tool_use_id: String,
        content: BashCodeExecutionToolResultContent,
    },
    TextEditorCodeExecutionToolResult {
        tool_use_id: String,
        content: TextEditorCodeExecutionToolResultContent,
    },

    // Beta web fetch types
    WebFetchToolResult {
        tool_use_id: String,
        content: WebFetchToolResultContent,
    },

    // Beta tool search types
    ToolSearchToolResult {
        tool_use_id: String,
        content: Vec<ToolSearchResultBlock>,
    },
    ToolReference {
        tool_name: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        description: Option<String>,
    },

    // Beta container types
    ContainerUpload {
        file_id: String,
        file_name: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        file_path: Option<String>,
    },
}

/// Beta tool definition (extends Tool)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BetaTool {
    // Standard tools
    Custom(CustomTool),
    Bash(BashTool),
    TextEditor(TextEditorTool),
    WebSearch(WebSearchTool),

    // Beta tools
    CodeExecution(CodeExecutionTool),
    McpToolset(McpToolset),
    WebFetch(WebFetchTool),
    ToolSearch(ToolSearchTool),
    Memory(MemoryTool),
    ComputerUse(ComputerUseTool),
}

/// Server tool names for beta features
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BetaServerToolName {
    WebSearch,
    WebFetch,
    CodeExecution,
    BashCodeExecution,
    TextEditorCodeExecution,
    ToolSearchToolRegex,
    ToolSearchToolBm25,
}

/// Server tool caller types (beta)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ServerToolCaller {
    /// Direct caller (the model itself)
    Direct,
    /// Code execution caller
    #[serde(rename = "code_execution_20250825")]
    CodeExecution20250825,
}