Anthropic Provider

# Configure using the CLI
goose configure

# Or set environment variables
export ANTHROPIC_API_KEY="your-api-key"
export ANTHROPIC_HOST="https://api.anthropic.com"  # optional

use goose::providers::create;
use goose::model::ModelConfig;

// Create with default model (claude-sonnet-4-5)
let model_config = ModelConfig::new("claude-sonnet-4-5")?;
let provider = create("anthropic", model_config, vec![]).await?;

// Stream a response
let messages = vec![Message::user().with_text("Hello, Claude!")];
let stream = provider.stream(
    &provider.get_model_config(),
    "session-123",
    "You are a helpful assistant.",
    &messages,
    &[],
).await?;

use goose::model::ModelConfig;

let model_config = ModelConfig::new("claude-opus-4-6")?
    .with_temperature(0.7)
    .with_max_tokens(4096)
    .with_top_p(0.9);

let provider = create("anthropic", model_config, vec![]).await?;

// Use fast model for quick operations
let (response, usage) = provider.complete_fast(
    "session-123",
    "You are a helpful assistant.",
    &messages,
    &[],
).await?;

let model_config = ModelConfig::new("claude-3-7-sonnet-20250219")?
    .with_extended_thinking(true);

// Check if caching is supported
if provider.supports_cache_control().await {
    // Caching is automatically applied to system prompts
    // and conversation history in long sessions
}

use futures::StreamExt;

let mut stream = provider.stream(
    &model_config,
    "session-123",
    "You are a helpful assistant.",
    &messages,
    &tools,
).await?;

while let Some(result) = stream.next().await {
    let (message, usage) = result?;
    if let Some(msg) = message {
        // Process streaming message chunk
        println!("Received: {:?}", msg);
    }
}

use rmcp::model::Tool;

let tools = vec![
    Tool {
        name: "get_weather".into(),
        description: Some("Get weather for a location".into()),
        input_schema: serde_json::json!({
            "type": "object",
            "properties": {
                "location": {"type": "string"},
            },
            "required": ["location"],
        }),
    },
];

let stream = provider.stream(
    &model_config,
    "session-123",
    "You are a helpful assistant.",
    &messages,
    &tools,
).await?;

impl ProviderDef for AnthropicProvider {
    fn metadata() -> ProviderMetadata {
        ProviderMetadata::with_models(
            "anthropic",
            "Anthropic",
            "Claude and other models from Anthropic",
            "claude-sonnet-4-5",
            models,
            "https://docs.anthropic.com/en/docs/about-claude/models",
            vec![
                ConfigKey::new("ANTHROPIC_API_KEY", true, true, None, true),
                ConfigKey::new(
                    "ANTHROPIC_HOST",
                    true,
                    false,
                    Some("https://api.anthropic.com"),
                    false,
                ),
            ],
        )
    }
}

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 4096,
  "system": "You are a helpful assistant.",
  "messages": [
    {
      "role": "user",
      "content": "Hello, Claude!"
    }
  ],
  "stream": true
}

let auth = AuthMethod::ApiKey {
    header_name: "x-api-key".to_string(),
    key: api_key,
};

anthropic-version: 2023-06-01

fn get_conditional_headers(&self) -> Vec<(&str, &str)> {
    let mut headers = Vec::new();
    
    if self.model.model_name.starts_with("claude-3-7-sonnet-") {
        if thinking_type(&self.model) == ThinkingType::Enabled {
            headers.push(("anthropic-beta", "output-128k-2025-02-19"));
        }
        headers.push(("anthropic-beta", "token-efficient-tools-2025-02-19"));
    }
    
    headers
}

match provider.stream(...).await {
    Ok(stream) => { /* handle stream */ },
    Err(ProviderError::Authentication(msg)) => {
        eprintln!("Invalid API key: {}", msg);
    },
    Err(ProviderError::RateLimited { retry_after }) => {
        eprintln!("Rate limited, retry after: {:?}", retry_after);
    },
    Err(ProviderError::ContextLengthExceeded(msg)) => {
        eprintln!("Context too long: {}", msg);
    },
    Err(e) => eprintln!("Error: {}", e),
}

// Get all available models from the API
let models = provider.fetch_supported_models().await?;

// Get recommended models (filtered and sorted)
let recommended = provider.fetch_recommended_models().await?;

let (message, usage) = provider.complete(...).await?;

println!("Model: {}", usage.model);
println!("Input tokens: {:?}", usage.usage.input_tokens);
println!("Output tokens: {:?}", usage.usage.output_tokens);
println!("Total tokens: {:?}", usage.usage.total_tokens);