fix: show command descriptions for auto-invoke tools (#725)

Author: brandonskiser

crates/q_cli/src/cli/chat/conversation_state.rs

@@ -303,38 +303,6 @@ impl ConversationState {
         self.next_message = Some(msg);
     }
 
-    /// Sets the next user message with "interrupted" tool results.
-    pub fn interrupt_tool_use(&mut self, interrupted_tools: Vec<(String, super::tools::Tool)>, deny_input: String) {
-        debug_assert!(self.next_message.is_none());
-        let tool_results = interrupted_tools
-            .into_iter()
-            .map(|(tool_use_id, _)| ToolResult {
-                tool_use_id,
-                content: vec![ToolResultContentBlock::Text(
-                    "Tool use was interrupted by the user".to_string(),
-                )],
-                status: fig_api_client::model::ToolResultStatus::Error,
-            })
-            .collect::<Vec<_>>();
-        let user_input_message_context = UserInputMessageContext {
-            shell_state: None,
-            env_state: Some(build_env_state()),
-            tool_results: Some(tool_results),
-            tools: if self.tools.is_empty() {
-                None
-            } else {
-                Some(self.tools.clone())
-            },
-            ..Default::default()
-        };
-        let msg = UserInputMessage {
-            content: deny_input,
-            user_input_message_context: Some(user_input_message_context),
-            user_intent: None,
-        };
-        self.next_message = Some(msg);
-    }
-
     /// Returns a [FigConversationState] capable of being sent by
     /// [fig_api_client::StreamingClient] while preparing the current conversation state to be sent
     /// in the next message.

crates/q_cli/src/cli/chat/mod.rs

@@ -253,15 +253,11 @@ enum ChatState {
     PromptUser {
         /// Tool uses to present to the user.
         tool_uses: Option<Vec<QueuedTool>>,
-        /// Whether or not the associated tool uses were previously interrupted.
-        tools_were_interrupted: bool,
     },
     /// Handle the user input, depending on if any tools require execution.
     HandleInput {
         input: String,
         tool_uses: Option<Vec<QueuedTool>>,
-        /// Whether or not the associated tool uses were previously interrupted.
-        tools_were_interrupted: bool,
     },
     /// Validate the list of tool uses provided by the model.
     ValidateTools(Vec<ToolUse>),
@@ -275,10 +271,7 @@ enum ChatState {
 
 impl Default for ChatState {
     fn default() -> Self {
-        Self::PromptUser {
-            tool_uses: None,
-            tools_were_interrupted: false,
-        }
+        Self::PromptUser { tool_uses: None }
     }
 }
 
@@ -293,10 +286,7 @@ where
 
         let mut ctrl_c_stream = signal(SignalKind::interrupt())?;
 
-        let mut next_state = Some(ChatState::PromptUser {
-            tool_uses: None,
-            tools_were_interrupted: false,
-        });
+        let mut next_state = Some(ChatState::PromptUser { tool_uses: None });
 
         if let Some(user_input) = self.initial_input.take() {
             execute!(
@@ -310,7 +300,6 @@ where
             next_state = Some(ChatState::HandleInput {
                 input: user_input,
                 tool_uses: None,
-                tools_were_interrupted: false,
             });
         }
 
@@ -320,15 +309,8 @@ where
             debug!(?chat_state, "changing to state");
 
             let result = match chat_state {
-                ChatState::PromptUser {
-                    tool_uses,
-                    tools_were_interrupted,
-                } => self.prompt_user(tool_uses, tools_were_interrupted).await,
-                ChatState::HandleInput {
-                    input,
-                    tool_uses,
-                    tools_were_interrupted,
-                } => self.handle_input(input, tool_uses, tools_were_interrupted).await,
+                ChatState::PromptUser { tool_uses } => self.prompt_user(tool_uses).await,
+                ChatState::HandleInput { input, tool_uses } => self.handle_input(input, tool_uses).await,
                 ChatState::ExecuteTools(tool_uses) => {
                     let tool_uses_clone = tool_uses.clone();
                     tokio::select! {
@@ -424,42 +406,20 @@ where
                         },
                     }
                     self.conversation_state.fix_history();
-                    next_state = Some(ChatState::PromptUser {
-                        tool_uses: None,
-                        tools_were_interrupted: false,
-                    });
+                    next_state = Some(ChatState::PromptUser { tool_uses: None });
                 },
             }
         }
     }
 
     /// Read input from the user.
-    async fn prompt_user(
-        &mut self,
-        mut tool_uses: Option<Vec<QueuedTool>>,
-        tools_were_interrupted: bool,
-    ) -> Result<ChatState, ChatError> {
+    async fn prompt_user(&mut self, mut tool_uses: Option<Vec<QueuedTool>>) -> Result<ChatState, ChatError> {
         if self.interactive {
             execute!(self.output, cursor::Show)?;
         }
         let tool_uses = tool_uses.take().unwrap_or_default();
-        // Don't print the tools if they were previously interrupted.
-        if !tool_uses.is_empty() && !tools_were_interrupted {
-            let terminal_width = self.terminal_width();
-            for (i, (_, tool)) in tool_uses.iter().enumerate() {
-                queue!(
-                    self.output,
-                    style::SetForegroundColor(Color::Cyan),
-                    style::Print(format!("{}. {}\n", i + 1, tool.display_name())),
-                    style::SetForegroundColor(Color::Reset),
-                    style::SetForegroundColor(Color::DarkGrey),
-                    style::Print(format!("{}\n", "▔".repeat(terminal_width))),
-                    style::SetForegroundColor(Color::Reset),
-                )?;
-                tool.queue_description(&self.ctx, &mut self.output)
-                    .map_err(|e| ChatError::Custom(format!("failed to print tool: {}", e).into()))?;
-                queue!(self.output, style::Print("\n"))?;
-            }
+        if !tool_uses.is_empty() {
+            self.print_tool_descriptions(&tool_uses)?;
 
             execute!(
                 self.output,
@@ -485,21 +445,16 @@ where
         Ok(ChatState::HandleInput {
             input: user_input,
             tool_uses: Some(tool_uses),
-            tools_were_interrupted,
         })
     }
 
     async fn handle_input(
         &mut self,
         user_input: String,
         tool_uses: Option<Vec<QueuedTool>>,
-        tools_were_interrupted: bool,
     ) -> Result<ChatState, ChatError> {
         let Ok(command) = Command::parse(&user_input) else {
-            return Ok(ChatState::PromptUser {
-                tool_uses,
-                tools_were_interrupted,
-            });
+            return Ok(ChatState::PromptUser { tool_uses });
         };
 
         let tool_uses = tool_uses.unwrap_or_default();
@@ -518,10 +473,10 @@ where
                     self.spinner = Some(Spinner::new(Spinners::Dots, "Thinking...".to_owned()));
                 }
 
-                match (tool_uses.is_empty(), tools_were_interrupted) {
-                    (false, false) => self.conversation_state.abandon_tool_use(tool_uses, user_input),
-                    (false, true) => self.conversation_state.interrupt_tool_use(tool_uses, user_input),
-                    _ => self.conversation_state.append_new_user_message(user_input),
+                if tool_uses.is_empty() {
+                    self.conversation_state.append_new_user_message(user_input);
+                } else {
+                    self.conversation_state.abandon_tool_use(tool_uses, user_input);
                 }
 
                 self.send_tool_use_telemetry().await;
@@ -536,10 +491,7 @@ where
                 queue!(self.output, style::Print('\n'))?;
                 std::process::Command::new("bash").args(["-c", &command]).status().ok();
                 queue!(self.output, style::Print('\n'))?;
-                ChatState::PromptUser {
-                    tool_uses: None,
-                    tools_were_interrupted,
-                }
+                ChatState::PromptUser { tool_uses: None }
             },
             Command::Clear => {
                 self.conversation_state.clear();
@@ -551,17 +503,11 @@ where
                     style::SetForegroundColor(Color::Reset)
                 )?;
 
-                ChatState::PromptUser {
-                    tool_uses: None,
-                    tools_were_interrupted,
-                }
+                ChatState::PromptUser { tool_uses: None }
             },
             Command::Help => {
                 execute!(self.output, style::Print(HELP_TEXT))?;
-                ChatState::PromptUser {
-                    tool_uses: None,
-                    tools_were_interrupted,
-                }
+                ChatState::PromptUser { tool_uses: None }
             },
             Command::Quit => ChatState::Exit,
         })
@@ -571,15 +517,15 @@ where
         // Execute the requested tools.
         let terminal_width = self.terminal_width();
         let mut tool_results = vec![];
-        for (i, tool) in tool_uses.into_iter().enumerate() {
+        for tool in tool_uses {
             let mut tool_telemetry = self.tool_use_telemetry_events.entry(tool.0.clone());
             tool_telemetry = tool_telemetry.and_modify(|ev| ev.is_accepted = true);
 
             let tool_start = std::time::Instant::now();
             queue!(
                 self.output,
                 style::SetForegroundColor(Color::Cyan),
-                style::Print(format!("\n{}. {}...\n", i + 1, tool.1.display_name_action())),
+                style::Print(format!("\n{}...\n", tool.1.display_name_action())),
                 style::SetForegroundColor(Color::DarkGrey),
                 style::Print(format!("{}\n", "▔".repeat(terminal_width))),
                 style::SetForegroundColor(Color::Reset),
@@ -820,10 +766,7 @@ where
         if !tool_uses.is_empty() {
             Ok(ChatState::ValidateTools(tool_uses))
         } else {
-            Ok(ChatState::PromptUser {
-                tool_uses: None,
-                tools_were_interrupted: false,
-            })
+            Ok(ChatState::PromptUser { tool_uses: None })
         }
     }
 
@@ -916,15 +859,34 @@ where
             || queued_tools.iter().all(|tool| !tool.1.requires_consent(&self.ctx));
 
         if skip_consent {
+            self.print_tool_descriptions(&queued_tools)?;
             Ok(ChatState::ExecuteTools(queued_tools))
         } else {
             Ok(ChatState::PromptUser {
                 tool_uses: Some(queued_tools),
-                tools_were_interrupted: false,
             })
         }
     }
 
+    fn print_tool_descriptions(&mut self, tool_uses: &[QueuedTool]) -> Result<(), ChatError> {
+        let terminal_width = self.terminal_width();
+        for (_, tool) in tool_uses.iter() {
+            queue!(
+                self.output,
+                style::SetForegroundColor(Color::Cyan),
+                style::Print(format!("{}\n", tool.display_name())),
+                style::SetForegroundColor(Color::Reset),
+                style::SetForegroundColor(Color::DarkGrey),
+                style::Print(format!("{}\n", "▔".repeat(terminal_width))),
+                style::SetForegroundColor(Color::Reset),
+            )?;
+            tool.queue_description(&self.ctx, &mut self.output)
+                .map_err(|e| ChatError::Custom(format!("failed to print tool: {}", e).into()))?;
+            queue!(self.output, style::Print("\n"))?;
+        }
+        Ok(())
+    }
+
     async fn send_tool_use_telemetry(&mut self) {
         for (_, mut event) in self.tool_use_telemetry_events.drain() {
             event.user_input_id = match self.tool_use_status {