Struct BoxRunnable 

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

A type-erased runnable that supports the | pipe operator for composition.

let chain = step1.boxed() | step2.boxed() | step3.boxed();
let result = chain.invoke(input, &config).await?;

Implementations

impl<I: Send + 'static, O: Send + 'static> BoxRunnable<I, O>

pub fn new<R: Runnable<I, O> + 'static>(runnable: R) -> Self

pub fn stream<'a>( &'a self, input: I, config: &'a RunnableConfig, ) -> RunnableOutputStream<'a, O>

Stream the output, delegating to the inner runnable’s stream().

pub fn bind( self, transform: impl Fn(RunnableConfig) -> RunnableConfig + Send + Sync + 'static, ) -> BoxRunnable<I, O>

Bind a config transform to this runnable, producing a new BoxRunnable that applies the transform before delegating.

pub fn with_config(self, config: RunnableConfig) -> BoxRunnable<I, O>

Return a new runnable that always uses the given config, ignoring the config passed at invocation time.

pub fn with_listeners( self, on_start: impl Fn(&RunnableConfig) + Send + Sync + 'static, on_end: impl Fn(&RunnableConfig) + Send + Sync + 'static, ) -> BoxRunnable<I, O>

Wrap this runnable with before/after listener callbacks.

impl<I: Send + 'static, O: Send + 'static> BoxRunnable<Vec<I>, Vec<O>>

pub fn map_each(inner: BoxRunnable<I, O>) -> BoxRunnable<Vec<I>, Vec<O>>

Shorthand for wrapping this runnable with RunnableEach. Requires I: Send + 'static, O: Send + 'static and that the runnable operates on Vec<I> -> Vec<O>.

See also RunnableEach::new() for wrapping a BoxRunnable<I, O>.

Trait Implementations

impl<I, M, O> BitOr<BoxRunnable<M, O>> for BoxRunnable<I, M>

where I: Send + 'static, M: Send + 'static, O: Send + 'static,

Pipe operator: a | b creates a RunnableSequence that runs a then b.

type Output = BoxRunnable<I, O>

The resulting type after applying the | operator.

fn bitor(self, rhs: BoxRunnable<M, O>) -> BoxRunnable<I, O>

Performs the | operation.

impl<I: Send + 'static, O: Send + 'static> Runnable<I, O> for BoxRunnable<I, O>

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

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

Execute this runnable on a single input.

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

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

Execute this runnable on multiple inputs sequentially.

fn stream<'a>( &'a self, input: I, config: &'a RunnableConfig, ) -> RunnableOutputStream<'a, O>

where I: 'a,

Stream the output. Default wraps invoke as a single-item stream. Override for true streaming (e.g., token-by-token from an LLM).

fn boxed(self) -> BoxRunnable<I, O>

where Self: Sized + 'static,

Wrap this runnable into a type-erased BoxRunnable for composition via |.