anthropic-sdk-rust 0.1.1

use anthropic_sdk::{Anthropic, ClientConfig, MessageCreateBuilder};
use std::time::Duration;
use reqwest::header::{HeaderMap, HeaderValue};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔍 Authentication Headers Diagnostic Tool");
    println!("==========================================\n");
    
    // Get API key from environment
    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. Using 'test-key' for header analysis.");
            "test-key".to_string()
        });
    
    println!("📋 Testing Authentication Headers with eBay Gateway\n");
    
    // Test 1: Current SDK headers
    println!("🧪 Test 1: Current SDK Authentication Headers");
    test_current_headers(&api_key).await?;
    
    // Test 2: Alternative Authorization header
    println!("\n🧪 Test 2: Alternative Authorization Header Format");
    test_authorization_header(&api_key).await?;
    
    // Test 3: Bearer token format
    println!("\n🧪 Test 3: Bearer Token Format");
    test_bearer_token(&api_key).await?;
    
    // Test 4: Custom eBay headers
    println!("\n🧪 Test 4: Custom eBay Gateway Headers");
    test_custom_ebay_headers(&api_key).await?;
    
    println!("\n💡 Recommendations:");
    println!("1. Check your eBay gateway API documentation for required headers");
    println!("2. The error 'token is missing in the header' suggests:");
    println!("   - Gateway expects 'Authorization: Bearer <token>' instead of 'x-api-key'");
    println!("   - Or a custom header like 'token' or 'access-token'");
    println!("3. You may need to modify the AuthHandler to use different headers");
    
    Ok(())
}

async fn test_current_headers(api_key: &str) -> Result<(), Box<dyn std::error::Error>> {
    println!("   Using standard Anthropic headers:");
    println!("   • x-api-key: {}", mask_key(api_key));
    println!("   • anthropic-version: 2023-06-01");
    println!("   • content-type: application/json");
    
    let config = ClientConfig::new(api_key)
        .with_base_url("https://platformgateway2.vip.ebay.com/hubgptgatewaysvc/v1/anthropic");
    
    let client = Anthropic::with_config(config)?;
    
    let response = client.messages()
        .create(
            MessageCreateBuilder::new("hubgpt-chat-completions-sonnet-3-7", 50)
                .user("Hello")
                .build()
        )
        .await;
    
    match response {
        Ok(_) => println!("   ✅ SUCCESS: Current headers work!"),
        Err(e) => println!("   ❌ FAILED: {}", e),
    }
    
    Ok(())
}

async fn test_authorization_header(api_key: &str) -> Result<(), Box<dyn std::error::Error>> {
    println!("   Testing Authorization header format:");
    println!("   • Authorization: {}", mask_key(api_key));
    
    // Create a custom HTTP client to test different headers
    let client = reqwest::Client::new();
    let url = "https://platformgateway2.vip.ebay.com/hubgptgatewaysvc/v1/anthropic/messages";
    
    let payload = serde_json::json!({
        "model": "hubgpt-chat-completions-sonnet-3-7",
        "max_tokens": 50,
        "messages": [{"role": "user", "content": "Hello"}]
    });
    
    let response = client
        .post(url)
        .header("Authorization", api_key)
        .header("Content-Type", "application/json")
        .header("anthropic-version", "2023-06-01")
        .json(&payload)
        .send()
        .await;
    
    match response {
        Ok(resp) => {
            if resp.status().is_success() {
                println!("   ✅ SUCCESS: Authorization header works!");
            } else {
                println!("   ❌ FAILED: HTTP {} - {}", resp.status(), resp.text().await.unwrap_or_default());
            }
        }
        Err(e) => println!("   ❌ CONNECTION ERROR: {}", e),
    }
    
    Ok(())
}

async fn test_bearer_token(api_key: &str) -> Result<(), Box<dyn std::error::Error>> {
    println!("   Testing Bearer token format:");
    println!("   • Authorization: Bearer {}", mask_key(api_key));
    
    let client = reqwest::Client::new();
    let url = "https://platformgateway2.vip.ebay.com/hubgptgatewaysvc/v1/anthropic/messages";
    
    let payload = serde_json::json!({
        "model": "hubgpt-chat-completions-sonnet-3-7",
        "max_tokens": 50,
        "messages": [{"role": "user", "content": "Hello"}]
    });
    
    let response = client
        .post(url)
        .header("Authorization", format!("Bearer {}", api_key))
        .header("Content-Type", "application/json")
        .header("anthropic-version", "2023-06-01")
        .json(&payload)
        .send()
        .await;
    
    match response {
        Ok(resp) => {
            if resp.status().is_success() {
                println!("   ✅ SUCCESS: Bearer token works!");
            } else {
                println!("   ❌ FAILED: HTTP {} - {}", resp.status(), resp.text().await.unwrap_or_default());
            }
        }
        Err(e) => println!("   ❌ CONNECTION ERROR: {}", e),
    }
    
    Ok(())
}

async fn test_custom_ebay_headers(api_key: &str) -> Result<(), Box<dyn std::error::Error>> {
    println!("   Testing custom eBay headers:");
    println!("   • token: {}", mask_key(api_key));
    println!("   • access-token: {}", mask_key(api_key));
    
    let client = reqwest::Client::new();
    let url = "https://platformgateway2.vip.ebay.com/hubgptgatewaysvc/v1/anthropic/messages";
    
    let payload = serde_json::json!({
        "model": "hubgpt-chat-completions-sonnet-3-7",
        "max_tokens": 50,
        "messages": [{"role": "user", "content": "Hello"}]
    });
    
    // Test common alternative header names
    let headers_to_test = vec![
        ("token", api_key),
        ("access-token", api_key),
        ("x-access-token", api_key),
        ("ebay-token", api_key),
        ("x-ebay-token", api_key),
    ];
    
    for (header_name, header_value) in headers_to_test {
        println!("   Testing: {} = {}", header_name, mask_key(header_value));
        
        let response = client
            .post(url)
            .header(header_name, header_value)
            .header("Content-Type", "application/json")
            .header("anthropic-version", "2023-06-01")
            .json(&payload)
            .send()
            .await;
        
        match response {
            Ok(resp) => {
                if resp.status().is_success() {
                    println!("   ✅ SUCCESS: {} header works!", header_name);
                    return Ok(());
                } else {
                    let status = resp.status();
                    let body = resp.text().await.unwrap_or_default();
                    println!("   ❌ {}: HTTP {} - {}", header_name, status, body);
                }
            }
            Err(e) => println!("   ❌ {}: CONNECTION ERROR: {}", header_name, e),
        }
    }
    
    Ok(())
}

fn mask_key(key: &str) -> String {
    if key.len() <= 8 {
        "*".repeat(key.len())
    } else {
        format!("{}...{}", &key[..4], &key[key.len()-4..])
    }
}