Struct FlowBuilder 

pub struct FlowBuilder { /* private fields */ }

Builder for a Flow using the cemented verbs.

Implementations

impl FlowBuilder

pub fn step(self, id: impl Into<String>) -> Self

Declare a new step.

pub fn after(self, dep: impl Into<String>) -> Self

Add a dependency (call multiple times for multiple deps).

pub fn after_when(self, dep: impl Into<String>, when: Guard) -> Self

Add a conditional dependency: satisfied only while when holds. Conditional edges out of one source are how a flow branches; pair with join_any on the merge step.

pub fn join_any(self) -> Self

Any one satisfied edge makes this step eligible (the merge node after a branch). Default is all — a synchronizing join.

pub fn gate(self, g: Guard) -> Self

Extra eligibility guard beyond dependencies.

pub fn done(self, g: Guard) -> Self

Completion condition.

pub fn posture(self, text: impl Into<String>) -> Self

Instruction imposed while active.

pub fn ground(self, template: impl Into<String>) -> Self

A grounding template projected while active — a curated, State- interpolated fact line that pins the model to known values. {key} interpolates a value; {key?yes:no} picks by truthiness. See render_ground.

pub fn allow<I, S>(self, tools: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Tools available while active (whitelist).

pub fn deny<I, S>(self, tools: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Tools forbidden while active.

pub fn terminal(self) -> Self

Mark the current step terminal.

pub fn once(self, tool: impl Into<String>) -> Self

A tool may run at most once.

pub fn before(self, a: impl Into<String>, b: impl Into<String>) -> Self

Ordering invariant: a before b.

pub fn require<I, S>(self, steps: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Required terminal steps for completion.

pub fn ambient<I, S>(self, tools: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Exempt cross-cutting tools from every step’s allow whitelist.

Flow-level, and order-independent with respect to .step(..). Use it for tools that serve the conversation rather than any one step of it — memory recall, escalation, logging. A tool named here still obeys deny, once and never(..).until(..); see Flow::ambient.

let flow = Flow::new()
    .ambient(["recall_context"])
    .step("book")
    .allow(["book_table"])
    .done(Guard::called_ok("book_table"))
    .build()
    .unwrap();
assert_eq!(flow.ambient, ["recall_context"]);

pub fn reset<I, S>(self, steps: I) -> ResetBuilder

where I: IntoIterator<Item = S>, S: Into<String>,

Un-latch steps whenever the guard given to when becomes true — the loop primitive. See Constraint::Reset for the exact forgiveness semantics.

pub fn never(self, tool: impl Into<String>) -> NeverBuilder

Forbid a tool until a guard holds (never(tool).until(guard)).

pub fn commit(self, tool: impl Into<String>, until: Guard) -> Self

Commit-tool sugar: at most once, gated until until, and flagged for confirmation. Composes once + never…until + the confirmation seam.

pub fn build(self) -> Result<Flow, ConfigError>

Finalize and validate the flow.

Trait Implementations

impl Default for FlowBuilder

fn default() -> FlowBuilder

Returns the “default value” for a type.