Rust SDK

[dependencies]
openmodex = "0.1"
tokio = { version = "1", features = ["full"] }
futures = "0.3"  # Required for streaming

use openmodex::{OpenModex, ChatCompletionRequest, ChatMessage, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let client = OpenModex::new("omx_sk_YOUR_KEY")?;

    let response = client.chat().completions().create(
        ChatCompletionRequest::new("gpt-4o")
            .message(ChatMessage::system("You are a helpful assistant."))
            .message(ChatMessage::user("Hello!"))
            .temperature(0.7)
            .max_tokens(256)
    ).await?;

    let content = response.choices[0]
        .message.as_ref()
        .and_then(|m| m.content.as_deref())
        .unwrap_or("");
    println!("{content}");

    Ok(())
}

use std::time::Duration;

let client = OpenModex::builder()
    .api_key("omx_sk_...")
    .base_url("https://api.openmodex.com/v1")
    .timeout(Duration::from_secs(60))
    .max_retries(3)
    .default_model("gpt-4o")
    .fallback_models(["claude-3.5-sonnet", "gemini-2.0-flash"])
    .default_header("X-Custom", "value")
    .build()?;

let response = client.chat().completions().create(
    ChatCompletionRequest::new("gpt-4o")
        .message(ChatMessage::system("You are a helpful assistant."))
        .message(ChatMessage::user("What is Rust?"))
        .temperature(0.7)
        .max_tokens(500)
        .top_p(0.9)
).await?;

println!("{}", response.choices[0]
    .message.as_ref()
    .and_then(|m| m.content.as_deref())
    .unwrap_or(""));

// Access usage statistics
if let Some(usage) = &response.usage {
    println!("Tokens: {} prompt + {} completion = {} total",
        usage.prompt_tokens, usage.completion_tokens, usage.total_tokens);
}

use futures::StreamExt;

let mut stream = client.chat().completions().create_stream(
    ChatCompletionRequest::new("gpt-4o")
        .message(ChatMessage::user("Write a poem about Rust."))
        .temperature(0.9)
        .max_tokens(512)
).await?;

while let Some(chunk) = stream.next().await {
    let chunk = chunk?;
    if let Some(content) = chunk.choices.first()
        .and_then(|c| c.delta.content.as_ref())
    {
        print!("{content}");
    }
}

use openmodex::EmbeddingRequest;

// Single input
let response = client.embeddings().create(
    EmbeddingRequest::new("text-embedding-3-small", "Hello world")
).await?;

println!("Dimensions: {}", response.data[0].embedding.len());

// Batch input
let response = client.embeddings().create(
    EmbeddingRequest::new_batch(
        "text-embedding-3-small",
        vec!["Hello".into(), "World".into()]
    ).dimensions(256)
).await?;

// List all available models
let models = client.models().list().await?;
for model in &models.data {
    println!("{}: {} ({})", model.id, model.name, model.provider);
}

// Get model details
let model = client.models().get("gpt-4o").await?;
println!("Context length: {}", model.context_length);

// Compare models side by side
let comparison = client.models()
    .compare(&["gpt-4o", "claude-3.5-sonnet"])
    .await?;

if let Some(highlights) = &comparison.highlights {
    println!("Cheapest: {}", highlights.cheapest);
    println!("Fastest: {}", highlights.fastest);
    println!("Best quality: {}", highlights.best_quality);
}

use openmodex::RoutingConfig;

let response = client.chat().completions().create(
    ChatCompletionRequest::new("gpt-4o")
        .message(ChatMessage::user("Hello!"))
        .routing(
            RoutingConfig::new("cost-optimized")
                .fallback(vec!["claude-3.5-sonnet".into(), "gemini-2.0-flash".into()])
                .allow_upgrade(true)
        )
).await?;

// Check which model actually served the request
if let Some(meta) = &response.openmodex {
    println!("Model used: {} ({})", meta.model_used, meta.provider);
    println!("Routing strategy: {}", meta.routing_strategy);
}

use openmodex::CacheConfig;

let response = client.chat().completions().create(
    ChatCompletionRequest::new("gpt-4o")
        .message(ChatMessage::user("What is 2 + 2?"))
        .cache(CacheConfig::enabled().ttl(3600))
).await?;

if let Some(meta) = &response.openmodex {
    println!("Cache hit: {}", meta.cache_hit);
}

let client = OpenModex::builder()
    .api_key("omx_sk_...")
    .fallback_models(["claude-3.5-sonnet", "gpt-4o-mini", "gemini-1.5-pro"])
    .max_retries(2)
    .build()?;

// If gpt-4o fails, the SDK tries claude-3.5-sonnet, then gpt-4o-mini, then gemini-1.5-pro
let response = client.chat().completions().create(
    ChatCompletionRequest::new("gpt-4o")
        .message(ChatMessage::user("Hello!"))
).await?;

if let Some(meta) = &response.openmodex {
    println!("Fallback used: {}", meta.fallback_used);
}

use openmodex::{Error, ApiError};

match client.chat().completions().create(request).await {
    Ok(response) => println!("{:?}", response),
    Err(Error::Api(api_err)) => {
        println!("Status: {}", api_err.status_code);
        println!("Message: {}", api_err.message);
        println!("Rate limited: {}", api_err.is_rate_limited());
        println!("Auth error: {}", api_err.is_auth_error());
        println!("Server error: {}", api_err.is_server_error());
    }
    Err(Error::MissingApiKey) => println!("No API key provided"),
    Err(Error::AllFallbacksFailed) => println!("All fallback models failed"),
    Err(Error::Timeout) => println!("Request timed out"),
    Err(e) => println!("Other error: {e}"),
}

let client = OpenModex::builder()
    .api_key("omx_sk_...")
    .base_url("https://api.openmodex.com/v1")
    .build()?;