Struct RunnableWithFallbacks 

pub struct RunnableWithFallbacks<I, O>
where
    I: Send + Sync + Clone + Debug + 'static,
    O: Send + Sync + Clone + Debug + 'static,
{
    pub runnable: DynRunnable<I, O>,
    pub fallbacks: Vec<DynRunnable<I, O>>,
    pub handle_all_errors: bool,
    /* private fields */
}

A Runnable that can fallback to other Runnables if it fails.

External APIs (e.g., APIs for a language model) may at times experience degraded performance or even downtime.

In these cases, it can be useful to have a fallback Runnable that can be used in place of the original Runnable (e.g., fallback to another LLM provider).

Fallbacks can be defined at the level of a single Runnable, or at the level of a chain of Runnables. Fallbacks are tried in order until one succeeds or all fail.

While you can instantiate a RunnableWithFallbacks directly, it is usually more convenient to use the with_fallbacks method on a Runnable.

Example

use agent_chain_core::runnables::{RunnableLambda, RunnableWithFallbacks};

// Create a primary runnable that might fail
let primary = RunnableLambda::new(|x: i32| {
    if x > 5 { Err(Error::other("too large")) }
    else { Ok(x * 2) }
});

// Create a fallback runnable
let fallback = RunnableLambda::new(|x: i32| Ok(x));

// Combine them with fallbacks
let with_fallbacks = RunnableWithFallbacks::new(primary, vec![fallback]);

// Will use primary for x <= 5, fallback for x > 5
assert_eq!(with_fallbacks.invoke(3, None).unwrap(), 6);
assert_eq!(with_fallbacks.invoke(10, None).unwrap(), 10);

Fields

runnable: DynRunnable<I, O>

The Runnable to run first.

fallbacks: Vec<DynRunnable<I, O>>

A sequence of fallbacks to try.

handle_all_errors: bool

Whether to handle all errors (true) or specific error types. In Rust, we simplify the Python’s exceptions_to_handle to a boolean flag since we don’t have the same exception hierarchy.

Implementations

impl<I, O> RunnableWithFallbacks<I, O>

where I: Send + Sync + Clone + Debug + 'static, O: Send + Sync + Clone + Debug + 'static,

pub fn new<R>(runnable: R, fallbacks: Vec<DynRunnable<I, O>>) -> Self

where R: Runnable<Input = I, Output = O> + Send + Sync + 'static,

Create a new RunnableWithFallbacks.

Arguments

• runnable - The primary runnable to try first
• fallbacks - A list of fallback runnables to try if the primary fails

pub fn from_dyn( runnable: DynRunnable<I, O>, fallbacks: Vec<DynRunnable<I, O>>, ) -> Self

Create a new RunnableWithFallbacks from a DynRunnable.

pub fn with_handle_all_errors(self, handle_all_errors: bool) -> Self

Set whether to handle all errors.

If true, any error will trigger fallback. If false, only certain errors will trigger fallback (default: true).

pub fn with_name(self, name: impl Into<String>) -> Self

Set the name of this runnable.

pub fn runnables(&self) -> impl Iterator<Item = &DynRunnable<I, O>>

Get an iterator over all runnables (primary + fallbacks).

pub fn config_specs(&self) -> Result<Vec<ConfigurableFieldSpec>>

Get the config specs from all runnables.

Trait Implementations

impl<I, O> Debug for RunnableWithFallbacks<I, O>

where I: Send + Sync + Clone + Debug + 'static, O: Send + Sync + Clone + Debug + 'static,

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

Formats the value using the given formatter.

impl<I, O> Runnable for RunnableWithFallbacks<I, O>

where I: Send + Sync + Clone + Debug + 'static, O: Send + Sync + Clone + Debug + 'static,

type Input = I

The input type for this Runnable.

type Output = O

The output type for this Runnable.

fn name(&self) -> Option<String>

Get the optional name of this Runnable.

fn invoke( &self, input: Self::Input, config: Option<RunnableConfig>, ) -> Result<Self::Output>

Transform a single input into an output.

fn ainvoke<'life0, 'async_trait>( &'life0 self, input: Self::Input, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Self::Output>> + Send + 'async_trait>>

where Self: 'static + 'async_trait, 'life0: 'async_trait,

Transform a single input into an output asynchronously.

fn batch( &self, inputs: Vec<Self::Input>, config: Option<ConfigOrList>, return_exceptions: bool, ) -> Vec<Result<Self::Output>>

where Self: 'static,

Transform multiple inputs into outputs in parallel.

fn abatch<'life0, 'async_trait>( &'life0 self, inputs: Vec<Self::Input>, config: Option<ConfigOrList>, return_exceptions: bool, ) -> Pin<Box<dyn Future<Output = Vec<Result<Self::Output>>> + Send + 'async_trait>>

where Self: 'static + 'async_trait, 'life0: 'async_trait,

Transform multiple inputs into outputs asynchronously.

fn stream( &self, input: Self::Input, config: Option<RunnableConfig>, ) -> BoxStream<'_, Result<Self::Output>>

Stream output from a single input.

fn astream( &self, input: Self::Input, config: Option<RunnableConfig>, ) -> BoxStream<'_, Result<Self::Output>>

where Self: 'static,

Stream output from a single input asynchronously.

fn get_name(&self, suffix: Option<&str>, name: Option<&str>) -> String

Get the name of this Runnable.

fn type_name(&self) -> &'static str

Get the type name of this Runnable.

fn transform<'a>( &'a self, input: BoxStream<'a, Self::Input>, config: Option<RunnableConfig>, ) -> BoxStream<'a, Result<Self::Output>>

Transform an input stream into an output stream.

fn atransform<'a>( &'a self, input: BoxStream<'a, Self::Input>, config: Option<RunnableConfig>, ) -> BoxStream<'a, Result<Self::Output>>

where Self: 'static,

Transform an input stream into an output stream asynchronously.

fn bind(self, kwargs: HashMap<String, Value>) -> RunnableBinding<Self>

where Self: Sized,

Bind arguments to this Runnable, returning a new Runnable.

fn with_config(self, config: RunnableConfig) -> RunnableBinding<Self>

where Self: Sized,

Bind config to this Runnable, returning a new Runnable.

fn with_retry( self, max_attempts: usize, wait_exponential_jitter: bool, ) -> RunnableRetry<Self>

where Self: Sized,

Create a new Runnable that retries on failure.

fn map(self) -> RunnableEach<Self>

where Self: Sized,

Return a new Runnable that maps a list of inputs to a list of outputs.