Enum FailureClass 

#[non_exhaustive]
pub enum FailureClass {
    InvalidRequest,
    Transient,
    PolicyRefusal,
    BudgetExhausted,
    Internal,
}

What kind of failure a task ended in.

#[non_exhaustive]: a later version may distinguish more, and a caller that matches exhaustively today should keep compiling when it does.

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.

InvalidRequest

The request was wrong and will be wrong again. Never retry it.

Transient

Infrastructure did not cooperate — a timeout, a refused connection, a rate limit upstream. The same request may well succeed later.

PolicyRefusal

The agent declined on purpose: a safety filter, an entitlement, a policy. Retrying is not merely useless, it is the wrong response — this is the class that should reach a person.

BudgetExhausted

A bound was hit: a token budget, a deadline, a step limit. Retrying identically hits it again; retrying with more budget may not.

Internal

The agent broke, or classified nothing. Also what an unrecognised class from a newer peer reads as.

Implementations

impl FailureClass

pub const ALL: &'static [FailureClass]

Every class, for exhaustiveness in tests and for rendering a table.

A slice, not [Self; N]. The length was in the type, so adding the sixth variant this enum is #[non_exhaustive] to allow would have changed ALL’s type and broken every caller that bound it — the exact break the attribute three lines up promises not to inflict.

pub const fn as_str(self) -> &'static str

The token this class is written as on the wire.

pub fn from_wire(token: &str) -> FailureClass

Reads a wire token.

An unrecognised token is Internal, not None: a peer classifying more finely than this build understands must not have its failures become unreadable.

pub const fn is_retryable(self) -> bool

Whether retrying the identical request could succeed.

BudgetExhausted is not retryable by this measure: the identical request hits the identical bound. It is retryable with a larger budget, which is a different request.

pub const fn needs_human(self) -> bool

Whether a person should see this rather than an automatic retry.

Trait Implementations

impl Clone for FailureClass

fn clone(&self) -> FailureClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FailureClass

impl Debug for FailureClass

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

Formats the value using the given formatter.

impl Display for FailureClass

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

Formats the value using the given formatter.

impl Eq for FailureClass

impl From<ErrorCode> for FailureClass

fn from(code: ErrorCode) -> FailureClass

The class a protocol error maps to when an executor returned one and said nothing more.

The mapping is deliberately blunt: everything the caller could have sent differently is InvalidRequest, and everything else is Internal. Nothing maps to Transient or PolicyRefusal, because no ErrorCode carries either meaning — an agent that knows it hit a rate limit, or refused on policy, has to say so itself, with set_error_class on the error it returns or by emitting its own classified Failed status. Guessing Transient here would tell callers to retry things that will never succeed.

impl Hash for FailureClass

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FailureClass

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FailureClass