Struct Usage 

pub struct Usage { /* private fields */ }

Thread-safe request and token counters.

A Client fills its own Usage from the usage object of every successful reply and counts each retry. The counters are atomic, so the totals can be read while requests are in flight; they are then a snapshot, not a transaction.

Usage::record and Usage::record_retry are public so that a caller who talks to another provider through the same code path can keep the same accounting.

Implementations

impl Usage

pub fn record(&self, input_tokens: u64, output_tokens: u64)

One completed request and the tokens it used.

pub fn record_retry(&self)

One attempt that had to be repeated. A request that is retried twice before it succeeds counts as one request and two retries.

pub fn requests(&self) -> u64

Requests that were answered.

Examples found in repository

examples/ask.rs (line 50)

fn main() -> Result<(), Error> {
    let client = Client::from_env(Config::default())?;

    let state = json!({
        "code": "1| import os\n2| def cwd():\n3|     return os.getcwd()",
        "query": "where is the working directory read",
    });
    let mut questions = Map::new();
    questions.insert(
        "line3".into(),
        json!({
            "type": "noul",
            "instructions": "Does line 3 of the code directly answer the query?",
        }),
    );
    questions.insert(
        "relevance".into(),
        json!({
            "type": "score",
            "instructions": "How relevant is the code to the query?",
            "criteria": ["unrelated", "tangential", "relevant", "exactly what was asked"],
        }),
    );

    match client.ask(&state, &questions) {
        Ok(answers) => {
            for (id, answer) in &answers {
                println!("{id}: {answer}");
            }
        }
        // Too much state for one request: a real caller would split it and ask again.
        Err(Error::TokenLimit(message)) => eprintln!("request too large: {message}"),
        Err(other) => return Err(other),
    }

    let usage = client.usage();
    println!(
        "{} request(s), {} retries, {} input tokens, ~${:.6}",
        usage.requests(),
        usage.retries(),
        usage.input_tokens(),
        usage.cost_usd()
    );
    Ok(())
}

pub fn retries(&self) -> u64

Attempts that were repeated after a transient failure.

Examples found in repository

examples/ask.rs (line 51)

fn main() -> Result<(), Error> {
    let client = Client::from_env(Config::default())?;

    let state = json!({
        "code": "1| import os\n2| def cwd():\n3|     return os.getcwd()",
        "query": "where is the working directory read",
    });
    let mut questions = Map::new();
    questions.insert(
        "line3".into(),
        json!({
            "type": "noul",
            "instructions": "Does line 3 of the code directly answer the query?",
        }),
    );
    questions.insert(
        "relevance".into(),
        json!({
            "type": "score",
            "instructions": "How relevant is the code to the query?",
            "criteria": ["unrelated", "tangential", "relevant", "exactly what was asked"],
        }),
    );

    match client.ask(&state, &questions) {
        Ok(answers) => {
            for (id, answer) in &answers {
                println!("{id}: {answer}");
            }
        }
        // Too much state for one request: a real caller would split it and ask again.
        Err(Error::TokenLimit(message)) => eprintln!("request too large: {message}"),
        Err(other) => return Err(other),
    }

    let usage = client.usage();
    println!(
        "{} request(s), {} retries, {} input tokens, ~${:.6}",
        usage.requests(),
        usage.retries(),
        usage.input_tokens(),
        usage.cost_usd()
    );
    Ok(())
}

pub fn input_tokens(&self) -> u64

Input tokens, as reported by the API.

Examples found in repository

examples/ask.rs (line 52)

fn main() -> Result<(), Error> {
    let client = Client::from_env(Config::default())?;

    let state = json!({
        "code": "1| import os\n2| def cwd():\n3|     return os.getcwd()",
        "query": "where is the working directory read",
    });
    let mut questions = Map::new();
    questions.insert(
        "line3".into(),
        json!({
            "type": "noul",
            "instructions": "Does line 3 of the code directly answer the query?",
        }),
    );
    questions.insert(
        "relevance".into(),
        json!({
            "type": "score",
            "instructions": "How relevant is the code to the query?",
            "criteria": ["unrelated", "tangential", "relevant", "exactly what was asked"],
        }),
    );

    match client.ask(&state, &questions) {
        Ok(answers) => {
            for (id, answer) in &answers {
                println!("{id}: {answer}");
            }
        }
        // Too much state for one request: a real caller would split it and ask again.
        Err(Error::TokenLimit(message)) => eprintln!("request too large: {message}"),
        Err(other) => return Err(other),
    }

    let usage = client.usage();
    println!(
        "{} request(s), {} retries, {} input tokens, ~${:.6}",
        usage.requests(),
        usage.retries(),
        usage.input_tokens(),
        usage.cost_usd()
    );
    Ok(())
}

pub fn output_tokens(&self) -> u64

Output tokens, as reported by the API. Jev reports them, but does not charge for them.

pub fn cost_usd(&self) -> f64

The input tokens at Jev’s list price, USD_PER_INPUT_MTOK. An estimate: the price is a constant in this crate, not something the API reports.

Examples found in repository

examples/ask.rs (line 53)

fn main() -> Result<(), Error> {
    let client = Client::from_env(Config::default())?;

    let state = json!({
        "code": "1| import os\n2| def cwd():\n3|     return os.getcwd()",
        "query": "where is the working directory read",
    });
    let mut questions = Map::new();
    questions.insert(
        "line3".into(),
        json!({
            "type": "noul",
            "instructions": "Does line 3 of the code directly answer the query?",
        }),
    );
    questions.insert(
        "relevance".into(),
        json!({
            "type": "score",
            "instructions": "How relevant is the code to the query?",
            "criteria": ["unrelated", "tangential", "relevant", "exactly what was asked"],
        }),
    );

    match client.ask(&state, &questions) {
        Ok(answers) => {
            for (id, answer) in &answers {
                println!("{id}: {answer}");
            }
        }
        // Too much state for one request: a real caller would split it and ask again.
        Err(Error::TokenLimit(message)) => eprintln!("request too large: {message}"),
        Err(other) => return Err(other),
    }

    let usage = client.usage();
    println!(
        "{} request(s), {} retries, {} input tokens, ~${:.6}",
        usage.requests(),
        usage.retries(),
        usage.input_tokens(),
        usage.cost_usd()
    );
    Ok(())
}

Trait Implementations

impl Debug for Usage

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

Formats the value using the given formatter.

impl Default for Usage

fn default() -> Self

Returns the “default value” for a type.