FluxTokens Rust SDK

Installation

Add to your Cargo.toml:

[dependencies]
fluxtokens = "1.0"
tokio = { version = "1", features = ["full"] }

Quick Start

use fluxtokens::{Client, ChatCompletionRequest, Message};

#[tokio::main]
async fn main() -> Result<(), fluxtokens::Error> {
    let client = Client::new("sk-flux-your-api-key");

    let response = client.chat().completions().create(
        ChatCompletionRequest::new("gpt-4.1-mini")
            .messages(vec![
                Message::system("You are a helpful assistant."),
                Message::user("Hello!"),
            ])
    ).await?;

    println!("{}", response.choices[0].message.content.as_ref().unwrap());
    Ok(())
}

Available Models

Usage Examples

Basic Chat Completion

let response = client.chat().completions().create(
    ChatCompletionRequest::new("gpt-4.1-mini")
        .messages(vec![
            Message::user("What is the capital of France?"),
        ])
        .temperature(0.7)
        .max_tokens(256)
).await?;

println!("{}", response.choices[0].message.content.as_ref().unwrap());
// Output: "The capital of France is Paris."

System Messages

let response = client.chat().completions().create(
    ChatCompletionRequest::new("gpt-4.1-mini")
        .messages(vec![
            Message::system("You are a pirate. Always respond in pirate speak."),
            Message::user("How are you today?"),
        ])
).await?;
// Output: "Ahoy, matey! I be doin' just fine, thank ye fer askin'!"

List Available Models

use fluxtokens::Models;

for model in Models::list() {
    println!("{} ({})", model.name, model.provider);
    println!("  Input: ${}/1M tokens", model.input_price);
    println!("  Output: ${}/1M tokens", model.output_price);
    println!("  Vision: {}", if model.supports_vision { "✅" } else { "❌" });
}

Configuration Options

use fluxtokens::{Client, ClientConfig};

let client = Client::with_config(
    "sk-flux-...",
    ClientConfig::default()
        .base_url("https://api.fluxtokens.io")
        .timeout(60)
        .max_retries(3)
);

Error Handling

use fluxtokens::Error;

match client.chat().completions().create(request).await {
    Ok(response) => {
        println!("{}", response.choices[0].message.content.as_ref().unwrap());
    }
    Err(Error::Authentication(msg)) => {
        eprintln!("Invalid API key: {}", msg);
    }
    Err(Error::RateLimit(msg)) => {
        eprintln!("Rate limit exceeded: {}", msg);
    }
    Err(Error::InsufficientBalance(msg)) => {
        eprintln!("Please add credits: {}", msg);
    }
    Err(Error::BadRequest(msg)) => {
        eprintln!("Invalid request: {}", msg);
    }
    Err(e) => {
        eprintln!("Error: {}", e);
    }
}

Error Type Checking

if error.is_retryable() {
    // Retry the request
}

if error.is_authentication() {
    // Handle auth error
}

Requirements

• Rust 1.70+
• Tokio runtime

Support

• 📧 Email: support@fluxtokens.io
• 💬 Discord: Join our community
• 📖 Docs: fluxtokens.io/docs

License

MIT © FluxTokens