Struct RunOutcome 

pub struct RunOutcome {
    pub run_id: RunId,
    pub status: RunStatus,
    pub consumed: Consumed,
    pub chain_head: Digest,
    pub output: Option<Tainted<Value>>,
}

What a run produced.

Fields

run_id: RunId

status: RunStatus

consumed: Consumed

What this run consumed — steps, effects, spend, elapsed, refusals.

Reported rather than left in the ledger because “what did the settlement run cost” has to be answerable per item, and a batch sums its items. A figure that only exists inside a dropped Ledger is a figure nobody can bill against.

The whole tally rather than only the money: the counts are what a ceiling is sized against, and an operator raising max_effects after a run stopped short is asking exactly the question this answers.

chain_head: Digest

Terminal hash of the run’s chain — what a signature would cover.

output: Option<Tainted<Value>>

What the run produced, with its label.

Labelled rather than bare, and the difference is not cosmetic: a caller acting on a run’s answer needs to know whether a model, a peer or a person wrote it. The label was stripped here until an A2A reply projection read a marker key out of an untrusted answer and let a remote peer choose the envelope its own reply arrived in — a confused-deputy reachable because the one fact that would have refused it had been dropped at the boundary.

Implementations

impl RunOutcome

pub const fn spend(&self) -> Spend

What this run spent, in metered units — the money half of consumed.

pub fn reason(&self) -> Option<Cow<'_, str>>

Why this run ended — RunStatus::reason without the match.

None for a success. The accessor is here as well as on the status because this is the type an embedder holds after run(..), and a summary field that silently stays empty is the shape this exists to prevent.

pub fn success(self) -> Result<Tainted<Value>, RunFailure>

The output if the run succeeded, or a RunFailure saying why not.

Every caller that acts on a run’s answer asks the same two questions — did it work, and what did it say — and pattern-matching status to learn the first is how the second gets read off a run that quarantined. This folds the pair into one ?:

let answer = runtime.run("greet", input).await?.success()?;

status stays public for the callers whose branches genuinely differ — a suspended run is not a failed one, and an operator surface treats them differently. This is for the caller to whom anything short of an answer is an error.

Errors

RunFailure for every non-succeeded status, carrying the run id and the status itself.

Trait Implementations

impl Clone for RunOutcome

fn clone(&self) -> Self

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.