Struct CompletionResponse 

pub struct CompletionResponse {
    pub text: Option<String>,
    pub tool_calls: Vec<ToolCall>,
    pub usage: Option<Usage>,
    pub model: Option<String>,
    pub finish_reason: Option<String>,
    pub ttft_ms: Option<u64>,
}

One model completion.

Construct with ..Default::default() for forward compatibility — fields are added in minor releases (e.g. usage in 0.2.0).

use io_harness::{CompletionResponse, ToolCall, Usage};

let response = CompletionResponse {
    tool_calls: vec![ToolCall {
        name: "write_file".into(),
        arguments: serde_json::json!({ "path": "NOTES.md" }),
    }],
    usage: Some(Usage { prompt_tokens: 1_200, completion_tokens: 80, total_tokens: 1_280,
                        ..Default::default() }),
    // Which model actually served this call, as the provider named it in its
    // own answer — not the slug that was asked for, and not the vendor.
    model: Some("claude-sonnet-4".into()),
    finish_reason: Some("tool_use".into()),
    ..Default::default()
};

// The branch a run loop takes: tool calls first, in the order the model made
// them, and free text only when there are none. A model may return both, and
// reading `text` first would drop the work it asked for.
if let Some(call) = response.tool_calls.first() {
    assert_eq!(call.name, "write_file");
} else {
    println!("the model answered instead of acting: {:?}", response.text);
}

// Usage is what the step's budget draw is made from; `None` means the provider
// said nothing, which is why the field is an `Option` rather than a zero.
assert_eq!(response.usage.map(|u| u.total_tokens), Some(1_280));

// Nothing measured the stream here, so time-to-first-token is unknown rather
// than instant. The trace keeps that distinction.
assert_eq!(response.ttft_ms, None);

Fields

text: Option<String>

Any free text the model returned.

tool_calls: Vec<ToolCall>

Tool calls the model requested, in order.

usage: Option<Usage>

Token usage, when the provider reports it. None if unknown.

model: Option<String>

(0.18.0) The model that served this call, as the provider identified it. None when the provider did not say.

This is the field that makes a fallback auditable: runs.provider holds one label for a whole run, and stops being true the moment a Fallback swaps vendors mid-run.

finish_reason: Option<String>

(0.18.0) Why the model stopped — stop_reason on Anthropic, finish_reason on the OpenAI wire, recorded verbatim rather than normalised, because a vendor’s own word for it is what its documentation explains. None when the provider did not say.

A turn that ended on a length cap and one that finished are different facts, and only this field tells them apart after the run.

ttft_ms: Option<u64>

(0.18.0) Milliseconds from the request being sent to the first content-bearing chunk arriving.

None — never zero — when nothing measured it: a provider that does not stream, or a test double. An unmeasured wait and an instant one are different facts and averaging the second into a latency report would be wrong in the direction that flatters the provider.

Trait Implementations

impl Clone for CompletionResponse

fn clone(&self) -> CompletionResponse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompletionResponse

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

Formats the value using the given formatter.

impl Default for CompletionResponse

fn default() -> CompletionResponse

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompletionResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CompletionResponse

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CompletionResponse

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 CompletionResponse