Enum EmbeddingError 

#[non_exhaustive]
pub enum EmbeddingError {
    HttpError(Error),
    JsonError(Error),
    UrlError(ParseError),
    DocumentError(Box<dyn Error + Send + Sync + 'static>),
    ResponseError(String),
    ProviderError(String),
    ProviderResponse(ProviderResponseError),
}

Errors returned by embedding models.

Inspect provider failures with Self::provider_response_body, Self::provider_response_json, and Self::provider_response_status.

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.

HttpError(Error)

Http error (e.g.: connection error, timeout, etc.)

JsonError(Error)

Json error (e.g.: serialization, deserialization)

UrlError(ParseError)

URL construction or parsing failed while preparing a provider request.

DocumentError(Box<dyn Error + Send + Sync + 'static>)

Available on non-target_family=wasm only.

Error processing the document for embedding

ResponseError(String)

Error parsing the completion response

ProviderError(String)

Error returned by the embedding model provider

ProviderResponse(ProviderResponseError)

Raw error response preserved from the embedding model provider

Implementations

impl EmbeddingError

pub fn from_http_response(status: StatusCode, body: impl Into<String>) -> Self

Builds an error from a captured HTTP status and raw response body, routing it so the provider_response_* helpers stay useful.

This is the single funnel every HTTP-error path should use instead of flattening a status and body into a ProviderError(String):

• A success (2xx) status carries a provider-authored error envelope, so it is preserved as Self::ProviderResponse together with the status.
• A non-success status is preserved as Self::HttpError(http_client::Error::InvalidStatusCodeWithMessage).

Either way the raw body is kept verbatim and the status stays recoverable through Self::provider_response_status. Read the response body exactly once and hand it here for both branches.

pub fn from_provider_body(body: impl Into<String>) -> Self

Preserves a raw provider error body that has no HTTP status.

Use this for non-HTTP transports (gRPC / SDK clients such as AWS Bedrock, Vertex AI, or the gRPC Gemini client) where the provider returns an error payload but no http::StatusCode is available. The body is preserved as Self::ProviderResponse with status == None, so Self::provider_response_body still surfaces it while Self::provider_response_status returns None.

pub fn provider_response_body(&self) -> Option<&str>

Returns the raw provider response body when available.

This is available for:

• Self::ProviderResponse using its preserved body.
• Self::HttpError when it wraps an HTTP non-success response that carries a body.

Returns None for any other variant — for example a Rig-generated ProviderError diagnostic, or a failure from a transport with no provider response body to preserve. An empty preserved body is reported as Some("") (the provider returned no payload), which is distinct from None; note that Self::provider_response_json maps that same empty body to Ok(None).

pub fn provider_response_json(&self) -> Result<Option<Value>, Error>

Parses the provider response body as JSON.

Returns:

• Ok(Some(value)) when a body is present and valid JSON.
• Ok(None) when no provider response body is available.
• Err(error) when a body is present but isn’t valid JSON.

pub fn provider_response_status(&self) -> Option<StatusCode>

Returns the HTTP status code when this error preserves one, either from a non-success HTTP response, from a preserved provider response, or from a 2xx error envelope.

Warning: this can return a 2xx status. Some providers send an error envelope alongside a success status, which Rig preserves via Self::ProviderResponse. Callers must not infer failure from the status code alone — the existence of this error already means the call failed. Returns None for non-HTTP transports (gRPC / SDK clients) and for variants that carry no provider response.

Trait Implementations

impl Debug for EmbeddingError

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

Formats the value using the given formatter.

impl Display for EmbeddingError

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

Formats the value using the given formatter.

impl Error for EmbeddingError

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<EmbeddingError> for VectorStoreError

fn from(source: EmbeddingError) -> Self

Converts to this type from the input type.

impl From<Error> for EmbeddingError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for EmbeddingError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ParseError> for EmbeddingError

fn from(source: ParseError) -> Self

Converts to this type from the input type.