Enum ToolErrorKind 

#[non_exhaustive]
pub enum ToolErrorKind {
    Transient,
    RateLimit,
    Quota,
    Auth,
    Permanent,
    Validation,
    Internal,
}

Cross-tool failure category.

Derive from Error via Self::classify. Used for retry middleware (RetryToolLayer retries Self::Transient / Self::RateLimit), observability sinks (operators surface the category in dashboards), and downstream recovery routing (different categories trigger different operator responses — page on Auth, alert on Quota, ignore Validation noise).

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.

Transient

Network blip, transient 5xx, generic transport failure — safe to retry.

RateLimit

Vendor signalled rate limiting (429 with Retry-After hint). Retryable after the configured cooldown.

Quota

Vendor signalled exhausted quota / billing cap. Retry will not succeed until the quota resets or operator intervenes — surface to ops, do not retry automatically.

Auth

Credential rejected (401 / 403 / Error::Auth). Retry will not succeed until credentials are rotated.

Permanent

Permanent vendor failure (4xx other than auth/rate/quota, 405, 410, 422 …). The same call will fail again.

Validation

Caller-side input rejected (Error::InvalidRequest, Error::Serde) — the operator’s payload does not match the tool contract. Retry is meaningless without changing the payload.

Internal

Tool-internal bug or misconfiguration (Error::Config, or any unclassified shape). Surface to ops; retry is not meaningful.

Implementations

impl ToolErrorKind

pub fn classify(error: &Error) -> Self

Derive the category from an Error.

The mapping is intentionally exhaustive over the variants Error surfaces today — the _ catch-all routes to Self::Internal so future variants stay observable until classified explicitly. Operational variants (Error::Cancelled, Error::DeadlineExceeded, Error::Interrupted, Error::ModelRetry) flow through Internal because they are agent-runtime control signals, not tool failures — call sites that observe them should not reach this classifier in the first place.

pub const fn is_retryable(self) -> bool

Whether the runtime should attempt the tool call again.

Transient and RateLimit are retryable; everything else is a surface-and-stop signal. RetryToolLayer consults this via the underlying RetryClassifier (which can be overridden per deployment) — operators that want different retry policy install a custom classifier rather than mutating this method.

Trait Implementations

impl Clone for ToolErrorKind

fn clone(&self) -> ToolErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ToolErrorKind

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

Formats the value using the given formatter.

impl Hash for ToolErrorKind

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

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 ToolErrorKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ToolErrorKind

impl Eq for ToolErrorKind

impl StructuralPartialEq for ToolErrorKind