Struct ProviderCall 

pub struct ProviderCall {
    pub step: u32,
    pub attempt: u32,
    pub provider: String,
    pub model: Option<String>,
    pub usage: Option<Usage>,
    pub latency_ms: u64,
    pub ttft_ms: Option<u64>,
    pub finish_reason: Option<String>,
    pub failure: Option<String>,
}

One call to a provider: what it cost, which model served it, and how long it took (0.18.0).

Per call, not per step. A step that failed twice and then answered is three of these, and the two that failed are kept because a model that produced tokens before erroring was still billed for them. steps.tokens holds one integer per step and cannot express any of that.

use io_harness::{ProviderCall, Store, Usage};

// The first attempt died after the model had already produced tokens...
store.record_provider_call(run_id, &ProviderCall {
    step: 1,
    attempt: 0,
    provider: "anthropic".into(),
    model: Some("claude-sonnet-4".into()),
    usage: Some(Usage { prompt_tokens: 900, completion_tokens: 20, total_tokens: 920,
                        ..Default::default() }),
    latency_ms: 4_100,
    failure: Some("Server (HTTP 529)".into()),
    ..Default::default()
})?;
// ...and the retry answered.
store.record_provider_call(run_id, &ProviderCall {
    step: 1,
    attempt: 1,
    provider: "anthropic".into(),
    model: Some("claude-sonnet-4".into()),
    usage: Some(Usage { prompt_tokens: 900, completion_tokens: 310, total_tokens: 1_210,
                        cache_read_tokens: 850, ..Default::default() }),
    latency_ms: 2_300,
    ttft_ms: Some(420),
    finish_reason: Some("end_turn".into()),
    ..Default::default()
})?;

let calls = store.provider_calls(run_id)?;
assert_eq!(calls.len(), 2);

// What the step actually cost is the sum over its calls — including the one
// that failed, which a trace keeping only the winner would have hidden.
let billed: u64 = calls.iter().filter_map(|c| c.usage).map(|u| u.total_tokens).sum();
assert_eq!(billed, 2_130);
assert_eq!(calls[0].failure.as_deref(), Some("Server (HTTP 529)"));

Fields

step: u32

The step this call was made for.

attempt: u32

Which attempt at that step this was, counting from 0.

provider: String

The provider that was asked, by Provider::name. For a Fallback this is the combined label; ProviderCall::model is what identifies who actually answered.

model: Option<String>

The model that served the call, as the provider named it. None when it did not say — a custom provider, or a wire that omits it.

usage: Option<Usage>

Tokens, as reported. None when the provider reported none, which is not the same fact as zero.

latency_ms: u64

Milliseconds the whole call took, measured by the harness around Provider::complete — so it includes the crate’s own request building and stream consumption, not only the provider’s part.

ttft_ms: Option<u64>

Milliseconds to the first content-bearing chunk, where the path streamed and measured it. None, never zero, when nothing measured it.

finish_reason: Option<String>

The provider’s own word for why the model stopped, verbatim.

failure: Option<String>

None when the call answered; the failure’s short name when it did not.

Trait Implementations

impl Clone for ProviderCall

fn clone(&self) -> ProviderCall

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProviderCall

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

Formats the value using the given formatter.

impl Default for ProviderCall

fn default() -> ProviderCall

Returns the “default value” for a type.

impl Eq for ProviderCall

impl PartialEq for ProviderCall

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ProviderCall