anthropic-sdk-rust 0.1.1

use anthropic_sdk::{Anthropic, ClientConfig, MessageCreateBuilder, MessageStreamEvent, ContentBlockDelta};
use anthropic_sdk::types::ContentBlock;
use std::time::Duration;
use std::io::{self, Write};
use futures::StreamExt;

// Helper function to extract text content from response
fn extract_text_from_content(content: &[ContentBlock]) -> String {
    content.iter()
        .filter_map(|block| match block {
            ContentBlock::Text { text } => Some(text.as_str()),
            _ => None,
        })
        .collect::<Vec<_>>()
        .join(" ")
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Testing Anthropic SDK Streaming with eBay Gateway...\n");
    
    // Get API key from environment or use dummy for configuration test
    let api_key = std::env::var("ANTHROPIC_API_KEY")
        .or_else(|_| std::env::var("EBAY_ANTHROPIC_API_KEY"))
        .unwrap_or_else(|_| {
            println!("⚠️  No API key found in environment variables.");
            println!("   Set ANTHROPIC_API_KEY or EBAY_ANTHROPIC_API_KEY");
            println!("   Using dummy key for configuration test only...\n");
            "dummy-key".to_string()
        });
    
    // Custom configuration for eBay gateway
    let config = ClientConfig::new(&api_key)
        .with_base_url("https://platformgateway2.vip.ebay.com/hubgptgatewaysvc/v1/anthropic")
        .with_timeout(Duration::from_secs(30))
        .with_max_retries(3);
    
    let client = Anthropic::with_config(config)?;
    
    println!("✅ Client created with custom eBay gateway configuration");
    println!("📡 Base URL: https://platformgateway2.vip.ebay.com/hubgptgatewaysvc/v1/anthropic");
    println!("🤖 Model: hubgpt-chat-completions-sonnet-3-7\n");
    
    // Test 1: Callback-based streaming
    println!("🧪 Test 1: Callback-based streaming...");
    
    if api_key != "dummy-key" {
        match client.messages()
            .create_with_builder("hubgpt-chat-completions-sonnet-3-7", 200)
            .user("Write a short haiku about programming")
            .temperature(0.8)
            .stream_send()
            .await
        {
            Ok(stream) => {
                println!("✅ Stream created successfully!");
                println!("📡 Streaming response...\n");
                
                let final_message = stream
                    .on_text(|delta, _snapshot| {
                        print!("{}", delta);
                        io::stdout().flush().unwrap();
                    })
                    .on_error(|error| {
                        eprintln!("\n❌ Stream error: {}", error);
                    })
                    .on_end(|| {
                        println!("\n✅ Stream completed!");
                    })
                    .final_message()
                    .await?;
                
                println!("📊 Usage: {} input, {} output tokens", 
                    final_message.usage.input_tokens, 
                    final_message.usage.output_tokens);
            }
            Err(e) => {
                println!("❌ Streaming test FAILED!");
                println!("🚨 Error: {}", e);
            }
        }
    } else {
        println!("⚠️  Skipping streaming test with dummy API key");
    }
    
    // Test 2: Manual stream iteration
    println!("\n🧪 Test 2: Manual stream iteration...");
    
    if api_key != "dummy-key" {
        let params = MessageCreateBuilder::new("hubgpt-chat-completions-sonnet-3-7", 150)
            .user("Count from 1 to 3")
            .stream(true)
            .build();
        
        match client.messages().create_stream(params).await {
            Ok(mut stream) => {
                println!("✅ Stream created successfully!");
                println!("📡 Processing events manually...\n");
                
                let mut content = String::new();
                
                while let Some(event) = stream.next().await {
                    match event? {
                        MessageStreamEvent::MessageStart { message } => {
                            println!("📨 Message started: {}", message.id);
                        }
                        MessageStreamEvent::ContentBlockStart { index, .. } => {
                            println!("📝 Content block {} started", index);
                        }
                        MessageStreamEvent::ContentBlockDelta { delta, .. } => {
                            match delta {
                                ContentBlockDelta::TextDelta { text } => {
                                    print!("{}", text);
                                    content.push_str(&text);
                                    io::stdout().flush().unwrap();
                                }
                                _ => {}
                            }
                        }
                        MessageStreamEvent::MessageDelta { usage, .. } => {
                            println!("\n📊 Usage: {} output tokens", usage.output_tokens);
                        }
                        MessageStreamEvent::MessageStop => {
                            println!("\n✅ Stream completed!");
                            break;
                        }
                        _ => {}
                    }
                }
                
                println!("📜 Complete response: {}", content);
            }
            Err(e) => {
                println!("❌ Manual streaming test FAILED!");
                println!("🚨 Error: {}", e);
            }
        }
    } else {
        println!("⚠️  Skipping manual streaming test with dummy API key");
    }
    
    // Test 3: Regular message (for comparison)
    println!("\n🧪 Test 3: Regular message (non-streaming)...");
    let response = client.messages()
        .create(
            MessageCreateBuilder::new("hubgpt-chat-completions-sonnet-3-7", 100)
                .user("Hello! Just say 'SDK configured correctly'")
                .build()
        )
        .await;
    
    match response {
        Ok(msg) => {
            println!("✅ Regular message PASSED!");
            let text = extract_text_from_content(&msg.content);
            println!("📝 Response: {}", text);
        }
        Err(e) => {
            println!("❌ Regular message FAILED!");
            println!("🚨 Error: {}", e);
            
            if api_key == "dummy-key" {
                println!("💡 This is expected with dummy API key.");
            }
        }
    }
    
    println!("\n🎉 Streaming tests completed!");
    
    if api_key == "dummy-key" {
        println!("\n💡 To test with real API calls:");
        println!("   export ANTHROPIC_API_KEY='your-ebay-gateway-key'");
        println!("   cargo run --example test_ebay_streaming");
    }
    
    Ok(())
}