AnthropicProvider

pub struct AnthropicConfig {
    pub api_key: String,
    pub base_url: String,
    pub version: String,
    pub default_model: String,
    pub default_max_tokens: u32,
    pub default_temperature: f32,
    pub timeout_secs: u64,
}

use mofa_foundation::llm::AnthropicProvider;

let provider = AnthropicProvider::new("sk-ant-xxx");

// Reads ANTHROPIC_API_KEY, ANTHROPIC_MODEL, ANTHROPIC_BASE_URL, ANTHROPIC_VERSION
let provider = AnthropicProvider::from_env();

use mofa_foundation::llm::{AnthropicProvider, AnthropicConfig};

let config = AnthropicConfig::new("sk-ant-xxx")
    .with_model("claude-3-opus-20240229")
    .with_temperature(0.8)
    .with_max_tokens(8192)
    .with_timeout(120);

let provider = AnthropicProvider::with_config(config);

provider.supports_streaming(); // true
provider.supports_tools();     // false (coming soon)
provider.supports_vision();    // false (coming soon)
provider.supports_embedding(); // false

use futures::StreamExt;
use mofa_foundation::llm::{LLMClient, AnthropicProvider};
use std::sync::Arc;

let provider = Arc::new(AnthropicProvider::new("sk-ant-xxx"));
let client = LLMClient::new(provider);

let mut stream = client.chat()
    .system("You are a creative storyteller.")
    .user("Tell me a short story about Rust")
    .send_stream()
    .await?;

while let Some(chunk) = stream.next().await {
    match chunk {
        Ok(chunk) => {
            if let Some(content) = chunk.content() {
                print!("{}", content);
            }
            if let Some(usage) = chunk.usage {
                println!("\nTokens: {} prompt + {} completion", 
                    usage.prompt_tokens, usage.completion_tokens);
            }
        }
        Err(e) => eprintln!("Stream error: {}", e),
    }
}

let response = client.chat()
    .system("You are a helpful assistant who speaks like a pirate.")
    .user("Hello, how are you?")
    .send()
    .await?;

let response = client.chat()
    .user("Write a creative poem")
    .temperature(0.9)  // More creative
    .send()
    .await?;

let response = client.chat()
    .user("What is 2+2?")
    .temperature(0.1)  // More deterministic
    .send()
    .await?;

let response = client.chat()
    .user("Count to 10")
    .stop(vec!["5".to_string()])
    .send()
    .await?;

use mofa_foundation::llm::LLMError;

match client.chat().user("Test").send().await {
    Ok(response) => println!("Success: {}", response.content().unwrap()),
    Err(LLMError::RateLimited(msg)) => {
        println!("Rate limited: {}", msg);
        // Implement backoff
    }
    Err(LLMError::ApiError { code, message }) => {
        println!("API error {}: {}", code.unwrap_or_default(), message);
    }
    Err(LLMError::Timeout(msg)) => {
        println!("Timeout: {}", msg);
        // Retry
    }
    Err(e) => println!("Error: {}", e),
}

// Vision (coming soon)
let content = MessageContent::Parts(vec![
    ContentPart::Text { text: "What's in this image?".to_string() },
    ContentPart::Image {
        image_url: ImageUrl {
            url: "data:image/jpeg;base64,...".to_string(),
            detail: None,
        },
    },
]);

use mofa_foundation::llm::*;
use std::sync::Arc;
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create provider from environment
    let provider = Arc::new(AnthropicProvider::from_env());
    let client = LLMClient::new(provider.clone());

    println!("Provider: {}", provider.name());
    println!("Default model: {}", provider.default_model());

    // Simple question
    let answer = client.ask_with_system(
        "You are a Rust expert.",
        "Explain ownership in one sentence."
    ).await?;
    println!("\nAnswer: {}", answer);

    // Streaming response
    println!("\nStreaming response:");
    let mut stream = client.chat()
        .system("You are a creative writer.")
        .user("Write a haiku about Rust programming.")
        .temperature(0.9)
        .max_tokens(200)
        .send_stream()
        .await?;

    while let Some(chunk) = stream.next().await {
        let chunk = chunk?;
        if let Some(content) = chunk.content() {
            print!("{}", content);
        }
    }
    println!("\n");

    // Multi-turn conversation
    let mut session = ChatSession::new(client)
        .with_system("You are a helpful assistant with perfect memory.");

    let r1 = session.send("My favorite color is blue.").await?;
    println!("Bot: {}", r1);

    let r2 = session.send("What's my favorite color?").await?;
    println!("Bot: {}", r2);

    // Model information
    let info = provider.get_model_info("claude-3.5-sonnet-20241022").await?;
    println!("\nModel info:");
    println!("  Name: {}", info.name);
    println!("  Max tokens: {:?}", info.max_output_tokens);
    println!("  Streaming: {}", info.capabilities.streaming);

    Ok(())
}

let response = client.chat()
    .user("Hello, Claude!")
    .send()
    .await?;

if let Some(usage) = response.usage {
    println!("Prompt tokens: {}", usage.prompt_tokens);
    println!("Completion tokens: {}", usage.completion_tokens);
    println!("Total tokens: {}", usage.total_tokens);
}