Enum Content 

pub enum Content {
    Text(String),
    Json(Value),
    Image {
        url: Option<String>,
        mime: Option<String>,
        name: Option<String>,
    },
    Audio {
        url: Option<String>,
        mime: Option<String>,
    },
}

Message content — moved to an enum to support multimodal and structured content

Variants

Text(String)

Json(Value)

Generic JSON content for structured payloads (e.g. function call args)

Image

Reference to an image (url) or metadata; adapters may upload or inline as needed

Fields

url: Option<String>

mime: Option<String>

name: Option<String>

Audio

Reference to audio content

Fields

url: Option<String>

mime: Option<String>

Implementations

impl Content

pub fn as_text(&self) -> String

Return a best-effort textual representation for legacy code paths

Examples found in repository

examples/multimodal_example.rs (line 25)

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/basic_usage.rs (line 43)

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 27)

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 33)

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/ascii_horse.rs (line 87)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example: Function Calling with a local tool 'ascii_horse'");

    // Define the tool
    let tool = Tool {
        name: "ascii_horse".to_string(),
        description: Some("Return an ASCII art horse. Accepts size: 'small'|'large'.".to_string()),
        parameters: Some(json!({
            "type": "object",
            "properties": {
                "size": { "type": "string", "enum": ["small", "large"] }
            },
            "required": ["size"]
        })),
    };

    // Build a request that offers the tool to the model
    let mut request = ChatCompletionRequest::new(
        "example-model".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::new_text("Please draw an ASCII horse for me."),
            function_call: None,
        }],
    );
    request.functions = Some(vec![tool.clone()]);
    request.function_call = Some(FunctionCallPolicy::Auto("ascii_horse".to_string()));

    println!(
        "Prepared request with functions: {}",
        serde_json::to_string_pretty(&request.functions).unwrap()
    );

    // Simulate model returning a function call (in a real run this would come from the provider)
    let simulated_call = FunctionCall {
        name: "ascii_horse".to_string(),
        arguments: Some(json!({ "size": "small" })),
    };
    println!(
        "Model requested function call: {}",
        serde_json::to_string_pretty(&simulated_call).unwrap()
    );

    // Execute the local tool
    let size_arg = simulated_call
        .arguments
        .as_ref()
        .and_then(|v| v.get("size"))
        .and_then(|s| s.as_str())
        .unwrap_or("small");

    let tool_output = ascii_horse(size_arg);

    // Convert tool output to a Message and append to conversation
    let tool_message = Message {
        role: Role::Assistant,
        content: Content::new_text(tool_output.clone()),
        function_call: None,
    };

    // In a normal flow you'd send the updated messages back to the model to continue the conversation.
    println!(
        "Tool output (appended as assistant message):\n\n{}\n",
        tool_message.content.as_text()
    );

    Ok(())
}

examples/proxy_example.rs (line 41)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 AI-lib Proxy Server Support Example");
    println!("=====================================");

    // Check proxy configuration
    match std::env::var("AI_PROXY_URL") {
        Ok(proxy_url) => {
            println!("✅ Proxy configuration detected: {}", proxy_url);
            println!("   All HTTP requests will go through this proxy server");
        }
        Err(_) => {
            println!("ℹ️  AI_PROXY_URL environment variable not set");
            println!("   To use proxy, set: export AI_PROXY_URL=http://proxy.example.com:8080");
        }
    }

    println!("\n🚀 Creating AI client...");
    let client = AiClient::new(Provider::Groq)?;
    println!(
        "✅ Client created successfully, provider: {:?}",
        client.current_provider()
    );

    // Create test request
    let request = ChatCompletionRequest::new(
        "llama3-8b-8192".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::Text("Hello! This request may go through a proxy.".to_string()),
            function_call: None,
        }],
    );

    println!("\n📤 Preparing to send request...");
    println!("   Model: {}", request.model);
    println!("   Message: {}", request.messages[0].content.as_text());

    // Get model list (this request will also go through proxy)
    match client.list_models().await {
        Ok(models) => {
            println!("\n📋 Model list obtained through proxy:");
            for model in models {
                println!("   • {}", model);
            }
        }
        Err(e) => {
            println!("\n⚠️  Failed to get model list: {}", e);
            println!("   This may be due to:");
            println!("   • GROQ_API_KEY environment variable not set");
            println!("   • Proxy server configuration error");
            println!("   • Network connection issue");
        }
    }

    println!("\n💡 Proxy Configuration Instructions:");
    println!("   • Set environment variable: AI_PROXY_URL=http://your-proxy:port");
    println!("   • Supports HTTP and HTTPS proxies");
    println!("   • Supports authenticated proxies: http://user:pass@proxy:port");
    println!("   • All AI providers will automatically use this proxy configuration");

    Ok(())
}

Additional examples can be found in:

• 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/test_gemini.rs
• examples/test_groq_generic.rs
• examples/test_streaming_clean.rs
• examples/test_proxy_working.rs
• examples/test_retry_mechanism.rs
• examples/batch_processing.rs
• examples/test_all_config_driven.rs
• examples/test_hybrid_architecture.rs

pub fn new_text<S: Into<String>>(s: S) -> Self

Convenience constructor for text content

Examples found in repository

examples/ascii_horse.rs (line 45)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example: Function Calling with a local tool 'ascii_horse'");

    // Define the tool
    let tool = Tool {
        name: "ascii_horse".to_string(),
        description: Some("Return an ASCII art horse. Accepts size: 'small'|'large'.".to_string()),
        parameters: Some(json!({
            "type": "object",
            "properties": {
                "size": { "type": "string", "enum": ["small", "large"] }
            },
            "required": ["size"]
        })),
    };

    // Build a request that offers the tool to the model
    let mut request = ChatCompletionRequest::new(
        "example-model".to_string(),
        vec![Message {
            role: Role::User,
            content: Content::new_text("Please draw an ASCII horse for me."),
            function_call: None,
        }],
    );
    request.functions = Some(vec![tool.clone()]);
    request.function_call = Some(FunctionCallPolicy::Auto("ascii_horse".to_string()));

    println!(
        "Prepared request with functions: {}",
        serde_json::to_string_pretty(&request.functions).unwrap()
    );

    // Simulate model returning a function call (in a real run this would come from the provider)
    let simulated_call = FunctionCall {
        name: "ascii_horse".to_string(),
        arguments: Some(json!({ "size": "small" })),
    };
    println!(
        "Model requested function call: {}",
        serde_json::to_string_pretty(&simulated_call).unwrap()
    );

    // Execute the local tool
    let size_arg = simulated_call
        .arguments
        .as_ref()
        .and_then(|v| v.get("size"))
        .and_then(|s| s.as_str())
        .unwrap_or("small");

    let tool_output = ascii_horse(size_arg);

    // Convert tool output to a Message and append to conversation
    let tool_message = Message {
        role: Role::Assistant,
        content: Content::new_text(tool_output.clone()),
        function_call: None,
    };

    // In a normal flow you'd send the updated messages back to the model to continue the conversation.
    println!(
        "Tool output (appended as assistant message):\n\n{}\n",
        tool_message.content.as_text()
    );

    Ok(())
}

pub fn new_json(v: JsonValue) -> Self

Convenience constructor for JSON content

pub fn new_image( url: Option<String>, mime: Option<String>, name: Option<String>, ) -> Self

Convenience constructor for image content

Examples found in repository

examples/multimodal_example.rs (lines 14-18)

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(())
}

pub fn new_audio(url: Option<String>, mime: Option<String>) -> Self

Convenience constructor for audio content

Trait Implementations

impl Clone for Content

fn clone(&self) -> Content

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Content

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Content

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Content

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

where __S: Serializer,

Serialize this value into the given Serde serializer.