Enum AiMuxError 

pub enum AiMuxError {
    ApiCall(Box<ApiCallError>),
    Retry(RetryError),
    JsonParse(String),
    InvalidResponseData(String),
    NoSuchTool {
        tool_name: String,
        available_tools: Option<Vec<String>>,
        tool_input: Option<String>,
    },
    InvalidToolInput {
        tool_name: String,
        tool_input: String,
        cause: String,
    },
    ToolCallRepair {
        original_error: Box<AiMuxError>,
        cause: Box<AiMuxError>,
    },
    InvalidArgument(String),
    InvalidPrompt(String),
    TokenExpired(String),
    UnsupportedFunctionality(String),
    NoSuchModel {
        model_id: String,
        model_type: String,
    },
    NoSuchProvider {
        provider_id: String,
    },
    Timeout(String),
    Aborted(String),
    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. ApiCallError is boxed only to keep the Rust enum compact; serde and every binding still observe the same object shape.

Variants

ApiCall(Box<ApiCallError>)

Retry(RetryError)

JsonParse(String)

InvalidResponseData(String)

NoSuchTool

A model requested a tool that was not present in the call’s tool set. Message templates for the three tool variants match the AI SDK verbatim (NoSuchToolError / InvalidToolInputError / ToolCallRepairError): the AI SDK feeds these strings back to the model as tool-error content, so the wording — including the available-tools list — is contract.

Fields

tool_name: String

available_tools: Option<Vec<String>>

tool_input: Option<String>

Original argument text, when supplied by the provider. Absent in older serialized errors and errors constructed without a call.

InvalidToolInput

A tool call could not be parsed or did not satisfy its input schema.

Fields

tool_name: String

tool_input: String

cause: String

ToolCallRepair

The repair callback failed or returned a call that was still invalid.

Fields

original_error: Box<AiMuxError>

cause: Box<AiMuxError>

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(String)

Other(String)

Implementations

impl AiMuxError

pub fn is_recoverable_stream_error(&self) -> bool

Returns true for a malformed individual stream frame that does not prove the underlying transport has failed. Stream reducers may report these errors and continue polling for later, independently framed data.

pub fn from_abort_signal(_signal: &AbortSignal) -> Self

Convert caller cancellation into the public error model.

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’s response headers, if any.

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 selected response handler filled when a response actually arrived. 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) -> Self

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.