Enum StreamEvent 

pub enum StreamEvent {
    State {
        state: State,
        step: usize,
    },
    Updates {
        node: String,
        updates: HashMap<String, Value>,
    },
    Message {
        node: String,
        content: String,
        is_final: bool,
    },
    Custom {
        node: String,
        event_type: String,
        data: Value,
    },
    Debug {
        event_type: String,
        data: Value,
    },
    NodeStart {
        node: String,
        step: usize,
    },
    NodeEnd {
        node: String,
        step: usize,
        duration_ms: u64,
    },
    StepComplete {
        step: usize,
        nodes_executed: Vec<String>,
    },
    Interrupted {
        node: String,
        message: String,
    },
    NodeInterrupt {
        node: String,
        message: String,
        data: Option<Value>,
    },
    Resumed {
        step: usize,
        pending_nodes: Vec<String>,
    },
    Done {
        state: State,
        total_steps: usize,
    },
    Error {
        message: String,
        node: Option<String>,
    },
    RouteDispatched {
        source: String,
        targets: Vec<String>,
    },
}

Events emitted during streaming

Variants

State

State snapshot

Fields

state: State

step: usize

Updates

State updates from a node

Fields

node: String

updates: HashMap<String, Value>

Message

Message/token from LLM

Fields

node: String

content: String

is_final: bool

Custom

Custom event from node

Fields

node: String

event_type: String

data: Value

Debug

Debug event

Fields

event_type: String

data: Value

NodeStart

Node started execution

Fields

node: String

step: usize

NodeEnd

Node completed execution

Fields

node: String

step: usize

duration_ms: u64

StepComplete

Super-step completed

Fields

step: usize

nodes_executed: Vec<String>

Interrupted

Execution was interrupted

Fields

node: String

message: String

NodeInterrupt

A node asked to pause, reported by Node::execute_stream.

The streamed path yields events rather than a NodeOutput, so a node’s own interrupt request needs a way through. The executor turns this into the pause and does not forward it, so a caller sees only Interrupted.

Fields

node: String

message: String

data: Option<Value>

Resumed

Execution resumed from a checkpoint

Fields

step: usize

pending_nodes: Vec<String>

Done

Graph execution completed

Fields

state: State

total_steps: usize

Error

Error occurred

Fields

message: String

node: Option<String>

RouteDispatched

Emitted when dynamic route dispatch occurs.

Fields

source: String

targets: Vec<String>

Implementations

impl StreamEvent

pub fn state(state: State, step: usize) -> Self

Create a state event

pub fn updates(node: &str, updates: HashMap<String, Value>) -> Self

Create an updates event

pub fn message(node: &str, content: &str, is_final: bool) -> Self

Create a message event

pub fn custom(node: &str, event_type: &str, data: Value) -> Self

Create a custom event

pub fn debug(event_type: &str, data: Value) -> Self

Create a debug event

pub fn node_start(node: &str, step: usize) -> Self

Create a node start event

pub fn node_end(node: &str, step: usize, duration_ms: u64) -> Self

Create a node end event

pub fn step_complete(step: usize, nodes_executed: Vec<String>) -> Self

Create a step complete event

pub fn interrupted(node: &str, message: &str) -> Self

Create an interrupted event

pub fn resumed(step: usize, pending_nodes: Vec<String>) -> Self

Create a resumed event

pub fn done(state: State, total_steps: usize) -> Self

Create a done event

pub fn error(message: &str, node: Option<&str>) -> Self

Create an error event

pub fn node_interrupt(node: &str, message: &str, data: Option<Value>) -> Self

Create an event reporting that a node asked to pause.

pub fn route_dispatched(source: &str, targets: Vec<String>) -> Self

Create a route dispatched event

Trait Implementations

impl Clone for StreamEvent

fn clone(&self) -> StreamEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StreamEvent

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

Formats the value using the given formatter.

impl Serialize for StreamEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.