Struct Flow 

pub struct Flow {
    pub steps: Vec<Step>,
    pub constraints: Vec<Constraint>,
    pub confirm_tools: Vec<String>,
    pub ambient: Vec<String>,
}

A governed conversation/tool DAG.

Fields

steps: Vec<Step>

The steps (DAG nodes).

constraints: Vec<Constraint>

Cross-cutting constraints.

confirm_tools: Vec<String>

Tools that require confirmation when reached (set by commit).

ambient: Vec<String>

Cross-cutting tools exempt from step allow whitelists.

A step’s allow list excludes by omission, which is correct for the domain tools a step is about and wrong for infrastructure no step is about — memory recall, escalation, logging. Naming a tool here says “this is not part of any step’s repertoire”, not “this is ungovernable”: deny, once and never(..).until(..) all still bind, because each of those names the tool and so is a decision about it.

Implementations

impl Flow

pub fn new() -> FlowBuilder

Start building a flow.

pub fn validate(&self) -> Result<(), ConfigError>

Validate referential integrity and acyclicity. Every problem found is reported in the returned ConfigError, not just the first.

pub fn state_keys_read(&self) -> BTreeSet<String>

Every state key any guard in the flow reads (is_true/is_set/eq/ captured atoms in step gates, completion guards, and never…until constraints).

A key in this set that nothing in the session writes — no tool, no extractor, no promotion — can never latch, which is the dominant silent failure in data-authored flows. Validators diff this set against the declared writers to catch it at load time, the way compile_with_tools catches tool typos.

pub fn compile(self) -> Result<CompiledFlow, FlowErrors>

Compile and validate the flow into a CompiledFlow, turning a class of runtime surprises into load-time errors.

On top of validate’s referential/acyclicity checks this reports: unreachable steps, commit tools guarded by an always-true condition (an effectively unguarded commit, which defeats the confirm-before-commit contract), never…until guards whose done(step) atoms reference unknown steps (unsatisfiable — the tool would be forbidden forever), and ordering cycles across the combined after + before edges (which deadlock every step on the cycle). Precomputes the ToolSurface universe.

To additionally validate tool names against a known registry, use compile_with_tools.

pub fn compile_with_tools( self, tools: &[&str], ) -> Result<CompiledFlow, FlowErrors>

Compile like compile, additionally validating every tool name the flow references (step allow/deny, once, never…until, and commit/confirm tools) against the given registry of known tool names.

A referenced tool missing from tools is reported as FlowError::UnknownTool — catching typos and drift between a flow script and the tools actually registered on the session.

let compiled = flow.compile_with_tools(&["lookup_account", "charge_card"])?;

pub fn to_mermaid(&self) -> String

Render the flow as a Mermaid flowchart — the spec is the diagram.

Trait Implementations

impl Clone for Flow

fn clone(&self) -> Flow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Flow

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

Formats the value using the given formatter.

impl Default for Flow

fn default() -> Flow

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Flow

fn deserialize<__D>( __deserializer: __D, ) -> Result<Flow, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Flow

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Serialize for Flow

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.