Struct RunnableSequence 

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

A sequence of Runnable steps composed into a pipeline.

Created via the pipe() method on RunnableExt, or directly with from_single / from_pair.

Type Safety

The I and O type parameters represent the pipeline’s overall input and output types. Intermediate types are erased at runtime via RunnableAny, but the compiler guarantees type compatibility at each pipe() call site.

Flattening

When two RunnableSequence values are piped together, their internal steps are merged (flattened) rather than nested, avoiding unnecessary indirection.

Implementations

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

pub fn from_single<R>(runnable: R) -> Self

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

Create a sequence from a single runnable step.

pub fn from_pair<R1, R2, M>(first: R1, second: R2) -> RunnableSequence<I, O>

where M: Send + Sync + 'static, R1: Runnable<I, M> + 'static, R1::Error: Into<LcelError>, R2: Runnable<M, O> + 'static, R2::Error: Into<LcelError>,

Create a sequence from two runnable steps.

The output type of the first must match the input type of the second.

pub fn pipe<O2, R>(self, other: R) -> RunnableSequence<I, O2>

where O2: Send + Sync + 'static, R: Runnable<O, O2> + Send + Sync + 'static, R::Error: Into<LcelError>,

Append a step to this sequence, returning a new sequence with the updated output type.

pub fn len(&self) -> usize

Number of steps in this sequence.

pub fn is_empty(&self) -> bool

Whether this sequence has no steps.

pub fn steps(&self) -> &[Box<dyn RunnableAny>]

Access the steps as a slice.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<I: Send + Sync + 'static, O: Send + Sync + 'static> Runnable<I, O> for RunnableSequence<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,

Execute the pipeline: feed input through each step sequentially.

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 processing: each step processes all inputs before passing to the next step. This allows LLM providers to optimize batch requests.

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,

Streaming: the first step runs through stream_any (single input → item stream) and every following step runs through transform_any. Steps that override stream (e.g. LLMs) therefore emit a real token stream instead of being collapsed to a single invoke.

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: chain each step’s transform to enable stream-to-stream pipeline processing.

type Error = LcelError

Error type.

fn batch_as_completed<'life0, 'async_trait>( &'life0 self, inputs: Vec<Input>, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Vec<(usize, Output)>, Self::Error>> + Send + 'async_trait>>

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

Batch processing that returns results in completion order.