Enum Error 

#[non_exhaustive]
pub enum Error {
    Unsupported(String),
    Auth(String),
    NotFound(String),
    InvalidRequest(String),
    RateLimited {
        retry_after: Option<Duration>,
    },
    Timeout {
        elapsed: Duration,
    },
    Refused {
        category: Option<String>,
    },
    Transient(String),
    OverBudget(String),
    Unreadable(String),
}

Why a call did not produce an answer.

The variants are chosen so a caller can decide what to do without reading the message. Retrying a bad credential earns a rate limit, and retrying a request the provider will never accept just spends the budget twice, so those cases are separated from the ones worth trying again.

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.

Unsupported(String)

The provider cannot do this at all. Ask crate::Provider::capabilities first.

Auth(String)

The credential was rejected. Never retry this one.

NotFound(String)

The model, endpoint or resource does not exist.

InvalidRequest(String)

The request was malformed, or the provider refused its shape.

RateLimited

Too many requests.

Honour retry_after when it is present. A backoff you guessed locally only makes the limit worse, because the provider is already telling you when it will clear.

Fields

retry_after: Option<Duration>

How long the provider asked you to wait, when it said.

Timeout

A deadline passed.

Different from Error::Transient on purpose. The work may still be running on the provider’s side, so a retry can produce a second answer you are billed for.

Fields

elapsed: Duration

How long the call ran before it was given up on.

Refused

The model declined to answer.

Surfaced rather than retried. A refusal is an answer, and asking again in the hope of a different one wastes a call and usually gets the same reply.

Fields

category: Option<String>

What the provider said it was declining, when it said.

Transient(String)

Something went wrong that is worth trying again.

OverBudget(String)

The call was not made, because it would have taken the run over its cap.

Never a provider’s answer. Nothing was sent and nothing was billed: this is crate::Budget refusing before the money goes, which is the only place a cap can be enforced rather than reported.

Not retryable. The same request against the same spent budget is refused again, and what has to change is the cap or the run.

Unreadable(String)

The provider answered, and the answer could not be read.

A successful status code with a body this crate cannot parse is a failure. Treating it as an empty answer is how a run continues on nothing.

Implementations

impl Error

pub fn is_retryable(&self) -> bool

Whether trying the same call again is reasonable.

This is a hint, not a promise. It says the failure was not the caller’s fault and not permanent. It does not say the call is safe to repeat, which is a question about your request rather than about the error. A Error::Timeout is retryable and may still leave you paying for two answers.

pub fn retry_after(&self) -> Option<Duration>

How long the provider asked you to wait, when it said.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.