use crate::core::state_graph::StateGraph;
use crate::{AgentNode, AgentState, LangGraphError};
use futures::future::join_all;
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::mpsc::{Sender, channel};
use tokio_stream::wrappers::ReceiverStream;
const STREAM_CHANNEL_CAPACITY: usize = 32;
#[derive(Debug)]
pub enum StreamEvent<S: AgentState + Send + Sync> {
WorkflowStarted,
StepStarted {
step: usize,
nodes: Vec<String>,
},
NodeStarted {
step: usize,
name: String,
},
NodeFinished {
step: usize,
name: String,
elapsed: Duration,
},
RoutingDecision {
step: usize,
from_nodes: Vec<String>,
to_nodes: Vec<String>,
},
WorkflowFinished {
state: Arc<S>,
total_steps: usize,
elapsed: Duration,
},
WorkflowError {
state: Arc<S>,
step: usize,
error: LangGraphError,
},
}
async fn fail<S: AgentState + Send + Sync>(
tx: &Sender<StreamEvent<S>>,
state: &Arc<S>,
step: usize,
error: LangGraphError,
) -> Result<(), ()> {
let _ = tx
.send(StreamEvent::WorkflowError {
state: Arc::clone(state),
step,
error,
})
.await;
Err(())
}
async fn emit<S: AgentState + Send + Sync>(
tx: &Sender<StreamEvent<S>>,
event: StreamEvent<S>,
) -> Result<(), ()> {
tx.send(event).await.map_err(|_| ())
}
async fn run_node_with_events<S: AgentState + Send + Sync>(
tx: &Sender<StreamEvent<S>>,
name: String,
node: &dyn AgentNode<S>,
state: Arc<S>,
step: usize,
) -> Result<(), LangGraphError> {
let _ = tx
.send(StreamEvent::NodeStarted {
step,
name: name.clone(),
})
.await;
let started = Instant::now();
let result = node.apply(state).await;
let _ = tx
.send(StreamEvent::NodeFinished {
step,
name,
elapsed: started.elapsed(),
})
.await;
result
}
async fn batch_apply_with_events<S: AgentState + Send + Sync>(
tx: &Sender<StreamEvent<S>>,
node_names: &[String],
nodes: Vec<&dyn AgentNode<S>>,
state: Arc<S>,
step: usize,
) -> Result<(), LangGraphError> {
let futures = node_names
.iter()
.zip(nodes)
.map(|(name, node)| run_node_with_events(tx, name.clone(), node, Arc::clone(&state), step));
for result in join_all(futures).await {
result?; }
Ok(())
}
async fn run_driver<S: AgentState + Send + Sync + 'static>(
graph: Arc<StateGraph<S>>,
state: Arc<S>,
tx: Sender<StreamEvent<S>>,
) -> Result<(), ()> {
let start_time = Instant::now();
let mut current = graph.start_nodes.clone();
let mut step_count: usize = 0;
let max_steps = graph.max_steps;
let mut reached_end = false;
emit(&tx, StreamEvent::WorkflowStarted).await?;
loop {
if step_count >= max_steps {
break;
}
step_count += 1;
if graph.is_end_node(¤t) {
current.remove(&graph.end_node);
reached_end = true;
}
if current.is_empty() {
break;
}
let node_names: Vec<String> = current.iter().cloned().collect();
let nodes = match graph.get_node_by_keys(¤t) {
Ok(n) => n,
Err(e) => return fail(&tx, &state, step_count, e).await,
};
if !nodes.is_empty() {
emit(
&tx,
StreamEvent::StepStarted {
step: step_count,
nodes: node_names.clone(),
},
)
.await?;
state.snapshot(step_count, node_names.clone()).await?;
if let Err(e) =
batch_apply_with_events(&tx, &node_names, nodes, Arc::clone(&state), step_count)
.await
{
return fail(&tx, &state, step_count, e).await;
}
}
let next = match graph.get_next_node_key(¤t, state.as_ref()) {
Ok(n) => n,
Err(e) => return fail(&tx, &state, step_count, e).await,
};
emit(
&tx,
StreamEvent::RoutingDecision {
step: step_count,
from_nodes: current.iter().cloned().collect(),
to_nodes: next.iter().cloned().collect(),
},
)
.await?;
current = next;
}
if !reached_end {
return fail(
&tx,
&state,
step_count,
LangGraphError::GraphError(format!(
"Reached max_steps ({}) without hitting the end node; the graph likely contains a cycle",
max_steps
)),
)
.await;
}
let _ = tx
.send(StreamEvent::WorkflowFinished {
state: Arc::clone(&state),
total_steps: step_count,
elapsed: start_time.elapsed(),
})
.await;
Ok(())
}
impl<S: AgentState + Send + Sync + 'static> StateGraph<S> {
pub fn stream(self: Arc<Self>, state: Arc<S>) -> ReceiverStream<StreamEvent<S>> {
let (tx, rx) = channel::<StreamEvent<S>>(STREAM_CHANNEL_CAPACITY);
tokio::spawn(async move {
let _ = run_driver(self, state, tx).await;
});
ReceiverStream::new(rx)
}
}