Struct ApiCallError 

pub struct ApiCallError {
    pub url: String,
    pub request_body_values: Value,
    pub status_code: Option<u16>,
    pub provider_code: Option<String>,
    pub message: String,
    pub response_body: Option<String>,
    pub response_headers: Option<HashMap<String, String>>,
    pub data: Option<Value>,
    pub is_retryable: bool,
}

What a failed API call observed — the field set of the AI SDK’s APICallError (statusCode / responseBody), which this project’s error taxonomy mirrors (docs/internal/vercel-research/07-kernel-infrastructure.md).

Carried by AiMuxError::ApiCall alone. There are no per-status variants: a 401, 404 or 429 is an ApiCall error whose classification is read from status_code, exactly as the AI SDK reads APICallError.statusCode. Transport failures (connection reset, DNS, body read) are ApiCall errors too — no response arrived, so status_code is None and is_retryable is true, exactly as the AI SDK’s handleFetchError builds an APICallError with no statusCode and isRetryable: true. message holds the provider’s text verbatim when one is available; transport and parsing failures use a library message with the source detail appended. The HTTP status is always a field, never baked into the string; Display composes the human-readable form from the fields at print time, so nothing downstream has to parse it back out.

Every producer must provide the sanitized request URL and request values. This keeps transport and response failures self-contained and matches the AI SDK’s APICallError contract.

Fields

url: String

Sanitized request URL. Required for every API-derived failure.

request_body_values: Value

Sanitized request values used to create the API request.

status_code: Option<u16>

HTTP status of the response, when it came from one (APICallError.statusCode). Always the observed status: the HTTP layer fills it for every response-derived error; errors built without an HTTP exchange leave it None.

provider_code: Option<String>

Provider’s machine-readable code (OpenAI’s code/type, e.g. "rate_limit_exceeded" vs "insufficient_quota"). Never an HTTP status. Our normalized take on APICallError.data.

message: String

Human-readable failure text. Provider text is verbatim when available; locally detected transport/parse failures include their source detail. Never includes an HTTP status prefix.

response_body: Option<String>

The raw response body, verbatim (APICallError.responseBody) — the lossless evidence when message/provider_code are extractions. None when the error did not come from a response body.

response_headers: Option<HashMap<String, String>>

Sanitized response headers.

data: Option<Value>

Parsed provider error data.

is_retryable: bool

Whether retrying can help (APICallError.isRetryable) — stored at construction, exactly like the AI SDK: the response path computes it from the status (408/409/429 or 5xx), and the transport path (no response, so no status to compute from) sets it to true explicitly.

Implementations

impl ApiCallError

pub fn new( message: impl Into<String>, url: impl Into<String>, request_body_values: Value, ) -> Self

Create an API failure with its required request context.

Trait Implementations

impl Clone for ApiCallError

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 ApiCallError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ApiCallError

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ApiCallError

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

HTTP {status}: {message} when a status is known (just HTTP {status} if the response had no body), else {message}. provider_code and response_body are machine-readable only and stay out of the text.

impl Serialize for ApiCallError

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 ApiCallError

type WithoutGenerics = ApiCallError

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 = ApiCallError

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.