1use indexmap::IndexMap;
8use serde::{Deserialize, Serialize};
9
10use crate::pool::Selector;
11use crate::snapshot::Snapshot;
12use crate::value::Value;
13
14pub type FrameId = std::sync::Arc<str>;
18
19#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
21pub struct Usage {
22 pub prompt_tokens: u64,
23 pub completion_tokens: u64,
24 pub total_tokens: u64,
25}
26
27impl Usage {
28 pub fn add(&mut self, other: &Usage) {
29 self.prompt_tokens = self.prompt_tokens.saturating_add(other.prompt_tokens);
30 self.completion_tokens = self.completion_tokens.saturating_add(other.completion_tokens);
31 self.total_tokens = self.total_tokens.saturating_add(other.total_tokens);
32 }
33
34 pub fn is_zero(&self) -> bool {
35 self.total_tokens == 0 && self.prompt_tokens == 0 && self.completion_tokens == 0
36 }
37}
38
39#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
41pub struct PauseReason {
42 pub frame: FrameId,
44 pub node_id: Option<String>,
46 pub kind: String,
48 #[serde(default)]
50 pub data: Value,
51}
52
53#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
55#[serde(tag = "type", rename_all = "snake_case")]
56#[non_exhaustive]
57pub enum Event {
58 RunStarted {
59 run_id: String,
60 resumed: bool,
61 },
62 NodeStarted {
63 frame: FrameId,
64 node_id: std::sync::Arc<str>,
65 exec_id: std::sync::Arc<str>,
66 kind: std::sync::Arc<str>,
67 title: std::sync::Arc<str>,
68 attempt: u32,
69 },
70 NodeChunk {
72 frame: FrameId,
73 node_id: std::sync::Arc<str>,
74 exec_id: std::sync::Arc<str>,
75 field: String,
76 chunk: String,
77 },
78 NodeProgress {
80 frame: FrameId,
81 node_id: std::sync::Arc<str>,
82 exec_id: std::sync::Arc<str>,
83 name: String,
84 data: Value,
85 },
86 NodeRetry {
87 frame: FrameId,
88 node_id: std::sync::Arc<str>,
89 exec_id: std::sync::Arc<str>,
90 attempt: u32,
91 error: String,
92 delay_ms: u64,
93 },
94 NodeSucceeded {
95 frame: FrameId,
96 node_id: std::sync::Arc<str>,
97 exec_id: std::sync::Arc<str>,
98 outputs: IndexMap<String, Value>,
99 #[serde(skip_serializing_if = "Option::is_none")]
101 branch: Option<String>,
102 #[serde(skip_serializing_if = "Option::is_none")]
103 usage: Option<Usage>,
104 #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
105 metadata: IndexMap<String, Value>,
106 elapsed_ms: u64,
107 },
108 NodeFailed {
110 frame: FrameId,
111 node_id: std::sync::Arc<str>,
112 exec_id: std::sync::Arc<str>,
113 error: String,
114 error_type: String,
115 handled: bool,
116 #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
117 outputs: IndexMap<String, Value>,
118 elapsed_ms: u64,
119 },
120 NodeSkipped {
122 frame: FrameId,
123 node_id: std::sync::Arc<str>,
124 },
125 NodePaused {
126 frame: FrameId,
127 node_id: std::sync::Arc<str>,
128 exec_id: std::sync::Arc<str>,
129 reason: PauseReason,
130 },
131 VariableUpdated {
133 frame: FrameId,
134 node_id: std::sync::Arc<str>,
135 selector: Selector,
136 value: Value,
137 },
138 RunSucceeded {
139 outputs: IndexMap<String, Value>,
140 usage: Usage,
141 handled_errors: u32,
143 elapsed_ms: u64,
144 },
145 RunFailed {
146 error: String,
147 #[serde(default)]
152 error_type: String,
153 usage: Usage,
154 elapsed_ms: u64,
155 },
156 RunAborted {
157 reason: String,
158 elapsed_ms: u64,
159 },
160 RunPaused {
162 reasons: Vec<PauseReason>,
163 snapshot: Box<Snapshot>,
164 },
165}
166
167impl Event {
168 pub fn is_terminal(&self) -> bool {
170 matches!(
171 self,
172 Event::RunSucceeded { .. } | Event::RunFailed { .. } | Event::RunAborted { .. } | Event::RunPaused { .. }
173 )
174 }
175
176 pub fn frame(&self) -> Option<&FrameId> {
178 match self {
179 Event::NodeStarted { frame, .. }
180 | Event::NodeChunk { frame, .. }
181 | Event::NodeProgress { frame, .. }
182 | Event::NodeRetry { frame, .. }
183 | Event::NodeSucceeded { frame, .. }
184 | Event::NodeFailed { frame, .. }
185 | Event::NodeSkipped { frame, .. }
186 | Event::NodePaused { frame, .. }
187 | Event::VariableUpdated { frame, .. } => Some(frame),
188 _ => None,
189 }
190 }
191}