Struct ChatCompletionRequest 

pub struct ChatCompletionRequest {
    pub model: String,
    pub messages: Vec<Message>,
    pub temperature: Option<f32>,
    pub max_tokens: Option<u32>,
    pub stream: Option<bool>,
    pub top_p: Option<f32>,
    pub frequency_penalty: Option<f32>,
    pub presence_penalty: Option<f32>,
    pub functions: Option<Vec<Tool>>,
    pub function_call: Option<FunctionCallPolicy>,
}

Fields

model: String

messages: Vec<Message>

temperature: Option<f32>

max_tokens: Option<u32>

stream: Option<bool>

top_p: Option<f32>

frequency_penalty: Option<f32>

presence_penalty: Option<f32>

functions: Option<Vec<Tool>>

Optional function/tool definitions for Function Calling

function_call: Option<FunctionCallPolicy>

Function call policy: “auto”/“none”/specific name

Implementations

impl ChatCompletionRequest

pub fn new(model: String, messages: Vec<Message>) -> Self

Examples found in repository

examples/multimodal_example.rs (lines 10-21)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Multimodal example: image + audio content in a message");

    let _client = AiClient::new(Provider::Groq)?;

    let request = ChatCompletionRequest::new(
        "multimodal-model".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::new_image(
                Some("https://example.com/dog.jpg".into()),
                Some("image/jpeg".into()),
                Some("dog.jpg".into()),
            ),
            function_call: None,
        }],
    );

    println!(
        "Prepared multimodal request; image URL: {}",
        request.messages[0].content.as_text()
    );

    // Note: this example demonstrates the type usage only and does not call the API.
    Ok(())
}

examples/explicit_config.rs (lines 18-25)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Explicit configuration example");
    let opts = ConnectionOptions {
        base_url: None,                                      // fallback to provider default
        proxy: Some("http://proxy.example.com:8080".into()), // or None to use AI_PROXY_URL
        api_key: None,                                       // rely on environment for now
        timeout: Some(std::time::Duration::from_secs(40)),
        disable_proxy: false,
    };

    let client = AiClient::with_options(Provider::Groq, opts)?;

    let req = ChatCompletionRequest::new(
        "llama3-8b-8192".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Ping from explicit config".into()),
            function_call: None,
        }],
    );

    // This may fail if GROQ_API_KEY not set; we only show structure.
    match client.chat_completion(req).await {
        Ok(resp) => println!("Response model: {}", resp.model),
        Err(e) => println!(
            "Request failed (expected in example without API key): {}",
            e
        ),
    }
    Ok(())
}

examples/cohere_stream.rs (lines 10-17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Ensure COHERE_API_KEY env var is set if making real requests
    let client = AiClient::new(Provider::Cohere)?;

    let request = ChatCompletionRequest::new(
        "command-xlarge-nightly".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Write a haiku about rust programming".to_string()),
            function_call: None,
        }],
    )
    .with_temperature(0.7)
    .with_max_tokens(60);

    // List models
    match client.list_models().await {
        Ok(models) => println!("Models: {:?}", models),
        Err(e) => eprintln!("Failed to list models: {}", e),
    }

    // Streaming
    let mut stream = client.chat_completion_stream(request).await?;
    while let Some(chunk) = stream.next().await {
        match chunk {
            Ok(c) => {
                for choice in c.choices {
                    if let Some(delta) = choice.delta.content {
                        print!("{}", delta);
                    }
                }
            }
            Err(e) => {
                eprintln!("Stream error: {}", e);
                break;
            }
        }
    }

    Ok(())
}

examples/basic_usage.rs (lines 22-29)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 AI-lib Basic Usage Example");
    println!("================================");

    // Switch model provider by changing Provider value
    let client = AiClient::new(Provider::Groq)?;
    println!(
        "✅ Created client with provider: {:?}",
        client.current_provider()
    );

    // Get list of supported models
    let models = client.list_models().await?;
    println!("📋 Available models: {:?}", models);

    // Create chat request
    let request = ChatCompletionRequest::new(
        "llama3-8b-8192".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Hello! Please introduce yourself briefly.".to_string()),
            function_call: None,
        }],
    )
    .with_temperature(0.7)
    .with_max_tokens(100);

    println!("📤 Sending request to model: {}", request.model);

    // Send request
    let response = client.chat_completion(request).await?;

    println!("📥 Received response:");
    println!("   ID: {}", response.id);
    println!("   Model: {}", response.model);
    println!(
        "   Content: {}",
        response.choices[0].message.content.as_text()
    );
    println!("   Usage: {} tokens", response.usage.total_tokens);

    Ok(())
}

examples/config_driven_example.rs (lines 34-41)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Config-driven AI-lib Example");
    println!("================================");

    // Demonstrate the advantages of config-driven approach: easy provider switching
    let providers = vec![
        (Provider::Groq, "Groq"),
        (Provider::OpenAI, "OpenAI"),
        (Provider::DeepSeek, "DeepSeek"),
    ];

    for (provider, name) in providers {
        println!("\n📡 Testing Provider: {}", name);

        // Create client - just change the enum value
        let client = AiClient::new(provider)?;
        println!(
            "✅ Client created successfully: {:?}",
            client.current_provider()
        );

        // Get model list
        match client.list_models().await {
            Ok(models) => println!("📋 Available models: {:?}", models),
            Err(e) => println!("⚠️  Failed to get model list: {}", e),
        }

        // Create test request
        let request = ChatCompletionRequest::new(
            "test-model".to_string(),
            vec![Message {
                role: Role::User,
                content: Content::Text("Hello from ai-lib!".to_string()),
                function_call: None,
            }],
        );

        println!("📤 Request prepared, model: {}", request.model);
        println!("   (Need to set corresponding API_KEY environment variable for actual calls)");
    }

    println!("\n🎯 Core advantages of config-driven approach:");
    println!("   • Zero-code switching: just change Provider enum value");
    println!("   • Unified interface: all providers use the same API");
    println!("   • Rapid expansion: add new compatible providers with just configuration");

    Ok(())
}

examples/debug_request.rs (lines 11-18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔍 Debug Request Format");
    println!("======================");

    // Create test request
    let request = ChatCompletionRequest::new(
        "gpt-3.5-turbo".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Hello!".to_string()),
            function_call: None,
        }],
    )
    .with_max_tokens(10);

    println!("📤 Original Request:");
    println!("   Model: {}", request.model);
    println!("   Message count: {}", request.messages.len());
    println!(
        "   Message[0]: {:?} - {}",
        request.messages[0].role,
        request.messages[0].content.as_text()
    );
    println!("   max_tokens: {:?}", request.max_tokens);

    // Test OpenAI
    println!("\n🤖 Testing OpenAI...");
    match AiClient::new(Provider::OpenAI) {
        Ok(client) => {
            match client.chat_completion(request.clone()).await {
                Ok(response) => {
                    println!("✅ Success!");
                    println!(
                        "   Response: {}",
                        response.choices[0].message.content.as_text()
                    );
                }
                Err(e) => {
                    println!("❌ Failed: {}", e);

                    // If it's a 400 error, it indicates request format issues
                    if e.to_string().contains("400") {
                        println!("   This usually indicates incorrect request format");
                        println!("   Let's check if the request contains necessary fields...");
                    }
                }
            }
        }
        Err(e) => println!("❌ Client creation failed: {}", e),
    }

    Ok(())
}

Additional examples can be found in:

• examples/test_without_proxy.rs
• examples/compare_requests.rs
• examples/ascii_horse.rs
• examples/proxy_example.rs
• examples/openai_test.rs
• examples/test_all_providers.rs
• examples/function_call_openai.rs
• examples/test_https_proxy.rs
• examples/test_anthropic.rs
• examples/test_streaming.rs
• examples/test_openai_specific.rs
• examples/quickstart.rs
• examples/test_gemini.rs
• examples/test_groq_generic.rs
• examples/test_streaming_clean.rs
• examples/test_proxy_working.rs
• examples/test_retry_mechanism.rs
• examples/test_streaming_improved.rs
• examples/batch_processing.rs
• examples/test_all_config_driven.rs
• examples/test_hybrid_architecture.rs

pub fn with_temperature(self, temperature: f32) -> Self

Examples found in repository

examples/cohere_stream.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Ensure COHERE_API_KEY env var is set if making real requests
    let client = AiClient::new(Provider::Cohere)?;

    let request = ChatCompletionRequest::new(
        "command-xlarge-nightly".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Write a haiku about rust programming".to_string()),
            function_call: None,
        }],
    )
    .with_temperature(0.7)
    .with_max_tokens(60);

    // List models
    match client.list_models().await {
        Ok(models) => println!("Models: {:?}", models),
        Err(e) => eprintln!("Failed to list models: {}", e),
    }

    // Streaming
    let mut stream = client.chat_completion_stream(request).await?;
    while let Some(chunk) = stream.next().await {
        match chunk {
            Ok(c) => {
                for choice in c.choices {
                    if let Some(delta) = choice.delta.content {
                        print!("{}", delta);
                    }
                }
            }
            Err(e) => {
                eprintln!("Stream error: {}", e);
                break;
            }
        }
    }

    Ok(())
}

examples/basic_usage.rs (line 30)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 AI-lib Basic Usage Example");
    println!("================================");

    // Switch model provider by changing Provider value
    let client = AiClient::new(Provider::Groq)?;
    println!(
        "✅ Created client with provider: {:?}",
        client.current_provider()
    );

    // Get list of supported models
    let models = client.list_models().await?;
    println!("📋 Available models: {:?}", models);

    // Create chat request
    let request = ChatCompletionRequest::new(
        "llama3-8b-8192".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Hello! Please introduce yourself briefly.".to_string()),
            function_call: None,
        }],
    )
    .with_temperature(0.7)
    .with_max_tokens(100);

    println!("📤 Sending request to model: {}", request.model);

    // Send request
    let response = client.chat_completion(request).await?;

    println!("📥 Received response:");
    println!("   ID: {}", response.id);
    println!("   Model: {}", response.model);
    println!(
        "   Content: {}",
        response.choices[0].message.content.as_text()
    );
    println!("   Usage: {} tokens", response.usage.total_tokens);

    Ok(())
}

examples/openai_test.rs (line 51)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🤖 OpenAI Provider Test");
    println!("======================");

    // Check API key
    match std::env::var("OPENAI_API_KEY") {
        Ok(_) => println!("✅ OPENAI_API_KEY detected"),
        Err(_) => {
            println!("❌ OPENAI_API_KEY environment variable not set");
            println!("   Please set: export OPENAI_API_KEY=your_api_key");
            return Ok(());
        }
    }

    // Create OpenAI client
    let client = AiClient::new(Provider::OpenAI)?;
    println!("✅ OpenAI client created successfully");

    // Get model list
    println!("\n📋 Getting OpenAI model list...");
    match client.list_models().await {
        Ok(models) => {
            println!("✅ Successfully got {} models", models.len());
            println!("   Common models:");
            for model in models.iter().filter(|m| m.contains("gpt")) {
                println!("   • {}", model);
            }
        }
        Err(e) => println!("❌ Failed to get model list: {}", e),
    }

    // Test chat completion
    println!("\n💬 Testing chat completion...");
    let request = ChatCompletionRequest::new(
        "gpt-3.5-turbo".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text(
                "Hello! Please respond with 'Hello from OpenAI!' to confirm the connection."
                    .to_string(),
            ),
            function_call: None,
        }],
    )
    .with_max_tokens(20)
    .with_temperature(0.7);

    match client.chat_completion(request).await {
        Ok(response) => {
            println!("✅ Chat completion successful!");
            println!("   Model: {}", response.model);
            println!(
                "   Response: {}",
                response.choices[0].message.content.as_text()
            );
            println!(
                "   Token usage: {} (prompt: {}, completion: {})",
                response.usage.total_tokens,
                response.usage.prompt_tokens,
                response.usage.completion_tokens
            );
        }
        Err(e) => println!("❌ Chat completion failed: {}", e),
    }

    println!("\n🎯 OpenAI config-driven test completed!");
    println!("   This demonstrates the power of config-driven architecture:");
    println!("   • No need to write OpenAI-specific code");
    println!("   • Just add configuration in ProviderConfigs");
    println!("   • Automatically supports all OpenAI-compatible features");

    Ok(())
}

examples/function_call_openai.rs (line 36)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔧 OpenAI Function Calling example (ai-lib)");

    // Ensure OPENAI_API_KEY is set in env before running
    let client = AiClient::new(Provider::OpenAI)?;

    // Build a simple user message
    let user_msg = Message {
        role: Role::User,
        content: Content::Text("Please call the ascii_horse tool with size=3".to_string()),
        function_call: None,
    };

    // Define a Tool (JSON Schema for parameters)
    let ascii_horse_tool = Tool {
        name: "ascii_horse".to_string(),
        description: Some("Draws an ASCII horse of given size".to_string()),
        parameters: Some(json!({
            "type": "object",
            "properties": {
                "size": { "type": "integer", "description": "Size of the horse" }
            },
            "required": ["size"]
        })),
    };

    let mut req = ChatCompletionRequest::new("gpt-4o-mini".to_string(), vec![user_msg]);
    req.functions = Some(vec![ascii_horse_tool]);
    req.function_call = Some(FunctionCallPolicy::Auto("auto".to_string()));
    req = req.with_max_tokens(200).with_temperature(0.0);

    println!("📤 Sending request to OpenAI (model={})", req.model);

    let resp = client.chat_completion(req).await?;

    // Handle a possible function call from the model: execute locally and send the result back
    for choice in resp.choices {
        let msg = choice.message;
        if let Some(fc) = msg.function_call {
            println!("🛠️  Model invoked function: {}", fc.name);
            let args = fc.arguments.unwrap_or(serde_json::json!(null));
            println!("   arguments: {}", args);

            // Simple local tool: ascii_horse
            if fc.name == "ascii_horse" {
                // Parse size param
                let size = args.get("size").and_then(|v| v.as_i64()).unwrap_or(3) as usize;
                let horse = generate_ascii_horse(size);
                println!("⚙️ Executed ascii_horse locally, output:\n{}", horse);

                // Send follow-up message with tool result as assistant message
                let tool_msg = Message {
                    role: Role::Assistant,
                    content: Content::Text(horse.clone()),
                    function_call: None,
                };

                let mut followup =
                    ChatCompletionRequest::new("gpt-4o-mini".to_string(), vec![tool_msg]);
                followup = followup.with_max_tokens(200).with_temperature(0.0);
                let follow_resp = client.chat_completion(followup).await?;
                for fc_choice in follow_resp.choices {
                    println!(
                        "🗨️ Final model response: {}",
                        fc_choice.message.content.as_text()
                    );
                }
            }
        } else {
            println!("💬 Model message: {}", msg.content.as_text());
        }
    }

    Ok(())
}

examples/test_streaming.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌊 流式响应测试");
    println!("================");

    // 检查Groq API密钥
    if std::env::var("GROQ_API_KEY").is_err() {
        println!("❌ 未设置GROQ_API_KEY");
        return Ok(());
    }

    // 创建Groq客户端
    let client = AiClient::new(Provider::Groq)?;
    println!("✅ Groq客户端创建成功");

    // 创建流式请求
    let request = ChatCompletionRequest::new(
        "llama3-8b-8192".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text(
                "Please write a short poem about AI in exactly 4 lines.".to_string(),
            ),
            function_call: None,
        }],
    )
    .with_max_tokens(100)
    .with_temperature(0.7);

    println!("\n📤 发送流式请求...");
    println!("   模型: {}", request.model);
    println!("   消息: {}", request.messages[0].content.as_text());

    // 获取流式响应
    match client.chat_completion_stream(request).await {
        Ok(mut stream) => {
            println!("\n🌊 开始接收流式响应:");
            println!("{}", "─".repeat(50));

            let mut full_content = String::new();
            let mut chunk_count = 0;

            while let Some(result) = stream.next().await {
                match result {
                    Ok(chunk) => {
                        chunk_count += 1;

                        if let Some(choice) = chunk.choices.first() {
                            if let Some(content) = &choice.delta.content {
                                print!("{}", content);
                                full_content.push_str(content);

                                // 刷新输出
                                use std::io::{self, Write};
                                io::stdout().flush().unwrap();
                            }

                            // 检查是否完成
                            if choice.finish_reason.is_some() {
                                println!("\n{}", "─".repeat(50));
                                println!("✅ 流式响应完成!");
                                println!("   完成原因: {:?}", choice.finish_reason);
                                break;
                            }
                        }
                    }
                    Err(e) => {
                        println!("\n❌ 流式响应错误: {}", e);
                        break;
                    }
                }
            }

            println!("\n📊 流式响应统计:");
            println!("   数据块数量: {}", chunk_count);
            println!("   总内容长度: {} 字符", full_content.len());
            println!("   完整内容: \"{}\"", full_content.trim());
        }
        Err(e) => {
            println!("❌ 流式请求失败: {}", e);
        }
    }

    println!("\n💡 流式响应的优势:");
    println!("   • 实时显示生成内容");
    println!("   • 更好的用户体验");
    println!("   • 可以提前停止生成");
    println!("   • 适合长文本生成");

    Ok(())
}

examples/test_openai_specific.rs (line 65)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🤖 OpenAI 专项测试");
    println!("==================");

    // 检查OpenAI API密钥
    match std::env::var("OPENAI_API_KEY") {
        Ok(key) => {
            let masked = format!("{}...{}", &key[..8], &key[key.len() - 4..]);
            println!("🔑 OpenAI API Key: {}", masked);
        }
        Err(_) => {
            println!("❌ 未设置OPENAI_API_KEY");
            return Ok(());
        }
    }

    // 创建OpenAI客户端
    println!("\n📡 创建OpenAI客户端...");
    let client = match AiClient::new(Provider::OpenAI) {
        Ok(client) => {
            println!("✅ 客户端创建成功");
            client
        }
        Err(e) => {
            println!("❌ 客户端创建失败: {}", e);
            return Ok(());
        }
    };

    // 测试模型列表
    println!("\n📋 获取模型列表...");
    match client.list_models().await {
        Ok(models) => {
            println!("✅ 成功获取 {} 个模型", models.len());

            // 显示GPT模型
            let gpt_models: Vec<_> = models
                .iter()
                .filter(|m| m.contains("gpt"))
                .take(5)
                .collect();
            println!("   GPT模型: {:?}", gpt_models);
        }
        Err(e) => {
            println!("❌ 获取模型列表失败: {}", e);
            return Ok(());
        }
    }

    // 测试聊天完成
    println!("\n💬 测试聊天完成...");
    let request = ChatCompletionRequest::new(
        "gpt-3.5-turbo".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Summarize the following text: ...".to_string()),
            function_call: None,
        }],
    )
    .with_max_tokens(20)
    .with_temperature(0.0); // 使用0温度确保一致性

    match client.chat_completion(request).await {
        Ok(response) => {
            println!("✅ 聊天完成成功!");
            println!("   模型: {}", response.model);
            println!(
                "   响应: '{}'",
                response.choices[0].message.content.as_text()
            );
            println!(
                "   Token使用: {} (prompt: {}, completion: {})",
                response.usage.total_tokens,
                response.usage.prompt_tokens,
                response.usage.completion_tokens
            );
            println!("   完成原因: {:?}", response.choices[0].finish_reason);
        }
        Err(e) => {
            println!("❌ 聊天完成失败: {}", e);

            // 分析错误类型
            let error_str = e.to_string();
            if error_str.contains("400") {
                println!("   → 这是请求格式错误");
            } else if error_str.contains("401") {
                println!("   → 这是认证错误，检查API密钥");
            } else if error_str.contains("429") {
                println!("   → 这是速率限制错误");
            } else if error_str.contains("500") {
                println!("   → 这是服务器错误");
            }
        }
    }

    println!("\n🎯 OpenAI测试完成!");

    Ok(())
}

Additional examples can be found in:

• examples/test_gemini.rs
• examples/test_streaming_clean.rs
• examples/test_streaming_improved.rs
• examples/batch_processing.rs

pub fn with_max_tokens(self, max_tokens: u32) -> Self

Examples found in repository

examples/cohere_stream.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Ensure COHERE_API_KEY env var is set if making real requests
    let client = AiClient::new(Provider::Cohere)?;

    let request = ChatCompletionRequest::new(
        "command-xlarge-nightly".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Write a haiku about rust programming".to_string()),
            function_call: None,
        }],
    )
    .with_temperature(0.7)
    .with_max_tokens(60);

    // List models
    match client.list_models().await {
        Ok(models) => println!("Models: {:?}", models),
        Err(e) => eprintln!("Failed to list models: {}", e),
    }

    // Streaming
    let mut stream = client.chat_completion_stream(request).await?;
    while let Some(chunk) = stream.next().await {
        match chunk {
            Ok(c) => {
                for choice in c.choices {
                    if let Some(delta) = choice.delta.content {
                        print!("{}", delta);
                    }
                }
            }
            Err(e) => {
                eprintln!("Stream error: {}", e);
                break;
            }
        }
    }

    Ok(())
}

examples/basic_usage.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 AI-lib Basic Usage Example");
    println!("================================");

    // Switch model provider by changing Provider value
    let client = AiClient::new(Provider::Groq)?;
    println!(
        "✅ Created client with provider: {:?}",
        client.current_provider()
    );

    // Get list of supported models
    let models = client.list_models().await?;
    println!("📋 Available models: {:?}", models);

    // Create chat request
    let request = ChatCompletionRequest::new(
        "llama3-8b-8192".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Hello! Please introduce yourself briefly.".to_string()),
            function_call: None,
        }],
    )
    .with_temperature(0.7)
    .with_max_tokens(100);

    println!("📤 Sending request to model: {}", request.model);

    // Send request
    let response = client.chat_completion(request).await?;

    println!("📥 Received response:");
    println!("   ID: {}", response.id);
    println!("   Model: {}", response.model);
    println!(
        "   Content: {}",
        response.choices[0].message.content.as_text()
    );
    println!("   Usage: {} tokens", response.usage.total_tokens);

    Ok(())
}

examples/debug_request.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔍 Debug Request Format");
    println!("======================");

    // Create test request
    let request = ChatCompletionRequest::new(
        "gpt-3.5-turbo".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Hello!".to_string()),
            function_call: None,
        }],
    )
    .with_max_tokens(10);

    println!("📤 Original Request:");
    println!("   Model: {}", request.model);
    println!("   Message count: {}", request.messages.len());
    println!(
        "   Message[0]: {:?} - {}",
        request.messages[0].role,
        request.messages[0].content.as_text()
    );
    println!("   max_tokens: {:?}", request.max_tokens);

    // Test OpenAI
    println!("\n🤖 Testing OpenAI...");
    match AiClient::new(Provider::OpenAI) {
        Ok(client) => {
            match client.chat_completion(request.clone()).await {
                Ok(response) => {
                    println!("✅ Success!");
                    println!(
                        "   Response: {}",
                        response.choices[0].message.content.as_text()
                    );
                }
                Err(e) => {
                    println!("❌ Failed: {}", e);

                    // If it's a 400 error, it indicates request format issues
                    if e.to_string().contains("400") {
                        println!("   This usually indicates incorrect request format");
                        println!("   Let's check if the request contains necessary fields...");
                    }
                }
            }
        }
        Err(e) => println!("❌ Client creation failed: {}", e),
    }

    Ok(())
}

examples/test_without_proxy.rs (line 28)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 测试不使用代理的连接");
    println!("======================");

    // 临时移除代理设置
    std::env::remove_var("AI_PROXY_URL");

    println!("ℹ️  已临时移除AI_PROXY_URL设置");

    // 测试DeepSeek（国内可直连）
    println!("\n🔍 测试DeepSeek (直连):");
    match AiClient::new(Provider::DeepSeek) {
        Ok(client) => {
            let request = ChatCompletionRequest::new(
                "deepseek-chat".to_string(),
                vec![Message {
                    role: Role::User,
                    content: Content::Text(
                        "Hello! Please respond with just 'Hi' to test.".to_string(),
                    ),
                    function_call: None,
                }],
            )
            .with_max_tokens(5);

            match client.chat_completion(request).await {
                Ok(response) => {
                    println!("✅ DeepSeek 直连成功!");
                    println!("   响应: {}", response.choices[0].message.content.as_text());
                    println!("   Token使用: {}", response.usage.total_tokens);
                }
                Err(e) => {
                    println!("❌ DeepSeek 请求失败: {}", e);
                    if e.to_string().contains("402") {
                        println!("   (这是余额不足错误，说明连接正常)");
                    }
                }
            }
        }
        Err(e) => println!("❌ DeepSeek 客户端创建失败: {}", e),
    }

    println!("\n💡 结论:");
    println!("   • DeepSeek可以直连，不需要代理");
    println!("   • OpenAI和Groq需要通过代理访问");
    println!("   • 代理可能会修改请求内容，导致格式错误");
    println!("   • 建议检查代理服务器的配置");

    Ok(())
}

examples/compare_requests.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔍 Compare Request Formats");
    println!("==========================");

    let request = ChatCompletionRequest::new(
        "test-model".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Hello!".to_string()),
            function_call: None,
        }],
    )
    .with_max_tokens(10);

    println!("📤 Test Request:");
    println!("   Model: {}", request.model);
    println!("   Message: {:?}", request.messages[0]);
    println!("   max_tokens: {:?}", request.max_tokens);

    // Test Groq (working normally)
    println!("\n🟢 Groq (working normally):");
    if let Ok(_groq_client) = AiClient::new(Provider::Groq) {
        // Groq uses independent adapter, we know it works normally
        println!("   ✅ Uses independent adapter (GroqAdapter)");
        println!("   ✅ Request format correct");
    }

    // Test OpenAI (has issues)
    println!("\n🔴 OpenAI (has issues):");
    if let Ok(_openai_client) = AiClient::new(Provider::OpenAI) {
        println!("   ❌ Uses config-driven adapter (GenericAdapter)");
        println!("   ❌ Request format error: 'you must provide a model parameter'");
        println!("   🔍 Possible issues:");
        println!("      - JSON serialization problem");
        println!("      - Field mapping error");
        println!("      - Request body construction error");
    }

    println!("\n💡 Solutions:");
    println!("   1. Check GenericAdapter's convert_request method");
    println!("   2. Ensure JSON field names are correct");
    println!("   3. Verify request body structure");
    println!("   4. Consider creating independent adapter for OpenAI");

    // Suggested fixes
    println!("\n🔧 Suggested Fixes:");
    println!("   Option 1: Fix GenericAdapter's request conversion logic");
    println!("   Option 2: Create independent adapter for OpenAI (like Groq)");
    println!("   Option 3: Add more debug information to locate the issue");

    Ok(())
}

examples/openai_test.rs (line 50)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🤖 OpenAI Provider Test");
    println!("======================");

    // Check API key
    match std::env::var("OPENAI_API_KEY") {
        Ok(_) => println!("✅ OPENAI_API_KEY detected"),
        Err(_) => {
            println!("❌ OPENAI_API_KEY environment variable not set");
            println!("   Please set: export OPENAI_API_KEY=your_api_key");
            return Ok(());
        }
    }

    // Create OpenAI client
    let client = AiClient::new(Provider::OpenAI)?;
    println!("✅ OpenAI client created successfully");

    // Get model list
    println!("\n📋 Getting OpenAI model list...");
    match client.list_models().await {
        Ok(models) => {
            println!("✅ Successfully got {} models", models.len());
            println!("   Common models:");
            for model in models.iter().filter(|m| m.contains("gpt")) {
                println!("   • {}", model);
            }
        }
        Err(e) => println!("❌ Failed to get model list: {}", e),
    }

    // Test chat completion
    println!("\n💬 Testing chat completion...");
    let request = ChatCompletionRequest::new(
        "gpt-3.5-turbo".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text(
                "Hello! Please respond with 'Hello from OpenAI!' to confirm the connection."
                    .to_string(),
            ),
            function_call: None,
        }],
    )
    .with_max_tokens(20)
    .with_temperature(0.7);

    match client.chat_completion(request).await {
        Ok(response) => {
            println!("✅ Chat completion successful!");
            println!("   Model: {}", response.model);
            println!(
                "   Response: {}",
                response.choices[0].message.content.as_text()
            );
            println!(
                "   Token usage: {} (prompt: {}, completion: {})",
                response.usage.total_tokens,
                response.usage.prompt_tokens,
                response.usage.completion_tokens
            );
        }
        Err(e) => println!("❌ Chat completion failed: {}", e),
    }

    println!("\n🎯 OpenAI config-driven test completed!");
    println!("   This demonstrates the power of config-driven architecture:");
    println!("   • No need to write OpenAI-specific code");
    println!("   • Just add configuration in ProviderConfigs");
    println!("   • Automatically supports all OpenAI-compatible features");

    Ok(())
}

Additional examples can be found in:

• examples/test_all_providers.rs
• examples/function_call_openai.rs
• examples/test_https_proxy.rs
• examples/test_anthropic.rs
• examples/test_streaming.rs
• examples/test_openai_specific.rs
• examples/test_gemini.rs
• examples/test_groq_generic.rs
• examples/test_streaming_clean.rs
• examples/test_proxy_working.rs
• examples/test_retry_mechanism.rs
• examples/test_streaming_improved.rs
• examples/batch_processing.rs
• examples/test_all_config_driven.rs
• examples/test_hybrid_architecture.rs

pub fn ignore_previous(self) -> Self

Drop previous conversational messages while keeping system messages and the last non-system message. Useful to reset context while preserving system instructions.

Trait Implementations

impl Clone for ChatCompletionRequest

fn clone(&self) -> ChatCompletionRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChatCompletionRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChatCompletionRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ChatCompletionRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.