openrouter-rust 0.1.0

use openrouter_rust::{
    OpenRouterClient,
    ChatCompletionBuilder,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = OpenRouterClient::builder()
        .api_key(std::env::var("OPENROUTER_API_KEY")?)
        .build()?;

    println!("Generation Metadata API Example\n");

    // First, make a chat completion to get a generation ID
    println!("1. Making a chat completion to get a generation ID...\n");
    
    let request = ChatCompletionBuilder::new("openai/gpt-3.5-turbo")
        .user_message("What is 2+2?")
        .max_tokens(50)
        .build();

    let response = client.chat_completion(request).await?;
    let generation_id = &response.id;

    println!("   Generation ID: {}", generation_id);
    if let Some(ref choice) = response.choices.first() {
        if let Some(ref content) = choice.message.content {
            println!("   Response: {}", content);
        }
    }

    // Now retrieve the generation metadata
    println!("\n2. Retrieving generation metadata...\n");

    let generation = client.get_generation(generation_id).await?;
    let data = &generation.data;

    println!("Generation Details:");
    println!("  ID: {}", data.id);
    
    if let Some(ref upstream_id) = data.upstream_id {
        println!("  Upstream ID: {}", upstream_id);
    }
    
    println!("  Model: {}", data.model);
    println!("  Created: {}", data.created_at);
    println!("  Total Cost: ${:.6}", data.total_cost);
    
    if let Some(ref upstream_cost) = data.upstream_inference_cost {
        println!("  Upstream Cost: ${:.6}", upstream_cost);
    }
    
    if let Some(ref cache_discount) = data.cache_discount {
        println!("  Cache Discount: ${:.6}", cache_discount);
    }

    println!("\nToken Usage:");
    if let Some(tokens) = data.tokens_prompt {
        println!("  Prompt Tokens: {}", tokens);
    }
    if let Some(tokens) = data.tokens_completion {
        println!("  Completion Tokens: {}", tokens);
    }
    if let Some(tokens) = data.native_tokens_prompt {
        println!("  Native Prompt Tokens: {}", tokens);
    }
    if let Some(tokens) = data.native_tokens_completion {
        println!("  Native Completion Tokens: {}", tokens);
    }
    if let Some(tokens) = data.native_tokens_reasoning {
        println!("  Native Reasoning Tokens: {}", tokens);
    }
    if let Some(tokens) = data.native_tokens_cached {
        println!("  Native Cached Tokens: {}", tokens);
    }

    println!("\nPerformance:");
    if let Some(latency) = data.latency {
        println!("  Total Latency: {}ms", latency);
    }
    if let Some(gen_time) = data.generation_time {
        println!("  Generation Time: {}ms", gen_time);
    }
    if let Some(mod_latency) = data.moderation_latency {
        println!("  Moderation Latency: {}ms", mod_latency);
    }

    println!("\nOther Info:");
    if let Some(ref provider) = data.provider_name {
        println!("  Provider: {}", provider);
    }
    if let Some(ref finish_reason) = data.finish_reason {
        println!("  Finish Reason: {}", finish_reason);
    }
    if let Some(ref native_finish) = data.native_finish_reason {
        println!("  Native Finish Reason: {}", native_finish);
    }
    if let Some(streamed) = data.streamed {
        println!("  Streamed: {}", streamed);
    }
    if let Some(cancelled) = data.cancelled {
        println!("  Cancelled: {}", cancelled);
    }
    if let Some(byok) = data.is_byok {
        println!("  BYOK: {}", byok);
    }
    if let Some(ref origin) = data.origin {
        println!("  Origin: {}", origin);
    }

    if let Some(ref provider_responses) = data.provider_responses {
        println!("\nProvider Responses ({} fallback attempts):", provider_responses.len());
        for (i, pr) in provider_responses.iter().enumerate() {
            println!("  Attempt {}: {}", i + 1, pr.provider_name);
            println!("    Endpoint: {}", pr.endpoint_id);
            println!("    Latency: {}ms", pr.latency);
            if let Some(status) = pr.status {
                println!("    Status: {}", status);
            }
        }
    }

    Ok(())
}