phi_agent/render/
json_stream.rs

1use std::io::{self, Write};
2
3use agent_base::{AgentResult, RuntimeEvent, UserEvent};
4use serde_json::{Value, json};
5
6use crate::render::EventRenderer;
7
8/// JSON stream renderer: outputs one JSON line per event (JSONL format).
9/// Suitable for IDE integrations and programmatic consumers.
10pub struct JsonStreamRenderer {
11    writer: Box<dyn Write + Send>,
12    turn_start: Option<std::time::Instant>,
13    tool_call_count: u32,
14    last_assistant_text: String,
15}
16
17impl JsonStreamRenderer {
18    /// Create a new JSON stream renderer writing to the given writer.
19    pub fn new(writer: Box<dyn Write + Send>) -> Self {
20        Self { writer, turn_start: None, tool_call_count: 0, last_assistant_text: String::new() }
21    }
22
23    /// Create a renderer that writes to stdout.
24    pub fn stdout() -> Self {
25        Self::new(Box::new(io::stdout()))
26    }
27
28    fn emit(&mut self, value: &Value) -> AgentResult<()> {
29        let line = serde_json::to_string(value)
30            .map_err(|e| agent_base::AgentError::internal(format!("JSON serialize error: {e}")))?;
31        writeln!(self.writer, "{}", line).map_err(|e| agent_base::AgentError::internal(format!("write error: {e}")))?;
32        Ok(())
33    }
34}
35
36impl EventRenderer for JsonStreamRenderer {
37    fn render(&mut self, event: RuntimeEvent) -> AgentResult<()> {
38        if self.turn_start.is_none() {
39            self.turn_start = Some(std::time::Instant::now());
40        }
41
42        match &event {
43            RuntimeEvent::ThoughtDelta { text, .. } => {
44                self.emit(&json!({ "type": "thought_delta", "text": text }))?;
45            },
46            RuntimeEvent::TextDelta { text, .. } => {
47                self.last_assistant_text.push_str(text);
48                self.emit(&json!({ "type": "text_delta", "text": text }))?;
49            },
50            RuntimeEvent::ToolCallStarted { tool_name, args_json, .. } => {
51                self.tool_call_count += 1;
52                let args: Value = serde_json::from_str(args_json).unwrap_or(Value::Null);
53                self.emit(&json!({
54                    "type": "tool_call_started",
55                    "tool": tool_name,
56                    "args": args,
57                }))?;
58            },
59            RuntimeEvent::ToolCallFinished { tool_name, summary, .. } => {
60                self.emit(&json!({
61                    "type": "tool_call_finished",
62                    "tool": tool_name,
63                    "summary": summary,
64                }))?;
65            },
66            RuntimeEvent::AwaitingApproval { request, .. } => {
67                self.emit(&json!({
68                    "type": "approval_request",
69                    "title": request.title,
70                    "risk": format!("{:?}", request.risk_level),
71                    "message": request.message,
72                }))?;
73            },
74            RuntimeEvent::PlanUpdated { explanation, plan, .. } => {
75                self.emit(&json!({
76                    "type": "plan_updated",
77                    "explanation": explanation,
78                    "plan": plan,
79                }))?;
80            },
81            RuntimeEvent::UserEvent { event: UserEvent::Structured { event_type, data }, .. } => {
82                self.emit(&json!({
83                    "type": "user_event",
84                    "event_type": event_type,
85                    "data": data,
86                }))?;
87            },
88            RuntimeEvent::UserEvent { .. } => {},
89            RuntimeEvent::Checkpoint { .. } => {},
90            RuntimeEvent::RunFinished { .. } => {},
91            RuntimeEvent::RunCancelled { .. } => {
92                self.emit(&json!({ "type": "run_cancelled" }))?;
93            },
94        }
95
96        Ok(())
97    }
98
99    fn finish_turn(&mut self) -> AgentResult<()> {
100        let duration_ms = self.turn_start.map(|s| s.elapsed().as_millis() as u64).unwrap_or(0);
101
102        self.emit(&json!({
103            "type": "turn_finished",
104            "duration_ms": duration_ms,
105            "tool_call_count": self.tool_call_count,
106            "assistant_text": self.last_assistant_text.trim(),
107        }))?;
108
109        self.turn_start = None;
110        self.tool_call_count = 0;
111        self.last_assistant_text.clear();
112
113        Ok(())
114    }
115}
116
117#[cfg(test)]
118mod tests {
119    use super::*;
120    use agent_base::{ApprovalRequest, PlanItem, PlanStepStatus, RiskLevel, SessionId, UserEvent};
121    use std::io::Write;
122    use std::sync::{Arc, Mutex};
123
124    struct SharedWriter {
125        inner: Arc<Mutex<Vec<u8>>>,
126    }
127
128    impl Write for SharedWriter {
129        fn write(&mut self, data: &[u8]) -> std::io::Result<usize> {
130            self.inner.lock().unwrap().extend_from_slice(data);
131            Ok(data.len())
132        }
133        fn flush(&mut self) -> std::io::Result<()> {
134            Ok(())
135        }
136    }
137
138    impl SharedWriter {
139        fn new() -> (Self, Arc<Mutex<Vec<u8>>>) {
140            let inner = Arc::new(Mutex::new(Vec::new()));
141            (Self { inner: inner.clone() }, inner)
142        }
143    }
144
145    fn session_id() -> SessionId {
146        SessionId { id: 1, external_id: None }
147    }
148
149    fn render_one(event: RuntimeEvent) -> Vec<String> {
150        let (writer, buf) = SharedWriter::new();
151        let mut r = JsonStreamRenderer::new(Box::new(writer));
152        r.render(event).unwrap();
153        drop(r);
154        let text = String::from_utf8(buf.lock().unwrap().clone()).unwrap();
155        if text.is_empty() { vec![] } else { text.lines().map(|l| l.to_string()).collect() }
156    }
157
158    fn render_and_finish(events: &[RuntimeEvent]) -> Vec<String> {
159        let (writer, buf) = SharedWriter::new();
160        let mut r = JsonStreamRenderer::new(Box::new(writer));
161        for e in events {
162            r.render(e.clone()).unwrap();
163        }
164        r.finish_turn().unwrap();
165        drop(r);
166        let text = String::from_utf8(buf.lock().unwrap().clone()).unwrap();
167        text.lines().map(|l| l.to_string()).collect()
168    }
169
170    #[test]
171    fn test_text_delta_produces_valid_json() {
172        let lines = render_one(RuntimeEvent::TextDelta { session_id: session_id(), text: "hello".into() });
173        assert_eq!(lines.len(), 1);
174        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
175        assert_eq!(v["type"], "text_delta");
176        assert_eq!(v["text"], "hello");
177    }
178
179    #[test]
180    fn test_thought_delta_produces_valid_json() {
181        let lines = render_one(RuntimeEvent::ThoughtDelta { session_id: session_id(), text: "thinking...".into() });
182        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
183        assert_eq!(v["type"], "thought_delta");
184    }
185
186    #[test]
187    fn test_tool_call_started_parses_args() {
188        let lines = render_one(RuntimeEvent::ToolCallStarted {
189            session_id: session_id(),
190            tool_name: "shell".into(),
191            args_json: r#"{"cmd":"ls"}"#.into(),
192        });
193        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
194        assert_eq!(v["type"], "tool_call_started");
195        assert_eq!(v["tool"], "shell");
196        assert_eq!(v["args"]["cmd"], "ls");
197    }
198
199    #[test]
200    fn test_tool_call_finished_produces_valid_json() {
201        let lines = render_one(RuntimeEvent::ToolCallFinished {
202            session_id: session_id(),
203            tool_name: "shell".into(),
204            summary: "done".into(),
205        });
206        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
207        assert_eq!(v["type"], "tool_call_finished");
208        assert_eq!(v["tool"], "shell");
209        assert_eq!(v["summary"], "done");
210    }
211
212    #[test]
213    fn test_awaiting_approval_produces_valid_json() {
214        let lines = render_one(RuntimeEvent::AwaitingApproval {
215            session_id: session_id(),
216            request: ApprovalRequest {
217                title: "Delete".into(),
218                message: "Dangerous".into(),
219                action_key: None,
220                risk_level: RiskLevel::Destructive,
221                raw: None,
222            },
223        });
224        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
225        assert_eq!(v["type"], "approval_request");
226        assert_eq!(v["title"], "Delete");
227    }
228
229    #[test]
230    fn test_plan_updated_produces_valid_json() {
231        let lines = render_one(RuntimeEvent::PlanUpdated {
232            session_id: session_id(),
233            objective: "test".into(),
234            explanation: Some("step 1 done".into()),
235            plan: vec![PlanItem { step: "Step 1".into(), status: PlanStepStatus::Completed }],
236        });
237        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
238        assert_eq!(v["type"], "plan_updated");
239    }
240
241    #[test]
242    fn test_user_event_structured() {
243        let lines = render_one(RuntimeEvent::UserEvent {
244            session_id: session_id(),
245            event: UserEvent::Structured { event_type: "custom".into(), data: serde_json::json!({"key": "value"}) },
246        });
247        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
248        assert_eq!(v["type"], "user_event");
249        assert_eq!(v["event_type"], "custom");
250        assert_eq!(v["data"]["key"], "value");
251    }
252
253    #[test]
254    fn test_user_event_progress_ignored() {
255        let lines = render_one(RuntimeEvent::UserEvent {
256            session_id: session_id(),
257            event: UserEvent::Progress { text: "loading...".into() },
258        });
259        assert!(lines.is_empty());
260    }
261
262    #[test]
263    fn test_run_finished_no_output() {
264        let lines = render_one(RuntimeEvent::RunFinished { session_id: session_id() });
265        assert!(lines.is_empty());
266    }
267
268    #[test]
269    fn test_run_cancelled_produces_valid_json() {
270        let lines = render_one(RuntimeEvent::RunCancelled { session_id: session_id() });
271        let v: serde_json::Value = serde_json::from_str(&lines[0]).unwrap();
272        assert_eq!(v["type"], "run_cancelled");
273    }
274
275    #[test]
276    fn test_finish_turn_emits_summary() {
277        let lines = render_and_finish(&[RuntimeEvent::TextDelta { session_id: session_id(), text: "hello".into() }]);
278        let last: serde_json::Value = serde_json::from_str(lines.last().unwrap()).unwrap();
279        assert_eq!(last["type"], "turn_finished");
280        assert!(last["duration_ms"].as_u64().is_some());
281        assert_eq!(last["tool_call_count"], 0);
282    }
283
284    #[test]
285    fn test_tool_call_count_incremented() {
286        let lines = render_and_finish(&[
287            RuntimeEvent::ToolCallStarted { session_id: session_id(), tool_name: "a".into(), args_json: "{}".into() },
288            RuntimeEvent::ToolCallStarted { session_id: session_id(), tool_name: "b".into(), args_json: "{}".into() },
289        ]);
290        let last: serde_json::Value = serde_json::from_str(lines.last().unwrap()).unwrap();
291        assert_eq!(last["tool_call_count"], 2);
292    }
293
294    #[test]
295    fn test_assistant_text_accumulated() {
296        let lines = render_and_finish(&[
297            RuntimeEvent::TextDelta { session_id: session_id(), text: "Hello ".into() },
298            RuntimeEvent::TextDelta { session_id: session_id(), text: "World".into() },
299        ]);
300        let last: serde_json::Value = serde_json::from_str(lines.last().unwrap()).unwrap();
301        assert_eq!(last["assistant_text"], "Hello World");
302    }
303}
phi_agent/render/json_stream.rs

phi_agent/render/
json_stream.rs
