Struct ClientConfig 

pub struct ClientConfig {
    pub api_key: Option<SecretString>,
    pub base_url: Option<Url>,
    pub default_model: Option<String>,
    pub timeout: Duration,
    pub retry: RetryPolicy,
    pub default_headers: HeaderMap,
}

Client configuration. Explicit values win over environment, then defaults.

Fields

api_key: Option<SecretString>

API key. Falls back to ENV_API_KEY.

base_url: Option<Url>

API root. Falls back to ENV_BASE_URL, then DEFAULT_BASE_URL.

default_model: Option<String>

Default model. Falls back to ENV_DEFAULT_MODEL, then DEFAULT_MODEL.

timeout: Duration

Per-attempt timeout including the body. Default: 10 s.

retry: RetryPolicy

Retry policy. Default matches the official SDKs.

default_headers: HeaderMap

Extra headers. Cannot override Authorization, Accept, or SDK identification headers.

Implementations

impl ClientConfig

pub fn new() -> Self

Empty config that will read the process environment in crate::Client::new.

Examples found in repository

examples/models.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_models().respond(json!({
        "models": [{
            "name": "jev-latest",
            "description": "TypeSafe flagship",
            "release_date": "2026-01-01"
        }]
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    client.warm_up().await?;
    for model in client.models().list().await? {
        println!("{} — {}", model.name, model.description);
    }
    Ok(())
}

examples/blocking.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()?;
    let mock = rt.block_on(MockServer::start());
    mock.on_system_one().respond(json!({
        "urgent": noul(0.91),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build_blocking()?;

    let response = client.system_one(
        "Help! My payouts have been failing for 3 days.",
        questions! { "urgent" => Question::noul("Does this convey urgency?") },
    )?;
    println!("urgent noul = {:?}", response.noul("urgent"));

    drop(client);
    drop(mock);
    drop(rt);
    Ok(())
}

examples/triage.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn api_key(self, key: impl Into<SecretString>) -> Self

Set the API key.

Examples found in repository

examples/models.rs (line 23)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_models().respond(json!({
        "models": [{
            "name": "jev-latest",
            "description": "TypeSafe flagship",
            "release_date": "2026-01-01"
        }]
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    client.warm_up().await?;
    for model in client.models().list().await? {
        println!("{} — {}", model.name, model.description);
    }
    Ok(())
}

examples/blocking.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()?;
    let mock = rt.block_on(MockServer::start());
    mock.on_system_one().respond(json!({
        "urgent": noul(0.91),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build_blocking()?;

    let response = client.system_one(
        "Help! My payouts have been failing for 3 days.",
        questions! { "urgent" => Question::noul("Does this convey urgency?") },
    )?;
    println!("urgent noul = {:?}", response.noul("urgent"));

    drop(client);
    drop(mock);
    drop(rt);
    Ok(())
}

examples/triage.rs (line 21)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn base_url(self, url: Url) -> Self

Set the API root.

Examples found in repository

examples/models.rs (line 24)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_models().respond(json!({
        "models": [{
            "name": "jev-latest",
            "description": "TypeSafe flagship",
            "release_date": "2026-01-01"
        }]
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    client.warm_up().await?;
    for model in client.models().list().await? {
        println!("{} — {}", model.name, model.description);
    }
    Ok(())
}

examples/blocking.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()?;
    let mock = rt.block_on(MockServer::start());
    mock.on_system_one().respond(json!({
        "urgent": noul(0.91),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build_blocking()?;

    let response = client.system_one(
        "Help! My payouts have been failing for 3 days.",
        questions! { "urgent" => Question::noul("Does this convey urgency?") },
    )?;
    println!("urgent noul = {:?}", response.noul("urgent"));

    drop(client);
    drop(mock);
    drop(rt);
    Ok(())
}

examples/triage.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn try_base_url(self, url: &str) -> Result<Self, Error>

Parse and set the API root.

pub fn default_model(self, model: impl Into<String>) -> Self

Set the default model.

pub fn timeout(self, timeout: Duration) -> Self

Set the per-attempt timeout.

pub fn retry(self, retry: RetryPolicy) -> Self

Set the retry policy.

pub fn header( self, name: impl AsRef<str>, value: impl AsRef<str>, ) -> Result<Self, Error>

Insert a default header. Protected names (Authorization, Accept, User-Agent, SDK identification, retry-count) are ignored.

pub fn default_headers(self, headers: HeaderMap) -> Self

Replace extra default headers. Protected names are ignored at send time.

pub fn build(self) -> Result<Client, Error>

Build an async Client.

Errors

Same as crate::Client::new.

Examples found in repository

examples/models.rs (line 25)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_models().respond(json!({
        "models": [{
            "name": "jev-latest",
            "description": "TypeSafe flagship",
            "release_date": "2026-01-01"
        }]
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    client.warm_up().await?;
    for model in client.models().list().await? {
        println!("{} — {}", model.name, model.description);
    }
    Ok(())
}

examples/triage.rs (line 23)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mock = MockServer::start().await;
    mock.on_system_one().respond(json!({
        "urgent": noul(0.97),
        "team": choice("technical", 0.82),
        "frustration": score(1.6, 0.78),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build()?;

    let response = client
        .system_one(
            "Help! My payouts have been failing for 3 days.",
            questions! {
                "urgent" => Question::noul("Does this convey urgency?")
                    .when_true("Explicitly time-sensitive")
                    .when_false("No time pressure"),
                "team" => Question::choice("Which team should handle this?")
                    .option("billing", "Payments, invoicing, refunds")
                    .option("technical", "Bugs, outages, integrations")
                    .option("sales", "Pricing, upgrades, new accounts"),
                "frustration" => Question::score("How frustrated is the customer?")
                    .level("Calm")
                    .level("Frustrated")
                    .level("Very angry"),
            },
        )
        .await?;

    println!("urgent      = {:?}", response.noul("urgent"));
    println!(
        "team        = {:?}",
        response.choice("team").map(|c| c.choice)
    );
    println!(
        "frustration = {:?}",
        response.score("frustration").map(|s| s.score)
    );
    Ok(())
}

pub fn build_blocking(self) -> Result<BlockingClient, Error>

Available on crate feature blocking only.

Build a BlockingClient.

Errors

Same as crate::BlockingClient::new.

Examples found in repository

examples/blocking.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()?;
    let mock = rt.block_on(MockServer::start());
    mock.on_system_one().respond(json!({
        "urgent": noul(0.91),
    }));

    let client = ClientConfig::new()
        .api_key("test")
        .base_url(mock.url())
        .build_blocking()?;

    let response = client.system_one(
        "Help! My payouts have been failing for 3 days.",
        questions! { "urgent" => Question::noul("Does this convey urgency?") },
    )?;
    println!("urgent noul = {:?}", response.noul("urgent"));

    drop(client);
    drop(mock);
    drop(rt);
    Ok(())
}

pub fn overlay_env( &mut self, lookup: impl FnMut(&str) -> Option<String>, ) -> Result<(), Error>

Fill unset fields from lookup (typically the process environment).

Empty or whitespace-only values are ignored. Explicit fields are left unchanged.

Trait Implementations

impl Clone for ClientConfig

fn clone(&self) -> ClientConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClientConfig

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

Formats the value using the given formatter.

impl Default for ClientConfig

fn default() -> Self

Returns the “default value” for a type.