✨ Add real-time tool activity tracking to chat interface

hyperb1iss · hyperb1iss · commit 37a8a9942f86 · 2025-11-27T14:56:44.000-08:00
Display Iris's tool calls as they happen during streaming responses. Users
now see which tools are being invoked in real-time, providing transparency
into the AI's reasoning process.

Tool activity display:
- Show current tool with animated spinner during execution
- Maintain visual history of completed tools above the response
- Capture tool call events from multi-turn streaming conversations
- Clear tool state appropriately on response completion and chat reset

Markdown rendering improvements:
- Add spacing around inline code blocks for readability
- Insert padding after code blocks and lists
- Fix text indentation for wrapped lines in nested lists
- Add bottom padding to ensure last messages scroll into view
diff --git a/src/agents/iris.rs b/src/agents/iris.rs
@@ -875,6 +875,22 @@ Guidelines:
                     aggregated_text.push_str(&text.text);
                     on_chunk(&text.text, &aggregated_text);
                 }
+                Ok(MultiTurnStreamItem::StreamAssistantItem(
+                    StreamedAssistantContent::ToolCall(tool_call),
+                )) => {
+                    // Update status to show tool execution
+                    let tool_name = &tool_call.function.name;
+                    let reason = format!("Calling {}", tool_name);
+                    crate::iris_status_dynamic!(
+                        IrisPhase::ToolExecution {
+                            tool_name: tool_name.clone(),
+                            reason: reason.clone()
+                        },
+                        format!("🔧 {}", reason),
+                        3,
+                        4
+                    );
+                }
                 Ok(MultiTurnStreamItem::FinalResponse(_)) => {
                     // Stream complete
                     break;
@@ -883,7 +899,7 @@ Guidelines:
                     return Err(anyhow::anyhow!("Streaming error: {}", e));
                 }
                 _ => {
-                    // Tool calls, reasoning, etc. - continue
+                    // Reasoning, etc. - continue
                 }
             }
         }
diff --git a/src/studio/app.rs b/src/studio/app.rs
@@ -41,7 +41,7 @@ use super::render::{
     render_changelog_panel, render_commit_panel, render_explore_panel, render_modal,
     render_pr_panel, render_release_notes_panel, render_review_panel,
 };
-use super::state::{ChatMessage, GitStatus, IrisStatus, Mode, Notification, PanelId, StudioState};
+use super::state::{GitStatus, IrisStatus, Mode, Notification, PanelId, StudioState};
 use super::theme;
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -640,13 +640,19 @@ impl StudioApp {
                 },
 
                 IrisTaskResult::ToolStatus { tool_name, message } => {
-                    // Tool status updates go to chat progress
-                    // For now, handle directly since it's UI-only (chat bubble updates)
+                    // Tool status updates - move current tool to history, set new current
+                    let tool_desc = format!("{} - {}", tool_name, message);
                     if let Some(Modal::Chat(chat)) = &mut self.state.modal {
-                        let tool_msg = format!("🔧 {} - {}", tool_name, message);
-                        chat.messages.push(ChatMessage::iris(tool_msg));
-                        chat.auto_scroll = true;
+                        // Move previous tool to history
+                        if let Some(prev) = chat.current_tool.take() {
+                            chat.tool_history.push(prev);
+                        }
+                        chat.current_tool = Some(tool_desc.clone());
+                    }
+                    if let Some(prev) = self.state.chat_state.current_tool.take() {
+                        self.state.chat_state.tool_history.push(prev);
                     }
+                    self.state.chat_state.current_tool = Some(tool_desc);
                     self.state.mark_dirty();
                     continue; // Already handled, skip event push
                 }
diff --git a/src/studio/reducer.rs b/src/studio/reducer.rs
@@ -424,8 +424,15 @@ pub fn reduce(
                 TaskType::Chat => {
                     if let Some(Modal::Chat(ref mut chat)) = state.modal {
                         chat.streaming_response = None;
+                        // Move final current_tool to history before clearing
+                        if let Some(tool) = chat.current_tool.take() {
+                            chat.tool_history.push(tool);
+                        }
                     }
                     state.chat_state.streaming_response = None;
+                    if let Some(tool) = state.chat_state.current_tool.take() {
+                        state.chat_state.tool_history.push(tool);
+                    }
                 }
                 TaskType::SemanticBlame => {
                     state.modes.explore.streaming_blame = None;
diff --git a/src/studio/render/chat.rs b/src/studio/render/chat.rs
@@ -78,6 +78,19 @@ pub fn render_messages(
             let formatted_lines = format_markdown(streaming, content_width, content_style);
             lines.extend(formatted_lines);
 
+            // Show tool activity history
+            for tool in &chat_state.tool_history {
+                lines.push(Line::from(vec![
+                    Span::styled("  ⚙ ", Style::default().fg(theme::NEON_CYAN)),
+                    Span::styled(
+                        tool.clone(),
+                        Style::default()
+                            .fg(theme::TEXT_MUTED)
+                            .add_modifier(Modifier::ITALIC),
+                    ),
+                ]));
+            }
+
             // Add streaming cursor
             let spinner =
                 theme::SPINNER_BRAILLE[last_render_ms as usize / 80 % theme::SPINNER_BRAILLE.len()];
@@ -89,19 +102,55 @@ pub fn render_messages(
             // Just show thinking indicator when no streaming content yet
             let spinner =
                 theme::SPINNER_BRAILLE[last_render_ms as usize / 80 % theme::SPINNER_BRAILLE.len()];
-            lines.push(Line::from(vec![
-                Span::styled(
-                    format!("{} ", spinner),
+
+            // Show tool history when thinking
+            for tool in &chat_state.tool_history {
+                lines.push(Line::from(vec![
+                    Span::styled("  ⚙ ", Style::default().fg(theme::NEON_CYAN)),
+                    Span::styled(
+                        tool.clone(),
+                        Style::default()
+                            .fg(theme::TEXT_MUTED)
+                            .add_modifier(Modifier::ITALIC),
+                    ),
+                ]));
+            }
+
+            // Show current tool activity prominently
+            if let Some(ref tool) = chat_state.current_tool {
+                lines.push(Line::from(vec![
+                    Span::styled(
+                        format!("{} ⚙ ", spinner),
+                        Style::default().fg(theme::NEON_CYAN),
+                    ),
+                    Span::styled(
+                        tool.clone(),
+                        Style::default()
+                            .fg(theme::TEXT_SECONDARY)
+                            .add_modifier(Modifier::ITALIC),
+                    ),
+                ]));
+            } else if chat_state.tool_history.is_empty() {
+                lines.push(Line::from(vec![
+                    Span::styled(
+                        format!("{} ", spinner),
+                        Style::default().fg(theme::ELECTRIC_PURPLE),
+                    ),
+                    Span::styled(
+                        "Iris is thinking",
+                        Style::default()
+                            .fg(theme::ELECTRIC_PURPLE)
+                            .add_modifier(Modifier::ITALIC),
+                    ),
+                    Span::styled("...", Style::default().fg(theme::TEXT_DIM)),
+                ]));
+            } else {
+                // Show spinner after tool history
+                lines.push(Line::from(Span::styled(
+                    format!("  {}", spinner),
                     Style::default().fg(theme::ELECTRIC_PURPLE),
-                ),
-                Span::styled(
-                    "Iris is thinking",
-                    Style::default()
-                        .fg(theme::ELECTRIC_PURPLE)
-                        .add_modifier(Modifier::ITALIC),
-                ),
-                Span::styled("...", Style::default().fg(theme::TEXT_DIM)),
-            ]));
+                )));
+            }
         }
     }
 
@@ -129,6 +178,13 @@ pub fn render_messages(
         ]));
     }
 
+    // Add bottom padding for scrolling - ensures last message can scroll into view
+    if !chat_state.messages.is_empty() || chat_state.is_responding {
+        lines.push(Line::from(""));
+        lines.push(Line::from(""));
+        lines.push(Line::from(""));
+    }
+
     lines
 }
 
@@ -234,11 +290,13 @@ pub fn format_markdown(content: &str, max_width: usize, base_style: Style) -> Ve
                     code_block_lines.clear();
                     code_lang.clear();
                     in_code_block = false;
+                    lines.push(Line::from("")); // Add spacing after code blocks
                 }
                 TagEnd::List(_) => {
                     list_depth = list_depth.saturating_sub(1);
                     if list_depth == 0 {
                         ordered_list_num = None;
+                        lines.push(Line::from("")); // Add spacing after top-level lists
                     }
                 }
                 TagEnd::Item => {
@@ -260,20 +318,60 @@ pub fn format_markdown(content: &str, max_width: usize, base_style: Style) -> Ve
                     code_block_lines.extend(text.lines().map(String::from));
                 } else {
                     let style = style_stack.last().copied().unwrap_or(base_style);
+
+                    // Add space after inline code if text doesn't start with punctuation/space
+                    if let Some(last_span) = current_spans.last() {
+                        let last_content = last_span.content.as_ref();
+                        if last_content.ends_with('`') {
+                            let first_char = text.chars().next().unwrap_or(' ');
+                            if !first_char.is_whitespace()
+                                && !matches!(
+                                    first_char,
+                                    '.' | ',' | ':' | ';' | ')' | ']' | '-' | '!' | '?'
+                                )
+                            {
+                                current_spans.push(Span::styled(" ", style));
+                            }
+                        }
+                    }
+
                     // Word wrap the text
                     let effective_width = max_width.saturating_sub(4 + list_depth * 2);
                     for chunk in wrap_text(&text, effective_width) {
                         if !current_spans.is_empty() && !chunk.is_empty() {
                             current_spans.push(Span::styled(chunk, style));
                         } else if !chunk.is_empty() {
-                            let indent = if list_depth > 0 { "" } else { "  " };
+                            // Base indent + list depth indent (aligns with bullet text)
+                            let indent = if list_depth > 0 {
+                                // 2 spaces per depth level + 2 for bullet alignment
+                                "  ".repeat(list_depth) + "  "
+                            } else {
+                                "  ".to_string()
+                            };
                             current_spans.push(Span::styled(format!("{}{}", indent, chunk), style));
                         }
                     }
                 }
             }
             Event::Code(code) => {
+                // Add space before inline code if needed (prevents "text`code`" from merging)
+                if let Some(last_span) = current_spans.last() {
+                    let last_content = last_span.content.as_ref();
+                    if !last_content.is_empty()
+                        && !last_content.ends_with(' ')
+                        && !last_content.ends_with('\n')
+                        && !last_content.ends_with('(')
+                        && !last_content.ends_with('[')
+                    {
+                        let style = style_stack.last().copied().unwrap_or(base_style);
+                        current_spans.push(Span::styled(" ", style));
+                    }
+                }
+                // Render without backticks - just styled text
                 current_spans.push(Span::styled(code.to_string(), theme::inline_code()));
+                // Add trailing space after inline code
+                let style = style_stack.last().copied().unwrap_or(base_style);
+                current_spans.push(Span::styled(" ", style));
             }
             Event::SoftBreak => {
                 // Treat as space
diff --git a/src/studio/state.rs b/src/studio/state.rs
@@ -274,6 +274,10 @@ pub struct ChatState {
     pub streaming_response: Option<String>,
     /// Whether to auto-scroll to bottom on new content
     pub auto_scroll: bool,
+    /// Current tool being executed (shown with spinner)
+    pub current_tool: Option<String>,
+    /// History of tools called during this response
+    pub tool_history: Vec<String>,
 }
 
 impl Default for ChatState {
@@ -285,6 +289,8 @@ impl Default for ChatState {
             is_responding: false,
             streaming_response: None,
             auto_scroll: true,
+            current_tool: None,
+            tool_history: Vec::new(),
         }
     }
 }
@@ -331,6 +337,9 @@ impl ChatState {
     pub fn add_iris_response(&mut self, content: &str) {
         self.messages.push(ChatMessage::iris(content));
         self.is_responding = false;
+        self.streaming_response = None;
+        self.current_tool = None;
+        self.tool_history.clear();
         self.auto_scroll = true; // Re-enable auto-scroll on new messages
     }
 
@@ -355,6 +364,9 @@ impl ChatState {
         self.input.clear();
         self.scroll_offset = 0;
         self.is_responding = false;
+        self.streaming_response = None;
+        self.current_tool = None;
+        self.tool_history.clear();
         self.auto_scroll = true;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -274,6 +274,10 @@ pub struct ChatState {`
`274`	`274`	`pub streaming_response: Option<String>,`
`275`	`275`	`/// Whether to auto-scroll to bottom on new content`
`276`	`276`	`pub auto_scroll: bool,`
	`277`	`+ /// Current tool being executed (shown with spinner)`
	`278`	`+ pub current_tool: Option<String>,`
	`279`	`+ /// History of tools called during this response`
	`280`	`+ pub tool_history: Vec<String>,`
`277`	`281`	`}`
`278`	`282`
`279`	`283`	`impl Default for ChatState {`
`@@ -285,6 +289,8 @@ impl Default for ChatState {`
`285`	`289`	`is_responding: false,`
`286`	`290`	`streaming_response: None,`
`287`	`291`	`auto_scroll: true,`
	`292`	`+ current_tool: None,`
	`293`	`+ tool_history: Vec::new(),`
`288`	`294`	`}`
`289`	`295`	`}`
`290`	`296`	`}`
`@@ -331,6 +337,9 @@ impl ChatState {`
`331`	`337`	`pub fn add_iris_response(&mut self, content: &str) {`
`332`	`338`	`self.messages.push(ChatMessage::iris(content));`
`333`	`339`	`self.is_responding = false;`
	`340`	`+ self.streaming_response = None;`
	`341`	`+ self.current_tool = None;`
	`342`	`+ self.tool_history.clear();`
`334`	`343`	`self.auto_scroll = true; // Re-enable auto-scroll on new messages`
`335`	`344`	`}`
`336`	`345`
`@@ -355,6 +364,9 @@ impl ChatState {`
`355`	`364`	`self.input.clear();`
`356`	`365`	`self.scroll_offset = 0;`
`357`	`366`	`self.is_responding = false;`
	`367`	`+ self.streaming_response = None;`
	`368`	`+ self.current_tool = None;`
	`369`	`+ self.tool_history.clear();`
`358`	`370`	`self.auto_scroll = true;`
`359`	`371`	`}`
`360`	`372`	`}`