fixup(mockllm): support tool use

Author: nikomatsakis

crates/chat-cli/src/api_client/mod.rs

@@ -620,7 +620,13 @@ impl ApiClient {
                 // Each user message gets the next response group in sequence
                 let response_index = ctx.count_user_messages().saturating_sub(1); // 0-indexed
 
-                tracing::debug!(actor="MockLLM", user_message=ctx.current_user_message(), count=ctx.count_user_messages(), response_index);
+                tracing::debug!(
+                    actor="MockLLM", 
+                    user_message=ctx.current_user_message(), 
+                    count=ctx.count_user_messages(), 
+                    response_index, 
+                    response_groups=?response_groups,
+                );
 
                 // Send the corresponding response group
                 if response_index < response_groups.len() {
@@ -635,29 +641,8 @@ impl ApiClient {
                                 input,
                                 stop,
                             } => {
-                                // For tool events, we need to create proper tool use structure
-                                if stop.unwrap_or(false) {
-                                    // This is a complete tool use - parse the arguments
-                                    let args = input
-                                        .as_ref()
-                                        .map(|s| {
-                                            serde_json::from_str(s).unwrap_or(serde_json::Value::String(s.clone()))
-                                        })
-                                        .unwrap_or(serde_json::Value::Null);
-
-                                    let _tool_use = crate::cli::chat::AssistantToolUse {
-                                        id: tool_use_id.clone(),
-                                        name: name.clone(),
-                                        orig_name: name.clone(),
-                                        args: args.clone(),
-                                        orig_args: args,
-                                    };
-
-                                    // For now, just send text response about tool use since we don't have direct tool event API
-                                    // TODO: Implement proper tool event support in MockLLMContext if needed
-                                    ctx.respond(format!("[Tool: {} with args: {}]", name, tool_use_id))
-                                        .await?;
-                                }
+                                ctx.respond_tool_use(tool_use_id.clone(), name.clone(), input.clone(), stop.clone())
+                                    .await?;
                             },
                             _ => {}, // Ignore other event types
                         }

crates/chat-cli/src/mock_llm.rs

@@ -38,12 +38,42 @@ impl MockLLMContext {
                         .map_err(|_| eyre::eyre!("Response channel closed"))
     }
 
+    async fn send_tool_use(
+        tx: &mut mpsc::Sender<Result<ChatResponseStream, RecvError>>,
+        tool_use_id: String,
+        name: String,
+        input: Option<String>,
+        stop: Option<bool>,
+    ) -> eyre::Result<()> {
+        tx
+            .send(Ok(ChatResponseStream::ToolUseEvent {
+                tool_use_id,
+                name,
+                input,
+                stop,
+            }))
+            .await
+            .map_err(|_| eyre::eyre!("Response channel closed"))
+    }
+
     /// Respond with text to the user.
     #[allow(dead_code)]
     pub async fn respond(&mut self, text: impl ToString) -> eyre::Result<()> {
         Self::send_text(&mut self.tx, text).await
     }
 
+    /// Respond with a tool use
+    #[allow(dead_code)]
+    pub async fn respond_tool_use(
+        &mut self,
+        tool_use_id: String,
+        name: String,
+        input: Option<String>,
+        stop: Option<bool>,
+    ) -> eyre::Result<()> {
+        Self::send_tool_use(&mut self.tx, tool_use_id, name, input, stop).await
+    }
+
     /// Count the number of user messages in the conversation (including the current one).
     /// Useful for determining which predefined response to use in sequence.
     #[allow(dead_code)]