Drop backticks

assets/settings/default.json

@@ -657,7 +657,6 @@
         "enable_all_context_servers": true,
         "tools": {
           "terminal": true,
-          "batch_tool": true,
           "code_actions": true,
           "code_symbols": true,
           "copy_path": false,

crates/agent/src/active_thread.rs

@@ -823,7 +823,7 @@ impl ActiveThread {
 
     fn handle_thread_event(
         &mut self,
-        _thread: &Entity<Thread>,
+        thread: &Entity<Thread>,
         event: &ThreadEvent,
         window: &mut Window,
         cx: &mut Context<Self>,
@@ -926,6 +926,45 @@ impl ActiveThread {
                 }
             }
             ThreadEvent::CheckpointChanged => cx.notify(),
+            ThreadEvent::StreamedFileChunk { path, chunk } => {
+                let project = thread.read(cx).project().clone();
+
+                if let Some(project_path) = project.update(cx, |project, cx| {
+                    project.find_project_path(path.as_ref(), cx)
+                }) {
+                    log::info!("Appending {}B chunk to {path}", chunk.len());
+
+                    let path = path.clone();
+                    let chunk = chunk.clone();
+
+                    cx.spawn(async move |_, cx| {
+                        match project.update(cx, |project, cx| {
+                            project.open_buffer(project_path.clone(), cx)
+                        }) {
+                            Ok(buffer_task) => {
+                                if let Ok(buffer) = buffer_task.await {
+                                    // Append the text to the buffer
+                                    if let Err(e) = cx.update(|cx| {
+                                        buffer.update(cx, |buffer, cx| {
+                                            let point = buffer.snapshot().len();
+                                            buffer.edit([(point..point, chunk.as_str())], None, cx)
+                                        })
+                                    }) {
+                                        log::warn!("Failed to edit buffer: {}", e);
+                                    } else {
+                                        log::info!("Successfully appended chunk to file: {path}",);
+                                    }
+                                }
+                            }
+                            Err(_) => {
+                                let todo = (); // TODO record the error in the messages somehow.
+                                todo!();
+                            }
+                        }
+                    })
+                    .detach();
+                }
+            }
         }
     }
 

crates/agent/src/thread.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use agent_rules::load_worktree_rules_file;
 use anyhow::{Context as _, Result, anyhow};
 use assistant_settings::AssistantSettings;
-use assistant_tool::{ActionLog, Tool, ToolWorkingSet};
+use assistant_tool::{ActionLog, ResponseDest, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use collections::{BTreeMap, HashMap};
 use fs::Fs;
@@ -261,6 +261,7 @@ pub struct Thread {
     cumulative_token_usage: TokenUsage,
     feedback: Option<ThreadFeedback>,
     message_feedback: HashMap<MessageId, ThreadFeedback>,
+    response_dest: ResponseDest,
 }
 
 impl Thread {
@@ -300,6 +301,7 @@ impl Thread {
             cumulative_token_usage: TokenUsage::default(),
             feedback: None,
             message_feedback: HashMap::default(),
+            response_dest: ResponseDest::default(),
         }
     }
 
@@ -364,6 +366,7 @@ impl Thread {
             cumulative_token_usage: serialized.cumulative_token_usage,
             feedback: None,
             message_feedback: HashMap::default(),
+            response_dest: ResponseDest::default(),
         }
     }
 
@@ -458,6 +461,10 @@ impl Thread {
         !self.tool_use.pending_tool_uses().is_empty()
     }
 
+    pub fn pending_tool_uses(&self) -> Vec<&PendingToolUse> {
+        self.tool_use.pending_tool_uses()
+    }
+
     pub fn checkpoint_for_message(&self, id: MessageId) -> Option<ThreadCheckpoint> {
         self.checkpoints_by_message.get(&id).cloned()
     }
@@ -1091,6 +1098,20 @@ impl Thread {
                                 current_token_usage = token_usage;
                             }
                             LanguageModelCompletionEvent::Text(chunk) => {
+                                match &thread.response_dest {
+                                    ResponseDest::File { path } => {
+                                        log::info!(
+                                            "Emitting {}B StreamedFileChunk for {path}",
+                                            chunk.len()
+                                        );
+                                        cx.emit(ThreadEvent::StreamedFileChunk {
+                                            path: path.clone(),
+                                            chunk: chunk.clone(),
+                                        });
+                                    }
+                                    ResponseDest::TextOnly => {}
+                                }
+
                                 if let Some(last_message) = thread.messages.last_mut() {
                                     if last_message.role == Role::Assistant {
                                         last_message.push_text(&chunk);
@@ -1106,7 +1127,7 @@ impl Thread {
                                         // will result in duplicating the text of the chunk in the rendered Markdown.
                                         thread.insert_message(
                                             Role::Assistant,
-                                            vec![MessageSegment::Text(chunk.to_string())],
+                                            vec![MessageSegment::Text(chunk)],
                                             cx,
                                         );
                                     };
@@ -1448,7 +1469,24 @@ impl Thread {
 
         cx.spawn({
             async move |thread: WeakEntity<Thread>, cx| {
-                let output = run_tool.await;
+                let new_response_dest;
+                let output = match run_tool.await {
+                    Ok((response_dest, output)) => {
+                        new_response_dest = response_dest;
+
+                        Ok(output)
+                    }
+                    Err(err) => {
+                        new_response_dest = ResponseDest::default();
+                        Err(err)
+                    }
+                };
+
+                thread.upgrade().map(|thread| {
+                    thread.update(cx, |thread, _cx| {
+                        thread.response_dest = new_response_dest;
+                    })
+                });
 
                 thread
                     .update(cx, |thread, cx| {
@@ -1911,6 +1949,10 @@ pub enum ThreadEvent {
     StreamedCompletion,
     StreamedAssistantText(MessageId, String),
     StreamedAssistantThinking(MessageId, String),
+    StreamedFileChunk {
+        path: Arc<str>,
+        chunk: String,
+    },
     DoneStreaming,
     MessageAdded(MessageId),
     MessageEdited(MessageId),

crates/assistant_tool/src/assistant_tool.rs

@@ -18,6 +18,20 @@ pub use crate::action_log::*;
 pub use crate::tool_registry::*;
 pub use crate::tool_working_set::*;
 
+/// Where the streamed-in text should go.
+/// For example, the file creation tool streams it to a file.
+#[derive(Debug, Clone)]
+pub enum ResponseDest {
+    File { path: Arc<str> },
+    TextOnly,
+}
+
+impl Default for ResponseDest {
+    fn default() -> Self {
+        Self::TextOnly
+    }
+}
+
 pub fn init(cx: &mut App) {
     ToolRegistry::default_global(cx);
 }
@@ -66,7 +80,7 @@ pub trait Tool: 'static + Send + Sync {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>>;
+    ) -> Task<Result<(ResponseDest, String)>>;
 }
 
 impl Debug for dyn Tool {

crates/assistant_tools/src/assistant_tools.rs

@@ -1,4 +1,3 @@
-mod batch_tool;
 mod code_action_tool;
 mod code_symbols_tool;
 mod copy_path_tool;
@@ -30,7 +29,6 @@ use gpui::App;
 use http_client::HttpClientWithUrl;
 use move_path_tool::MovePathTool;
 
-use crate::batch_tool::BatchTool;
 use crate::code_action_tool::CodeActionTool;
 use crate::code_symbols_tool::CodeSymbolsTool;
 use crate::create_directory_tool::CreateDirectoryTool;
@@ -55,7 +53,6 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
 
     let registry = ToolRegistry::global(cx);
     registry.register_tool(TerminalTool);
-    registry.register_tool(BatchTool);
     registry.register_tool(CreateDirectoryTool);
     registry.register_tool(CreateFileTool);
     registry.register_tool(CopyPathTool);

crates/assistant_tools/src/batch_tool.rs

@@ -1,310 +0,0 @@
-use crate::schema::json_schema_for;
-use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool, ToolWorkingSet};
-use futures::future::join_all;
-use gpui::{App, AppContext, Entity, Task};
-use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
-use project::Project;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use ui::IconName;
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct ToolInvocation {
-    /// The name of the tool to invoke
-    pub name: String,
-
-    /// The input to the tool in JSON format
-    pub input: serde_json::Value,
-}
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct BatchToolInput {
-    /// The tool invocations to run as a batch. These tools will be run either sequentially
-    /// or concurrently depending on the `run_tools_concurrently` flag.
-    ///
-    /// <example>
-    /// Basic file operations (concurrent)
-    ///
-    /// ```json
-    /// {
-    ///   "invocations": [
-    ///     {
-    ///       "name": "read_file",
-    ///       "input": {
-    ///         "path": "src/main.rs"
-    ///       }
-    ///     },
-    ///     {
-    ///       "name": "list_directory",
-    ///       "input": {
-    ///         "path": "src/lib"
-    ///       }
-    ///     },
-    ///     {
-    ///       "name": "regex_search",
-    ///       "input": {
-    ///         "regex": "fn run\\("
-    ///       }
-    ///     }
-    ///   ],
-    ///   "run_tools_concurrently": true
-    /// }
-    /// ```
-    /// </example>
-    ///
-    /// <example>
-    /// Multiple find-replace operations on the same file (sequential)
-    ///
-    /// ```json
-    /// {
-    ///   "invocations": [
-    ///     {
-    ///       "name": "find_replace_file",
-    ///       "input": {
-    ///         "path": "src/config.rs",
-    ///         "display_description": "Update default timeout value",
-    ///         "find": "pub const DEFAULT_TIMEOUT: u64 = 30;\n\npub const MAX_RETRIES: u32 = 3;\n\npub const SERVER_URL: &str = \"https://api.example.com\";",
-    ///         "replace": "pub const DEFAULT_TIMEOUT: u64 = 60;\n\npub const MAX_RETRIES: u32 = 3;\n\npub const SERVER_URL: &str = \"https://api.example.com\";"
-    ///       }
-    ///     },
-    ///     {
-    ///       "name": "find_replace_file",
-    ///       "input": {
-    ///         "path": "src/config.rs",
-    ///         "display_description": "Update API endpoint URL",
-    ///         "find": "pub const MAX_RETRIES: u32 = 3;\n\npub const SERVER_URL: &str = \"https://api.example.com\";\n\npub const API_VERSION: &str = \"v1\";",
-    ///         "replace": "pub const MAX_RETRIES: u32 = 3;\n\npub const SERVER_URL: &str = \"https://api.newdomain.com\";\n\npub const API_VERSION: &str = \"v1\";"
-    ///       }
-    ///     }
-    ///   ],
-    ///   "run_tools_concurrently": false
-    /// }
-    /// ```
-    /// </example>
-    ///
-    /// <example>
-    /// Searching and analyzing code (concurrent)
-    ///
-    /// ```json
-    /// {
-    ///   "invocations": [
-    ///     {
-    ///       "name": "regex_search",
-    ///       "input": {
-    ///         "regex": "impl Database"
-    ///       }
-    ///     },
-    ///     {
-    ///       "name": "path_search",
-    ///       "input": {
-    ///         "glob": "**/*test*.rs"
-    ///       }
-    ///     }
-    ///   ],
-    ///   "run_tools_concurrently": true
-    /// }
-    /// ```
-    /// </example>
-    ///
-    /// <example>
-    /// Multi-file refactoring (concurrent)
-    ///
-    /// ```json
-    /// {
-    ///   "invocations": [
-    ///     {
-    ///       "name": "find_replace_file",
-    ///       "input": {
-    ///         "path": "src/models/user.rs",
-    ///         "display_description": "Add email field to User struct",
-    ///         "find": "pub struct User {\n    pub id: u64,\n    pub username: String,\n    pub created_at: DateTime<Utc>,\n}",
-    ///         "replace": "pub struct User {\n    pub id: u64,\n    pub username: String,\n    pub email: String,\n    pub created_at: DateTime<Utc>,\n}"
-    ///       }
-    ///     },
-    ///     {
-    ///       "name": "find_replace_file",
-    ///       "input": {
-    ///         "path": "src/db/queries.rs",
-    ///         "display_description": "Update user insertion query",
-    ///         "find": "pub async fn insert_user(conn: &mut Connection, user: &User) -> Result<(), DbError> {\n    conn.execute(\n        \"INSERT INTO users (id, username, created_at) VALUES ($1, $2, $3)\",\n        &[&user.id, &user.username, &user.created_at],\n    ).await?;\n    \n    Ok(())\n}",
-    ///         "replace": "pub async fn insert_user(conn: &mut Connection, user: &User) -> Result<(), DbError> {\n    conn.execute(\n        \"INSERT INTO users (id, username, email, created_at) VALUES ($1, $2, $3, $4)\",\n        &[&user.id, &user.username, &user.email, &user.created_at],\n    ).await?;\n    \n    Ok(())\n}"
-    ///       }
-    ///     }
-    ///   ],
-    ///   "run_tools_concurrently": true
-    /// }
-    /// ```
-    /// </example>
-    pub invocations: Vec<ToolInvocation>,
-
-    /// Whether to run the tools in this batch concurrently. If this is false (the default), the tools will run sequentially.
-    #[serde(default)]
-    pub run_tools_concurrently: bool,
-}
-
-pub struct BatchTool;
-
-impl Tool for BatchTool {
-    fn name(&self) -> String {
-        "batch_tool".into()
-    }
-
-    fn needs_confirmation(&self, input: &serde_json::Value, cx: &App) -> bool {
-        serde_json::from_value::<BatchToolInput>(input.clone())
-            .map(|input| {
-                let working_set = ToolWorkingSet::default();
-                input.invocations.iter().any(|invocation| {
-                    working_set
-                        .tool(&invocation.name, cx)
-                        .map_or(false, |tool| tool.needs_confirmation(&invocation.input, cx))
-                })
-            })
-            .unwrap_or(false)
-    }
-
-    fn description(&self) -> String {
-        include_str!("./batch_tool/description.md").into()
-    }
-
-    fn icon(&self) -> IconName {
-        IconName::Cog
-    }
-
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> serde_json::Value {
-        json_schema_for::<BatchToolInput>(format)
-    }
-
-    fn ui_text(&self, input: &serde_json::Value) -> String {
-        match serde_json::from_value::<BatchToolInput>(input.clone()) {
-            Ok(input) => {
-                let count = input.invocations.len();
-                let mode = if input.run_tools_concurrently {
-                    "concurrently"
-                } else {
-                    "sequentially"
-                };
-
-                let first_tool_name = input
-                    .invocations
-                    .first()
-                    .map(|inv| inv.name.clone())
-                    .unwrap_or_default();
-
-                let all_same = input
-                    .invocations
-                    .iter()
-                    .all(|invocation| invocation.name == first_tool_name);
-
-                if all_same {
-                    format!(
-                        "Run `{}` {} times {}",
-                        first_tool_name,
-                        input.invocations.len(),
-                        mode
-                    )
-                } else {
-                    format!("Run {} tools {}", count, mode)
-                }
-            }
-            Err(_) => "Batch tools".to_string(),
-        }
-    }
-
-    fn run(
-        self: Arc<Self>,
-        input: serde_json::Value,
-        messages: &[LanguageModelRequestMessage],
-        project: Entity<Project>,
-        action_log: Entity<ActionLog>,
-        cx: &mut App,
-    ) -> Task<Result<String>> {
-        let input = match serde_json::from_value::<BatchToolInput>(input) {
-            Ok(input) => input,
-            Err(err) => return Task::ready(Err(anyhow!(err))),
-        };
-
-        if input.invocations.is_empty() {
-            return Task::ready(Err(anyhow!("No tool invocations provided")));
-        }
-
-        let run_tools_concurrently = input.run_tools_concurrently;
-
-        let foreground_task = {
-            let working_set = ToolWorkingSet::default();
-            let invocations = input.invocations;
-            let messages = messages.to_vec();
-
-            cx.spawn(async move |cx| {
-                let mut tasks = Vec::new();
-                let mut tool_names = Vec::new();
-
-                for invocation in invocations {
-                    let tool_name = invocation.name.clone();
-                    tool_names.push(tool_name.clone());
-
-                    let tool = cx
-                        .update(|cx| working_set.tool(&tool_name, cx))
-                        .map_err(|err| {
-                            anyhow!("Failed to look up tool '{}': {}", tool_name, err)
-                        })?;
-
-                    let Some(tool) = tool else {
-                        return Err(anyhow!("Tool '{}' not found", tool_name));
-                    };
-
-                    let project = project.clone();
-                    let action_log = action_log.clone();
-                    let messages = messages.clone();
-                    let task = cx
-                        .update(|cx| tool.run(invocation.input, &messages, project, action_log, cx))
-                        .map_err(|err| anyhow!("Failed to start tool '{}': {}", tool_name, err))?;
-
-                    tasks.push(task);
-                }
-
-                Ok((tasks, tool_names))
-            })
-        };
-
-        cx.background_spawn(async move {
-            let (tasks, tool_names) = foreground_task.await?;
-            let mut results = Vec::with_capacity(tasks.len());
-
-            if run_tools_concurrently {
-                results.extend(join_all(tasks).await)
-            } else {
-                for task in tasks {
-                    results.push(task.await);
-                }
-            };
-
-            let mut formatted_results = String::new();
-            let mut error_occurred = false;
-
-            for (i, result) in results.into_iter().enumerate() {
-                let tool_name = &tool_names[i];
-
-                match result {
-                    Ok(output) => {
-                        formatted_results
-                            .push_str(&format!("Tool '{}' result:\n{}\n\n", tool_name, output));
-                    }
-                    Err(err) => {
-                        error_occurred = true;
-                        formatted_results
-                            .push_str(&format!("Tool '{}' error: {}\n\n", tool_name, err));
-                    }
-                }
-            }
-
-            if error_occurred {
-                formatted_results
-                    .push_str("Note: Some tool invocations failed. See individual results above.");
-            }
-
-            Ok(formatted_results.trim().to_string())
-        })
-    }
-}

crates/assistant_tools/src/code_action_tool.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, Entity, Task};
 use language::{self, Anchor, Buffer, ToPointUtf16};
 use language_model::LanguageModelRequestMessage;
@@ -143,7 +143,7 @@ impl Tool for CodeActionTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<CodeActionToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -251,7 +251,7 @@ impl Tool for CodeActionTool {
                     log.buffer_edited(buffer.clone(), cx)
                 })?;
 
-                Ok(response)
+                Ok((ResponseDest::TextOnly, response))
             } else {
                 // No action specified, so list the available ones.
                 let (position_start, position_end) = buffer.read_with(cx, |buffer, _| {
@@ -319,7 +319,7 @@ impl Tool for CodeActionTool {
                     }
                 }
 
-                Ok(response)
+                Ok((ResponseDest::TextOnly, response))
             }
         })
     }

crates/assistant_tools/src/code_symbols_tool.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use collections::IndexMap;
 use gpui::{App, AsyncApp, Entity, Task};
 use language::{OutlineItem, ParseStatus, Point};
@@ -129,7 +129,7 @@ impl Tool for CodeSymbolsTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<CodeSymbolsInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -146,9 +146,14 @@ impl Tool for CodeSymbolsTool {
             None => None,
         };
 
-        cx.spawn(async move |cx| match input.path {
-            Some(path) => file_outline(project, path, action_log, regex, input.offset, cx).await,
-            None => project_symbols(project, regex, input.offset, cx).await,
+        cx.spawn(async move |cx| {
+            match input.path {
+                Some(path) => {
+                    file_outline(project, path, action_log, regex, input.offset, cx).await
+                }
+                None => project_symbols(project, regex, input.offset, cx).await,
+            }
+            .map(|output| (ResponseDest::TextOnly, output))
         })
     }
 }

crates/assistant_tools/src/copy_path_tool.rs

@@ -1,5 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
+use assistant_tool::ResponseDest;
 use assistant_tool::{ActionLog, Tool};
 use gpui::{App, AppContext, Entity, Task};
 use language_model::LanguageModelRequestMessage;
@@ -77,7 +78,7 @@ impl Tool for CopyPathTool {
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<CopyPathToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -105,9 +106,9 @@ impl Tool for CopyPathTool {
 
         cx.background_spawn(async move {
             match copy_task.await {
-                Ok(_) => Ok(format!(
-                    "Copied {} to {}",
-                    input.source_path, input.destination_path
+                Ok(_) => Ok((
+                    ResponseDest::TextOnly,
+                    format!("Copied {} to {}", input.source_path, input.destination_path),
                 )),
                 Err(err) => Err(anyhow!(
                     "Failed to copy {} to {}: {}",

crates/assistant_tools/src/create_directory_tool.rs

@@ -1,5 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
+use assistant_tool::ResponseDest;
 use assistant_tool::{ActionLog, Tool};
 use gpui::{App, Entity, Task};
 use language_model::LanguageModelRequestMessage;
@@ -68,7 +69,7 @@ impl Tool for CreateDirectoryTool {
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<CreateDirectoryToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -87,7 +88,10 @@ impl Tool for CreateDirectoryTool {
                 .await
                 .map_err(|err| anyhow!("Unable to create directory {destination_path}: {err}"))?;
 
-            Ok(format!("Created directory {destination_path}"))
+            Ok((
+                ResponseDest::TextOnly,
+                format!("Created directory {destination_path}"),
+            ))
         })
     }
 }

crates/assistant_tools/src/create_file_tool.rs

@@ -1,5 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
+use assistant_tool::ResponseDest;
 use assistant_tool::{ActionLog, Tool};
 use gpui::{App, Entity, Task};
 use language_model::LanguageModelRequestMessage;
@@ -24,13 +25,6 @@ pub struct CreateFileToolInput {
     /// You can create a new file by providing a path of "directory1/new_file.txt"
     /// </example>
     pub path: String,
-
-    /// The text contents of the file to create.
-    ///
-    /// <example>
-    /// To create a file with the text "Hello, World!", provide contents of "Hello, World!"
-    /// </example>
-    pub contents: String,
 }
 
 pub struct CreateFileTool;
@@ -73,7 +67,7 @@ impl Tool for CreateFileTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<CreateFileToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -82,7 +76,6 @@ impl Tool for CreateFileTool {
             Some(project_path) => project_path,
             None => return Task::ready(Err(anyhow!("Path to create was outside the project"))),
         };
-        let contents: Arc<str> = input.contents.as_str().into();
         let destination_path: Arc<str> = input.path.as_str().into();
 
         cx.spawn(async move |cx| {
@@ -93,7 +86,6 @@ impl Tool for CreateFileTool {
                 .await
                 .map_err(|err| anyhow!("Unable to open buffer for {destination_path}: {err}"))?;
             cx.update(|cx| {
-                buffer.update(cx, |buffer, cx| buffer.set_text(contents, cx));
                 action_log.update(cx, |action_log, cx| {
                     action_log.will_create_buffer(buffer.clone(), cx)
                 });
@@ -104,7 +96,7 @@ impl Tool for CreateFileTool {
                 .await
                 .map_err(|err| anyhow!("Unable to save buffer for {destination_path}: {err}"))?;
 
-            Ok(format!("Created file {destination_path}"))
+            Ok((ResponseDest::File { path: destination_path.clone() }, format!("Created file {destination_path} - next, its exact contents will become your response:")))
         })
     }
 }

crates/assistant_tools/src/create_file_tool/description.md

@@ -1,3 +1,5 @@
-Creates a new file at the specified path within the project, containing the given text content. Returns confirmation that the file was created.
+Creates a new file at the specified path within the project. The entire message you respond with will then be streamed into the file.
 
-This tool is the most efficient way to create new files within the project, so it should always be chosen whenever it's necessary to create a new file in the project with specific text content, or whenever a file in the project needs such a drastic change that you would prefer to replace the entire thing instead of making individual edits. This tool should not be used when making changes to parts of an existing file but not all of it. In those cases, it's better to use another approach to edit the file.
+This tool is the most efficient way to create new files within the project, so it should always be chosen whenever it's necessary to create a new file in the project with specific text content, or whenever a file in the project needs such a drastic change that you would prefer to replace the entire thing instead of making individual edits. This tool should not be used when making changes to parts of an existing file but not all of it.
+
+Note that *all* the text you respond with will be streamed into the file, so you must ONLY respond with the contents of the file.

crates/assistant_tools/src/delete_path_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use futures::{SinkExt, StreamExt, channel::mpsc};
 use gpui::{App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -63,7 +63,7 @@ impl Tool for DeletePathTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let path_str = match serde_json::from_value::<DeletePathToolInput>(input) {
             Ok(input) => input.path,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -124,7 +124,7 @@ impl Tool for DeletePathTool {
 
             match delete {
                 Some(deletion_task) => match deletion_task.await {
-                    Ok(()) => Ok(format!("Deleted {path_str}")),
+                    Ok(()) => Ok((ResponseDest::TextOnly, format!("Deleted {path_str}"))),
                     Err(err) => Err(anyhow!("Failed to delete {path_str}: {err}")),
                 },
                 None => Err(anyhow!(

crates/assistant_tools/src/diagnostics_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, Entity, Task};
 use language::{DiagnosticSeverity, OffsetRangeExt};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -83,7 +83,7 @@ impl Tool for DiagnosticsTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         match serde_json::from_value::<DiagnosticsToolInput>(input)
             .ok()
             .and_then(|input| input.path)
@@ -119,11 +119,14 @@ impl Tool for DiagnosticsTool {
                         )?;
                     }
 
-                    if output.is_empty() {
-                        Ok("File doesn't have errors or warnings!".to_string())
-                    } else {
-                        Ok(output)
-                    }
+                    Ok((
+                        ResponseDest::TextOnly,
+                        if output.is_empty() {
+                            "File doesn't have errors or warnings!".to_string()
+                        } else {
+                            output
+                        },
+                    ))
                 })
             }
             _ => {
@@ -154,11 +157,14 @@ impl Tool for DiagnosticsTool {
                     action_log.checked_project_diagnostics();
                 });
 
-                if has_diagnostics {
-                    Task::ready(Ok(output))
-                } else {
-                    Task::ready(Ok("No errors or warnings found in the project.".to_string()))
-                }
+                Task::ready(Ok((
+                    ResponseDest::TextOnly,
+                    if has_diagnostics {
+                        output
+                    } else {
+                        "No errors or warnings found in the project.".to_string()
+                    },
+                )))
             }
         }
     }

crates/assistant_tools/src/fetch_tool.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use crate::schema::json_schema_for;
 use anyhow::{Context as _, Result, anyhow, bail};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use futures::AsyncReadExt as _;
 use gpui::{App, AppContext as _, Entity, Task};
 use html_to_markdown::{TagHandler, convert_html_to_markdown, markdown};
@@ -146,7 +146,7 @@ impl Tool for FetchTool {
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<FetchToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -164,7 +164,7 @@ impl Tool for FetchTool {
                 bail!("no textual content found");
             }
 
-            Ok(text)
+            Ok((ResponseDest::TextOnly, text))
         })
     }
 }

crates/assistant_tools/src/find_replace_file_tool.rs

@@ -1,6 +1,6 @@
 use crate::{replace::replace_with_flexible_indent, schema::json_schema_for};
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, AppContext, AsyncApp, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -169,7 +169,7 @@ impl Tool for FindReplaceFileTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<FindReplaceFileToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -261,8 +261,7 @@ impl Tool for FindReplaceFileTool {
             }).await;
 
 
-            Ok(format!("Edited {}:\n\n```diff\n{}\n```", input.path.display(), diff_str))
-
+            Ok((ResponseDest::TextOnly,format!("Edited {}:\n\n```diff\n{}\n```", input.path.display(), diff_str)))
         })
     }
 }

crates/assistant_tools/src/list_directory_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -77,7 +77,7 @@ impl Tool for ListDirectoryTool {
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<ListDirectoryToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -101,7 +101,7 @@ impl Tool for ListDirectoryTool {
                 .collect::<Vec<_>>()
                 .join("\n");
 
-            return Task::ready(Ok(output));
+            return Task::ready(Ok((ResponseDest::TextOnly, output)));
         }
 
         let Some(project_path) = project.read(cx).find_project_path(&input.path, cx) else {
@@ -132,9 +132,13 @@ impl Tool for ListDirectoryTool {
             )
             .unwrap();
         }
-        if output.is_empty() {
-            return Task::ready(Ok(format!("{} is empty.", input.path)));
-        }
-        Task::ready(Ok(output))
+        Task::ready(Ok((
+            ResponseDest::TextOnly,
+            if output.is_empty() {
+                format!("{} is empty.", input.path)
+            } else {
+                output
+            },
+        )))
     }
 }

crates/assistant_tools/src/move_path_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -90,7 +90,7 @@ impl Tool for MovePathTool {
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<MovePathToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -116,9 +116,9 @@ impl Tool for MovePathTool {
 
         cx.background_spawn(async move {
             match rename_task.await {
-                Ok(_) => Ok(format!(
-                    "Moved {} to {}",
-                    input.source_path, input.destination_path
+                Ok(_) => Ok((
+                    ResponseDest::TextOnly,
+                    format!("Moved {} to {}", input.source_path, input.destination_path),
                 )),
                 Err(err) => Err(anyhow!(
                     "Failed to move {} to {}: {}",

crates/assistant_tools/src/now_tool.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use chrono::{Local, Utc};
 use gpui::{App, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -60,7 +60,7 @@ impl Tool for NowTool {
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         _cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input: NowToolInput = match serde_json::from_value(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -72,6 +72,6 @@ impl Tool for NowTool {
         };
         let text = format!("The current datetime is {now}.");
 
-        Task::ready(Ok(text))
+        Task::ready(Ok((ResponseDest::TextOnly, text)))
     }
 }

crates/assistant_tools/src/open_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -53,7 +53,7 @@ impl Tool for OpenTool {
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input: OpenToolInput = match serde_json::from_value(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -62,7 +62,10 @@ impl Tool for OpenTool {
         cx.background_spawn(async move {
             open::that(&input.path_or_url).context("Failed to open URL or file path")?;
 
-            Ok(format!("Successfully opened {}", input.path_or_url))
+            Ok((
+                ResponseDest::TextOnly,
+                format!("Successfully opened {}", input.path_or_url),
+            ))
         })
     }
 }

crates/assistant_tools/src/path_search_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -71,7 +71,7 @@ impl Tool for PathSearchTool {
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let (offset, glob) = match serde_json::from_value::<PathSearchToolInput>(input) {
             Ok(input) => (input.offset, input.glob),
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -109,33 +109,35 @@ impl Tool for PathSearchTool {
                 }
             }
 
-            if matches.is_empty() {
-                Ok(format!("No paths in the project matched the glob {glob:?}"))
-            } else {
-                // Sort to group entries in the same directory together.
-                matches.sort();
-
-                let total_matches = matches.len();
-                let response = if total_matches > RESULTS_PER_PAGE + offset as usize {
-                let paginated_matches: Vec<_> = matches
-                      .into_iter()
-                      .skip(offset as usize)
-                      .take(RESULTS_PER_PAGE)
-                      .collect();
-
-                    format!(
-                        "Found {} total matches. Showing results {}-{} (provide 'offset' parameter for more results):\n\n{}",
-                        total_matches,
-                        offset + 1,
-                        offset as usize + paginated_matches.len(),
-                        paginated_matches.join("\n")
-                    )
+            Ok((ResponseDest::TextOnly,
+                if matches.is_empty() {
+                    format!("No paths in the project matched the glob {glob:?}")
                 } else {
-                    matches.join("\n")
-                };
+                    // Sort to group entries in the same directory together.
+                    matches.sort();
 
-                Ok(response)
-            }
-        })
+                    let total_matches = matches.len();
+                    let response = if total_matches > RESULTS_PER_PAGE + offset as usize {
+                    let paginated_matches: Vec<_> = matches
+                          .into_iter()
+                          .skip(offset as usize)
+                          .take(RESULTS_PER_PAGE)
+                          .collect();
+
+                        format!(
+                            "Found {} total matches. Showing results {}-{} (provide 'offset' parameter for more results):\n\n{}",
+                            total_matches,
+                            offset + 1,
+                            offset as usize + paginated_matches.len(),
+                            paginated_matches.join("\n")
+                        )
+                    } else {
+                        matches.join("\n")
+                    };
+
+                    response
+                }
+            ))
+          })
     }
 }

crates/assistant_tools/src/read_file_tool.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::{code_symbols_tool::file_outline, schema::json_schema_for};
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, Entity, Task};
 use itertools::Itertools;
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -88,7 +88,7 @@ impl Tool for ReadFileTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<ReadFileToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -106,46 +106,48 @@ impl Tool for ReadFileTool {
                 })?
                 .await?;
 
-            // Check if specific line ranges are provided
-            if input.start_line.is_some() || input.end_line.is_some() {
-                let result = buffer.read_with(cx, |buffer, _cx| {
-                    let text = buffer.text();
-                    let start = input.start_line.unwrap_or(1);
-                    let lines = text.split('\n').skip(start - 1);
-                    if let Some(end) = input.end_line {
-                        let count = end.saturating_sub(start).max(1); // Ensure at least 1 line
-                        Itertools::intersperse(lines.take(count), "\n").collect()
-                    } else {
-                        Itertools::intersperse(lines, "\n").collect()
-                    }
-                })?;
-
-                action_log.update(cx, |log, cx| {
-                    log.buffer_read(buffer, cx);
-                })?;
-
-                Ok(result)
-            } else {
-                // No line ranges specified, so check file size to see if it's too big.
-                let file_size = buffer.read_with(cx, |buffer, _cx| buffer.text().len())?;
-
-                if file_size <= MAX_FILE_SIZE_TO_READ {
-                    // File is small enough, so return its contents.
-                    let result = buffer.read_with(cx, |buffer, _cx| buffer.text())?;
+            Ok((ResponseDest::TextOnly,
+                // Check if specific line ranges are provided
+                if input.start_line.is_some() || input.end_line.is_some() {
+                    let answer = buffer.read_with(cx, |buffer, _cx| {
+                        let text = buffer.text();
+                        let start = input.start_line.unwrap_or(1);
+                        let lines = text.split('\n').skip(start - 1);
+                        if let Some(end) = input.end_line {
+                            let count = end.saturating_sub(start).max(1); // Ensure at least 1 line
+                            Itertools::intersperse(lines.take(count), "\n").collect()
+                        } else {
+                            Itertools::intersperse(lines, "\n").collect()
+                        }
+                    })?;
 
                     action_log.update(cx, |log, cx| {
                         log.buffer_read(buffer, cx);
                     })?;
 
-                    Ok(result)
+                    answer
                 } else {
-                    // File is too big, so return an error with the outline
-                    // and a suggestion to read again with line numbers.
-                    let outline = file_outline(project, file_path, action_log, None, 0, cx).await?;
+                    // No line ranges specified, so check file size to see if it's too big.
+                    let file_size = buffer.read_with(cx, |buffer, _cx| buffer.text().len())?;
 
-                    Ok(format!("This file was too big to read all at once. Here is an outline of its symbols:\n\n{outline}\n\nUsing the line numbers in this outline, you can call this tool again while specifying the start_line and end_line fields to see the implementations of symbols in the outline."))
+                    if file_size <= MAX_FILE_SIZE_TO_READ {
+                        // File is small enough, so return its contents.
+                        let answer = buffer.read_with(cx, |buffer, _cx| buffer.text())?;
+
+                        action_log.update(cx, |log, cx| {
+                            log.buffer_read(buffer, cx);
+                        })?;
+
+                        answer
+                    } else {
+                        // File is too big, so return an error with the outline
+                        // and a suggestion to read again with line numbers.
+                        let outline = file_outline(project, file_path, action_log, None, 0, cx).await?;
+
+                        format!("This file was too big to read all at once. Here is an outline of its symbols:\n\n{outline}\n\nUsing the line numbers in this outline, you can call this tool again while specifying the start_line and end_line fields to see the implementations of symbols in the outline.")
+                    }
                 }
-            }
+            ))
         })
     }
 }

crates/assistant_tools/src/regex_search_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use futures::StreamExt;
 use gpui::{App, Entity, Task};
 use language::OffsetRangeExt;
@@ -92,7 +92,7 @@ impl Tool for RegexSearchTool {
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         const CONTEXT_LINES: u32 = 2;
 
         let (offset, regex, case_sensitive) =
@@ -189,18 +189,20 @@ impl Tool for RegexSearchTool {
                 })??;
             }
 
-            if matches_found == 0 {
-                Ok("No matches found".to_string())
-            } else if has_more_matches {
-                Ok(format!(
-                    "Showing matches {}-{} (there were more matches found; use offset: {} to see next page):\n{output}",
-                    offset + 1,
-                    offset + matches_found,
-                    offset + RESULTS_PER_PAGE,
-                ))
-            } else {
-                Ok(format!("Found {matches_found} matches:\n{output}"))
-            }
+            Ok((ResponseDest::TextOnly,
+                if matches_found == 0 {
+                    "No matches found".to_string()
+                } else if has_more_matches {
+                    format!(
+                        "Showing matches {}-{} (there were more matches found; use offset: {} to see next page):\n{output}",
+                        offset + 1,
+                        offset + matches_found,
+                        offset + RESULTS_PER_PAGE,
+                    )
+                } else {
+                    format!("Found {matches_found} matches:\n{output}")
+                }
+            ))
         })
     }
 }

crates/assistant_tools/src/rename_tool.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, Entity, Task};
 use language::{self, Buffer, ToPointUtf16};
 use language_model::LanguageModelRequestMessage;
@@ -90,7 +90,7 @@ impl Tool for RenameTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<RenameToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -139,7 +139,7 @@ impl Tool for RenameTool {
                 log.buffer_edited(buffer.clone(), cx)
             })?;
 
-            Ok(format!("Renamed '{}' to '{}'", input.symbol, input.new_name))
+            Ok((ResponseDest::TextOnly, format!("Renamed '{}' to '{}'", input.symbol, input.new_name)))
         })
     }
 }

crates/assistant_tools/src/symbol_info_tool.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, AsyncApp, Entity, Task};
 use language::{self, Anchor, Buffer, BufferSnapshot, Location, Point, ToPoint, ToPointUtf16};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -122,7 +122,7 @@ impl Tool for SymbolInfoTool {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input = match serde_json::from_value::<SymbolInfoToolInput>(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -203,7 +203,7 @@ impl Tool for SymbolInfoTool {
             if output.is_empty() {
                 Err(anyhow!("None found."))
             } else {
-                Ok(output)
+                Ok((ResponseDest::TextOnly, output))
             }
         })
     }

crates/assistant_tools/src/terminal_tool.rs

@@ -1,6 +1,6 @@
 use crate::schema::json_schema_for;
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use futures::io::BufReader;
 use futures::{AsyncBufReadExt, AsyncReadExt, FutureExt};
 use gpui::{App, AppContext, Entity, Task};
@@ -79,7 +79,7 @@ impl Tool for TerminalTool {
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         let input: TerminalToolInput = match serde_json::from_value(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
@@ -132,7 +132,10 @@ impl Tool for TerminalTool {
 
 const LIMIT: usize = 16 * 1024;
 
-async fn run_command_limited(working_dir: Arc<Path>, command: String) -> Result<String> {
+async fn run_command_limited(
+    working_dir: Arc<Path>,
+    command: String,
+) -> Result<(ResponseDest, String)> {
     let shell = get_system_shell();
 
     let mut cmd = new_smol_command(&shell)
@@ -231,7 +234,7 @@ async fn run_command_limited(working_dir: Arc<Path>, command: String) -> Result<
         )
     };
 
-    Ok(output_with_status)
+    Ok((ResponseDest::TextOnly, output_with_status))
 }
 
 async fn consume_reader<T: AsyncReadExt + Unpin>(
@@ -275,7 +278,7 @@ mod tests {
             run_command_limited(Path::new(".").into(), "echo 'Hello, World!'".to_string()).await;
 
         assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "```\nHello, World!\n```");
+        assert_eq!(result.unwrap().1, "```\nHello, World!\n```");
     }
 
     #[gpui::test(iterations = 10)]
@@ -287,7 +290,7 @@ mod tests {
 
         assert!(result.is_ok());
         assert_eq!(
-            result.unwrap(),
+            result.unwrap().1,
             "```\nstdout 1\nstderr 1\nstdout 2\nstderr 2\n```"
         );
     }
@@ -304,7 +307,7 @@ mod tests {
         .await;
 
         assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "```\n1\n2\n3\n```");
+        assert_eq!(result.unwrap().1, "```\n1\n2\n3\n```");
     }
 
     #[gpui::test(iterations = 10)]
@@ -316,7 +319,7 @@ mod tests {
         let result = run_command_limited(Path::new(".").into(), cmd).await;
 
         assert!(result.is_ok());
-        let output = result.unwrap();
+        let output = result.unwrap().1;
 
         let content_start = output.find("```\n").map(|i| i + 4).unwrap_or(0);
         let content_end = output.rfind("\n```").unwrap_or(output.len());
@@ -334,7 +337,7 @@ mod tests {
         let result = run_command_limited(Path::new(".").into(), cmd).await;
 
         assert!(result.is_ok());
-        let output = result.unwrap();
+        let output = result.unwrap().1;
 
         assert!(output.starts_with("Command output too long. The first 16334 bytes:\n\n"));
 
@@ -352,7 +355,7 @@ mod tests {
         let result = run_command_limited(Path::new(".").into(), "exit 42".to_string()).await;
 
         assert!(result.is_ok());
-        let output = result.unwrap();
+        let output = result.unwrap().1;
 
         // Extract the shell name from path for cleaner test output
         let shell_path = std::env::var("SHELL").unwrap_or("bash".to_string());

crates/assistant_tools/src/thinking_tool.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
+use assistant_tool::{ActionLog, ResponseDest, Tool};
 use gpui::{App, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -51,10 +51,10 @@ impl Tool for ThinkingTool {
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         _cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         // This tool just "thinks out loud" and doesn't perform any actions.
         Task::ready(match serde_json::from_value::<ThinkingToolInput>(input) {
-            Ok(_input) => Ok("Finished thinking.".to_string()),
+            Ok(_input) => Ok((ResponseDest::TextOnly, "Finished thinking.".to_string())),
             Err(err) => Err(anyhow!(err)),
         })
     }

crates/context_server/src/context_server_tool.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use anyhow::{Result, anyhow, bail};
-use assistant_tool::{ActionLog, Tool, ToolSource};
+use assistant_tool::{ActionLog, ResponseDest, Tool, ToolSource};
 use gpui::{App, Entity, Task};
 use icons::IconName;
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -76,7 +76,7 @@ impl Tool for ContextServerTool {
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<(ResponseDest, String)>> {
         if let Some(server) = self.server_manager.read(cx).get_server(&self.server_id) {
             let tool_name = self.tool.name.clone();
             let server_clone = server.clone();
@@ -114,7 +114,7 @@ impl Tool for ContextServerTool {
                         }
                     }
                 }
-                Ok(result)
+                Ok((ResponseDest::TextOnly, result))
             })
         } else {
             Task::ready(Err(anyhow!("Context server not found")))