Enum EvalError 

pub enum EvalError {
    BenchmarkLoad(String, Error),
    BenchmarkParse(String, String),
    EmptyBenchmarkSet,
    BudgetExceeded {
        used: u64,
        budget: u64,
    },
    Llm(LlmError),
    JudgeParse {
        case_index: usize,
        detail: String,
    },
    Semaphore(String),
    BenchmarkTooLarge {
        path: String,
        size: u64,
        limit: u64,
    },
    PathTraversal(String),
    OutOfRange {
        kind: String,
        value: f64,
        min: f64,
        max: f64,
    },
    SearchSpaceExhausted {
        strategy: &'static str,
    },
    InvalidRadius {
        radius: f64,
    },
    Storage(String),
}

Errors that can occur during experiment evaluation, benchmark loading, or persistence.

Most variants carry structured context (file paths, token counts, parameter names) so that callers can surface actionable diagnostics to the user.

Examples

use zeph_experiments::EvalError;

let err = EvalError::BudgetExceeded { used: 1_500, budget: 1_000 };
assert!(err.to_string().contains("1500"));

let err = EvalError::InvalidRadius { radius: -1.0 };
assert!(err.to_string().contains("finite and positive"));

Variants

BenchmarkLoad(String, Error)

The benchmark TOML file could not be opened or read.

BenchmarkParse(String, String)

The benchmark TOML file could not be parsed.

EmptyBenchmarkSet

BenchmarkSet::validate was called on an empty cases vec.

BudgetExceeded

The cumulative token budget for judge calls was exhausted.

When this error is returned from Evaluator::evaluate, the report will have is_partial = true and only include cases scored before the budget was hit.

Fields

used: u64

budget: u64

Llm(LlmError)

An LLM call failed (network, auth, timeout, or API error).

JudgeParse

The judge model returned a non-finite or structurally invalid score.

Fields

case_index: usize

Zero-based index of the benchmark case that produced the invalid output.

detail: String

Description of the parse failure (e.g., "non-finite score: NaN").

Semaphore(String)

The internal tokio semaphore used for concurrency control was closed.

This is an internal invariant violation and should never occur in normal usage.

BenchmarkTooLarge

The benchmark file exceeds the 10 MiB size limit.

Fields

path: String

Canonicalized path of the file.

size: u64

Actual file size in bytes.

limit: u64

Maximum allowed size in bytes (currently 10 MiB).

PathTraversal(String)

The benchmark file’s canonical path escaped the expected parent directory.

This indicates a symlink traversal attack and is rejected before any file I/O.

OutOfRange

A parameter value was outside its declared [min, max] range.

Fields

kind: String

Parameter name (e.g., "temperature").

value: f64

The value that was rejected.

min: f64

Minimum allowed value (inclusive).

max: f64

Maximum allowed value (inclusive).

SearchSpaceExhausted

All variations in the generator’s search space have been visited.

Fields

strategy: &'static str

Name of the strategy that exhausted (e.g., "grid").

InvalidRadius

The Neighborhood radius was not finite and positive.

Fields

radius: f64

The invalid radius value that was rejected.

Storage(String)

An experiment result could not be persisted to SQLite.

Trait Implementations

impl Debug for EvalError

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

Formats the value using the given formatter.

impl Display for EvalError

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

Formats the value using the given formatter.

impl Error for EvalError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<LlmError> for EvalError

fn from(source: LlmError) -> Self

Converts to this type from the input type.