Enum Bound 

#[non_exhaustive]
pub enum Bound {
    Deadline,
    ToolBudget,
    TokenBudget,
}

A bound that ended a run before its work did.

Separate from RunOutcome because the two answer different questions. “The model ran out of the time you gave it” and “the provider refused the request” call for different reactions, and a caller — the CLI’s exit code, or a script driving many runs — should not have to read an error message to tell them apart (ADR-0015). The outcome says whether an answer arrived; this says whether an allowance is what ended the run, and the two are independent. Deadline and ToolBudget always arrive alongside RunOutcome::Error, because no final message does; TokenBudget can arrive on a run that answered.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Deadline

RunConfig::with_deadline — the run took longer than it was given.

ToolBudget

RunConfig::with_tool_budget — the run made all the calls it had.

TokenBudget

RunConfig::with_token_budget, or a BudgetPool the run drew dry — it spent its allowance and was refused another round.

The odd one out, and worth knowing why before branching on it. This bound is graceful: mentra ends the run at a round boundary keeping everything committed so far, exactly as if the model had finished. So a run can report RunOutcome::Ok with an ordinary answer and this bound, which is the honest description of “you got an answer, and the allowance is why there is not more of one”. Whether an answer arrives comes down to what the last committed message was: prose, and the turn succeeds; a tool result, and it fails owing a final message it never got.

Reportable at all only because mentra records the decision at the boundary it makes it (RunOptions::ended_early). Comparing usage against the budget afterwards would answer a different question — what is true now, rather than what the runner decided on — and a pooled run can cross the line without being the run that was stopped by it.

Trait Implementations

impl Clone for Bound

fn clone(&self) -> Bound

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Bound

impl Debug for Bound

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Bound

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Bound

impl PartialEq for Bound

fn eq(&self, other: &Bound) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Bound

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Bound