Struct TypedSequentialFlow 

pub struct TypedSequentialFlow<I, O> { /* private fields */ }

Pipeline of typed transformations.

Constructed with new; extended with then. Drive with run.

Implementations

impl TypedSequentialFlow<(), ()>

pub fn start_with<A>( name: impl Into<String>, agent: A, ) -> TypedSequentialFlow<A::Input, A::Output>

where A: Agent + Send + Sync + 'static, A::Input: Send + 'static, A::Output: Send + 'static, A::Error: Error + Send + Sync + 'static,

Start a typed pipeline with a named klieo_core::agent::Agent as the first stage.

Equivalent to TypedSequentialFlow::new with an auto-wrapping closure, but takes any concrete klieo_core::agent::Agent directly — no manual map_err needed.

Example

use klieo_flows::TypedSequentialFlow;

// `Classifier` implements `klieo_core::agent::Agent`.
let flow = TypedSequentialFlow::start_with("pipeline", Classifier)
    .then_agent(Retriever)
    .then_agent(Drafter);

impl<I, O> TypedSequentialFlow<I, O>

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

pub fn new<F, Fut>(name: impl Into<String>, stage: F) -> Self

where F: Fn(AgentContext, I) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<O, FlowError>> + Send + 'static,

Start a typed pipeline with the given name and first stage.

pub fn then_agent<A>(self, agent: A) -> TypedSequentialFlow<I, A::Output>

where A: Agent<Input = O> + Send + Sync + 'static, A::Output: Send + 'static, A::Error: Error + Send + Sync + 'static,

Append a stage from a concrete klieo_core::agent::Agent.

The agent’s Input must match this flow’s current output type O. Returns a new TypedSequentialFlow<I, A::Output>.

pub fn then<F, Fut, P>(self, stage: F) -> TypedSequentialFlow<I, P>

where F: Fn(AgentContext, O) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<P, FlowError>> + Send + 'static, P: Send + 'static,

Append a stage that consumes the previous output type O and produces a new output type P.

pub async fn run(&self, ctx: AgentContext, input: I) -> Result<O, FlowError>

Run the pipeline end-to-end. The composed stage chain is wrapped in a single typed_sequential_flow.run tracing span.

pub fn name(&self) -> &str

Configured pipeline name.