use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use crate::pool::Selector;
use crate::snapshot::Snapshot;
use crate::value::Value;
pub type FrameId = std::sync::Arc<str>;
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct Usage {
pub prompt_tokens: u64,
pub completion_tokens: u64,
pub total_tokens: u64,
}
impl Usage {
pub fn add(&mut self, other: &Usage) {
self.prompt_tokens = self.prompt_tokens.saturating_add(other.prompt_tokens);
self.completion_tokens = self.completion_tokens.saturating_add(other.completion_tokens);
self.total_tokens = self.total_tokens.saturating_add(other.total_tokens);
}
pub fn is_zero(&self) -> bool {
self.total_tokens == 0 && self.prompt_tokens == 0 && self.completion_tokens == 0
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PauseReason {
pub frame: FrameId,
pub node_id: Option<String>,
pub kind: String,
#[serde(default)]
pub data: Value,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
#[non_exhaustive]
pub enum Event {
RunStarted {
run_id: String,
resumed: bool,
},
NodeStarted {
frame: FrameId,
node_id: String,
exec_id: String,
kind: String,
title: String,
attempt: u32,
},
NodeChunk {
frame: FrameId,
node_id: String,
exec_id: String,
field: String,
chunk: String,
},
NodeProgress {
frame: FrameId,
node_id: String,
exec_id: String,
name: String,
data: Value,
},
NodeRetry {
frame: FrameId,
node_id: String,
exec_id: String,
attempt: u32,
error: String,
delay_ms: u64,
},
NodeSucceeded {
frame: FrameId,
node_id: String,
exec_id: String,
outputs: IndexMap<String, Value>,
#[serde(skip_serializing_if = "Option::is_none")]
branch: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
usage: Option<Usage>,
#[serde(default, skip_serializing_if = "IndexMap::is_empty")]
metadata: IndexMap<String, Value>,
elapsed_ms: u64,
},
NodeFailed {
frame: FrameId,
node_id: String,
exec_id: String,
error: String,
error_type: String,
handled: bool,
#[serde(default, skip_serializing_if = "IndexMap::is_empty")]
outputs: IndexMap<String, Value>,
elapsed_ms: u64,
},
NodeSkipped {
frame: FrameId,
node_id: String,
},
NodePaused {
frame: FrameId,
node_id: String,
exec_id: String,
reason: PauseReason,
},
VariableUpdated {
frame: FrameId,
node_id: String,
selector: Selector,
value: Value,
},
RunSucceeded {
outputs: IndexMap<String, Value>,
usage: Usage,
handled_errors: u32,
elapsed_ms: u64,
},
RunFailed {
error: String,
#[serde(default)]
error_type: String,
usage: Usage,
elapsed_ms: u64,
},
RunAborted {
reason: String,
elapsed_ms: u64,
},
RunPaused {
reasons: Vec<PauseReason>,
snapshot: Box<Snapshot>,
},
}
impl Event {
pub fn is_terminal(&self) -> bool {
matches!(
self,
Event::RunSucceeded { .. } | Event::RunFailed { .. } | Event::RunAborted { .. } | Event::RunPaused { .. }
)
}
pub fn frame(&self) -> Option<&FrameId> {
match self {
Event::NodeStarted { frame, .. }
| Event::NodeChunk { frame, .. }
| Event::NodeProgress { frame, .. }
| Event::NodeRetry { frame, .. }
| Event::NodeSucceeded { frame, .. }
| Event::NodeFailed { frame, .. }
| Event::NodeSkipped { frame, .. }
| Event::NodePaused { frame, .. }
| Event::VariableUpdated { frame, .. } => Some(frame),
_ => None,
}
}
}