Struct CompiledGraph 

pub struct CompiledGraph<S: GraphState> { /* private fields */ }

A validated, ready-to-run graph. Cheap to clone (the underlying nodes are Arc<dyn Node<S>>).

Implementations

impl<S: GraphState> CompiledGraph<S>

pub fn analyze(&self) -> GraphAnalysis

Compute static-graph diagnostics. See GraphAnalysis.

impl<S: GraphState> CompiledGraph<S>

pub fn with_durability(self, d: Durability) -> Self

Override checkpoint timing relative to step execution. Default is Durability::Sync.

pub fn durability(&self) -> &Durability

Current durability mode.

pub fn node_count(&self) -> usize

Number of registered nodes — useful for testing / introspection.

pub fn node_names(&self) -> Vec<&str>

Names of all registered nodes.

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

Optional graph version tag (set via crate::builder::Graph::with_version).

pub fn annotations(&self, node_name: &str) -> &HashMap<String, Value>

All annotations attached to node_name, or an empty map if the node has no annotations / isn’t registered.

pub fn annotation(&self, node_name: &str, key: &str) -> Option<&Value>

Look up a single annotation value by (node_name, key).

impl<S: GraphState + Clone + Send + 'static> CompiledGraph<S>

pub fn with_checkpointer(self, cp: Arc<dyn Checkpointer<S>>) -> Self

Attach a checkpointer; the engine will save state after each superstep.

pub fn with_interrupt_before<I, N>(self, names: I) -> Self

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

Pause the graph BEFORE each named node executes. Requires a checkpointer (errors at invoke time if not configured). Interrupt names are validated at invoke time, not compile time, because with_interrupt_before runs after compile(). Resume via CompiledGraph::resume.

pub fn with_interrupt_after<I, N>(self, names: I) -> Self

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

Pause the graph AFTER each named node completes (state already updated). Requires a checkpointer. Resume via CompiledGraph::resume.

pub async fn resume( &self, run_id: Uuid, step: u64, state: S, config: RunnableConfig, ) -> Result<S>

where S::Update: Clone,

Continue execution from a previously-interrupted run.

state is the (possibly user-edited) state to seed the next superstep with. run_id and step come from the original GraphInterrupted error. The resume’s RunnableConfig::run_id is set to run_id so observers can correlate with the original run.

pub async fn get_state(&self, run_id: Uuid) -> Result<Option<S>>

Latest checkpointed state for run_id. Returns None if there is no checkpointer attached or no state recorded for that run.

pub async fn get_state_at(&self, run_id: Uuid, step: u64) -> Result<Option<S>>

State at a specific superstep — for time-travel.

pub async fn get_state_history(&self, run_id: Uuid) -> Result<Vec<(u64, S)>>

Full step history for run_id. Each (step, state) pair is one superstep boundary — earliest first.

pub async fn update_state( &self, run_id: Uuid, step: u64, state: &S, ) -> Result<()>

Save a (possibly user-edited) state at step for run_id. Used to patch state before resuming an interrupted run.

Errors if no checkpointer is attached.

impl<S> CompiledGraph<S>

where S: GraphState + Clone + Send + 'static, <S as GraphState>::Update: Clone,

pub async fn stream_mode( &self, input: S, modes: StreamModes, config: RunnableConfig, ) -> Result<EventStream>

Stream events filtered by StreamModes — see the stream_mode module for what each mode captures.

impl<S: GraphState> CompiledGraph<S>

pub fn snapshot(&self) -> GraphSnapshot

Snapshot the graph’s static shape.

impl<S: GraphState> CompiledGraph<S>

pub fn to_ascii(&self) -> String

Render the graph as an ASCII summary suitable for terminal output.

Layout:

Graph (start: <name>)
  nodes:
    - a
    - b
    - c
  edges:
    a -> b
    b -> c

impl<S: GraphState> CompiledGraph<S>

pub fn to_dot(&self) -> String

Render the graph as a GraphViz digraph source string.

Layout:

• Every registered node is a rectangle.
• The configured start node is highlighted with a bold border.
• A synthetic __END__ node is included as a stadium-shaped sink.
• Static edges declared via Graph::edge are drawn as arrows.

Dynamic routing (via Goto::Send / Goto::Multiple returned from a node) is not captured — only what the builder declared statically.

impl<S: GraphState> CompiledGraph<S>

Methods on CompiledGraph<S> that emit a Mermaid flowchart diagram.

pub fn to_mermaid(&self) -> String

Render the graph as a Mermaid flowchart TD source string.

Includes:

• The configured start node (highlighted with a bold border).
• Every registered node.
• Every static edge declared via Graph::edge.
• A synthetic __END__ sink node — edges drawn from any node that has no outgoing static edge (since dynamic Goto::End cannot be inferred from the static graph).

Trait Implementations

impl<S: Clone + GraphState> Clone for CompiledGraph<S>

fn clone(&self) -> CompiledGraph<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: GraphState> Debug for CompiledGraph<S>

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

Formats the value using the given formatter.

impl<S> Runnable<S, S> for CompiledGraph<S>

where S: GraphState + Clone + Send + 'static, <S as GraphState>::Update: Clone,

fn stream_events<'life0, 'async_trait>( &'life0 self, input: S, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<EventStream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Override the default stream_events to emit real per-node events as the engine runs (real-time, not synthetic OnEnd-only). Engine events embed serde_json::Value::Null so S: Serialize is not required.

fn invoke<'life0, 'async_trait>( &'life0 self, input: S, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<S>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

One-shot invocation. The hot path.

fn name(&self) -> &str

Friendly name for telemetry / introspection.

fn batch<'life0, 'async_trait>( &'life0 self, inputs: Vec<I>, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<Vec<O>, CognisError>> + Send + 'async_trait>>

where 'life0: 'async_trait, I: 'static, O: 'static, Self: Sized + Sync + 'async_trait,

Run multiple inputs in parallel. Defaults to buffer_unordered honouring config.max_concurrency.

fn stream<'life0, 'async_trait>( &'life0 self, input: I, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<RunnableStream<O>, CognisError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sized + Sync + 'async_trait,

Stream the final output (chunks of O). Default emits one item via invoke — non-streaming runnables are correct without override.

fn input_schema(&self) -> Option<Value>

JSON Schema for the input type, if known.

fn output_schema(&self) -> Option<Value>

JSON Schema for the output type, if known.