Struct RunnableWithFallbacks 

pub struct RunnableWithFallbacks<I: Send + Sync + 'static, O: Send + Sync + 'static> { /* private fields */ }

A Runnable that tries fallbacks when the primary fails.

If the primary runnable returns an error on invoke, each fallback is tried in order. The first successful result is returned. If all fail, the primary’s error is returned (so the user sees the error from the runnable they explicitly chose).

The input type I must be Clone so that the input can be re-boxed for each fallback attempt.

Implementations

impl<I: Clone + Send + Sync + 'static, O: Send + Sync + 'static> RunnableWithFallbacks<I, O>

pub fn new<R>(primary: R, fallbacks: Vec<Box<dyn RunnableAny>>) -> Self

where R: Runnable<I, O> + 'static, R::Error: Into<LcelError>,

Create a new fallback runnable with the given primary and fallbacks.

pub fn fallback_count(&self) -> usize

Number of fallback runnables.

Trait Implementations

impl<I: Send + Sync + 'static, O: Send + Sync + 'static> Debug for RunnableWithFallbacks<I, O>

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

Formats the value using the given formatter.

impl<I: Clone + Send + Sync + 'static, O: Send + Sync + 'static> Runnable<I, O> for RunnableWithFallbacks<I, O>

fn invoke<'life0, 'async_trait>( &'life0 self, input: I, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<O, LcelError>> + Send + 'async_trait>>

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

Try the primary, then fallbacks on failure.

fn stream<'life0, 'async_trait>( &'life0 self, input: I, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<O, LcelError>> + Send>>, LcelError>> + Send + 'async_trait>>

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

Stream: try the primary first. On failure, try fallbacks. Returns the first successful stream, or the primary’s error.

fn batch<'life0, 'async_trait>( &'life0 self, inputs: Vec<I>, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Vec<O>, LcelError>> + Send + 'async_trait>>

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

Batch: apply fallback logic per-item.

fn transform<'life0, 'async_trait>( &'life0 self, input: Pin<Box<dyn Stream<Item = Result<I, LcelError>> + Send>>, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<O, LcelError>> + Send>>, LcelError>> + Send + 'async_trait>>

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

Transform: use invoke with fallback, wrap as stream.

type Error = LcelError

Error type.