Enum AiMuxError 

pub enum AiMuxError {
    ApiCall(ApiCallError),
    JsonParse(String),
    InvalidResponseData(String),
    Tool(String),
    InvalidArgument(String),
    InvalidPrompt(String),
    TokenExpired(String),
    UnsupportedFunctionality(String),
    NoSuchModel {
        model_id: String,
        model_type: String,
    },
    NoSuchProvider {
        provider_id: String,
    },
    Timeout(String),
    Aborted,
    Other(String),
}

Unified error type for all aimux operations.

Variants are cut by what the caller does about it, not by where the failure came from. ApiCall carries the ApiCallError detail inline (unboxed, like async-openai’s ApiError(ApiError)); the size guard in error_value_golden_test keeps the enum under clippy’s result_large_err threshold.

Constructed as a named struct literal everywhere (ApiCallError { status_code: .., ..Default::default() }), the same shape as the AI SDK’s named-options constructor.

Variants

ApiCall(ApiCallError)

JsonParse(String)

InvalidResponseData(String)

Tool(String)

InvalidArgument(String)

InvalidPrompt(String)

TokenExpired(String)

The access token has expired (or was invalidated) and must be refreshed by the caller. RFC-0018 subscription mode: the library maps a 401 from the Codex subscription endpoint to this variant; the integrator orchestrates codex_refresh + retry.

This is not a status-code avatar: Auth-style 401s and token expiry share the same status, so status_code alone cannot express the difference — the variant carries the extra bit (“refresh helps”).

UnsupportedFunctionality(String)

NoSuchModel

Registry-level “model id does not resolve” (the AI SDK’s NoSuchModelError { modelId, modelType }). Pre-HTTP: the upstream API was never called, so there is no status.

Fields

model_id: String

model_type: String

What kind of model was requested ("languageModel", "imageModel", …), the AI SDK’s modelType.

NoSuchProvider

Registry-level “provider name does not resolve” (the AI SDK’s NoSuchProviderError).

Fields

provider_id: String

Timeout(String)

Aborted

Other(String)

Implementations

impl AiMuxError

pub fn is_retryable(&self) -> bool

Returns true if the error is transient and can be retried.

Reads the stored ApiCallError::is_retryable field, filled at construction (the AI SDK’s APICallError.isRetryable): 408/409/429/5xx on the response path, true on the transport path. Timeout is a spent caller-side time budget — the AI SDK treats it as part of the abort family (isAbortError matches "TimeoutError") and does not retry it; neither do we.

pub fn retry_after_hint(&self) -> Option<i64>

Returns the retry-after delay hint (in milliseconds) carried by this error, if any — distilled from the retry-after-ms / retry-after response headers into ApiCallError::retry_after_ms. Returns None for errors that don’t advertise a delay, in which case the retry strategy falls back to exponential backoff.

Mirrors the header-consulting behaviour of retryWithExponentialBackoffRespectingRetryHeaders in the TS SDK.

pub fn status_code(&self) -> Option<u16>

Returns the HTTP status code carried by this error, if any.

This is the observed status only — the field the HTTP layer filled when a response actually arrived (parse_provider_error, send_with_retry_raw). An error built without an HTTP exchange (a missing API key, a bare constructor, a transport failure) reports None: no status was seen, so none is invented.

TokenExpired reports Some(401) by definition, not by fabrication: its only producer is the codex subscription channel’s observed-401 mapping (RFC-0018), which trades the carried fields for the “refresh helps” bit — the status is part of the variant’s contract.

Trait Implementations

impl Clone for AiMuxError

fn clone(&self) -> AiMuxError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AiMuxError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AiMuxError

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AiMuxError

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

Formats the value using the given formatter.

impl Error for AiMuxError

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.

impl From<Error> for AiMuxError

Canonical serde classification: syntactically broken/truncated JSON is a parse failure; well-formed JSON that violates the expected shape is invalid response data. Io has no transport context here, so it stays JsonParse; call sites with a concrete transport error should preserve that instead.

fn from(e: Error) -> Self

Converts to this type from the input type.

impl Serialize for AiMuxError

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TS for AiMuxError

type WithoutGenerics = AiMuxError

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or ().
The only requirement for these dummy types is that EXPORT_TO must be None.

type OptionInnerType = AiMuxError

If the implementing type is std::option::Option<T>, then this associated type is set to T. All other implementations of TS should set this type to Self instead.

fn ident(cfg: &Config) -> String

Identifier of this type, excluding generic parameters.

fn docs() -> Option<String>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

fn name(cfg: &Config) -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete(cfg: &Config) -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl(cfg: &Config) -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline(cfg: &Config) -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened(cfg: &Config) -> String

Flatten a type declaration. This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<PathBuf>

Returns the output path to where T should be exported, relative to the output directory. The returned path does not include any base directory.

fn visit_dependencies(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all dependency of this type.

fn dependencies(cfg: &Config) -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use TS::export_all.

fn export_all(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies. To export only this type, without its dependencies, use TS::export.

fn export_to_string(cfg: &Config) -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String. This function does not format the output, even if the format feature is enabled.