Struct BenchRun 

pub struct BenchRun {
    pub dataset: String,
    pub model: String,
    pub run_id: String,
    pub started_at: String,
    pub finished_at: String,
    pub status: RunStatus,
    pub results: Vec<ScenarioResult>,
    pub aggregate: Aggregate,
}

Top-level benchmark run record written to results.json.

The schema is a superset of the LongMemEval leaderboard submission format (NFR-008), making it directly usable for leaderboard submission after a longmemeval run.

Create a default instance, then populate BenchRun::results incrementally and call BenchRun::recompute_aggregate before persisting with ResultWriter.

Examples

use zeph_bench::{BenchRun, RunStatus, Aggregate};

let run = BenchRun {
    dataset: "gaia".into(),
    model: "openai/gpt-4o".into(),
    run_id: "a1b2c3".into(),
    started_at: "2026-04-09T10:00:00Z".into(),
    finished_at: String::new(),
    status: RunStatus::Running,
    results: vec![],
    aggregate: Aggregate::default(),
};
assert_eq!(run.dataset, "gaia");
assert!(run.results.is_empty());

Fields

dataset: String

Dataset name (e.g. "longmemeval").

model: String

Provider/model identifier (e.g. "openai/gpt-4o").

run_id: String

UUID v4 uniquely identifying this run.

started_at: String

RFC 3339 timestamp when the run started.

finished_at: String

RFC 3339 timestamp when the run ended (empty string if interrupted).

status: RunStatus

Run status.

results: Vec<ScenarioResult>

Per-scenario results.

aggregate: Aggregate

Aggregate statistics.

Implementations

impl BenchRun

pub fn recompute_aggregate(&mut self)

Recompute BenchRun::aggregate from the current BenchRun::results list.

Call this after appending one or more ScenarioResults to keep the aggregate statistics in sync before writing to disk.

Examples

use zeph_bench::{BenchRun, RunStatus, ScenarioResult, Aggregate};

let mut run = BenchRun {
    dataset: "frames".into(),
    model: "openai/gpt-4o-mini".into(),
    run_id: "r1".into(),
    started_at: "2026-01-01T00:00:00Z".into(),
    finished_at: String::new(),
    status: RunStatus::Running,
    results: vec![
        ScenarioResult {
            scenario_id: "frames_0".into(),
            score: 1.0,
            response_excerpt: "Paris".into(),
            error: None,
            elapsed_ms: 500,
        },
    ],
    aggregate: Aggregate::default(),
};

run.recompute_aggregate();
assert_eq!(run.aggregate.total, 1);
assert!((run.aggregate.mean_score - 1.0).abs() < f64::EPSILON);
assert_eq!(run.aggregate.exact_match, 1);

pub fn completed_ids(&self) -> HashSet<String>

Return the set of scenario IDs already present in BenchRun::results.

Used by the --resume logic to determine which scenarios can be skipped.

Examples

use zeph_bench::{BenchRun, RunStatus, ScenarioResult, Aggregate};

let run = BenchRun {
    dataset: "gaia".into(),
    model: "openai/gpt-4o".into(),
    run_id: "r2".into(),
    started_at: "2026-01-01T00:00:00Z".into(),
    finished_at: String::new(),
    status: RunStatus::Interrupted,
    results: vec![
        ScenarioResult {
            scenario_id: "t1".into(),
            score: 1.0,
            response_excerpt: "1945".into(),
            error: None,
            elapsed_ms: 300,
        },
    ],
    aggregate: Aggregate::default(),
};

let done = run.completed_ids();
assert!(done.contains("t1"));
assert!(!done.contains("t2"));

Trait Implementations

impl Clone for BenchRun

fn clone(&self) -> BenchRun

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BenchRun

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BenchRun

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BenchRun

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.