Struct RetryProvider 

pub struct RetryProvider<I> { /* private fields */ }

Retry wrapper: implements Provider and retries inner failures per RetryPolicy.

Streaming semantics: only when stream_chat returns Err (connection setup failure) is the whole call retried; errors inside the stream are passed through verbatim and never retried — once the stream is established this implementation cannot tell an “interruption before the first event” from an “interruption after part of the output was delivered”, and retrying would duplicate or corrupt output. Hence “retry before the first event” only covers method-level failures; interruptions within the stream (including after setup but before the first event) are left to the caller (the Agent) to handle.

Timeouts are the inner provider’s (for example OpenAiProvider) responsibility: each attempt may hit the inner Timeout error, and Retryable::Default includes Timeout, so “timeouts are retried too” falls out naturally.

Errors

After retries are exhausted, the last error is returned (neither the first nor an aggregate); non-retryable errors are returned immediately on the first failure.

Cancellation semantics

Dropping the future while waiting on backoff cancels the whole call; no further attempts are made. An already-issued inner request is cancelled together with the future (whether the network request continues at the transport layer depends on the underlying client).

Implementations

impl<I> RetryProvider<I>

pub fn new(inner: I) -> Self

Wraps with the default policy (3 attempts / exponential backoff + jitter / default retry judgment).

pub fn with_policy(self, policy: RetryPolicy) -> Self

Replaces the retry policy.

Examples

For tests / local simulation: fixed short waits, at most 2 attempts, ignoring the vendor’s Retry-After:

use std::time::Duration;
use molo::{Backoff, FakeProvider, RetryPolicy, RetryProvider};

let provider = RetryProvider::new(FakeProvider::new([])).with_policy(
    RetryPolicy::default()
        .with_max_attempts(2)
        .with_backoff(Backoff::Fixed(Duration::from_millis(10)))
        .with_respect_retry_after(false),
);

Trait Implementations

impl<I> Debug for RetryProvider<I>

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

Formats the value using the given formatter.

impl<I: Provider + Send + Sync> Provider for RetryProvider<I>

fn model(&self) -> Option<&str>

Model identifier exposed by this provider, when known.

fn capabilities(&self) -> ProviderCapabilities

Capability metadata for this provider instance.

fn chat<'life0, 'async_trait>( &'life0 self, request: ChatRequest, ) -> Pin<Box<dyn Future<Output = Result<ChatResponse, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sends one turn of conversation and returns the model’s reply (text, or a request to call tools).

fn chat_with_context<'life0, 'life1, 'async_trait>( &'life0 self, request: ChatRequest, context: &'life1 ProviderRequestContext, ) -> Pin<Box<dyn Future<Output = Result<ChatResponse, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sends one turn with request-scoped provider context.

fn stream_chat<'life0, 'async_trait>( &'life0 self, request: ChatRequest, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, Result<StreamEvent, ProviderError>>, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Streams one turn of conversation for direct provider use.

fn stream_chat_with_context<'life0, 'life1, 'async_trait>( &'life0 self, request: ChatRequest, context: &'life1 ProviderRequestContext, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, Result<StreamEvent, ProviderError>>, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Streams one turn with request-scoped provider context.