Struct Flow 

pub struct Flow {
    pub name: Option<String>,
    pub description: Option<String>,
    pub version: Option<String>,
    pub schemas: FlowSchema,
    pub steps: Vec<Step>,
    pub output: ValueExpr,
    pub test: Option<TestConfig>,
    pub examples: Option<Vec<ExampleInput>>,
    pub metadata: HashMap<String, Value>,
}

A workflow consisting of a sequence of steps and their outputs.

A flow represents a complete workflow that can be executed. It contains:

• A sequence of steps to execute
• Named outputs that can reference step outputs

Flows should not be cloned. They should generally be stored and passed as a reference or inside an Arc.

Fields

name: Option<String>

The name of the flow.

description: Option<String>

The description of the flow.

version: Option<String>

The version of the flow.

schemas: FlowSchema

Consolidated schema information for the flow. Contains input/output schemas, step output schemas, and shared $defs.

steps: Vec<Step>

The steps to execute for the flow.

output: ValueExpr

The outputs of the flow, mapping output names to their values.

test: Option<TestConfig>

Test configuration for the flow.

examples: Option<Vec<ExampleInput>>

Example inputs for the workflow that can be used for testing and UI dropdowns.

metadata: HashMap<String, Value>

Extensible metadata for the flow that can be used by tools and frameworks.

Implementations

impl Flow

pub fn builder() -> FlowBuilder

Create a new FlowBuilder.

impl Flow

pub fn slow_clone(&self) -> Flow

Create a clone of this flow.

Warning: This method performs a deep clone of the entire workflow structure, including all steps, metadata, and configurations. This can be expensive for large workflows.

Performance

• Cloning large workflows with many steps can be slow
• Consider using Arc<Flow> for shared ownership instead
• Only use this when you need to modify the workflow structure

Example

use stepflow_core::workflow::Flow;

let original_flow = Flow::default();
let cloned_flow = original_flow.slow_clone();

pub fn name(&self) -> Option<&str>

pub fn description(&self) -> Option<&str>

pub fn version(&self) -> Option<&str>

pub fn metadata(&self) -> &HashMap<String, Value>

pub fn steps(&self) -> &[Step]

Returns a reference to all steps in the flow.

pub fn examples(&self) -> &[ExampleInput]

pub fn variables(&self) -> Option<VariableSchema>

Get the variable schema for the flow.

This constructs a VariableSchema from the schema definition, extracting runtime metadata like defaults, secrets, and required variables.

pub fn variable_schema(&self) -> Option<&SchemaRef>

Get a reference to the variable schema (raw SchemaRef).

pub fn step(&self, index: usize) -> &Step

Returns a reference to the step at the given index.

Panics

Panics if the index is out of bounds.

pub fn step_mut(&mut self, index: usize) -> &mut Step

Returns a mutable reference to the step at the given index.

Panics

Panics if the index is out of bounds.

pub fn output(&self) -> &ValueExpr

Returns a reference to the flow’s output value.

pub fn test(&self) -> Option<&TestConfig>

pub fn test_mut(&mut self) -> Option<&mut TestConfig>

pub fn schemas(&self) -> &FlowSchema

Get the flow’s schema information.

pub fn schemas_mut(&mut self) -> &mut FlowSchema

Get a mutable reference to the flow’s schema information.

pub fn input_schema(&self) -> Option<&SchemaRef>

Get the flow’s input schema.

pub fn set_input_schema(&mut self, input_schema: Option<SchemaRef>)

Set the flow’s input schema.

pub fn output_schema(&self) -> Option<&SchemaRef>

Get the flow’s output schema.

pub fn set_output_schema(&mut self, output_schema: Option<SchemaRef>)

Set the flow’s output schema.

pub fn step_output_schema(&self, step_id: &str) -> Option<&SchemaRef>

Get the output schema for a specific step.

pub fn set_step_output_schema( &mut self, step_id: String, step_schema: SchemaRef, )

Set the output schema for a specific step.

pub fn get_all_examples(&self) -> Vec<ExampleInput>

Get all example inputs, including those derived from test cases.

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 From<Flow> for FlowRef

fn from(flow: Flow) -> FlowRef

Converts to this type from the input type.

impl JsonSchema for Flow

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

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 inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Flow

fn eq(&self, other: &Flow) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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.

impl StructuralPartialEq for Flow