Enum Composable 

#[non_exhaustive]
pub enum Composable {
    Agent(AgentBuilder),
    Pipeline(Pipeline),
    FanOut(FanOut),
    Loop(Loop),
    Fallback(Fallback),
    MapOver(MapOver),
    Branch(Branch),
    Transform(StateComposite),
}

A composable workflow node — can be sequenced, fan-out, looped, etc.

New node kinds may be added, so a match needs a _ arm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Agent(AgentBuilder)

A single agent node.

Pipeline(Pipeline)

A sequential pipeline of steps.

FanOut(FanOut)

A parallel fan-out of branches.

Loop(Loop)

A loop with optional termination predicate.

Fallback(Fallback)

A fallback chain (try each until one succeeds).

MapOver(MapOver)

One agent applied to every item of a state list (patterns::map_over).

Branch(Branch)

Run one of two workflows, chosen by a state predicate (patterns::conditional).

Transform(StateComposite)

Reshape state between steps with an S transform chain (agent >> S::pick(..) >> agent). The pipeline’s input passes through unchanged.

Implementations

impl Composable

pub fn compile( self, llm: Arc<dyn BaseLlm>, ) -> Result<Arc<dyn TextAgent>, ConfigError>

Compile this composable tree into an executable TextAgent.

Recursively compiles the tree: pipelines become SequentialTextAgent, fan-outs become ParallelTextAgent, loops become LoopTextAgent, fallbacks become FallbackTextAgent, map-overs become MapOverTextAgent, and agents compile via AgentBuilder::build() — whose ConfigError (an MCP toolset on a text agent) is the only way this fails.

let pipeline = AgentBuilder::new("writer").instruction("Write a draft")
    >> AgentBuilder::new("reviewer").instruction("Review and improve");

let agent = pipeline.compile(llm)?;
let state = State::new();
let result = agent.run(&state).await?;

impl Composable

pub fn middleware(self, middleware: impl Into<MiddlewareComposite>) -> Self

Attach middleware to a Loop or Fallback node — the place where combinator-level observers (M::on_loop, M::on_fallback) live.

For other node kinds (single agent, pipeline, fan-out, map-over) this is a no-op: attach M:: middleware to the agent itself via AgentBuilder::middleware instead.

impl Composable

pub fn first_step(&self) -> Option<&Composable>

The first step of a Pipeline, or None if this is not a pipeline (or the pipeline is empty).

pub fn last_step(&self) -> Option<&Composable>

The last step of a Pipeline, or None if this is not a pipeline (or the pipeline is empty).

pub fn nth_step(&self, n: usize) -> Option<&Composable>

The nth step of a Pipeline, or None if this is not a pipeline or the index is out of bounds.

pub fn pipeline_steps(&self) -> Option<&[Composable]>

All steps of a Pipeline, or None if this is not a pipeline.

pub fn fan_out_branches(&self) -> Option<&[Composable]>

The branches of a FanOut, or None if this is not a fan-out.

pub fn loop_predicate(&self) -> Option<&LoopPredicate>

The termination predicate of a Loop, or None if this is not a loop (or the loop has no predicate).

pub fn loop_body(&self) -> Option<&Composable>

The body of a Loop, or None if this is not a loop.

pub fn fallback_candidates(&self) -> Option<&[Composable]>

The candidates of a Fallback chain, or None if this is not a fallback.

Trait Implementations

impl BitOr for Composable

Composable | Composable → FanOut (flattening)

type Output = Composable

The resulting type after applying the | operator.

fn bitor(self, rhs: Composable) -> Self::Output

Performs the | operation.

impl BitOr<AgentBuilder> for Composable

Composable | AgentBuilder → FanOut (flattening)

type Output = Composable

The resulting type after applying the | operator.

fn bitor(self, rhs: AgentBuilder) -> Self::Output

Performs the | operation.

impl Clone for Composable

fn clone(&self) -> Composable

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Composable

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

Formats the value using the given formatter.

impl Div for Composable

Composable / Composable → Fallback (flattening)

type Output = Composable

The resulting type after applying the / operator.

fn div(self, rhs: Composable) -> Self::Output

Performs the / operation.

impl Div<AgentBuilder> for Composable

Composable / AgentBuilder → Fallback (flattening)

type Output = Composable

The resulting type after applying the / operator.

fn div(self, rhs: AgentBuilder) -> Self::Output

Performs the / operation.

impl From<AgentBuilder> for Composable

fn from(b: AgentBuilder) -> Self

Converts to this type from the input type.

impl From<Branch> for Composable

fn from(b: Branch) -> Self

Converts to this type from the input type.

impl From<Fallback> for Composable

fn from(f: Fallback) -> Self

Converts to this type from the input type.

impl From<FanOut> for Composable

fn from(f: FanOut) -> Self

Converts to this type from the input type.

impl From<Loop> for Composable

fn from(l: Loop) -> Self

Converts to this type from the input type.

impl From<MapOver> for Composable

fn from(m: MapOver) -> Self

Converts to this type from the input type.

impl From<Pipeline> for Composable

fn from(p: Pipeline) -> Self

Converts to this type from the input type.

impl From<StateComposite> for Composable

fn from(transform: StateComposite) -> Self

Converts to this type from the input type.

impl From<StateTransform> for Composable

fn from(transform: StateTransform) -> Self

Converts to this type from the input type.

impl Mul<LoopPredicate> for Composable

Composable * until(pred) → conditional Loop

type Output = Composable

The resulting type after applying the * operator.

fn mul(self, rhs: LoopPredicate) -> Self::Output

Performs the * operation.

impl Mul<u32> for Composable

Composable * 3 → Loop(max=3)

type Output = Composable

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl Shr for Composable

Composable >> Composable → Pipeline (flattening)

type Output = Composable

The resulting type after applying the >> operator.

fn shr(self, rhs: Composable) -> Self::Output

Performs the >> operation.

impl Shr<AgentBuilder> for Composable

Composable >> AgentBuilder → Pipeline (flattening)

type Output = Composable

The resulting type after applying the >> operator.

fn shr(self, rhs: AgentBuilder) -> Self::Output

Performs the >> operation.

impl Shr<Composable> for StateTransform

A state transform as a pipeline step: a >> S::pick(..) >> b.

type Output = Composable

The resulting type after applying the >> operator.

fn shr(self, rhs: Composable) -> Self::Output

Performs the >> operation.

impl Shr<Composable> for StateComposite

A state transform as a pipeline step: a >> S::pick(..) >> b.

type Output = Composable

The resulting type after applying the >> operator.

fn shr(self, rhs: Composable) -> Self::Output

Performs the >> operation.

impl Shr<Composable> for AgentBuilder

AgentBuilder >> Composable → Pipeline (flattening)

type Output = Composable

The resulting type after applying the >> operator.

fn shr(self, rhs: Composable) -> Self::Output

Performs the >> operation.

impl Shr<StateComposite> for Composable

A state transform as a pipeline step: a >> S::pick(..) >> b.

type Output = Composable

The resulting type after applying the >> operator.

fn shr(self, rhs: StateComposite) -> Self::Output

Performs the >> operation.

impl Shr<StateTransform> for Composable

A state transform as a pipeline step: a >> S::pick(..) >> b.

type Output = Composable

The resulting type after applying the >> operator.

fn shr(self, rhs: StateTransform) -> Self::Output

Performs the >> operation.