Struct RunSummary 

pub struct RunSummary {
    pub run_id: i64,
    pub outcome: String,
    pub success: bool,
    pub steps: u32,
    pub tokens: u64,
    pub duration_ms: Option<u64>,
    pub finished_at: String,
}

What one finished run cost and whether it worked.

Written once by Store::finish_run and read back with Store::run_summary. Before 0.12.0 a consumer had to assemble this itself from three different queries plus knowledge of which of eleven outcome strings count as success — and could not get duration_ms at all, because nothing recorded when a run ended.

Serialisable, so a scoring tool can store or ship it without restating the shape.

use io_harness::{Store, StepRecord};

let store = Store::memory()?;
let run_id = store.start_run("add a hello function", "src/hello.rs")?;
store.record(run_id, &StepRecord::new(1, "wrote src/hello.rs", "ok").with_trace("", "", 1_280))?;
store.finish_run(run_id, "step_cap_reached")?;

// One row instead of three queries plus knowledge of which of eleven outcome
// strings mean success. This is what a scoring tool reads per run.
let summary = store.run_summary(run_id)?.expect("the run has finished");
assert!(!summary.success);
// `outcome` and `success` are both kept on purpose: the flag says whether it
// worked, the string says *how* it ended, and a step cap, a stall and a
// human's refusal are three different things to act on.
assert_eq!(summary.outcome, "step_cap_reached");
assert_eq!((summary.steps, summary.tokens), (1, 1_280));

// `None` while a run is unfinished or paused for a human — absent rather than
// a row of zeroes, which would read like a run that did nothing.
let paused = store.start_run("rewrite the changelog", "CHANGELOG.md")?;
store.finish_run(paused, "awaiting_approval")?;
assert!(store.run_summary(paused)?.is_none());

Fields

run_id: i64

The run this describes.

outcome: String

The raw outcome string, as written to runs.outcome.

Kept alongside Self::success rather than replaced by it: the string says which ending, the flag says whether it was the good one, and collapsing them would throw away the distinction between a step cap, a stall and a human’s refusal.

success: bool

Whether the run achieved what it was asked to do.

True for exactly one outcome — success. Every other ending, including the ones that are nobody’s fault like a rate-limited provider, is not the task being done.

steps: u32

Steps completed, as MAX(step).

Not COUNT(*) over steps: a retry writes its own row under the same step number, so counting rows counts trace entries rather than agent steps. For a tree this is the ROOT agent’s step count, not the tree’s total — each agent has its own summary.

tokens: u64

Tokens spent by this run, summed from its committed steps.

Tokens, not money. A provider reports usage and never a price, so the crate has nothing to convert with; see Containment::max_total_cost.

duration_ms: Option<u64>

Wall-clock milliseconds from the run’s start to its end.

None for a run started before 0.7.0, which has no started_at to measure from. Includes time the process was not running — a run that crashed at midnight and resumed at nine counts the nine hours, because that is how long the run took even though it was not working.

finished_at: String

When the run ended, from the database clock.

Trait Implementations

impl Clone for RunSummary

fn clone(&self) -> RunSummary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunSummary

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunSummary

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RunSummary

impl PartialEq for RunSummary

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RunSummary

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 RunSummary