Struct CompiledStateGraph 

pub struct CompiledStateGraph { /* private fields */ }

A compiled, executable state graph.

This is the result of StateGraph::compile() and implements Runnable. In the full Pregel engine (Phase 6), this will execute in BSP super-steps. Currently it provides a simplified sequential execution model.

Implementations

impl CompiledStateGraph

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

Get the node names in this graph.

pub fn channel_names(&self) -> Vec<String>

Get the channel names in this graph.

pub fn has_node(&self, name: &str) -> bool

Check if a node exists.

pub fn name(&self) -> &str

Get the graph name.

pub fn checkpointer(&self) -> Option<&Arc<dyn BaseCheckpointSaver>>

Get the checkpointer, if any.

pub fn store(&self) -> Option<&Arc<dyn BaseStore>>

Get the store, if any.

pub fn get_next_nodes(&self, state: &HashMap<String, JsonValue>) -> Vec<String>

Determine which nodes should execute next given the current state.

This is the “plan” phase of the BSP cycle.

pub fn get_state( &self, config: &RunnableConfig, ) -> Result<StateSnapshot, GraphError>

Get the current state of the graph from the checkpointer.

Returns a StateSnapshot containing the current channel values, the names of nodes that will execute next, pending tasks, and any unresolved interrupts.

Requires a checkpointer to be configured.

Example

let snapshot = compiled.get_state(&config)?;
println!("next: {:?}", snapshot.next);
println!("values: {}", snapshot.values);

pub fn update_state( &self, config: &RunnableConfig, values: &JsonValue, ) -> Result<RunnableConfig, GraphError>

Manually update the graph state.

Applies the given values to the current checkpoint’s channels and saves a new checkpoint. This allows updating custom state fields (like name, birthday) outside of normal node execution.

Requires a checkpointer to be configured.

Arguments

• config - The runnable config (must include thread_id)
• values - A JSON object of channel updates, e.g. {"name": "LangGraph"}

Example

compiled.update_state(&config, json!({"name": "LangGraph (library)"}))?;
let snapshot = compiled.get_state(&config)?;
assert_eq!(snapshot.values["name"], "LangGraph (library)");

pub fn get_state_history( &self, config: &RunnableConfig, ) -> Result<Vec<StateSnapshot>, GraphError>

Get the state history (all checkpoints) for a thread.

Returns a list of StateSnapshot in reverse chronological order (newest first). Each snapshot contains the checkpoint’s channel values, which node would execute next, and metadata.

This enables “time travel” — reviewing past states and resuming from any checkpoint.

Example

let history = compiled.get_state_history(&config)?;
for snapshot in &history {
    println!("messages: {}, next: {:?}", snapshot.values["messages"].as_array().map(|a| a.len()), snapshot.next);
}

impl CompiledStateGraph

pub fn astream( &self, input: &JsonValue, config: &RunnableConfig, stream_modes: Vec<StreamMode>, ) -> ReceiverStream<StreamPart>

Public streaming API: returns a ReceiverStream of StreamParts.

Trait Implementations

impl Clone for CompiledStateGraph

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Runnable for CompiledStateGraph

fn invoke( &self, input: &JsonValue, config: &RunnableConfig, ) -> Result<JsonValue, RunnableError>

Execute synchronously.

fn ainvoke<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, input: &'life1 JsonValue, config: &'life2 RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<JsonValue, RunnableError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Execute asynchronously.

fn name(&self) -> &str

Human-readable name for tracing/debugging.