Struct TokenEnvelope 

pub struct TokenEnvelope {
    pub model: String,
    pub provider: ProviderKind,
    pub input_tokens: usize,
    pub output_tokens: usize,
    pub cache_read_tokens: usize,
    pub cache_write_tokens: usize,
    pub reasoning_tokens: usize,
    pub cost_usd: Option<f64>,
    pub tokens_saved: usize,
    pub is_retry: bool,
}

Provider-neutral token usage envelope.

Fields

model: String

Canonical model identifier.

provider: ProviderKind

Provider that served the request.

input_tokens: usize

Total input tokens (prompt + context).

output_tokens: usize

Total output tokens (completion).

cache_read_tokens: usize

Cache read tokens (provider-specific).

cache_write_tokens: usize

Cache write tokens.

reasoning_tokens: usize

Reasoning/thinking tokens (if supported).

cost_usd: Option<f64>

Estimated cost in USD (if available).

tokens_saved: usize

Tokens saved by compression.

is_retry: bool

Whether this was a retry.

Implementations

impl TokenEnvelope

pub fn total_tokens(&self) -> usize

Returns input, output, and reasoning tokens combined.

pub fn effective_tokens(&self) -> usize

Returns total tokens excluding tokens served from the provider cache.

pub fn compression_ratio(&self) -> f64

Returns the fraction of original input eliminated by compression.

pub const fn is_cached(&self) -> bool

Returns whether any input tokens were served from a provider cache.

pub fn merge(envelopes: &[Self]) -> Self

Aggregates envelopes into a single canonical usage summary.

Trait Implementations

impl Clone for TokenEnvelope

fn clone(&self) -> TokenEnvelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokenEnvelope

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

Formats the value using the given formatter.

impl Default for TokenEnvelope

fn default() -> TokenEnvelope

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TokenEnvelope

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TokenEnvelope

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

where __S: Serializer,

Serialize this value into the given Serde serializer.