fabro/crates/llm/tests/integration.rs

use llm::provider::ProviderAdapter;
use llm::providers::{AnthropicAdapter, GeminiAdapter, OpenAiAdapter};
use llm::types::{Message, Request};

fn make_request(model: &str) -> Request {
    Request {
        model: model.to_string(),
        messages: vec![Message::user("Say hello in exactly one word")],
        provider: None,
        tools: None,
        tool_choice: None,
        response_format: None,
        temperature: Some(0.0),
        top_p: None,
        max_tokens: Some(50),
        stop_sequences: None,
        reasoning_effort: None,
        metadata: None,
        provider_options: None,
    }
}

#[tokio::test]
#[ignore = "requires ANTHROPIC_API_KEY"]
async fn anthropic_complete() {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set");
    let adapter = AnthropicAdapter::new(api_key);
    let request = make_request("claude-haiku-4-5-20251001");
    let response = adapter.complete(&request).await.unwrap();

    assert!(!response.text().is_empty(), "response text should not be empty");
    assert_eq!(response.finish_reason, llm::types::FinishReason::Stop);
    assert!(response.usage.input_tokens > 0);
    assert!(response.usage.output_tokens > 0);
    assert_eq!(response.provider, "anthropic");
}

#[tokio::test]
#[ignore = "requires OPENAI_API_KEY"]
async fn openai_complete() {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set");
    let adapter = OpenAiAdapter::new(api_key);
    let request = make_request("gpt-4o-mini");
    let response = adapter.complete(&request).await.unwrap();

    assert!(!response.text().is_empty(), "response text should not be empty");
    assert_eq!(response.finish_reason, llm::types::FinishReason::Stop);
    assert!(response.usage.input_tokens > 0);
    assert!(response.usage.output_tokens > 0);
    assert_eq!(response.provider, "openai");
}

#[tokio::test]
#[ignore = "requires GEMINI_API_KEY"]
async fn gemini_complete() {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY must be set");
    let adapter = GeminiAdapter::new(api_key);
    let request = make_request("gemini-2.5-flash");
    let response = adapter.complete(&request).await.unwrap();

    assert!(!response.text().is_empty(), "response text should not be empty");
    assert_eq!(response.finish_reason, llm::types::FinishReason::Stop);
    assert!(response.usage.input_tokens > 0);
    assert!(response.usage.output_tokens > 0);
    assert_eq!(response.provider, "gemini");
}

async fn run_multi_turn_cache_test(
    adapter: &dyn ProviderAdapter,
    model: &str,
    min_cache_ratio: f64,
) {
    // Claude Haiku 4.5 requires 4096 tokens minimum for prompt caching.
    // Each repeat is ~78 tokens; 70 repeats ≈ 5460 tokens, safely above the threshold.
    let padding = "This is a detailed context paragraph that provides background information \
        about the conversation. It contains various facts and details that the model should \
        remember throughout the multi-turn interaction. The purpose of this padding is to \
        ensure the system prompt exceeds the minimum cache threshold for the provider. \
        We include information about mathematics, science, history, and general knowledge. \
        The model should use this context when answering questions. "
        .repeat(70);

    let system_message = Message::system(format!(
        "You are a helpful math assistant. Answer briefly.\n\n{padding}"
    ));

    let questions = [
        "What is 1+1?",
        "What is 2+2?",
        "What is 3+3?",
        "What is 4+4?",
        "What is 5+5?",
        "What is 6+6?",
    ];

    let mut messages = vec![system_message, Message::user(questions[0])];

    for turn in 0..6 {
        let request = Request {
            model: model.to_string(),
            messages: messages.clone(),
            provider: None,
            tools: None,
            tool_choice: None,
            response_format: None,
            temperature: Some(0.0),
            top_p: None,
            max_tokens: Some(100),
            stop_sequences: None,
            reasoning_effort: None,
            metadata: None,
            provider_options: None,
        };

        let response = adapter.complete(&request).await.unwrap();
        let text = response.text();
        assert!(!text.is_empty(), "response text should not be empty on turn {turn}");

        if turn == 5 {
            let cache_read = response.usage.cache_read_tokens.unwrap_or(0) as f64;
            let input = response.usage.input_tokens as f64;
            let ratio = cache_read / input;
            assert!(
                ratio >= min_cache_ratio,
                "cache ratio {ratio:.3} should be at least {min_cache_ratio} on final turn"
            );
        }

        messages.push(Message::assistant(text));
        if turn < 5 {
            messages.push(Message::user(questions[turn + 1]));
        }
    }
}

#[tokio::test]
#[ignore = "requires ANTHROPIC_API_KEY"]
async fn anthropic_multi_turn_cache() {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set");
    let adapter = AnthropicAdapter::new(api_key);
    run_multi_turn_cache_test(&adapter, "claude-haiku-4-5-20251001", 0.5).await;
}

#[tokio::test]
#[ignore = "requires OPENAI_API_KEY"]
async fn openai_multi_turn_cache() {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set");
    let adapter = OpenAiAdapter::new(api_key);
    run_multi_turn_cache_test(&adapter, "gpt-4o-mini", 0.5).await;
}

#[tokio::test]
#[ignore = "requires GEMINI_API_KEY"]
async fn gemini_multi_turn_cache() {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY must be set");
    let adapter = GeminiAdapter::new(api_key);
    run_multi_turn_cache_test(&adapter, "gemini-2.5-flash", 0.5).await;
}