Enum BenchCommand 

pub enum BenchCommand {
    List,
    Download {
        dataset: String,
    },
    Run {
        dataset: String,
        output: PathBuf,
        scenario: Option<String>,
        provider: Option<String>,
        baseline: bool,
        resume: bool,
        no_deterministic: bool,
    },
    Show {
        results: PathBuf,
    },
}

Top-level subcommands available under zeph bench.

Each variant maps to one logical operation:

• List — inspect what datasets are available locally.
• Download — fetch a dataset from its canonical URL.
• Run — execute a full benchmark run and write results.
• Show — print a summary of a previously saved run.

Examples

use zeph_bench::BenchCommand;

// The enum is parsed by Clap; construct directly in tests.
let cmd = BenchCommand::List;
assert!(matches!(cmd, BenchCommand::List));

Variants

List

List available benchmark datasets and their cache status

Download

Download a dataset to the local cache

Fields

dataset: String

Dataset name (e.g. gaia, tau-bench)

Run

Run a benchmark against the agent

Fields

dataset: String

Dataset name (e.g. locomo, gaia, frames)

output: PathBuf

Directory where results.json and summary.md are written

scenario: Option<String>

Run only the scenario with this ID (runs all scenarios if omitted)

provider: Option<String>

LLM provider name as declared in [[llm.providers]] (uses default if omitted)

baseline: bool

Run with a baseline (non-agentic) configuration that disables tools and memory

resume: bool

Resume a previously interrupted run, skipping already-completed scenarios

no_deterministic: bool

Disable deterministic mode — by default temperature is forced to 0.0 for reproducibility; pass this flag to use the provider’s configured temperature

Show

Print a human-readable summary of results from a previous benchmark run

Fields

results: PathBuf

Path to the results.json file produced by bench run

Trait Implementations

impl Debug for BenchCommand

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

Formats the value using the given formatter.

impl FromArgMatches for BenchCommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for BenchCommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand