feat: add editing and MCP command handling, enhance SSE streaming with usage tracking

- Implemented `Edit` and `McpAdd` commands in the command parser and handler.
- Added a new `stream` module to the runtime for handling streaming events.
- Enhanced `SseParser` to parse usage information from SSE events.
- Introduced `ToolCallAccumulator` for tracking tool calls independently.
- Updated `AppStateRest` to include `app_config` and `MiscState` to track `effort_level` and `selected_index`.
- Modified `LlmClient` to support streaming responses with usage tracking.
- Improved error handling and retry logic in the streaming API calls.
- Added tests for new features and improved markdown rendering in the chat view.

src/app/runtime/stream/mod.rs

@@ -70,6 +70,15 @@ impl SseParser {
             return None;
         }
         let value: Value = serde_json::from_str(&data).ok()?;
+        if let Some(usage) = value.get("usage") {
+            if !usage.is_null() {
+                let prompt_tokens = usage.get("prompt_tokens").and_then(|v| v.as_u64()).unwrap_or(0);
+                let completion_tokens = usage.get("completion_tokens").and_then(|v| v.as_u64()).unwrap_or(0);
+                let total_tokens = usage.get("total_tokens").and_then(|v| v.as_u64())
+                    .unwrap_or(prompt_tokens + completion_tokens);
+                return Some(StreamEvent::Usage { prompt_tokens, completion_tokens, total_tokens });
+            }
+        }
         match event_type.as_str() {
             "message.stop" => Some(StreamEvent::Done),
             "message.start" => None,
@@ -85,7 +94,7 @@ impl SseParser {
                         return Some(StreamEvent::Reasoning(reasoning.to_string()));
                     }
                     if let Some(tool_calls) = delta.get("tool_calls").and_then(|tc| tc.as_array()) {
-                        for tc in tool_calls {
+                        if let Some(tc) = tool_calls.first() {
                             let index = tc.get("index").and_then(|i| i.as_u64()).unwrap_or(0) as usize;
                             let id = tc.get("id").and_then(|i| i.as_str()).map(|s| s.to_string());
                             let name = tc.get("function")
@@ -121,6 +130,9 @@ impl SseParser {
         }
     }
 
+    /// Clears any partially-buffered SSE frame. Reserved for reconnect/retry flows that
+    /// reuse a parser instance across requests rather than constructing a fresh one.
+    #[allow(dead_code)]
     pub fn reset(&mut self) {
         self.buffer.clear();
         self.event_type = None;
@@ -128,6 +140,10 @@ impl SseParser {
     }
 }
 
+/// Fallback parser for providers that send bare JSON chunks instead of SSE-framed
+/// `data: ...` lines. Not used by the `SseParser` streaming path (which handles
+/// standard SSE framing directly), kept for providers/tests that feed raw chunks.
+#[allow(dead_code)]
 pub fn parse_stream_chunk(data: &str) -> Option<StreamEvent> {
     let value: Value = serde_json::from_str(data).ok()?;
     if value == Value::Null {
@@ -170,3 +186,107 @@ pub fn parse_stream_chunk(data: &str) -> Option<StreamEvent> {
     }
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn feed_parses_single_token_chunk() {
+        let mut p = SseParser::new();
+        let events = p.feed("data: {\"choices\":[{\"delta\":{\"content\":\"hello\"}}]}\n\n");
+        assert_eq!(events.len(), 1);
+        match &events[0] {
+            StreamEvent::Token(t) => assert_eq!(t, "hello"),
+            other => panic!("expected Token, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn feed_handles_chunk_split_mid_line() {
+        let mut p = SseParser::new();
+        let e1 = p.feed("data: {\"choices\":[{\"delta\":{\"content\":\"partial");
+        assert!(e1.is_empty(), "no event until the line and blank separator complete");
+        let e2 = p.feed("\"}}]}\n\n");
+        assert_eq!(e2.len(), 1);
+        match &e2[0] {
+            StreamEvent::Token(t) => assert_eq!(t, "partial"),
+            other => panic!("expected Token, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn feed_emits_done_on_done_sentinel() {
+        let mut p = SseParser::new();
+        let events = p.feed("data: [DONE]\n\n");
+        assert_eq!(events.len(), 1);
+        assert!(matches!(events[0], StreamEvent::Done));
+    }
+
+    #[test]
+    fn feed_emits_done_on_finish_reason_stop() {
+        let mut p = SseParser::new();
+        let events = p.feed(
+            "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n",
+        );
+        assert_eq!(events.len(), 1);
+        assert!(matches!(events[0], StreamEvent::Done));
+    }
+
+    #[test]
+    fn feed_parses_tool_call_delta() {
+        let mut p = SseParser::new();
+        let events = p.feed(
+            "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_1\",\"function\":{\"name\":\"bash\",\"arguments\":\"{\\\"cmd\\\"\"}}]}}]}\n\n",
+        );
+        assert_eq!(events.len(), 1);
+        match &events[0] {
+            StreamEvent::ToolCallDelta { index, id, name, arguments_delta } => {
+                assert_eq!(*index, 0);
+                assert_eq!(id.as_deref(), Some("call_1"));
+                assert_eq!(name.as_deref(), Some("bash"));
+                assert_eq!(arguments_delta, "{\"cmd\"");
+            }
+            other => panic!("expected ToolCallDelta, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn feed_parses_usage_chunk() {
+        let mut p = SseParser::new();
+        let events = p.feed(
+            "data: {\"choices\":[],\"usage\":{\"prompt_tokens\":10,\"completion_tokens\":5,\"total_tokens\":15}}\n\n",
+        );
+        assert_eq!(events.len(), 1);
+        match &events[0] {
+            StreamEvent::Usage { prompt_tokens, completion_tokens, total_tokens } => {
+                assert_eq!(*prompt_tokens, 10);
+                assert_eq!(*completion_tokens, 5);
+                assert_eq!(*total_tokens, 15);
+            }
+            other => panic!("expected Usage, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn feed_ignores_empty_data_lines() {
+        let mut p = SseParser::new();
+        let events = p.feed(": comment\n\n");
+        assert!(events.is_empty());
+    }
+
+    #[test]
+    fn feed_multiple_events_across_one_chunk() {
+        let mut p = SseParser::new();
+        let chunk = "data: {\"choices\":[{\"delta\":{\"content\":\"a\"}}]}\n\ndata: {\"choices\":[{\"delta\":{\"content\":\"b\"}}]}\n\n";
+        let events = p.feed(chunk);
+        assert_eq!(events.len(), 2);
+        match (&events[0], &events[1]) {
+            (StreamEvent::Token(a), StreamEvent::Token(b)) => {
+                assert_eq!(a, "a");
+                assert_eq!(b, "b");
+            }
+            other => panic!("expected two Tokens, got {:?}", other),
+        }
+    }
+}