Struct Config 

pub struct Config { /* private fields */ }

Configuration for the OpenAI client.

The configuration can be created from environment variables or manually constructed with the builder pattern.

Environment Variables

Standard OpenAI

• OPENAI_API_KEY: The OpenAI API key (required)
• OPENAI_API_BASE: Custom base URL for the API (optional)
• OPENAI_ORGANIZATION: Organization ID (optional)
• OPENAI_PROJECT: Project ID (optional)
• OPENAI_MAX_RETRIES: Maximum number of retries (optional, default: 3)

Azure OpenAI

• AZURE_OPENAI_API_KEY: The Azure OpenAI API key (alternative to OPENAI_API_KEY)
• AZURE_OPENAI_ENDPOINT: Azure OpenAI endpoint (e.g., <https://my-resource.openai.azure.com>)
• AZURE_OPENAI_DEPLOYMENT: Deployment name (required for Azure)
• AZURE_OPENAI_API_VERSION: API version (optional, default: 2024-02-01)

Example

// From environment variables
let config = Config::from_env().unwrap();

// Manual configuration for OpenAI
let config = Config::builder()
    .api_key("your-api-key")
    .max_retries(5)
    .build();

// Manual configuration for Azure OpenAI
let config = Config::builder()
    .api_key("your-azure-api-key")
    .api_base("https://my-resource.openai.azure.com")
    .azure_deployment("my-deployment")
    .azure_api_version("2024-02-01")
    .build();

Implementations

impl Config

pub fn builder() -> ConfigBuilder

Create a new configuration builder.

Examples found in repository

examples/testing_patterns.rs (line 139)

    fn client(&self) -> Result<Client> {
        let config = Config::builder()
            .api_key("test-api-key")
            .api_base(&self.base_url())
            .build();

        Ok(Client::builder(config)?.build())
    }

    /// Configure error simulation
    fn configure_errors(&self, config: ErrorSimulationConfig) {
        *self.error_config.lock().unwrap() = config;
    }

    /// Mock a chat completion response
    async fn mock_chat_completion(&mut self, expected_prompt: &str, response_text: &str) {
        let mock_response = serde_json::json!({
            "id": "chatcmpl-123",
            "object": "chat.completion",
            "created": 1677652288,
            "model": "gpt-3.5-turbo",
            "choices": [{
                "index": 0,
                "message": {
                    "role": "assistant",
                    "content": response_text
                },
                "finish_reason": "stop"
            }],
            "usage": {
                "prompt_tokens": 50,
                "completion_tokens": 20,
                "total_tokens": 70
            }
        });

        self.server
            .mock("POST", "/v1/chat/completions")
            .match_body(mockito::Matcher::JsonString(
                serde_json::json!({
                    "model": "gpt-3.5-turbo",
                    "messages": [{"role": "user", "content": expected_prompt}]
                })
                .to_string(),
            ))
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(mock_response.to_string())
            .create_async()
            .await;
    }

    /// Mock a streaming chat completion response
    async fn mock_streaming_chat(&mut self, response_chunks: Vec<&str>) {
        let mut sse_data = String::new();

        for (i, chunk) in response_chunks.iter().enumerate() {
            let chunk_response = serde_json::json!({
                "id": "chatcmpl-123",
                "object": "chat.completion.chunk",
                "created": 1677652288,
                "model": "gpt-3.5-turbo",
                "choices": [{
                    "index": 0,
                    "delta": {
                        "content": chunk
                    },
                    "finish_reason": if i == response_chunks.len() - 1 { "stop" } else { "null" }
                }]
            });

            sse_data.push_str(&format!("data: {}\n\n", chunk_response));
        }

        sse_data.push_str("data: [DONE]\n\n");

        self.server
            .mock("POST", "/v1/chat/completions")
            .match_header("accept", "text/event-stream")
            .with_status(200)
            .with_header("content-type", "text/event-stream")
            .with_body(sse_data)
            .create_async()
            .await;
    }

    /// Mock an error response (rate limit, server error, etc.)
    async fn mock_error_response(&mut self, endpoint: &str, error_type: ErrorType) {
        let (status, body) = match error_type {
            ErrorType::RateLimit => (
                429,
                serde_json::json!({
                    "error": {
                        "type": "rate_limit_exceeded",
                        "message": "Rate limit exceeded, please try again later"
                    }
                })
                .to_string(),
            ),
            ErrorType::ServerError => (
                500,
                serde_json::json!({
                    "error": {
                        "type": "server_error",
                        "message": "Internal server error"
                    }
                })
                .to_string(),
            ),
            ErrorType::InvalidRequest => (
                400,
                serde_json::json!({
                    "error": {
                        "type": "invalid_request_error",
                        "message": "Invalid request parameters"
                    }
                })
                .to_string(),
            ),
            ErrorType::Unauthorized => (
                401,
                serde_json::json!({
                    "error": {
                        "type": "invalid_request_error",
                        "message": "Incorrect API key provided"
                    }
                })
                .to_string(),
            ),
        };

        self.server
            .mock("POST", endpoint)
            .with_status(status)
            .with_header("content-type", "application/json")
            .with_body(body)
            .create_async()
            .await;
    }

    /// Get logged requests for verification
    fn get_request_log(&self) -> Vec<MockRequest> {
        self.request_log.lock().unwrap().clone()
    }

    /// Clear request log
    fn clear_request_log(&self) {
        self.request_log.lock().unwrap().clear();
    }

    /// Verify that a specific request was made
    fn verify_request(&self, method: &str, path: &str) -> bool {
        let log = self.request_log.lock().unwrap();
        log.iter()
            .any(|req| req.method == method && req.path == path)
    }
}

/// Types of errors to simulate in testing
#[derive(Debug, Clone)]
enum ErrorType {
    RateLimit,
    ServerError,
    InvalidRequest,
    Unauthorized,
}

/// Test utilities for OpenAI API testing
struct TestUtils;

impl TestUtils {
    /// Create a test client with mock configuration
    fn create_test_client() -> Result<Client> {
        let config = Config::builder()
            .api_key("test-api-key")
            .api_base("http://localhost:1234") // Mock server URL
            .max_retries(2)
            .build();

        Ok(Client::builder(config)?.build())
    }

    /// Assert that a response contains expected content
    fn assert_response_content(response: &str, expected_content: &str) {
        assert!(
            response.contains(expected_content),
            "Response '{}' does not contain expected content '{}'",
            response,
            expected_content
        );
    }

    /// Assert token usage is within expected bounds
    fn assert_token_usage(usage: &TokenUsage, min_tokens: i32, max_tokens: i32) {
        assert!(
            usage.total_tokens >= min_tokens && usage.total_tokens <= max_tokens,
            "Token usage {} is outside expected range {}-{}",
            usage.total_tokens,
            min_tokens,
            max_tokens
        );
    }

    /// Create test data for batch testing
    fn create_test_prompts(count: usize) -> Vec<String> {
        (0..count)
            .map(|i| format!("Test prompt number {}", i + 1))
            .collect()
    }

    /// Measure execution time of an async operation
    async fn time_async_operation<F, T, E>(operation: F) -> (std::result::Result<T, E>, Duration)
    where
        F: std::future::Future<Output = std::result::Result<T, E>>,
    {
        let start = Instant::now();
        let result = operation.await;
        let duration = start.elapsed();
        (result, duration)
    }

    /// Create a mock response with custom token usage
    fn create_mock_response_with_usage(
        content: &str,
        prompt_tokens: i32,
        completion_tokens: i32,
    ) -> String {
        serde_json::json!({
            "id": "chatcmpl-test",
            "object": "chat.completion",
            "created": 1677652288,
            "model": "gpt-3.5-turbo",
            "choices": [{
                "index": 0,
                "message": {
                    "role": "assistant",
                    "content": content
                },
                "finish_reason": "stop"
            }],
            "usage": {
                "prompt_tokens": prompt_tokens,
                "completion_tokens": completion_tokens,
                "total_tokens": prompt_tokens + completion_tokens
            }
        })
        .to_string()
    }
}

/// Token usage information for testing
#[derive(Debug, Clone, Serialize, Deserialize)]
struct TokenUsage {
    prompt_tokens: i32,
    completion_tokens: i32,
    total_tokens: i32,
}

/// Integration test runner for live API testing
struct IntegrationTestRunner {
    client: Client,
    test_results: Vec<IntegrationTestResult>,
}

/// Result of an integration test
#[derive(Debug, Clone)]
struct IntegrationTestResult {
    test_name: String,
    success: bool,
    duration: Duration,
    error_message: Option<String>,
    response_data: Option<String>,
}

impl IntegrationTestRunner {
    /// Create a new integration test runner
    fn new(client: Client) -> Self {
        Self {
            client,
            test_results: Vec::new(),
        }
    }

    /// Run a basic chat completion test
    async fn test_basic_chat_completion(&mut self) -> Result<()> {
        let test_name = "basic_chat_completion";
        info!("Running integration test: {}", test_name);

        let (result, duration) = TestUtils::time_async_operation::<_, String, Error>(async {
            // Note: This would use real API in integration tests
            // self.client.chat_simple("Hello, world!").await

            // For demonstration, we'll simulate a successful response
            Ok("Hello! How can I help you today?".to_string())
        })
        .await;

        let test_result = match result {
            Ok(response) => {
                info!(" Basic chat completion test passed in {:?}", duration);
                IntegrationTestResult {
                    test_name: test_name.to_string(),
                    success: true,
                    duration,
                    error_message: None,
                    response_data: Some(response),
                }
            }
            Err(e) => {
                error!(" Basic chat completion test failed: {}", e);
                IntegrationTestResult {
                    test_name: test_name.to_string(),
                    success: false,
                    duration,
                    error_message: Some(e.to_string()),
                    response_data: None,
                }
            }
        };

        self.test_results.push(test_result);
        Ok(())
    }

    /// Test streaming functionality
    async fn test_streaming_completion(&mut self) -> Result<()> {
        let test_name = "streaming_completion";
        info!("Running integration test: {}", test_name);

        let (result, duration) = TestUtils::time_async_operation::<_, String, Error>(async {
            // Note: This would use real streaming API in integration tests
            // let mut stream = self.client.chat().user("Tell me a story").stream().await?;
            // let mut chunks = Vec::new();
            // while let Some(chunk) = stream.next().await {
            //     chunks.push(chunk?.content());
            // }
            // Ok(chunks.join(""))

            // For demonstration, simulate streaming chunks
            let chunks = vec!["Once", " upon", " a", " time..."];
            Ok(chunks.join(""))
        })
        .await;

        let test_result = match result {
            Ok(response) => {
                info!(" Streaming completion test passed in {:?}", duration);
                IntegrationTestResult {
                    test_name: test_name.to_string(),
                    success: true,
                    duration,
                    error_message: None,
                    response_data: Some(response),
                }
            }
            Err(e) => {
                error!(" Streaming completion test failed: {}", e);
                IntegrationTestResult {
                    test_name: test_name.to_string(),
                    success: false,
                    duration,
                    error_message: Some(e.to_string()),
                    response_data: None,
                }
            }
        };

        self.test_results.push(test_result);
        Ok(())
    }

    /// Test error handling
    async fn test_error_handling(&mut self) -> Result<()> {
        let test_name = "error_handling";
        info!("Running integration test: {}", test_name);

        let (result, duration) = TestUtils::time_async_operation::<_, String, Error>(async {
            // Test with invalid API key to trigger authentication error
            let bad_config = Config::builder().api_key("invalid-key").build();

            let _bad_client = Client::builder(bad_config)?.build();

            // This should fail with an authentication error
            // bad_client.chat_simple("Test").await

            // For demonstration, simulate an auth error
            Err(Error::InvalidRequest("Authentication failed".to_string()))
        })
        .await;

        let test_result = match result {
            Ok(_) => {
                warn!("Error handling test unexpectedly succeeded");
                IntegrationTestResult {
                    test_name: test_name.to_string(),
                    success: false,
                    duration,
                    error_message: Some(
                        "Expected authentication error but request succeeded".to_string(),
                    ),
                    response_data: None,
                }
            }
            Err(e) => {
                info!(
                    " Error handling test passed (correctly failed) in {:?}",
                    duration
                );
                IntegrationTestResult {
                    test_name: test_name.to_string(),
                    success: true,
                    duration,
                    error_message: None,
                    response_data: Some(format!("Expected error: {}", e)),
                }
            }
        };

        self.test_results.push(test_result);
        Ok(())
    }

examples/auth_patterns.rs (line 97)

async fn direct_api_key() -> Result<()> {
    // Create client with direct API key
    let api_key = "sk-your-api-key-here"; // Replace with actual key
    let config = Config::builder().api_key(api_key).build();
    let client = Client::builder(config)?.build();

    println!("Client created with direct API key");

    // Note: This will fail with invalid key
    match client.send_chat(client.chat_simple("Hello")).await {
        Ok(response) => {
            if let Some(content) = response.content() {
                println!("Response: {}", content);
            } else {
                println!("Response: (no content)");
            }
        }
        Err(e) => println!("Expected error with demo key: {}", e),
    }

    Ok(())
}

fn organization_config() -> Result<()> {
    // Configure client with organization ID
    let config = Config::builder()
        .api_key("your-api-key")
        .organization("org-123456789")
        .build();

    let _client = Client::builder(config)?.build();
    println!("Client configured with organization ID");

    // Organization ID is sent in headers with all requests
    // Useful for:
    // - Usage tracking per organization
    // - Access control
    // - Billing segregation

    Ok(())
}

fn project_config() -> Result<()> {
    // Configure client with project ID
    let config = Config::builder()
        .api_key("your-api-key")
        .project("proj-abc123")
        .build();

    let _client = Client::builder(config)?.build();
    println!("Client configured with project ID");

    // Project ID helps with:
    // - Fine-grained usage tracking
    // - Project-specific rate limits
    // - Cost allocation

    Ok(())
}

fn custom_headers() -> Result<()> {
    // Note: Custom headers are not yet supported in the current API
    // This would typically be used for:
    // - Request tracing
    // - A/B testing
    // - Custom routing

    let config = Config::builder().api_key("your-api-key").build();

    let _client = Client::builder(config)?.build();
    println!("Client configured (custom headers not yet supported)");

    // TODO: Add support for custom headers in the future
    println!("Custom headers feature planned for future implementation");

    Ok(())
}

fn proxy_config() -> Result<()> {
    // Note: Proxy configuration is not yet supported in the current API
    // This would typically be used for:
    // - Enterprise security policies
    // - Request monitoring
    // - Network isolation

    let config = Config::builder().api_key("your-api-key").build();

    let _client = Client::builder(config)?.build();
    println!("Client configured (proxy support not yet available)");

    // TODO: Add proxy support in the future
    println!("Proxy configuration feature planned for future implementation");

    Ok(())
}

fn multiple_clients() -> Result<()> {
    use reqwest_middleware::ClientBuilder;
    use std::time::Duration;

    // Create multiple clients for different use cases

    // Production client with retries and longer timeout
    let prod_http_client = ClientBuilder::new(
        reqwest::Client::builder()
            .timeout(Duration::from_secs(60))
            .build()
            .expect("Failed to build reqwest client"),
    )
    .build();

    let prod_config = Config::builder()
        .api_key("prod-api-key")
        .organization("org-prod")
        .http_client(prod_http_client)
        .max_retries(5)
        .build();
    let prod_client = Client::builder(prod_config)?.build();

    // Development client with debug logging and shorter timeout
    let dev_http_client = ClientBuilder::new(
        reqwest::Client::builder()
            .timeout(Duration::from_secs(10))
            .build()
            .expect("Failed to build reqwest client"),
    )
    .build();

    let dev_config = Config::builder()
        .api_key("dev-api-key")
        .organization("org-dev")
        .api_base("https://api.openai-dev.com") // Custom endpoint
        .http_client(dev_http_client)
        .build();
    let dev_client = Client::builder(dev_config)?.build();

    // Test client with mocked responses
    let test_config = Config::builder()
        .api_key("test-api-key")
        .api_base("http://localhost:8080") // Local mock server
        .build();
    let _test_client = Client::builder(test_config)?.build();

    println!("Created multiple clients:");
    println!("- Production client with retries");
    println!("- Development client with custom endpoint");
    println!("- Test client with mock server");

    // Use appropriate client based on context
    let _client = if cfg!(debug_assertions) {
        &dev_client
    } else {
        &prod_client
    };

    println!(
        "Using {} client",
        if cfg!(debug_assertions) {
            "dev"
        } else {
            "prod"
        }
    );

    Ok(())
}

fn config_validation() -> Result<()> {
    // Validate configuration before use

    fn validate_api_key(key: &str) -> bool {
        // OpenAI API keys typically start with "sk-"
        key.starts_with("sk-") && key.len() > 20
    }

    fn validate_org_id(org: &str) -> bool {
        // Organization IDs typically start with "org-"
        org.starts_with("org-") && org.len() > 4
    }

    let api_key = "sk-test-key-123456789";
    let org_id = "org-12345";

    if !validate_api_key(api_key) {
        println!("Warning: API key format appears invalid");
    }

    if !validate_org_id(org_id) {
        println!("Warning: Organization ID format appears invalid");
    }

    // Build config only if validation passes
    if validate_api_key(api_key) {
        let config = Config::builder()
            .api_key(api_key)
            .organization(org_id)
            .build();

        let _client = Client::builder(config)?.build();
        println!("Configuration validated and client created");
    }

    Ok(())
}

examples/error_handling.rs (line 197)

async fn auth_error_handling() -> Result<()> {
    // Try with invalid API key
    let config = Config::builder().api_key("invalid-api-key").build();
    let invalid_client = Client::builder(config)?.build();

    match invalid_client
        .send_chat(invalid_client.chat_simple("Hello"))
        .await
    {
        Ok(_) => println!("Unexpected success"),
        Err(Error::Authentication(message)) => {
            println!("Authentication failed as expected: {}", message);

            // Suggest remediation
            println!("Suggestions:");
            println!("1. Check your OPENAI_API_KEY environment variable");
            println!("2. Verify API key at https://platform.openai.com/api-keys");
            println!("3. Ensure your API key has necessary permissions");
        }
        Err(e) => println!("Unexpected error type: {}", e),
    }

    Ok(())
}

async fn network_error_handling() -> Result<()> {
    use openai_ergonomic::Config;
    use reqwest_middleware::ClientBuilder;

    // Create a reqwest client with very short timeout to simulate network issues
    let reqwest_client = reqwest::Client::builder()
        .timeout(Duration::from_secs(1))
        .build()
        .expect("Failed to build reqwest client");

    let http_client = ClientBuilder::new(reqwest_client).build();

    let config = Config::builder()
        .api_key("test-key")
        .http_client(http_client)
        .build();

    let client = Client::builder(config)?.build();

    match client.send_chat(client.chat_simple("Hello")).await {
        Ok(_) => println!("Unexpected success"),
        Err(Error::Http(source)) => {
            println!("Network error as expected: {}", source);

            // Implement exponential backoff
            let mut backoff = Duration::from_millis(100);
            for attempt in 1..=3 {
                println!("Retry attempt {} after {:?}", attempt, backoff);
                sleep(backoff).await;
                backoff *= 2;

                // In real scenario, retry with proper timeout
                // match client.send_chat(client.chat_simple("Hello")).await { ... }
            }
        }
        Err(e) => println!("Other error: {}", e),
    }

    Ok(())
}

examples/retry_patterns.rs (line 402)

async fn idempotency_example(_client: &Client) -> Result<()> {
    // Generate idempotency key
    let idempotency_key = generate_idempotency_key();
    println!("Using idempotency key: {}", idempotency_key);

    // Simulate retrying the same request
    for attempt in 1..=3 {
        println!("\nAttempt {} with same idempotency key", attempt);

        // In a real implementation, you'd pass the idempotency key in headers
        let mut headers = std::collections::HashMap::new();
        headers.insert("Idempotency-Key".to_string(), idempotency_key.clone());
        println!("  Would send {} headers", headers.len());

        let config = Config::builder()
            .api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
            .build();

        // Note: Headers (including idempotency key) are not yet supported in current API

        let client_with_idempotency = Client::builder(config)?.build();

        match client_with_idempotency
            .send_chat(client_with_idempotency.chat_simple("Idempotent request"))
            .await
        {
            Ok(response) => {
                if let Some(content) = response.content() {
                    println!("Response: {}", content);
                } else {
                    println!("Response: (no content)");
                }
                // Server should return same response for same idempotency key
            }
            Err(e) => println!("Error: {}", e),
        }

        if attempt < 3 {
            sleep(Duration::from_secs(1)).await;
        }
    }

    Ok(())
}

examples/moderations.rs (line 52)

async fn main() -> Result<()> {
    use openai_ergonomic::Config;

    println!("=== Content Moderation Example ===\n");

    // Initialize client
    let client = if let Ok(c) = Client::from_env() {
        c.build()
    } else {
        println!("Note: OPENAI_API_KEY not found. Running in demo mode.");
        println!("Set OPENAI_API_KEY to test real API calls.\n");
        println!("To use the Moderations API:");
        println!("  let client = Client::from_env()?.build();");
        println!("  let builder = client.moderations().check(\"text to moderate\");");
        println!("  let response = client.moderations().create(builder).await?;");
        println!();
        println!("Running demonstration examples...\n");
        // Create a dummy client for demo purposes
        Client::builder(Config::builder().api_key("demo-key").build())?.build()
    };

    // Example 1: Basic moderation
    println!("1. Basic Moderation:");
    basic_moderation(&client);

    // Example 2: Category detection
    println!("\n2. Category Detection:");
    category_detection(&client);

    // Example 3: Custom thresholds
    println!("\n3. Custom Thresholds:");
    custom_thresholds(&client);

    // Example 4: Multi-language moderation
    println!("\n4. Multi-language Moderation:");
    multilingual_moderation(&client);

    // Example 5: Batch moderation
    println!("\n5. Batch Moderation:");
    batch_moderation(&client);

    // Example 6: Response filtering
    println!("\n6. Response Filtering:");
    response_filtering(&client).await?;

    // Example 7: Policy enforcement
    println!("\n7. Policy Enforcement:");
    policy_enforcement(&client);

    // Example 8: Moderation pipeline
    println!("\n8. Moderation Pipeline:");
    moderation_pipeline(&client).await?;

    Ok(())
}

examples/azure_openai.rs (line 77)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    tracing_subscriber::fmt::init();

    println!("Azure OpenAI Integration Example");
    println!("=================================\n");

    // Example 1: Using environment variables
    println!("Example 1: Using environment variables");
    match Client::from_env() {
        Ok(client) => {
            let client = client.build();
            println!("Client created from environment variables");

            // Make a simple chat request
            let builder = client.chat_simple("Hello from Azure OpenAI!");
            match client.send_chat(builder).await {
                Ok(response) => {
                    if let Some(content) = response.content() {
                        println!("Response: {content}");
                    }
                }
                Err(e) => {
                    println!("Error: {e}");
                }
            }
        }
        Err(e) => {
            println!("Could not create client from environment: {e}");
            println!("Make sure to set AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY, and AZURE_OPENAI_DEPLOYMENT");
        }
    }

    println!("\n---\n");

    // Example 2: Manual configuration
    println!("Example 2: Manual configuration");

    // This example shows how to configure Azure `OpenAI` programmatically.
    // Replace these values with your actual Azure `OpenAI` resource details.
    let config = Config::builder()
        .api_key("your-azure-api-key")
        .api_base("https://my-resource.openai.azure.com")
        .azure_deployment("gpt-4")
        .azure_api_version("2024-02-01")
        .build();

    println!("Config: {config:?}");
    println!("Is Azure: {}", config.is_azure());

    // Note: This will fail unless you provide valid credentials above
    // Uncomment the following to test with your actual credentials:
    /*
    let client = Client::builder(config)?.build();

    // Simple chat completion
    let response = client
        .chat_simple("Tell me a short joke about Azure")
        .await?;
    println!("Response: {}", response);

    // More advanced chat with custom parameters
    let response = client
        .chat()
        .user("What are the main features of Azure OpenAI?")
        .temperature(0.7)
        .max_tokens(500)
        .send()
        .await?;

    println!("\nAdvanced response:");
    println!("{}", response.content());

    // Streaming example
    use futures::StreamExt;

    println!("\nStreaming example:");
    let mut stream = client
        .chat()
        .user("Count from 1 to 5")
        .stream()
        .await?;

    while let Some(chunk) = stream.next().await {
        print!("{}", chunk?.content());
    }
    println!();
    */

    println!("\n---\n");

    // Example 3: Key differences between `OpenAI` and Azure `OpenAI`
    println!("Example 3: Key differences between OpenAI and Azure OpenAI");
    println!("\nOpenAI:");
    println!("  - Endpoint: https://api.openai.com/v1");
    println!("  - Authentication: Bearer token in Authorization header");
    println!("  - Model specification: Use model names like 'gpt-4', 'gpt-3.5-turbo'");
    println!("  - Example: client.chat().model('gpt-4').send().await?\n");

    println!("Azure OpenAI:");
    println!("  - Endpoint: https://{{{{resource-name}}}}.openai.azure.com");
    println!("  - Authentication: api-key header");
    println!("  - Deployment specification: Use your deployment name");
    println!("  - API version required as query parameter");
    println!("  - Example: Configure deployment in Config, then use client normally\n");

    println!("With this library, you only need to configure the endpoint and deployment,");
    println!("and the library handles all the differences automatically!");

    Ok(())
}

Additional examples can be found in:

• examples/http_middleware_retry.rs
• examples/caching_strategies.rs
• examples/token_counting.rs

pub fn from_env() -> Result<Self>

Create configuration from environment variables.

Supports both standard OpenAI and Azure OpenAI configurations. For Azure OpenAI, set AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY, and AZURE_OPENAI_DEPLOYMENT.

pub fn api_key(&self) -> &str

Get the API key.

Examples found in repository

examples/audio_speech.rs (line 403)

fn create_configuration(client: &Client) -> Configuration {
    let mut configuration = Configuration::new();
    configuration.bearer_access_token = Some(client.config().api_key().to_string());

    if let Some(base_url) = client.config().base_url() {
        configuration.base_path = base_url.to_string();
    }

    if let Some(org_id) = client.config().organization_id() {
        configuration.user_agent = Some(format!(
            "openai-ergonomic/{} org/{}",
            env!("CARGO_PKG_VERSION"),
            org_id
        ));
    }

    configuration
}

examples/audio_transcription.rs (line 572)

fn create_configuration(client: &Client) -> Configuration {
    let mut configuration = Configuration::new();
    configuration.bearer_access_token = Some(client.config().api_key().to_string());

    if let Some(base_url) = client.config().base_url() {
        configuration.base_path = base_url.to_string();
    }

    if let Some(org_id) = client.config().organization_id() {
        configuration.user_agent = Some(format!(
            "openai-ergonomic/{} org/{}",
            env!("CARGO_PKG_VERSION"),
            org_id
        ));
    }

    configuration
}

pub fn api_base(&self) -> &str

Get the API base URL.

pub fn organization(&self) -> Option<&str>

Get the organization ID, if set.

pub fn project(&self) -> Option<&str>

Get the project ID, if set.

pub fn max_retries(&self) -> u32

Get the maximum number of retries.

pub fn default_model(&self) -> Option<&str>

Get the default model to use.

pub fn base_url(&self) -> Option<&str>

Get the base URL, if different from default.

Examples found in repository

examples/audio_speech.rs (line 405)

fn create_configuration(client: &Client) -> Configuration {
    let mut configuration = Configuration::new();
    configuration.bearer_access_token = Some(client.config().api_key().to_string());

    if let Some(base_url) = client.config().base_url() {
        configuration.base_path = base_url.to_string();
    }

    if let Some(org_id) = client.config().organization_id() {
        configuration.user_agent = Some(format!(
            "openai-ergonomic/{} org/{}",
            env!("CARGO_PKG_VERSION"),
            org_id
        ));
    }

    configuration
}

examples/audio_transcription.rs (line 574)

fn create_configuration(client: &Client) -> Configuration {
    let mut configuration = Configuration::new();
    configuration.bearer_access_token = Some(client.config().api_key().to_string());

    if let Some(base_url) = client.config().base_url() {
        configuration.base_path = base_url.to_string();
    }

    if let Some(org_id) = client.config().organization_id() {
        configuration.user_agent = Some(format!(
            "openai-ergonomic/{} org/{}",
            env!("CARGO_PKG_VERSION"),
            org_id
        ));
    }

    configuration
}

pub fn organization_id(&self) -> Option<&str>

Get the organization ID, if set.

Examples found in repository

examples/audio_speech.rs (line 409)

fn create_configuration(client: &Client) -> Configuration {
    let mut configuration = Configuration::new();
    configuration.bearer_access_token = Some(client.config().api_key().to_string());

    if let Some(base_url) = client.config().base_url() {
        configuration.base_path = base_url.to_string();
    }

    if let Some(org_id) = client.config().organization_id() {
        configuration.user_agent = Some(format!(
            "openai-ergonomic/{} org/{}",
            env!("CARGO_PKG_VERSION"),
            org_id
        ));
    }

    configuration
}

examples/audio_transcription.rs (line 578)

fn create_configuration(client: &Client) -> Configuration {
    let mut configuration = Configuration::new();
    configuration.bearer_access_token = Some(client.config().api_key().to_string());

    if let Some(base_url) = client.config().base_url() {
        configuration.base_path = base_url.to_string();
    }

    if let Some(org_id) = client.config().organization_id() {
        configuration.user_agent = Some(format!(
            "openai-ergonomic/{} org/{}",
            env!("CARGO_PKG_VERSION"),
            org_id
        ));
    }

    configuration
}

pub fn auth_header(&self) -> String

Create an authorization header value.

pub fn http_client(&self) -> Option<&ClientWithMiddleware>

Get the custom HTTP client, if set.

pub fn azure_deployment(&self) -> Option<&str>

Get the Azure deployment name, if set.

pub fn azure_api_version(&self) -> Option<&str>

Get the Azure API version, if set.

pub fn is_azure(&self) -> bool

Check if this configuration is for Azure OpenAI.

Examples found in repository

examples/azure_openai.rs (line 85)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    tracing_subscriber::fmt::init();

    println!("Azure OpenAI Integration Example");
    println!("=================================\n");

    // Example 1: Using environment variables
    println!("Example 1: Using environment variables");
    match Client::from_env() {
        Ok(client) => {
            let client = client.build();
            println!("Client created from environment variables");

            // Make a simple chat request
            let builder = client.chat_simple("Hello from Azure OpenAI!");
            match client.send_chat(builder).await {
                Ok(response) => {
                    if let Some(content) = response.content() {
                        println!("Response: {content}");
                    }
                }
                Err(e) => {
                    println!("Error: {e}");
                }
            }
        }
        Err(e) => {
            println!("Could not create client from environment: {e}");
            println!("Make sure to set AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY, and AZURE_OPENAI_DEPLOYMENT");
        }
    }

    println!("\n---\n");

    // Example 2: Manual configuration
    println!("Example 2: Manual configuration");

    // This example shows how to configure Azure `OpenAI` programmatically.
    // Replace these values with your actual Azure `OpenAI` resource details.
    let config = Config::builder()
        .api_key("your-azure-api-key")
        .api_base("https://my-resource.openai.azure.com")
        .azure_deployment("gpt-4")
        .azure_api_version("2024-02-01")
        .build();

    println!("Config: {config:?}");
    println!("Is Azure: {}", config.is_azure());

    // Note: This will fail unless you provide valid credentials above
    // Uncomment the following to test with your actual credentials:
    /*
    let client = Client::builder(config)?.build();

    // Simple chat completion
    let response = client
        .chat_simple("Tell me a short joke about Azure")
        .await?;
    println!("Response: {}", response);

    // More advanced chat with custom parameters
    let response = client
        .chat()
        .user("What are the main features of Azure OpenAI?")
        .temperature(0.7)
        .max_tokens(500)
        .send()
        .await?;

    println!("\nAdvanced response:");
    println!("{}", response.content());

    // Streaming example
    use futures::StreamExt;

    println!("\nStreaming example:");
    let mut stream = client
        .chat()
        .user("Count from 1 to 5")
        .stream()
        .await?;

    while let Some(chunk) = stream.next().await {
        print!("{}", chunk?.content());
    }
    println!();
    */

    println!("\n---\n");

    // Example 3: Key differences between `OpenAI` and Azure `OpenAI`
    println!("Example 3: Key differences between OpenAI and Azure OpenAI");
    println!("\nOpenAI:");
    println!("  - Endpoint: https://api.openai.com/v1");
    println!("  - Authentication: Bearer token in Authorization header");
    println!("  - Model specification: Use model names like 'gpt-4', 'gpt-3.5-turbo'");
    println!("  - Example: client.chat().model('gpt-4').send().await?\n");

    println!("Azure OpenAI:");
    println!("  - Endpoint: https://{{{{resource-name}}}}.openai.azure.com");
    println!("  - Authentication: api-key header");
    println!("  - Deployment specification: Use your deployment name");
    println!("  - API version required as query parameter");
    println!("  - Example: Configure deployment in Config, then use client normally\n");

    println!("With this library, you only need to configure the endpoint and deployment,");
    println!("and the library handles all the differences automatically!");

    Ok(())
}

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.