hyper_agent_ai/

claude.rs

use serde::{Deserialize, Serialize};

// ---------------------------------------------------------------------------
// Claude Model Catalog
// ---------------------------------------------------------------------------

/// All available Claude API models.
///
/// Latest generation models are listed first, followed by legacy models.
/// Use the alias variants for auto-upgrading to the latest snapshot,
/// or the dated variants for pinned, reproducible behavior.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ClaudeModel {
    // ── Latest generation ─────────────────────────────────────────────
    /// Opus 4.6 — most intelligent, best for agents & coding.
    #[serde(rename = "claude-opus-4-6")]
    Opus4_6,
    /// Sonnet 4.6 — best speed/intelligence balance.
    #[serde(rename = "claude-sonnet-4-6")]
    Sonnet4_6,
    /// Haiku 4.5 — fastest, near-frontier intelligence.
    #[serde(rename = "claude-haiku-4-5-20251001")]
    Haiku4_5,

    // ── Legacy ────────────────────────────────────────────────────────
    /// Sonnet 4.5
    #[serde(rename = "claude-sonnet-4-5-20250929")]
    Sonnet4_5,
    /// Opus 4.5
    #[serde(rename = "claude-opus-4-5-20251101")]
    Opus4_5,
    /// Opus 4.1
    #[serde(rename = "claude-opus-4-1-20250805")]
    Opus4_1,
    /// Sonnet 4
    #[serde(rename = "claude-sonnet-4-20250514")]
    Sonnet4,
    /// Opus 4
    #[serde(rename = "claude-opus-4-20250514")]
    Opus4,
    /// Haiku 3 (deprecated, retiring 2026-04-19)
    #[serde(rename = "claude-3-haiku-20240307")]
    Haiku3,
}

impl ClaudeModel {
    /// The exact API model ID string.
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Opus4_6 => "claude-opus-4-6",
            Self::Sonnet4_6 => "claude-sonnet-4-6",
            Self::Haiku4_5 => "claude-haiku-4-5-20251001",
            Self::Sonnet4_5 => "claude-sonnet-4-5-20250929",
            Self::Opus4_5 => "claude-opus-4-5-20251101",
            Self::Opus4_1 => "claude-opus-4-1-20250805",
            Self::Sonnet4 => "claude-sonnet-4-20250514",
            Self::Opus4 => "claude-opus-4-20250514",
            Self::Haiku3 => "claude-3-haiku-20240307",
        }
    }

    /// Input price per million tokens (USD).
    pub fn input_price_per_mtok(&self) -> f64 {
        match self {
            Self::Opus4_6 | Self::Opus4_5 => 5.0,
            Self::Sonnet4_6 | Self::Sonnet4_5 | Self::Sonnet4 => 3.0,
            Self::Opus4_1 | Self::Opus4 => 15.0,
            Self::Haiku4_5 => 1.0,
            Self::Haiku3 => 0.25,
        }
    }

    /// Output price per million tokens (USD).
    pub fn output_price_per_mtok(&self) -> f64 {
        match self {
            Self::Opus4_6 | Self::Opus4_5 => 25.0,
            Self::Sonnet4_6 | Self::Sonnet4_5 | Self::Sonnet4 => 15.0,
            Self::Opus4_1 | Self::Opus4 => 75.0,
            Self::Haiku4_5 => 5.0,
            Self::Haiku3 => 1.25,
        }
    }

    /// Max output tokens.
    pub fn max_output_tokens(&self) -> u32 {
        match self {
            Self::Opus4_6 => 128_000,
            Self::Sonnet4_6 | Self::Sonnet4_5 | Self::Sonnet4 | Self::Haiku4_5 => 64_000,
            Self::Opus4_5 => 64_000,
            Self::Opus4_1 | Self::Opus4 => 32_000,
            Self::Haiku3 => 4_096,
        }
    }
}

impl std::fmt::Display for ClaudeModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

/// Represents a tool definition sent to Claude API.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolDefinition {
    pub name: String,
    pub description: String,
    pub input_schema: serde_json::Value,
}

/// A tool call returned by Claude in a response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolCall {
    pub tool_name: String,
    pub tool_input: serde_json::Value,
}

/// The parsed decision from a Claude API response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentDecision {
    /// The reasoning / thinking text from the model.
    pub reasoning: String,
    /// Optional tool calls the model wants to execute.
    pub tool_calls: Vec<ToolCall>,
    /// Confidence level extracted from the response (0.0 - 1.0), default 0.5.
    pub confidence: f64,
    /// Raw content blocks for debugging.
    pub raw_content: Vec<serde_json::Value>,
}

/// Errors specific to the Claude API client.
#[derive(Debug, thiserror::Error)]
pub enum ClaudeError {
    #[error("API key not set")]
    ApiKeyNotSet,
    #[error("HTTP error: {0}")]
    HttpError(String),
    #[error("API error (status {status}): {message}")]
    ApiError { status: u16, message: String },
    #[error("Rate limited: retry after {retry_after_secs}s")]
    RateLimited { retry_after_secs: u64 },
    #[error("Timeout: {0}")]
    Timeout(String),
    #[error("Parse error: {0}")]
    ParseError(String),
    #[error("Keyring error: {0}")]
    KeyringError(String),
    #[error("OAuth error: {0}")]
    OAuthError(String),
    #[error("Authentication required — no API key or OAuth token configured")]
    AuthRequired,
}

// ---------------------------------------------------------------------------
// motosan-ai backed call_claude
// ---------------------------------------------------------------------------

/// Call Claude via motosan-ai and return a parsed AgentDecision.
///
/// This replaces the former hand-rolled `ClaudeClient::send_and_parse`.
/// `max_retries` configures exponential-backoff retry for rate-limit (429)
/// and transient errors. Pass `0` to disable retries.
pub async fn call_claude(
    api_key: &str,
    model: &str,
    system: &str,
    user: &str,
    tools: &[ToolDefinition],
    max_retries: u32,
) -> Result<AgentDecision, ClaudeError> {
    let retry_policy = motosan_ai::RetryPolicy::new()
        .max_retries(max_retries)
        .base_delay_ms(1_000)
        .max_delay_ms(30_000)
        .jitter(true)
        .respect_retry_after(true);

    let client = motosan_ai::Client::builder()
        .provider(motosan_ai::Provider::Anthropic)
        .api_key(api_key)
        .model(model)
        .retry_policy(retry_policy)
        .build()
        .map_err(|e| ClaudeError::HttpError(e.to_string()))?;

    let ai_tools: Vec<motosan_ai::Tool> = tools
        .iter()
        .map(|t| motosan_ai::Tool {
            name: t.name.clone(),
            description: Some(t.description.clone()),
            input_schema: Some(t.input_schema.clone()),
        })
        .collect();

    let mut req_builder = motosan_ai::ChatRequest::builder()
        .system(system)
        .message(motosan_ai::Message::user(user))
        .max_tokens(4096);

    if !ai_tools.is_empty() {
        req_builder = req_builder.tools(ai_tools);
    }

    let req = req_builder.build();

    let resp = client.chat_with(req).await.map_err(map_motosan_error)?;

    let confidence = extract_confidence(&resp.content).unwrap_or(0.5);

    Ok(AgentDecision {
        reasoning: resp.content,
        tool_calls: resp
            .tool_calls
            .iter()
            .map(|tc| ToolCall {
                tool_name: tc.name.clone(),
                tool_input: tc.input.clone(),
            })
            .collect(),
        confidence,
        raw_content: vec![],
    })
}

/// Map motosan-ai errors into ClaudeError.
fn map_motosan_error(e: motosan_ai::MotosanError) -> ClaudeError {
    match e {
        motosan_ai::MotosanError::Auth(_) => ClaudeError::ApiKeyNotSet,
        motosan_ai::MotosanError::RateLimit(_) => ClaudeError::RateLimited {
            retry_after_secs: 60,
        },
        motosan_ai::MotosanError::Network(msg) => ClaudeError::HttpError(msg),
        other => ClaudeError::HttpError(other.to_string()),
    }
}

// ---------------------------------------------------------------------------
// Response Parsing (kept for backward compat / raw JSON responses)
// ---------------------------------------------------------------------------

/// Parse a Claude API response JSON into an AgentDecision.
pub fn parse_agent_decision(response: &serde_json::Value) -> Result<AgentDecision, ClaudeError> {
    let content = response
        .get("content")
        .and_then(|c| c.as_array())
        .ok_or_else(|| {
            ClaudeError::ParseError("Missing 'content' array in response".to_string())
        })?;

    let mut reasoning = String::new();
    let mut tool_calls = Vec::new();
    let mut confidence = 0.5_f64;
    let raw_content: Vec<serde_json::Value> = content.clone();

    for block in content {
        let block_type = block.get("type").and_then(|t| t.as_str()).unwrap_or("");

        match block_type {
            "text" => {
                if let Some(text) = block.get("text").and_then(|t| t.as_str()) {
                    if !reasoning.is_empty() {
                        reasoning.push('\n');
                    }
                    reasoning.push_str(text);

                    // Try to extract confidence from text (e.g., "Confidence: 0.8")
                    if let Some(conf) = extract_confidence(text) {
                        confidence = conf;
                    }
                }
            }
            "tool_use" => {
                let name = block
                    .get("name")
                    .and_then(|n| n.as_str())
                    .unwrap_or("unknown")
                    .to_string();
                let input = block
                    .get("input")
                    .cloned()
                    .unwrap_or(serde_json::Value::Null);
                tool_calls.push(ToolCall {
                    tool_name: name,
                    tool_input: input,
                });
            }
            _ => {}
        }
    }

    Ok(AgentDecision {
        reasoning,
        tool_calls,
        confidence,
        raw_content,
    })
}

/// Try to extract a confidence value from text like "Confidence: 0.85" or "confidence: 0.7".
fn extract_confidence(text: &str) -> Option<f64> {
    let lower = text.to_lowercase();
    // Look for patterns like "confidence: 0.85" or "confidence level: 0.9"
    for line in lower.lines() {
        let line = line.trim();
        if line.contains("confidence") {
            // Try to find a float after "confidence" keyword
            for part in line.split_whitespace() {
                if let Ok(val) = part
                    .trim_matches(|c: char| !c.is_ascii_digit() && c != '.')
                    .parse::<f64>()
                {
                    if (0.0..=1.0).contains(&val) {
                        return Some(val);
                    }
                }
            }
        }
    }
    None
}

// ---------------------------------------------------------------------------
// Trading Tool Definitions
// ---------------------------------------------------------------------------

/// Returns the standard set of trading tool definitions for the Claude agent.
pub fn trading_tools() -> Vec<ToolDefinition> {
    vec![
        ToolDefinition {
            name: "place_order".to_string(),
            description: "Place a limit or market order on the exchange.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "asset": {
                        "type": "integer",
                        "description": "Asset index (e.g., 0 for BTC, 1 for ETH)"
                    },
                    "is_buy": {
                        "type": "boolean",
                        "description": "True for buy, false for sell"
                    },
                    "price": {
                        "type": "string",
                        "description": "Limit price as a decimal string"
                    },
                    "size": {
                        "type": "string",
                        "description": "Order size as a decimal string"
                    },
                    "reduce_only": {
                        "type": "boolean",
                        "description": "If true, only reduce existing position"
                    },
                    "order_type": {
                        "type": "object",
                        "description": "Order type specification, e.g. {\"limit\": {\"tif\": \"Gtc\"}}"
                    }
                },
                "required": ["asset", "is_buy", "price", "size", "reduce_only", "order_type"]
            }),
        },
        ToolDefinition {
            name: "cancel_order".to_string(),
            description: "Cancel an existing order on the exchange.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "asset": {
                        "type": "integer",
                        "description": "Asset index"
                    },
                    "order_id": {
                        "type": "integer",
                        "description": "The order ID to cancel"
                    }
                },
                "required": ["asset", "order_id"]
            }),
        },
        ToolDefinition {
            name: "get_positions".to_string(),
            description: "Get current open positions and account state.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {},
                "required": []
            }),
        },
        ToolDefinition {
            name: "do_nothing".to_string(),
            description: "Explicitly decide to take no action. Use this when market conditions don't warrant any trades.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "reason": {
                        "type": "string",
                        "description": "Reason for not taking action"
                    }
                },
                "required": ["reason"]
            }),
        },
        ToolDefinition {
            name: "set_stop_loss".to_string(),
            description: "Set a stop-loss trigger on an existing position. The stop-loss will trigger a market sell (for longs) or market buy (for shorts) when the price reaches the specified trigger price. The position must already exist.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "Trading pair symbol of the position, e.g. BTC-PERP"
                    },
                    "trigger_price": {
                        "type": "number",
                        "description": "Price at which the stop-loss triggers. For long positions this should be below entry price; for short positions above entry price."
                    }
                },
                "required": ["symbol", "trigger_price"]
            }),
        },
        ToolDefinition {
            name: "set_take_profit".to_string(),
            description: "Set a take-profit trigger on an existing position. The take-profit will trigger a market sell (for longs) or market buy (for shorts) when the price reaches the specified trigger price. The position must already exist.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "Trading pair symbol of the position, e.g. BTC-PERP"
                    },
                    "trigger_price": {
                        "type": "number",
                        "description": "Price at which the take-profit triggers. For long positions this should be above entry price; for short positions below entry price."
                    }
                },
                "required": ["symbol", "trigger_price"]
            }),
        },
        ToolDefinition {
            name: "get_market_data".to_string(),
            description: "Get orderbook (bids/asks) for a symbol. Use to check spread and liquidity before placing limit orders.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "Trading pair symbol, e.g. BTC-PERP"
                    },
                    "depth": {
                        "type": "integer",
                        "description": "Number of orderbook levels to return (default 5)"
                    }
                },
                "required": ["symbol"]
            }),
        },
        ToolDefinition {
            name: "close_all_positions".to_string(),
            description: "Emergency: close ALL open positions immediately with market orders. Use this when circuit breaker triggers, major bearish news hits, or system anomaly is detected. This is a one-click panic button that flattens the entire portfolio.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "reason": {
                        "type": "string",
                        "description": "Reason for the emergency close (e.g. 'circuit_breaker', 'bearish_news', 'system_anomaly')"
                    }
                },
                "required": ["reason"]
            }),
        },
        ToolDefinition {
            name: "get_funding_rate".to_string(),
            description: "Get current funding rate for a perpetual contract symbol. Use to assess overnight holding cost. A positive rate means longs pay shorts; negative means shorts pay longs.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "Trading pair symbol, e.g. BTC-PERP"
                    }
                },
                "required": ["symbol"]
            }),
        },
    ]
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_tool_definition_serialization() {
        let tool = ToolDefinition {
            name: "test_tool".to_string(),
            description: "A test tool".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "param1": {"type": "string"}
                }
            }),
        };
        let json = serde_json::to_value(&tool).unwrap();
        assert_eq!(json["name"], "test_tool");
        assert_eq!(json["description"], "A test tool");
    }

    #[test]
    fn test_agent_decision_serialization() {
        let decision = AgentDecision {
            reasoning: "Market is bullish".to_string(),
            tool_calls: vec![ToolCall {
                tool_name: "place_order".to_string(),
                tool_input: serde_json::json!({"asset": 0, "is_buy": true}),
            }],
            confidence: 0.85,
            raw_content: vec![],
        };
        let json = serde_json::to_value(&decision).unwrap();
        assert_eq!(json["reasoning"], "Market is bullish");
        assert_eq!(json["confidence"], 0.85);
        assert_eq!(json["toolCalls"][0]["toolName"], "place_order");
    }

    #[test]
    fn test_agent_decision_deserialization() {
        let json = serde_json::json!({
            "reasoning": "Bearish signal",
            "toolCalls": [],
            "confidence": 0.3,
            "rawContent": []
        });
        let decision: AgentDecision = serde_json::from_value(json).unwrap();
        assert_eq!(decision.reasoning, "Bearish signal");
        assert_eq!(decision.confidence, 0.3);
        assert!(decision.tool_calls.is_empty());
    }

    #[test]
    fn test_parse_agent_decision_text_only() {
        let response = serde_json::json!({
            "content": [
                {
                    "type": "text",
                    "text": "I recommend waiting. The market is uncertain.\nConfidence: 0.3"
                }
            ]
        });
        let decision = parse_agent_decision(&response).unwrap();
        assert!(decision.reasoning.contains("recommend waiting"));
        assert!(decision.tool_calls.is_empty());
        assert!((decision.confidence - 0.3).abs() < f64::EPSILON);
    }

    #[test]
    fn test_parse_agent_decision_with_tool_use() {
        let response = serde_json::json!({
            "content": [
                {
                    "type": "text",
                    "text": "BTC looks strong. Placing a buy order.\nConfidence: 0.85"
                },
                {
                    "type": "tool_use",
                    "id": "toolu_123",
                    "name": "place_order",
                    "input": {
                        "asset": 0,
                        "is_buy": true,
                        "price": "65000",
                        "size": "0.01",
                        "reduce_only": false,
                        "order_type": {"limit": {"tif": "Gtc"}}
                    }
                }
            ]
        });
        let decision = parse_agent_decision(&response).unwrap();
        assert!(decision.reasoning.contains("BTC looks strong"));
        assert_eq!(decision.tool_calls.len(), 1);
        assert_eq!(decision.tool_calls[0].tool_name, "place_order");
        assert_eq!(decision.tool_calls[0].tool_input["asset"], 0);
        assert_eq!(decision.tool_calls[0].tool_input["is_buy"], true);
        assert!((decision.confidence - 0.85).abs() < f64::EPSILON);
    }

    #[test]
    fn test_parse_agent_decision_multiple_tool_calls() {
        let response = serde_json::json!({
            "content": [
                {
                    "type": "text",
                    "text": "Rebalancing positions."
                },
                {
                    "type": "tool_use",
                    "id": "toolu_1",
                    "name": "cancel_order",
                    "input": {"asset": 0, "order_id": 12345}
                },
                {
                    "type": "tool_use",
                    "id": "toolu_2",
                    "name": "place_order",
                    "input": {"asset": 0, "is_buy": false, "price": "70000", "size": "0.05", "reduce_only": true, "order_type": {"limit": {"tif": "Gtc"}}}
                }
            ]
        });
        let decision = parse_agent_decision(&response).unwrap();
        assert_eq!(decision.tool_calls.len(), 2);
        assert_eq!(decision.tool_calls[0].tool_name, "cancel_order");
        assert_eq!(decision.tool_calls[1].tool_name, "place_order");
    }

    #[test]
    fn test_parse_agent_decision_missing_content() {
        let response = serde_json::json!({});
        let result = parse_agent_decision(&response);
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), ClaudeError::ParseError(_)));
    }

    #[test]
    fn test_parse_agent_decision_empty_content() {
        let response = serde_json::json!({"content": []});
        let decision = parse_agent_decision(&response).unwrap();
        assert!(decision.reasoning.is_empty());
        assert!(decision.tool_calls.is_empty());
        assert!((decision.confidence - 0.5).abs() < f64::EPSILON);
    }

    #[test]
    fn test_extract_confidence_basic() {
        assert_eq!(extract_confidence("Confidence: 0.85"), Some(0.85));
        assert_eq!(extract_confidence("confidence: 0.7"), Some(0.7));
        assert_eq!(extract_confidence("My confidence level: 0.9"), Some(0.9));
    }

    #[test]
    fn test_extract_confidence_no_match() {
        assert_eq!(extract_confidence("No confidence here"), None);
        assert_eq!(extract_confidence("Just some text"), None);
    }

    #[test]
    fn test_extract_confidence_out_of_range() {
        assert_eq!(extract_confidence("Confidence: 5.0"), None);
    }

    #[test]
    fn test_extract_confidence_multiline() {
        let text = "I think we should buy.\nConfidence: 0.8\nEnd of analysis.";
        assert_eq!(extract_confidence(text), Some(0.8));
    }

    #[test]
    fn test_trading_tools_definitions() {
        let tools = trading_tools();
        assert_eq!(tools.len(), 9);

        let names: Vec<&str> = tools.iter().map(|t| t.name.as_str()).collect();
        assert!(names.contains(&"place_order"));
        assert!(names.contains(&"cancel_order"));
        assert!(names.contains(&"get_positions"));
        assert!(names.contains(&"do_nothing"));
        assert!(names.contains(&"set_stop_loss"));
        assert!(names.contains(&"set_take_profit"));
        assert!(names.contains(&"close_all_positions"));
        assert!(names.contains(&"get_market_data"));
        assert!(names.contains(&"get_funding_rate"));
    }

    #[test]
    fn test_trading_tools_have_valid_schemas() {
        let tools = trading_tools();
        for tool in &tools {
            assert!(!tool.name.is_empty());
            assert!(!tool.description.is_empty());
            assert_eq!(tool.input_schema["type"], "object");
            assert!(tool.input_schema.get("properties").is_some());
        }
    }

    #[test]
    fn test_tool_call_serialization() {
        let tc = ToolCall {
            tool_name: "place_order".to_string(),
            tool_input: serde_json::json!({"asset": 0}),
        };
        let json = serde_json::to_value(&tc).unwrap();
        assert_eq!(json["toolName"], "place_order");
        assert_eq!(json["toolInput"]["asset"], 0);
    }

    #[test]
    fn test_claude_error_display() {
        let err = ClaudeError::ApiKeyNotSet;
        assert_eq!(format!("{}", err), "API key not set");

        let err = ClaudeError::RateLimited {
            retry_after_secs: 30,
        };
        assert_eq!(format!("{}", err), "Rate limited: retry after 30s");

        let err = ClaudeError::ApiError {
            status: 500,
            message: "Internal error".to_string(),
        };
        assert!(format!("{}", err).contains("500"));
        assert!(format!("{}", err).contains("Internal error"));
    }

    #[test]
    fn test_parse_agent_decision_unknown_block_type_ignored() {
        let response = serde_json::json!({
            "content": [
                {"type": "text", "text": "Analysis done."},
                {"type": "unknown_type", "data": "ignored"},
            ]
        });
        let decision = parse_agent_decision(&response).unwrap();
        assert_eq!(decision.reasoning, "Analysis done.");
        assert!(decision.tool_calls.is_empty());
    }

    // ---- ClaudeModel enum tests ----

    #[test]
    fn test_claude_model_as_str_all_variants() {
        assert_eq!(ClaudeModel::Opus4_6.as_str(), "claude-opus-4-6");
        assert_eq!(ClaudeModel::Sonnet4_6.as_str(), "claude-sonnet-4-6");
        assert_eq!(ClaudeModel::Haiku4_5.as_str(), "claude-haiku-4-5-20251001");
        assert_eq!(
            ClaudeModel::Sonnet4_5.as_str(),
            "claude-sonnet-4-5-20250929"
        );
        assert_eq!(ClaudeModel::Opus4_5.as_str(), "claude-opus-4-5-20251101");
        assert_eq!(ClaudeModel::Opus4_1.as_str(), "claude-opus-4-1-20250805");
        assert_eq!(ClaudeModel::Sonnet4.as_str(), "claude-sonnet-4-20250514");
        assert_eq!(ClaudeModel::Opus4.as_str(), "claude-opus-4-20250514");
        assert_eq!(ClaudeModel::Haiku3.as_str(), "claude-3-haiku-20240307");
    }

    #[test]
    fn test_claude_model_display() {
        assert_eq!(
            format!("{}", ClaudeModel::Haiku4_5),
            "claude-haiku-4-5-20251001"
        );
        assert_eq!(
            format!("{}", ClaudeModel::Sonnet4),
            "claude-sonnet-4-20250514"
        );
    }

    #[test]
    fn test_claude_model_serde_roundtrip() {
        let model = ClaudeModel::Haiku4_5;
        let json = serde_json::to_string(&model).unwrap();
        assert_eq!(json, "\"claude-haiku-4-5-20251001\"");

        let deserialized: ClaudeModel = serde_json::from_str(&json).unwrap();
        assert_eq!(deserialized, model);
    }

    #[test]
    fn test_claude_model_deserialize_all_variants() {
        let cases = vec![
            ("\"claude-opus-4-6\"", ClaudeModel::Opus4_6),
            ("\"claude-sonnet-4-6\"", ClaudeModel::Sonnet4_6),
            ("\"claude-haiku-4-5-20251001\"", ClaudeModel::Haiku4_5),
            ("\"claude-sonnet-4-5-20250929\"", ClaudeModel::Sonnet4_5),
            ("\"claude-opus-4-5-20251101\"", ClaudeModel::Opus4_5),
            ("\"claude-opus-4-1-20250805\"", ClaudeModel::Opus4_1),
            ("\"claude-sonnet-4-20250514\"", ClaudeModel::Sonnet4),
            ("\"claude-opus-4-20250514\"", ClaudeModel::Opus4),
            ("\"claude-3-haiku-20240307\"", ClaudeModel::Haiku3),
        ];
        for (json_str, expected) in cases {
            let model: ClaudeModel = serde_json::from_str(json_str).unwrap();
            assert_eq!(model, expected, "Failed for {}", json_str);
        }
    }

    #[test]
    fn test_claude_model_deserialize_unknown_fails() {
        let result = serde_json::from_str::<ClaudeModel>("\"claude-unknown-model\"");
        assert!(result.is_err());
    }

    #[test]
    fn test_claude_model_pricing() {
        assert!(
            ClaudeModel::Haiku3.input_price_per_mtok()
                < ClaudeModel::Haiku4_5.input_price_per_mtok()
        );
        assert!(
            ClaudeModel::Haiku4_5.input_price_per_mtok()
                < ClaudeModel::Sonnet4.input_price_per_mtok()
        );

        assert_eq!(ClaudeModel::Opus4.input_price_per_mtok(), 15.0);
        assert_eq!(ClaudeModel::Opus4.output_price_per_mtok(), 75.0);

        let all_models = vec![
            ClaudeModel::Opus4_6,
            ClaudeModel::Sonnet4_6,
            ClaudeModel::Haiku4_5,
            ClaudeModel::Sonnet4,
            ClaudeModel::Opus4,
            ClaudeModel::Haiku3,
        ];
        for model in all_models {
            assert!(
                model.output_price_per_mtok() > model.input_price_per_mtok(),
                "{:?} output should cost more than input",
                model
            );
        }
    }

    #[test]
    fn test_claude_model_max_output_tokens() {
        assert_eq!(ClaudeModel::Opus4_6.max_output_tokens(), 128_000);
        assert_eq!(ClaudeModel::Sonnet4_6.max_output_tokens(), 64_000);
        assert_eq!(ClaudeModel::Haiku4_5.max_output_tokens(), 64_000);
        assert_eq!(ClaudeModel::Opus4.max_output_tokens(), 32_000);
        assert_eq!(ClaudeModel::Haiku3.max_output_tokens(), 4_096);
    }

    #[test]
    fn test_claude_model_copy_clone() {
        let model = ClaudeModel::Sonnet4_6;
        let copied = model; // Copy
        let cloned = model.clone(); // Clone
        assert_eq!(model, copied);
        assert_eq!(model, cloned);
    }

    #[test]
    fn test_parse_agent_decision_multiple_text_blocks() {
        let response = serde_json::json!({
            "content": [
                {"type": "text", "text": "First thought."},
                {"type": "text", "text": "Second thought.\nConfidence: 0.6"},
            ]
        });
        let decision = parse_agent_decision(&response).unwrap();
        assert!(decision.reasoning.contains("First thought."));
        assert!(decision.reasoning.contains("Second thought."));
        assert!((decision.confidence - 0.6).abs() < f64::EPSILON);
    }

    // ---- RetryPolicy integration tests ----

    #[test]
    fn test_retry_policy_default_values() {
        let policy = motosan_ai::RetryPolicy::new()
            .max_retries(3)
            .base_delay_ms(1_000)
            .max_delay_ms(30_000)
            .jitter(true)
            .respect_retry_after(true);

        assert_eq!(policy.max_retries, 3);
        assert_eq!(policy.base_delay_ms, 1_000);
        assert_eq!(policy.max_delay_ms, 30_000);
        assert!(policy.jitter);
        assert!(policy.respect_retry_after);
    }

    #[test]
    fn test_retry_policy_zero_retries() {
        let policy = motosan_ai::RetryPolicy::new()
            .max_retries(0)
            .base_delay_ms(1_000)
            .max_delay_ms(30_000)
            .jitter(true)
            .respect_retry_after(true);

        assert_eq!(policy.max_retries, 0);
    }

    #[test]
    fn test_retry_policy_exponential_backoff() {
        let policy = motosan_ai::RetryPolicy::new()
            .max_retries(5)
            .base_delay_ms(1_000)
            .max_delay_ms(30_000)
            .jitter(false)
            .respect_retry_after(false);

        let d1 = policy.delay_for_attempt(1);
        let d2 = policy.delay_for_attempt(2);
        let d3 = policy.delay_for_attempt(3);

        // Without jitter, delays should be exponential: 1000, 2000, 4000
        assert_eq!(d1.as_millis(), 1_000);
        assert_eq!(d2.as_millis(), 2_000);
        assert_eq!(d3.as_millis(), 4_000);
    }

    #[test]
    fn test_retry_policy_respects_max_delay() {
        let policy = motosan_ai::RetryPolicy::new()
            .max_retries(10)
            .base_delay_ms(1_000)
            .max_delay_ms(5_000)
            .jitter(false)
            .respect_retry_after(false);

        let d5 = policy.delay_for_attempt(5);
        // 1000 * 2^4 = 16000, capped at 5000
        assert_eq!(d5.as_millis(), 5_000);
    }

    #[test]
    fn test_retry_policy_custom_max_retries() {
        let policy = motosan_ai::RetryPolicy::new()
            .max_retries(7)
            .base_delay_ms(500)
            .max_delay_ms(10_000)
            .jitter(false)
            .respect_retry_after(true);

        assert_eq!(policy.max_retries, 7);
        assert_eq!(policy.base_delay_ms, 500);
        assert_eq!(policy.max_delay_ms, 10_000);
    }
}