Enum StreamErrorKind 

#[non_exhaustive]
pub enum StreamErrorKind {
    Connectivity,
    ConnectionLost,
    RateLimited(Option<Duration>),
    ServerError,
    InvalidRequest,
    Unknown,
}

Classification of a StreamDelta::Error event.

Mirrors ChatOutcome’s error variants so providers that emit errors via streaming preserve the same precision that non-streaming chat() callers see — every supported provider can map its underlying error (HTTP status, validation failure, mid-stream disconnect) directly onto one of these categories at the construction site.

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.

Connectivity

The request could not establish a provider connection because DNS, routing, or the network is unavailable. Callers may wait indefinitely for connectivity, provided cancellation remains cooperative.

ConnectionLost

An established provider response stream lost its underlying network connection. It has the same wait policy as Self::Connectivity, but durable runtimes must close that provider call’s audit attempt before retrying it.

RateLimited(Option<Duration>)

Provider returned HTTP 429 / explicit rate-limit signal.

Carries the server-supplied retry delay when the provider gave one — a Retry-After header, or a hint embedded in the error body (Gemini’s google.rpc.RetryInfo, OpenAI’s “try again in 20s”). None when the provider supplied no usable hint, in which case callers use backoff.

ServerError

Provider returned HTTP 5xx or reported a transient runtime failure.

InvalidRequest

Caller-side error: validation failure before dispatch, HTTP 4xx other than 429, or a non-retriable provider rejection.

Unknown

Escape hatch for a streaming error a provider could not classify into one of the categories above.

Producers should prefer a specific variant whenever the underlying signal (HTTP status, validation failure, mid-stream disconnect) allows it; Unknown exists so future error sources and providers can be added without a breaking change. It is treated as non-recoverable by StreamErrorKind::is_recoverable (callers should not blindly retry an unclassified failure).

Implementations

impl StreamErrorKind

pub const fn is_recoverable(self) -> bool

true when the error is potentially transient and the caller may retry. Connectivity, rate-limit, and server errors are recoverable; invalid-request is not.

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

The server-supplied retry delay carried by a rate-limit error, if any.

pub const fn is_connectivity(self) -> bool

true for failures governed by the unbounded, cancellable offline wait.

Trait Implementations

impl Clone for StreamErrorKind

fn clone(&self) -> StreamErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StreamErrorKind

impl Debug for StreamErrorKind

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

Formats the value using the given formatter.

impl Eq for StreamErrorKind

impl PartialEq for StreamErrorKind

fn eq(&self, other: &StreamErrorKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StreamErrorKind