Struct TuneTaskResult 

pub struct TuneTaskResult {

    pub task_id: String,
    pub category: TaskCategory,
    pub passed: bool,
    pub tool_match_score: f64,
    pub loop_detected: bool,
    pub stagnation_detected: bool,
    pub iterations: usize,
    pub latency_ms: u64,
    pub completion_tokens: Option<u64>,
    pub time_to_first_tool_call_ms: Option<u64>,
    pub detail: Option<String>,
    pub unmeasured: Option<String>,
    pub transport_retries: u32,
    pub generated: GeneratedOutput,
}

Result of evaluating one task against one candidate’s sampling settings.

Fields

task_id: String

ID of the super::task::TuneTask this result corresponds to.

category: TaskCategory

Category the task belongs to (carried for leaderboard grouping).

passed: bool

true if the agent loop completed and its tool calls matched the task’s expected outcome (for NoToolCall tasks: no call was made).

tool_match_score: f64

AST-style match score against the expected outcome, 0.0–1.0.

Partial credit: e.g. right tool name but a missing required argument scores between 0.0 and 1.0, not a hard fail.

loop_detected: bool

true if the agent loop’s LoopDetector fired during this task.

stagnation_detected: bool

true if the agent loop’s StagnationDetector fired during this task.

iterations: usize

Number of tool-executing agent-loop iterations that completed.

The loop reports an iteration only after it has executed that turn’s tool calls, so a turn that answered in text — including the final one — is not counted, and a guard-aborted run reports one fewer than the turn it aborted on. Read it as “how many tool-call batches this run produced”, which is what decides whether a repeat was even possible.

latency_ms: u64

Wall-clock time spent on this task, in milliseconds.

completion_tokens: Option<u64>

Completion tokens generated across the task’s agent run, summed from the upstream’s per-response usage reports.

Counted independently of how the run ended, so a run a guard aborted still reports the tokens it burned — those are the runs whose cost matters most. None only when the upstream reported no usage at all, which stays distinct from a measured zero.

time_to_first_tool_call_ms: Option<u64>

Wall-clock milliseconds from the start of the task to the first tool call the model actually issued — how long it took to take its first useful action.

This is the figure an agentic client’s user feels: a turn that emits a valid call in 300 ms and one that emits the same call after 140 s of unconstrained generation score identically on every accuracy axis. None when the task never called a tool, which is the correct outcome for an Irrelevance task.

detail: Option<String>

Optional human-readable detail (e.g. which expected call was missed), surfaced in the leaderboard drill-down.

unmeasured: Option<String>

Why this run is not a measurement of the model, when it is not one.

None on every run that actually reached the model, including every way of doing badly: a wrong tool call, a detected loop, a stagnated answer and an exhausted iteration budget are all real observations and score honestly as failures.

Some(reason) is the different thing — the request never produced a response to score, because the upstream was unreachable, the stream broke, or the loop could not start. Such a run still carries passed: false and tool_match_score: 0.0, and those zeros mean nothing: they are the absence of a measurement wearing the costume of a bad one.

Measured, which is why this field exists. A run whose llama-server had died scored a composite of 0.222 across 45 failed requests and rendered as an ordinary, believable arm — a −0.562 delta that read as a catastrophic regression rather than as an empty column. An arm that cannot tell “the model did badly” from “there was no model” is reporting a number it never took.

transport_retries: u32

How many attempts this run threw away to a transport failure before the one reported here.

0 on a run that succeeded first time. Non-zero means the harness hit Self::unmeasured and tried again, so the numbers above come from a later attempt than the one the suite nominally ran.

Recorded rather than swallowed because a silently-retried run is not the same measurement as a clean one, and an eval that hides its retries can report a healthy suite while the upstream underneath it is failing one request in ten. It is also the reading its own kill criterion needs: if this stays 0 across two full evals, the retry is unnecessary and goes.

generated: GeneratedOutput

What the model generated, as opposed to how much of it.

See GeneratedOutput — a token total and a wall time cannot distinguish a model thinking at length from one failing to stop, and those call for opposite responses.

Implementations

impl TuneTaskResult

pub const fn is_measured(&self) -> bool

Whether this run produced a real observation of the model.

Read this rather than passed, wherever the question is “is this number worth anything” rather than “did the model succeed”.

Trait Implementations

impl Clone for TuneTaskResult

fn clone(&self) -> TuneTaskResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TuneTaskResult

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TuneTaskResult

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TuneTaskResult

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

where __S: Serializer,

Serialize this value into the given Serde serializer.