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

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

    // 切换模型提供商，只需更改 Provider 的值
    let client = AiClient::new(Provider::Groq)?;
    println!(
        "✅ Created client with provider: {:?}",
        client.current_provider()
    );

    // 获取支持的模型列表
    let models = client.list_models().await?;
    println!("📋 Available models: {:?}", models);

    // 创建聊天请求
    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);

    // 发送请求
    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 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔍 调试请求格式");
    println!("===============");

    // 创建测试请求
    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!("📤 原始请求:");
    println!("   模型: {}", request.model);
    println!("   消息数量: {}", request.messages.len());
    println!(
        "   消息[0]: {:?} - {}",
        request.messages[0].role,
        request.messages[0].content.as_text()
    );
    println!("   max_tokens: {:?}", request.max_tokens);

    // 测试OpenAI
    println!("\n🤖 测试OpenAI...");
    match AiClient::new(Provider::OpenAI) {
        Ok(client) => {
            match client.chat_completion(request.clone()).await {
                Ok(response) => {
                    println!("✅ 成功!");
                    println!("   响应: {}", response.choices[0].message.content.as_text());
                }
                Err(e) => {
                    println!("❌ 失败: {}", e);

                    // 如果是400错误，说明请求格式有问题
                    if e.to_string().contains("400") {
                        println!("   这通常表示请求格式不正确");
                        println!("   让我们检查请求是否包含必要字段...");
                    }
                }
            }
        }
        Err(e) => println!("❌ 客户端创建失败: {}", 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 37)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🌐 AI-lib 代理服务器支持示例");
    println!("============================");

    // 检查代理配置
    match std::env::var("AI_PROXY_URL") {
        Ok(proxy_url) => {
            println!("✅ 检测到代理配置: {}", proxy_url);
            println!("   所有HTTP请求将通过此代理服务器");
        }
        Err(_) => {
            println!("ℹ️  未设置AI_PROXY_URL环境变量");
            println!("   如需使用代理，请设置: export AI_PROXY_URL=http://proxy.example.com:8080");
        }
    }

    println!("\n🚀 创建AI客户端...");
    let client = AiClient::new(Provider::Groq)?;
    println!("✅ 客户端创建成功，提供商: {:?}", client.current_provider());

    // 创建测试请求
    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📤 准备发送请求...");
    println!("   模型: {}", request.model);
    println!("   消息: {}", request.messages[0].content.as_text());

    // 获取模型列表（这个请求也会通过代理）
    match client.list_models().await {
        Ok(models) => {
            println!("\n📋 通过代理获取到的模型列表:");
            for model in models {
                println!("   • {}", model);
            }
        }
        Err(e) => {
            println!("\n⚠️  获取模型列表失败: {}", e);
            println!("   这可能是由于:");
            println!("   • 未设置GROQ_API_KEY环境变量");
            println!("   • 代理服务器配置错误");
            println!("   • 网络连接问题");
        }
    }

    println!("\n💡 代理配置说明:");
    println!("   • 设置环境变量: AI_PROXY_URL=http://your-proxy:port");
    println!("   • 支持HTTP和HTTPS代理");
    println!("   • 支持带认证的代理: http://user:pass@proxy:port");
    println!("   • 所有AI提供商都会自动使用此代理配置");

    Ok(())
}

Additional examples can be found in:

• examples/openai_test.rs
• examples/test_all_providers.rs
• examples/function_call_openai.rs
• examples/test_anthropic.rs
• examples/test_https_proxy.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_all_config_driven.rs
• examples/batch_processing.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.