Struct CaseOutcome 

#[non_exhaustive]
pub struct CaseOutcome {
    pub name: String,
    pub passed: bool,
    pub predicates: Vec<(String, bool)>,
    pub latency: Duration,
    pub tokens: Option<u32>,
    pub tool_calls: Vec<String>,
    pub final_text: Option<String>,
    pub error: Option<String>,
    pub transcript: Vec<Value>,
}

The result of running one eval case.

Serialize/Deserialize let a host persist a run to results/*.json and the HTML report load it back. Duration round-trips through serde’s built-in {secs, nanos} form; the predicates tuples serialize as [label, passed] pairs.

#[non_exhaustive]: likely to gain diagnostic fields. The runner builds it via CaseOutcome::new (the canonical constructor) rather than a struct literal, so a new field is a one-line change there; external crates that need to construct one should use CaseOutcome::new too.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

The case name (the host’s case identifier).

passed: bool

Whether EVERY expectation held (the case passed).

predicates: Vec<(String, bool)>

Per-predicate (label, passed) in the case’s expect order — for pinpointing WHICH predicate failed.

latency: Duration

Wall-clock time for the whole case run (player-context prefetch + every model turn + tool application).

tokens: Option<u32>

Completion tokens summed across the case’s model turns, when the backend reported usage; None when no turn carried a usage object (e.g. a llama-server route that omits it).

tool_calls: Vec<String>

The tool calls the model made, as "name(compact-args)" strings (for debugging a failure). Excludes the harness’s automatic up-front get_player_context prefetch.

final_text: Option<String>

The model’s final free-text reply (the summary line), if any.

error: Option<String>

An error from the run itself (backend failure, etc.). When Some, passed is false and the predicates were scored against whatever world state existed when the run aborted.

transcript: Vec<Value>

The full per-case conversation transcript (every user/assistant/tool message), with the leading role:"system" message(s) STRIPPED — the system prompt is stored once at run level (see RunRecord::system_prompt). Rendered by the HTML report’s per-case expander.

#[serde(default)] is REQUIRED for backward compatibility: existing results/*.json were written before this field existed; without the default, the report loader (crate::report_html::generate_report) would fail to deserialize them and silently drop those runs from the report.

Implementations

impl CaseOutcome

pub fn new( name: String, passed: bool, predicates: Vec<(String, bool)>, latency: Duration, tokens: Option<u32>, tool_calls: Vec<String>, final_text: Option<String>, error: Option<String>, transcript: Vec<Value>, ) -> Self

The canonical constructor, taking every field in declaration order. Used by the runner (and any external crate) so the #[non_exhaustive] struct can be built without a struct literal; adding a field updates this one signature.

Trait Implementations

impl Clone for CaseOutcome

fn clone(&self) -> CaseOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CaseOutcome

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CaseOutcome

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CaseOutcome

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

where __S: Serializer,

Serialize this value into the given Serde serializer.