Struct Usage 

pub struct Usage {
    pub requests: u64,
    pub input_tokens: u64,
    pub cache_write_tokens: u64,
    pub cache_write_1h_tokens: u64,
    pub cache_read_tokens: u64,
    pub output_tokens: u64,
    pub total_tokens: u64,
    pub tool_calls: u64,
}

Token and request usage accumulated by model and runtime layers.

Fields

requests: u64

Number of provider requests.

input_tokens: u64

Input or prompt tokens.

Provider adapters should normalize this as total provider-billed input tokens for the request, including cache-write and cache-read tokens when those subtotals are present. Pricing helpers subtract the cache subtotals before applying cache-specific rates.

cache_write_tokens: u64

Provider-reported total tokens written to a prompt cache across all durations.

Use Self::effective_cache_write_tokens for derived accounting because externally constructed or deserialized usage may contain inconsistent counters.

cache_write_1h_tokens: u64

Provider-reported one-hour cache writes included in Self::cache_write_tokens.

Providers without a one-hour cache-write breakdown leave this at zero. Use Self::effective_cache_write_1h_tokens for derived accounting.

cache_read_tokens: u64

Tokens read from a provider prompt cache.

output_tokens: u64

Output or completion tokens.

total_tokens: u64

Total tokens.

tool_calls: u64

Number of successful function tool calls executed by the runtime.

Implementations

impl Usage

pub const fn effective_cache_write_tokens(&self) -> u64

Return the effective aggregate cache-write tokens for derived accounting.

Provider counters remain raw evidence. This projection repairs a one-hour subset larger than the reported aggregate, then caps writes at the inclusive input total so malformed counters cannot create additional billed tokens.

pub const fn effective_cache_write_1h_tokens(&self) -> u64

Return effective one-hour cache-write tokens for derived accounting.

pub const fn effective_cache_read_tokens(&self) -> u64

Return effective cache-read tokens for derived accounting.

Cache writes take precedence when malformed write and read subtotals exceed inclusive input. Reads are capped at the input remaining after effective writes.

pub const fn effective_standard_input_tokens(&self) -> u64

Return input tokens not assigned to an effective cache-write or read category.

pub const fn add_assign(&mut self, other: &Self)

Add another usage value into this one.

pub const fn is_empty(&self) -> bool

Return whether no usage has been recorded.

pub const fn with_additional_tool_calls(self, tool_calls: u64) -> Self

Return a copy with additional successful tool calls applied.

Trait Implementations

impl Clone for Usage

fn clone(&self) -> Usage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Usage

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

Formats the value using the given formatter.

impl Default for Usage

fn default() -> Usage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Usage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Usage

impl PartialEq for Usage

fn eq(&self, other: &Usage) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Usage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Usage