Struct InterruptibleNode 

pub struct InterruptibleNode<S: StateSchema, F> { /* private fields */ }

Resume-aware node (LangGraph-style interrupt).

The wrapped closure is called twice per runtime interrupt:

• first pass: resume is None — the node either completes normally or suspends itself by returning Err(GraphError::InterruptRequest { payload });
• resume: after a human answers, the node is re-entered with resume = Some(decision) so the closure can continue past the suspension.

Branch on that second argument instead of re-walking expensive side effects (an API call, a DB write) that already happened on the first pass — keep any such work memoized in the state between the two passes.

Implementations

impl<S: StateSchema, F> InterruptibleNode<S, F>

where F: Fn(&S, Option<&Value>) -> Pin<Box<dyn Future<Output = NodeResult<S>> + Send>> + Send + Sync,

pub fn new(name: impl Into<String>, func: F) -> Self

Create a resume-aware node. The closure takes the current state and the injected resume decision (None on first pass, Some(decision) on resume).

Trait Implementations

impl<S: StateSchema, F> GraphNode<S> for InterruptibleNode<S, F>

where F: Fn(&S, Option<&Value>) -> Pin<Box<dyn Future<Output = NodeResult<S>> + Send>> + Send + Sync + 'static,

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 S, config: Option<NodeConfig>, ) -> Pin<Box<dyn Future<Output = Result<StateUpdate<S>, GraphError>> + Send + 'async_trait>>

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

Execute the node

fn name(&self) -> &str

Get node name