1use aether_core::events::{
2 AgentEvent, CompactionOutcome, ContextEvent, LlmCallOutcome, MessageEvent, ModelEvent, ToolEvent, TurnEvent,
3 TurnOutcome,
4};
5use schemars::JsonSchema;
6use serde::{Deserialize, Serialize};
7
8#[derive(Clone, Copy, PartialEq, Eq, Debug, clap::ValueEnum, Deserialize, Serialize, JsonSchema)]
9#[serde(rename_all = "lowercase")]
10pub enum OutputFormat {
11 Text,
12 Pretty,
13 Json,
14}
15
16pub(crate) fn print_message(format: OutputFormat, message: &AgentEvent) -> Result<(), serde_json::Error> {
17 match format {
18 OutputFormat::Text => {
19 if let Some(text) = format_text(message) {
20 if matches!(message, AgentEvent::Turn(TurnEvent::Ended { outcome: TurnOutcome::Failed { .. } })) {
21 eprintln!("{text}");
22 } else {
23 println!("{text}");
24 }
25 }
26 }
27 OutputFormat::Pretty => println!("{}", serde_json::to_string_pretty(message)?),
28 OutputFormat::Json => println!("{}", serde_json::to_string(message)?),
29 }
30
31 Ok(())
32}
33
34fn format_text(message: &AgentEvent) -> Option<String> {
35 match message {
36 AgentEvent::Message(MessageEvent::Text { chunk, is_complete: true, .. }) => Some(chunk.clone()),
37 AgentEvent::Message(MessageEvent::Thought { chunk, is_complete: true, .. }) => {
38 Some(format!("Thought: {chunk}"))
39 }
40 AgentEvent::Tool(ToolEvent::Call { request, .. }) => {
41 Some(format!("Tool call: {}({})", request.name, request.arguments))
42 }
43 AgentEvent::Tool(ToolEvent::Result { result, .. }) => {
44 Some(format!("Tool result [{}]: {}", result.name, result.result))
45 }
46 AgentEvent::Tool(ToolEvent::Error { error, .. }) => {
47 Some(format!("Tool error [{}]: {}", error.name, error.error))
48 }
49 AgentEvent::Tool(ToolEvent::TaskStatus { request, task_id, status, status_message }) => Some(format!(
50 "Task status [{}]: {} {}{}",
51 request.name,
52 task_id,
53 status,
54 status_message.as_deref().map(|message| format!(" - {message}")).unwrap_or_default()
55 )),
56 AgentEvent::Tool(ToolEvent::TaskCreated { request, task_id, .. }) => {
57 Some(format!("Tool deferred [{}]: task {}", request.name, task_id))
58 }
59 AgentEvent::Tool(ToolEvent::TaskCompleted { request, task_id, result, .. }) => {
60 Some(format!("Background task completed [{}]: {}: {}", request.name, task_id, result.result))
61 }
62 AgentEvent::Tool(ToolEvent::TaskFailed { request, task_id, error, .. }) => {
63 Some(format!("Background task failed [{}]: {}: {}", request.name, task_id, error.error))
64 }
65 AgentEvent::Tool(ToolEvent::TaskCancelled { request, task_id, .. }) => {
66 Some(format!("Background task cancelled [{}]: {task_id}", request.name))
67 }
68 AgentEvent::Turn(TurnEvent::Ended { outcome }) => Some(match outcome {
69 TurnOutcome::Completed => "Done".to_string(),
70 TurnOutcome::Cancelled => "Cancelled".to_string(),
71 TurnOutcome::Failed { error, .. } => format!("Error: {error}"),
72 }),
73 AgentEvent::Turn(TurnEvent::AutoContinue { attempt, max_attempts, .. }) => {
74 Some(format!("Continuing ({attempt}/{max_attempts})..."))
75 }
76 AgentEvent::Turn(event @ TurnEvent::RetryScheduled { .. }) => event
77 .retry_info()
78 .map(|retry| format!("Retrying ({}/{}) in {}ms", retry.attempt, retry.max_attempts, retry.delay_ms)),
79 AgentEvent::Turn(TurnEvent::LlmCallEnded {
80 outcome: LlmCallOutcome::Failed { error, will_retry: true, .. },
81 ..
82 }) => Some(format!("LLM call failed (will retry): {error}")),
83 AgentEvent::Model(ModelEvent::Switched { previous, new }) => {
84 Some(format!("Model switched: {previous} -> {new}"))
85 }
86 AgentEvent::Tool(ToolEvent::Progress { request, progress, total, message }) => {
87 let bar = total.map_or_else(|| progress.to_string(), |total| format!("{progress}/{total}"));
88 let suffix = message.as_deref().map(|message| format!(" - {message}")).unwrap_or_default();
89 Some(format!("Tool progress [{}]: {bar}{suffix}", request.name))
90 }
91 AgentEvent::Tool(ToolEvent::DisplayUpdate { request, meta }) => {
92 Some(format!("Tool progress [{}]: {} - {}", request.name, meta.display.title, meta.display.value))
93 }
94 AgentEvent::Tool(ToolEvent::SubAgentProgress { payload, .. }) => match &payload.event {
95 AgentEvent::SessionUsage(_) => None,
96 event => {
97 format_text(event).map(|text| format!("Sub-agent {} [{}]: {text}", payload.agent_name, payload.task_id))
98 }
99 },
100 AgentEvent::Context(ContextEvent::CompactionStarted { message_count, .. }) => {
101 Some(format!("Context compaction started ({message_count} messages)"))
102 }
103 AgentEvent::Context(ContextEvent::CompactionEnded { outcome, .. }) => Some(match outcome {
104 CompactionOutcome::Completed => "Context compaction completed".to_string(),
105 CompactionOutcome::Failed { error } => format!("Context compaction failed: {error}"),
106 CompactionOutcome::Cancelled => "Context compaction cancelled".to_string(),
107 }),
108 AgentEvent::Context(ContextEvent::CompactionResult { summary, messages_removed, .. }) => {
109 Some(format!("Context compacted: {messages_removed} messages removed. {summary}"))
110 }
111 AgentEvent::Context(ContextEvent::UsageUpdated { usage }) => Some(format_context_usage(usage)),
112 AgentEvent::Context(ContextEvent::Cleared) => Some("Context cleared".to_string()),
113 AgentEvent::SessionUsage(usage) => Some(format_session_usage(usage)),
114 AgentEvent::Turn(
115 TurnEvent::Started { .. }
116 | TurnEvent::UserMessageInserted { .. }
117 | TurnEvent::UserMessageDiscarded { .. }
118 | TurnEvent::LlmCallStarted { .. }
119 | TurnEvent::LlmCallEnded {
120 outcome:
121 LlmCallOutcome::Completed { .. }
122 | LlmCallOutcome::Cancelled
123 | LlmCallOutcome::Failed { will_retry: false, .. },
124 ..
125 },
126 )
127 | AgentEvent::Tool(
128 ToolEvent::InputStarted { .. } | ToolEvent::InputDelta { .. } | ToolEvent::DefinitionsUpdated { .. },
129 )
130 | AgentEvent::Message(MessageEvent::Text { .. } | MessageEvent::Thought { .. }) => None,
131 }
132}
133
134fn format_context_usage(usage: &llm::ContextUsage) -> String {
135 match (usage.context_limit, usage.usage_ratio) {
136 (Some(limit), Some(ratio)) => {
137 format!("Context: {} / {limit} tokens ({:.1}%)", usage.input_tokens, ratio * 100.0)
138 }
139 _ => format!("Context: {} tokens", usage.input_tokens),
140 }
141}
142
143fn format_session_usage(usage: &llm::SessionUsageEvent) -> String {
144 let call_cost =
145 usage.estimated_cost.map_or_else(|| "unknown".to_string(), |cost| format!("${:.6}", cost.total_usd));
146 let totals = &usage.totals;
147 let cumulative_cost = if totals.is_fully_priced() {
148 format!("estimated total: ${:.6}", totals.estimated_usd)
149 } else {
150 format!("known subtotal: ${:.6}, {} unpriced calls", totals.estimated_usd, totals.unpriced_calls)
151 };
152 format!(
153 "Session usage #{} [{}]: {} in, {} out (call cost: {}, cumulative: {} tokens, {})",
154 usage.sequence,
155 usage.source.agent_name,
156 usage.tokens.input_tokens,
157 usage.tokens.output_tokens,
158 call_cost,
159 totals.tokens.total_tokens(),
160 cumulative_cost,
161 )
162}
163
164#[cfg(test)]
165mod tests {
166 use super::*;
167 use aether_core::events::StreamState;
168
169 #[test]
170 fn format_text_formats_complete_text() {
171 assert_eq!(
172 format_text(&AgentEvent::text("id", "hello world", StreamState::Complete)),
173 Some("hello world".to_string())
174 );
175 }
176
177 #[test]
178 fn format_text_skips_incomplete_text() {
179 assert_eq!(format_text(&AgentEvent::text("id", "partial", StreamState::Partial)), None);
180 }
181
182 #[test]
183 fn format_text_formats_complete_thought() {
184 assert_eq!(
185 format_text(&AgentEvent::thought("id", "reasoning here", StreamState::Complete)),
186 Some("Thought: reasoning here".to_string())
187 );
188 }
189
190 #[test]
191 fn format_text_skips_incomplete_thought() {
192 assert_eq!(format_text(&AgentEvent::thought("id", "partial", StreamState::Partial)), None);
193 }
194
195 #[test]
196 fn format_text_formats_tool_call() {
197 let message = AgentEvent::Tool(ToolEvent::Call {
198 request: llm::ToolCallRequest {
199 id: "tc1".to_string(),
200 name: "bash".to_string(),
201 arguments: r#"{"cmd":"ls"}"#.to_string(),
202 },
203 });
204 assert_eq!(format_text(&message), Some(r#"Tool call: bash({"cmd":"ls"})"#.to_string()));
205 }
206
207 #[test]
208 fn format_text_skips_streamed_tool_input() {
209 let started = AgentEvent::Tool(ToolEvent::InputStarted { id: "tc1".to_string(), name: "bash".to_string() });
210 let delta = AgentEvent::Tool(ToolEvent::InputDelta { id: "tc1".to_string(), chunk: "partial".to_string() });
211 assert_eq!(format_text(&started), None);
212 assert_eq!(format_text(&delta), None);
213 }
214
215 #[test]
216 fn format_text_formats_tool_result() {
217 assert_eq!(format_text(&tool_result()), Some("Tool result [bash]: ok".to_string()));
218 }
219
220 #[test]
221 fn format_text_formats_tool_error() {
222 let message = AgentEvent::Tool(ToolEvent::Error {
223 error: llm::ToolCallError {
224 id: "tc1".to_string(),
225 name: "bash".to_string(),
226 arguments: None,
227 error: "not found".to_string(),
228 },
229 });
230 assert_eq!(format_text(&message), Some("Tool error [bash]: not found".to_string()));
231 }
232
233 #[test]
234 fn format_text_formats_turn_outcomes() {
235 assert_eq!(
236 format_text(&AgentEvent::Turn(TurnEvent::Ended { outcome: TurnOutcome::failed("boom") })),
237 Some("Error: boom".to_string())
238 );
239 assert_eq!(format_text(&AgentEvent::turn_ended(TurnOutcome::Cancelled)), Some("Cancelled".to_string()));
240 assert_eq!(format_text(&AgentEvent::turn_ended(TurnOutcome::Completed)), Some("Done".to_string()));
241 }
242
243 #[test]
244 fn format_text_formats_retry_events() {
245 let started = AgentEvent::Turn(TurnEvent::LlmCallStarted {
246 purpose: llm::LlmCallPurpose::Chat,
247 model: llm::ModelIdentity::default(),
248 display_name: "test".to_string(),
249 attempt: 0,
250 max_attempts: 3,
251 });
252 assert_eq!(format_text(&started), None);
253 assert_eq!(format_text(&retry_scheduled()), Some("Retrying (1/3) in 10ms".to_string()));
254 let retrying = AgentEvent::Turn(TurnEvent::LlmCallEnded {
255 purpose: llm::LlmCallPurpose::Chat,
256 outcome: LlmCallOutcome::failed("overloaded", true),
257 });
258 assert_eq!(format_text(&retrying), Some("LLM call failed (will retry): overloaded".to_string()));
259 let terminal = AgentEvent::Turn(TurnEvent::LlmCallEnded {
260 purpose: llm::LlmCallPurpose::Chat,
261 outcome: LlmCallOutcome::failed("boom", false),
262 });
263 assert_eq!(format_text(&terminal), None);
264 }
265
266 #[test]
267 fn format_text_formats_auto_continue_and_model_switch() {
268 let continuing = AgentEvent::Turn(TurnEvent::AutoContinue {
269 attempt: 2,
270 max_attempts: 5,
271 message_id: llm::MessageId::new(),
272 content: vec![],
273 });
274 assert_eq!(format_text(&continuing), Some("Continuing (2/5)...".to_string()));
275 let switched =
276 AgentEvent::Model(ModelEvent::Switched { previous: "old-model".to_string(), new: "new-model".to_string() });
277 assert_eq!(format_text(&switched), Some("Model switched: old-model -> new-model".to_string()));
278 }
279
280 #[test]
281 fn format_text_formats_tool_progress() {
282 assert_eq!(
283 format_text(&tool_progress(50.0, Some(100.0), Some("halfway"))),
284 Some("Tool progress [bash]: 50/100 - halfway".to_string())
285 );
286 assert_eq!(format_text(&tool_progress(42.0, None, None)), Some("Tool progress [bash]: 42".to_string()));
287 }
288
289 #[test]
290 fn format_text_formats_context_events() {
291 let started = AgentEvent::Context(ContextEvent::CompactionStarted {
292 compaction_id: "compaction".into(),
293 message_count: 42,
294 });
295 assert_eq!(format_text(&started), Some("Context compaction started (42 messages)".to_string()));
296 let result = AgentEvent::Context(ContextEvent::CompactionResult {
297 compaction_id: "compaction".into(),
298 message_id: llm::MessageId::new(),
299 summary: "summary here".to_string(),
300 messages_removed: 10,
301 });
302 assert_eq!(format_text(&result), Some("Context compacted: 10 messages removed. summary here".to_string()));
303 assert_eq!(format_text(&usage_update()), Some("Context: 100000 / 200000 tokens (50.0%)".to_string()));
304 assert_eq!(format_text(&AgentEvent::Context(ContextEvent::Cleared)), Some("Context cleared".to_string()));
305 }
306
307 fn tool_result() -> AgentEvent {
308 AgentEvent::Tool(ToolEvent::Result {
309 result: llm::ToolCallResult {
310 id: "tc1".to_string(),
311 name: "bash".to_string(),
312 arguments: "{}".to_string(),
313 result: "ok".to_string(),
314 },
315 result_meta: None,
316 })
317 }
318
319 fn tool_progress(progress: f64, total: Option<f64>, message: Option<&str>) -> AgentEvent {
320 AgentEvent::Tool(ToolEvent::Progress {
321 request: llm::ToolCallRequest {
322 id: "tc1".to_string(),
323 name: "bash".to_string(),
324 arguments: "{}".to_string(),
325 },
326 progress,
327 total,
328 message: message.map(str::to_string),
329 })
330 }
331
332 fn retry_scheduled() -> AgentEvent {
333 AgentEvent::Turn(TurnEvent::RetryScheduled {
334 purpose: llm::LlmCallPurpose::Chat,
335 attempt: 1,
336 max_attempts: 3,
337 delay_ms: 10,
338 })
339 }
340
341 fn usage_update() -> AgentEvent {
342 AgentEvent::Context(ContextEvent::UsageUpdated {
343 usage: llm::ContextUsage {
344 input_tokens: 100_000.into(),
345 context_limit: Some(200_000.into()),
346 usage_ratio: Some(0.5),
347 },
348 })
349 }
350}