Struct RunOutcome 

pub struct RunOutcome {

    pub text: String,
    pub stop_reason: StopReason,
    pub usage: Usage,
    pub turns: u32,
    pub refusal: Option<Refusal>,
    pub exhausted: bool,
    pub tool_calls: Vec<ToolCallTrace>,
    pub malformed_tool_args: u32,
    pub blocked_sends: u32,
    pub taint: Taint,
    pub stop_cause: StopCause,
    pub cost_usd: Option<f64>,
    pub ended_on_failed_call: bool,
    pub compactions: u32,
    pub usage_complete: bool,
}

Fields

text: String

Text of the final assistant turn.

stop_reason: StopReason

usage: Usage

turns: u32

refusal: Option<Refusal>

exhausted: bool

True when the loop stopped because it hit max_turns, not because the model was finished. The answer is probably incomplete.

tool_calls: Vec<ToolCallTrace>

Every tool call attempted, in order.

malformed_tool_args: u32

Calls whose arguments did not parse as JSON.

blocked_sends: u32

Outbound calls refused because the trifecta was armed.

taint: Taint

Taint state when the run ended.

stop_cause: StopCause

cost_usd: Option<f64>

Cost of this run, when the provider has prices configured.

ended_on_failed_call: bool

The model said it was finished, and the last thing it did was fail.

The silent-failure shape: an agent that stops on its own after a failed call may have understood the failure and said so, or may be reporting success over it. Measured elsewhere, 75.8% of self-assessing AppWorld runs are false successes and no LLM-judge configuration exceeds AUROC 0.65 at catching one — while this signal is free, deterministic, and visible nowhere in the answer text.

Deliberately an observation rather than a verdict, which is why it is named for what it saw. “Read this file” answered with “that file does not exist” is a correct run that ends on a failed call, so this is not an error condition; it is a flag a case or a human can gate on, and a false positive costs one read. Only Completed runs can set it: a run the harness cut short already says so through stop_cause and exhausted.

The last call only. One failure among successes is ordinary recovery — what this names is a run whose final act failed and which then declared itself done.

compactions: u32

How many times the transcript was summarised to keep it sendable.

Reported because compaction is lossy: an answer produced after four compactions is a different claim about the harness than the same answer produced without any, and only one of them tests that summaries carry the task forward.

usage_complete: bool

False when usage is a lower bound rather than a measurement.

A run cancelled mid-stream keeps the input tokens, which arrive in the first frame, but not the output tokens of the cut turn, which arrive in a frame that never comes. Reporting the shortfall as zero would be a quiet lie in the same field a budget reads; saying the number is partial costs one bool.

Trait Implementations

impl Clone for RunOutcome

fn clone(&self) -> RunOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunOutcome

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

Formats the value using the given formatter.

impl From<&RunOutcome> for RunStats

fn from(o: &RunOutcome) -> Self

Converts to this type from the input type.