Bump to 0.184.10 for @maxdeviant

Cherry-picked language_models: Pass up `mode` from the
`LanguageModelRequest` (#29552)

This PR makes it so we pass up the `mode` from the
`LanguageModelRequest` when interacting with the Zed provider instead of
passing a hard-coded value.

Release Notes:

- agent: Fixed an issue where max mode was always being used.

Co-authored-by: Marshall Bowers <git@maxdeviant.com>

Cargo.toml

@@ -109,7 +109,7 @@ members = [
     "crates/project",
     "crates/project_panel",
     "crates/project_symbols",
-    "crates/prompt_library",
+    "crates/rules_library",
     "crates/prompt_store",
     "crates/proto",
     "crates/recent_projects",
@@ -318,7 +318,7 @@ prettier = { path = "crates/prettier" }
 project = { path = "crates/project" }
 project_panel = { path = "crates/project_panel" }
 project_symbols = { path = "crates/project_symbols" }
-prompt_library = { path = "crates/prompt_library" }
+rules_library = { path = "crates/rules_library" }
 prompt_store = { path = "crates/prompt_store" }
 proto = { path = "crates/proto" }
 recent_projects = { path = "crates/recent_projects" }
@@ -499,6 +499,7 @@ prost-types = "0.9"
 pulldown-cmark = { version = "0.12.0", default-features = false }
 quote = "1.0.9"
 rand = "0.8.5"
+ref-cast = "1.0.24"
 rayon = "1.8"
 regex = "1.5"
 repair_json = "0.1.0"
@@ -605,7 +606,7 @@ wasmtime-wasi = "29"
 which = "6.0.0"
 wit-component = "0.221"
 workspace-hack = "0.1.0"
-zed_llm_client = "0.6.1"
+zed_llm_client = "0.7.1"
 zstd = "0.11"
 metal = "0.29"
 

assets/icons/zed_max_mode.svg

@@ -0,0 +1,14 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_2489_484)">
+<path d="M11 8.9V11C8.51716 11 7.48284 11 5 11V10.4L11 5.6V5H5V7.1" stroke="black" stroke-width="1.5"/>
+<path d="M1.5 5.5V1.5H5" stroke="black" stroke-opacity="0.5" stroke-width="1.5"/>
+<path d="M14.5 5.5V1.5H11" stroke="black" stroke-opacity="0.5" stroke-width="1.5"/>
+<path d="M1.5 10.5V14.5H5" stroke="black" stroke-opacity="0.5" stroke-width="1.5"/>
+<path d="M14.5 10.5V14.5H11" stroke="black" stroke-opacity="0.5" stroke-width="1.5"/>
+</g>
+<defs>
+<clipPath id="clip0_2489_484">
+<rect width="16" height="16" fill="white"/>
+</clipPath>
+</defs>
+</svg>

assets/keymaps/default-linux.json

@@ -212,7 +212,7 @@
       "ctrl-shift-g": "search::SelectPreviousMatch",
       "ctrl-alt-/": "assistant::ToggleModelSelector",
       "ctrl-k h": "assistant::DeployHistory",
-      "ctrl-k l": "assistant::OpenPromptLibrary",
+      "ctrl-k l": "assistant::OpenRulesLibrary",
       "new": "assistant::NewChat",
       "ctrl-t": "assistant::NewChat",
       "ctrl-n": "assistant::NewChat"
@@ -241,7 +241,7 @@
       "ctrl-alt-n": "agent::NewTextThread",
       "ctrl-shift-h": "agent::OpenHistory",
       "ctrl-alt-c": "agent::OpenConfiguration",
-      "ctrl-alt-p": "assistant::OpenPromptLibrary",
+      "ctrl-alt-p": "assistant::OpenRulesLibrary",
       "ctrl-i": "agent::ToggleProfileSelector",
       "ctrl-alt-/": "assistant::ToggleModelSelector",
       "ctrl-shift-a": "agent::ToggleContextPicker",
@@ -308,9 +308,9 @@
   {
     "context": "PromptLibrary",
     "bindings": {
-      "new": "prompt_library::NewPrompt",
-      "ctrl-n": "prompt_library::NewPrompt",
-      "ctrl-shift-s": "prompt_library::ToggleDefaultPrompt"
+      "new": "rules_library::NewRule",
+      "ctrl-n": "rules_library::NewRule",
+      "ctrl-shift-s": "rules_library::ToggleDefaultRule"
     }
   },
   {
@@ -675,7 +675,7 @@
     }
   },
   {
-    "context": "Editor && mode == full",
+    "context": "!ContextEditor > Editor && mode == full",
     "bindings": {
       "alt-enter": "editor::OpenExcerpts",
       "shift-enter": "editor::ExpandExcerpts",

assets/keymaps/default-macos.json

@@ -5,8 +5,8 @@
     "context": "PromptLibrary",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-n": "prompt_library::NewPrompt",
-      "cmd-shift-s": "prompt_library::ToggleDefaultPrompt",
+      "cmd-n": "rules_library::NewRule",
+      "cmd-shift-s": "rules_library::ToggleDefaultRule",
       "cmd-w": "workspace::CloseWindow"
     }
   },
@@ -257,7 +257,7 @@
       "cmd-shift-g": "search::SelectPreviousMatch",
       "cmd-alt-/": "assistant::ToggleModelSelector",
       "cmd-k h": "assistant::DeployHistory",
-      "cmd-k l": "assistant::OpenPromptLibrary",
+      "cmd-k l": "assistant::OpenRulesLibrary",
       "cmd-t": "assistant::NewChat",
       "cmd-n": "assistant::NewChat"
     }
@@ -286,7 +286,7 @@
       "cmd-alt-n": "agent::NewTextThread",
       "cmd-shift-h": "agent::OpenHistory",
       "cmd-alt-c": "agent::OpenConfiguration",
-      "cmd-alt-p": "assistant::OpenPromptLibrary",
+      "cmd-alt-p": "assistant::OpenRulesLibrary",
       "cmd-i": "agent::ToggleProfileSelector",
       "cmd-alt-/": "assistant::ToggleModelSelector",
       "cmd-shift-a": "agent::ToggleContextPicker",
@@ -738,7 +738,7 @@
     }
   },
   {
-    "context": "Editor && mode == full",
+    "context": "!ContextEditor > Editor && mode == full",
     "use_key_equivalents": true,
     "bindings": {
       "alt-enter": "editor::OpenExcerpts",

assets/prompts/assistant_system_prompt.hbs

@@ -27,10 +27,28 @@ If appropriate, use tool calls to explore the current project, which contains th
 - `{{root_name}}`
 {{/each}}
 
+- Bias towards not asking the user for help if you can find the answer yourself.
 - When providing paths to tools, the path should always begin with a path that starts with a project root directory listed above.
+- Before you read or edit a file, you must first find the full path. DO NOT ever guess a file path!
+{{# if (has_tool 'grep') }}
 - When looking for symbols in the project, prefer the `grep` tool.
 - As you learn about the structure of the project, use that information to scope `grep` searches to targeted subtrees of the project.
-- Bias towards not asking the user for help if you can find the answer yourself.
+- The user might specify a partial file path. If you don't know the full path, use `find_path` (not `grep`) before you read the file.
+{{/if}}
+
+## Code Block Formatting
+
+Whenever you mention a code block, you MUST use ONLY use the following format when the code in the block comes from a file
+in the project:
+
+```path/to/Something.blah#L123-456
+(code goes here)
+```
+
+The `#L123-456` means the line number range 123 through 456, and the path/to/Something.blah
+is a path in the project. (If this code block does not come from a file in the project, then you may instead use
+the normal markdown style of three backticks followed by language name. However, you MUST use this format if
+the code in the block comes from a file in the project.)
 
 ## Fixing Diagnostics
 

assets/settings/default.json

@@ -167,7 +167,23 @@
   // Default: not set, defaults to "bar"
   "cursor_shape": null,
   // Determines when the mouse cursor should be hidden in an editor or input box.
+  //
+  // 1. Never hide the mouse cursor:
+  //    "never"
+  // 2. Hide only when typing:
+  //    "on_typing"
+  // 3. Hide on both typing and cursor movement:
+  //    "on_typing_and_movement"
   "hide_mouse": "on_typing_and_movement",
+  // Determines how snippets are sorted relative to other completion items.
+  //
+  // 1. Place snippets at the top of the completion list:
+  //    "top"
+  // 2. Place snippets normally without any preference:
+  //    "inline"
+  // 3. Place snippets at the bottom of the completion list:
+  //    "bottom"
+  "snippet_sort_order": "inline",
   // How to highlight the current line in the editor.
   //
   // 1. Don't highlight the current line:
@@ -646,7 +662,7 @@
           "fetch": true,
           "list_directory": false,
           "now": true,
-          "path_search": true,
+          "find_path": true,
           "read_file": true,
           "grep": true,
           "thinking": true,
@@ -670,7 +686,7 @@
           "list_directory": true,
           "move_path": false,
           "now": false,
-          "path_search": true,
+          "find_path": true,
           "read_file": true,
           "grep": true,
           "rename": false,

clippy.toml

@@ -1,2 +1,7 @@
 allow-private-module-inception = true
 avoid-breaking-exported-api = false
+ignore-interior-mutability = [
+    # Suppresses clippy::mutable_key_type, which is a false positive as the Eq
+    # and Hash impls do not use fields with interior mutability.
+    "agent::context::AgentContextKey"
+]

crates/agent/Cargo.toml

@@ -28,7 +28,6 @@ async-watch.workspace = true
 buffer_diff.workspace = true
 chrono.workspace = true
 client.workspace = true
-clock.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 component.workspace = true
@@ -62,9 +61,10 @@ parking_lot.workspace = true
 paths.workspace = true
 picker.workspace = true
 project.workspace = true
-prompt_library.workspace = true
+rules_library.workspace = true
 prompt_store.workspace = true
 proto.workspace = true
+ref-cast.workspace = true
 release_channel.workspace = true
 rope.workspace = true
 schemars.workspace = true

crates/agent/src/agent_diff.rs

@@ -962,11 +962,13 @@ mod tests {
             })
             .unwrap();
 
+        let prompt_store = None;
         let thread_store = cx
             .update(|cx| {
                 ThreadStore::load(
                     project.clone(),
                     cx.new(|_| ToolWorkingSet::default()),
+                    prompt_store,
                     Arc::new(PromptBuilder::new(None).unwrap()),
                     cx,
                 )

crates/agent/src/assistant.rs

@@ -39,6 +39,7 @@ use thread::ThreadId;
 pub use crate::active_thread::ActiveThread;
 use crate::assistant_configuration::{AddContextServerModal, ManageProfilesModal};
 pub use crate::assistant_panel::{AssistantPanel, ConcreteAssistantPanelDelegate};
+pub use crate::context::{ContextLoadResult, LoadedContext};
 pub use crate::inline_assistant::InlineAssistant;
 pub use crate::thread::{Message, Thread, ThreadEvent};
 pub use crate::thread_store::ThreadStore;

crates/agent/src/assistant_configuration/tool_picker.rs

@@ -271,7 +271,7 @@ impl PickerDelegate for ToolPickerDelegate {
                 .get(id.as_ref())
                 .and_then(|preset| preset.tools.get(&tool.name))
                 .copied()
-                .unwrap_or(false),
+                .unwrap_or(self.profile.enable_all_context_servers),
         };
 
         Some(

crates/agent/src/assistant_panel.rs

@@ -5,28 +5,29 @@ use std::time::Duration;
 
 use anyhow::{Result, anyhow};
 use assistant_context_editor::{
-    AssistantPanelDelegate, ConfigurationError, ContextEditor, SlashCommandCompletionProvider,
-    humanize_token_count, make_lsp_adapter_delegate, render_remaining_tokens,
+    AssistantContext, AssistantPanelDelegate, ConfigurationError, ContextEditor, ContextEvent,
+    SlashCommandCompletionProvider, humanize_token_count, make_lsp_adapter_delegate,
+    render_remaining_tokens,
 };
 use assistant_settings::{AssistantDockPosition, AssistantSettings};
 use assistant_slash_command::SlashCommandWorkingSet;
 use assistant_tool::ToolWorkingSet;
 
-use client::zed_urls;
+use client::{UserStore, zed_urls};
 use editor::{Anchor, AnchorRangeExt as _, Editor, EditorEvent, MultiBuffer};
 use fs::Fs;
 use gpui::{
-    Action, Animation, AnimationExt as _, AnyElement, App, AsyncWindowContext, Corner, Entity,
-    EventEmitter, FocusHandle, Focusable, FontWeight, KeyContext, Pixels, Subscription, Task,
-    UpdateGlobal, WeakEntity, prelude::*, pulsating_between,
+    Action, Animation, AnimationExt as _, AnyElement, App, AsyncWindowContext, ClipboardItem,
+    Corner, Entity, EventEmitter, FocusHandle, Focusable, FontWeight, KeyContext, Pixels,
+    Subscription, Task, UpdateGlobal, WeakEntity, prelude::*, pulsating_between,
 };
 use language::LanguageRegistry;
 use language_model::{LanguageModelProviderTosView, LanguageModelRegistry};
 use language_model_selector::ToggleModelSelector;
 use project::Project;
-use prompt_library::{PromptLibrary, open_prompt_library};
-use prompt_store::{PromptBuilder, PromptId, UserPromptId};
+use prompt_store::{PromptBuilder, PromptStore, UserPromptId};
 use proto::Plan;
+use rules_library::{RulesLibrary, open_rules_library};
 use settings::{Settings, update_settings_file};
 use time::UtcOffset;
 use ui::{
@@ -36,7 +37,7 @@ use util::ResultExt as _;
 use workspace::Workspace;
 use workspace::dock::{DockPosition, Panel, PanelEvent};
 use zed_actions::agent::OpenConfiguration;
-use zed_actions::assistant::{OpenPromptLibrary, ToggleFocus};
+use zed_actions::assistant::{OpenRulesLibrary, ToggleFocus};
 
 use crate::active_thread::{ActiveThread, ActiveThreadEvent};
 use crate::assistant_configuration::{AssistantConfiguration, AssistantConfigurationEvent};
@@ -79,11 +80,11 @@ pub fn init(cx: &mut App) {
                         panel.update(cx, |panel, cx| panel.new_prompt_editor(window, cx));
                     }
                 })
-                .register_action(|workspace, action: &OpenPromptLibrary, window, cx| {
+                .register_action(|workspace, action: &OpenRulesLibrary, window, cx| {
                     if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
                         workspace.focus_panel::<AssistantPanel>(window, cx);
                         panel.update(cx, |panel, cx| {
-                            panel.deploy_prompt_library(action, window, cx)
+                            panel.deploy_rules_library(action, window, cx)
                         });
                     }
                 })
@@ -116,6 +117,8 @@ enum ActiveView {
     },
     PromptEditor {
         context_editor: Entity<ContextEditor>,
+        title_editor: Entity<Editor>,
+        _subscriptions: Vec<gpui::Subscription>,
     },
     History,
     Configuration,
@@ -176,10 +179,88 @@ impl ActiveView {
             _subscriptions: subscriptions,
         }
     }
+
+    pub fn prompt_editor(
+        context_editor: Entity<ContextEditor>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Self {
+        let title = context_editor.read(cx).title(cx).to_string();
+
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::single_line(window, cx);
+            editor.set_text(title, window, cx);
+            editor
+        });
+
+        // This is a workaround for `editor.set_text` emitting a `BufferEdited` event, which would
+        // cause a custom summary to be set. The presence of this custom summary would cause
+        // summarization to not happen.
+        let mut suppress_first_edit = true;
+
+        let subscriptions = vec![
+            window.subscribe(&editor, cx, {
+                {
+                    let context_editor = context_editor.clone();
+                    move |editor, event, window, cx| match event {
+                        EditorEvent::BufferEdited => {
+                            if suppress_first_edit {
+                                suppress_first_edit = false;
+                                return;
+                            }
+                            let new_summary = editor.read(cx).text(cx);
+
+                            context_editor.update(cx, |context_editor, cx| {
+                                context_editor
+                                    .context()
+                                    .update(cx, |assistant_context, cx| {
+                                        assistant_context.set_custom_summary(new_summary, cx);
+                                    })
+                            })
+                        }
+                        EditorEvent::Blurred => {
+                            if editor.read(cx).text(cx).is_empty() {
+                                let summary = context_editor
+                                    .read(cx)
+                                    .context()
+                                    .read(cx)
+                                    .summary_or_default();
+
+                                editor.update(cx, |editor, cx| {
+                                    editor.set_text(summary, window, cx);
+                                });
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }),
+            window.subscribe(&context_editor.read(cx).context().clone(), cx, {
+                let editor = editor.clone();
+                move |assistant_context, event, window, cx| match event {
+                    ContextEvent::SummaryGenerated => {
+                        let summary = assistant_context.read(cx).summary_or_default();
+
+                        editor.update(cx, |editor, cx| {
+                            editor.set_text(summary, window, cx);
+                        })
+                    }
+                    _ => {}
+                }
+            }),
+        ];
+
+        Self::PromptEditor {
+            context_editor,
+            title_editor: editor,
+            _subscriptions: subscriptions,
+        }
+    }
 }
 
 pub struct AssistantPanel {
     workspace: WeakEntity<Workspace>,
+    user_store: Entity<UserStore>,
     project: Entity<Project>,
     fs: Arc<dyn Fs>,
     language_registry: Arc<LanguageRegistry>,
@@ -188,6 +269,7 @@ pub struct AssistantPanel {
     message_editor: Entity<MessageEditor>,
     _active_thread_subscriptions: Vec<Subscription>,
     context_store: Entity<assistant_context_editor::ContextStore>,
+    prompt_store: Option<Entity<PromptStore>>,
     configuration: Option<Entity<AssistantConfiguration>>,
     configuration_subscription: Option<Subscription>,
     local_timezone: UtcOffset,
@@ -204,14 +286,25 @@ impl AssistantPanel {
     pub fn load(
         workspace: WeakEntity<Workspace>,
         prompt_builder: Arc<PromptBuilder>,
-        cx: AsyncWindowContext,
+        mut cx: AsyncWindowContext,
     ) -> Task<Result<Entity<Self>>> {
+        let prompt_store = cx.update(|_window, cx| PromptStore::global(cx));
         cx.spawn(async move |cx| {
+            let prompt_store = match prompt_store {
+                Ok(prompt_store) => prompt_store.await.ok(),
+                Err(_) => None,
+            };
             let tools = cx.new(|_| ToolWorkingSet::default())?;
             let thread_store = workspace
                 .update(cx, |workspace, cx| {
                     let project = workspace.project().clone();
-                    ThreadStore::load(project, tools.clone(), prompt_builder.clone(), cx)
+                    ThreadStore::load(
+                        project,
+                        tools.clone(),
+                        prompt_store.clone(),
+                        prompt_builder.clone(),
+                        cx,
+                    )
                 })?
                 .await?;
 
@@ -229,7 +322,16 @@ impl AssistantPanel {
                 .await?;
 
             workspace.update_in(cx, |workspace, window, cx| {
-                cx.new(|cx| Self::new(workspace, thread_store, context_store, window, cx))
+                cx.new(|cx| {
+                    Self::new(
+                        workspace,
+                        thread_store,
+                        context_store,
+                        prompt_store,
+                        window,
+                        cx,
+                    )
+                })
             })
         })
     }
@@ -238,11 +340,13 @@ impl AssistantPanel {
         workspace: &Workspace,
         thread_store: Entity<ThreadStore>,
         context_store: Entity<assistant_context_editor::ContextStore>,
+        prompt_store: Option<Entity<PromptStore>>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
         let thread = thread_store.update(cx, |this, cx| this.create_thread(cx));
         let fs = workspace.app_state().fs.clone();
+        let user_store = workspace.app_state().user_store.clone();
         let project = workspace.project();
         let language_registry = project.read(cx).languages().clone();
         let workspace = workspace.weak_handle();
@@ -260,6 +364,7 @@ impl AssistantPanel {
                 fs.clone(),
                 workspace.clone(),
                 message_editor_context_store.clone(),
+                prompt_store.clone(),
                 thread_store.downgrade(),
                 thread.clone(),
                 window,
@@ -291,7 +396,6 @@ impl AssistantPanel {
                 thread.clone(),
                 thread_store.clone(),
                 language_registry.clone(),
-                message_editor_context_store.clone(),
                 workspace.clone(),
                 window,
                 cx,
@@ -307,6 +411,7 @@ impl AssistantPanel {
         Self {
             active_view,
             workspace,
+            user_store,
             project: project.clone(),
             fs: fs.clone(),
             language_registry,
@@ -319,6 +424,7 @@ impl AssistantPanel {
                 message_editor_subscription,
             ],
             context_store,
+            prompt_store,
             configuration: None,
             configuration_subscription: None,
             local_timezone: UtcOffset::from_whole_seconds(
@@ -352,18 +458,17 @@ impl AssistantPanel {
         self.local_timezone
     }
 
+    pub(crate) fn prompt_store(&self) -> &Option<Entity<PromptStore>> {
+        &self.prompt_store
+    }
+
     pub(crate) fn thread_store(&self) -> &Entity<ThreadStore> {
         &self.thread_store
     }
 
-    fn cancel(
-        &mut self,
-        _: &editor::actions::Cancel,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
+    fn cancel(&mut self, _: &editor::actions::Cancel, window: &mut Window, cx: &mut Context<Self>) {
         self.thread
-            .update(cx, |thread, cx| thread.cancel_last_completion(cx));
+            .update(cx, |thread, cx| thread.cancel_last_completion(window, cx));
     }
 
     fn new_thread(&mut self, action: &NewThread, window: &mut Window, cx: &mut Context<Self>) {
@@ -413,7 +518,6 @@ impl AssistantPanel {
                 thread.clone(),
                 self.thread_store.clone(),
                 self.language_registry.clone(),
-                message_editor_context_store.clone(),
                 self.workspace.clone(),
                 window,
                 cx,
@@ -432,6 +536,7 @@ impl AssistantPanel {
                 self.fs.clone(),
                 self.workspace.clone(),
                 message_editor_context_store,
+                self.prompt_store.clone(),
                 self.thread_store.downgrade(),
                 thread,
                 window,
@@ -477,22 +582,20 @@ impl AssistantPanel {
         });
 
         self.set_active_view(
-            ActiveView::PromptEditor {
-                context_editor: context_editor.clone(),
-            },
+            ActiveView::prompt_editor(context_editor.clone(), window, cx),
             window,
             cx,
         );
         context_editor.focus_handle(cx).focus(window);
     }
 
-    fn deploy_prompt_library(
+    fn deploy_rules_library(
         &mut self,
-        action: &OpenPromptLibrary,
+        action: &OpenRulesLibrary,
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        open_prompt_library(
+        open_rules_library(
             self.language_registry.clone(),
             Box::new(PromptLibraryInlineAssist::new(self.workspace.clone())),
             Arc::new(|| {
@@ -502,9 +605,9 @@ impl AssistantPanel {
                     None,
                 ))
             }),
-            action.prompt_to_select.map(|uuid| PromptId::User {
-                uuid: UserPromptId(uuid),
-            }),
+            action
+                .prompt_to_select
+                .map(|uuid| UserPromptId(uuid).into()),
             cx,
         )
         .detach_and_log_err(cx);
@@ -553,10 +656,9 @@ impl AssistantPanel {
                         cx,
                     )
                 });
+
                 this.set_active_view(
-                    ActiveView::PromptEditor {
-                        context_editor: editor,
-                    },
+                    ActiveView::prompt_editor(editor.clone(), window, cx),
                     window,
                     cx,
                 );
@@ -600,7 +702,6 @@ impl AssistantPanel {
                         thread.clone(),
                         this.thread_store.clone(),
                         this.language_registry.clone(),
-                        message_editor_context_store.clone(),
                         this.workspace.clone(),
                         window,
                         cx,
@@ -619,6 +720,7 @@ impl AssistantPanel {
                         this.fs.clone(),
                         this.workspace.clone(),
                         message_editor_context_store,
+                        this.prompt_store.clone(),
                         this.thread_store.downgrade(),
                         thread,
                         window,
@@ -796,7 +898,7 @@ impl AssistantPanel {
 
     pub(crate) fn active_context_editor(&self) -> Option<Entity<ContextEditor>> {
         match &self.active_view {
-            ActiveView::PromptEditor { context_editor } => Some(context_editor.clone()),
+            ActiveView::PromptEditor { context_editor, .. } => Some(context_editor.clone()),
             _ => None,
         }
     }
@@ -839,7 +941,7 @@ impl Focusable for AssistantPanel {
         match &self.active_view {
             ActiveView::Thread { .. } => self.message_editor.focus_handle(cx),
             ActiveView::History => self.history.focus_handle(cx),
-            ActiveView::PromptEditor { context_editor } => context_editor.focus_handle(cx),
+            ActiveView::PromptEditor { context_editor, .. } => context_editor.focus_handle(cx),
             ActiveView::Configuration => {
                 if let Some(configuration) = self.configuration.as_ref() {
                     configuration.focus_handle(cx)
@@ -963,9 +1065,34 @@ impl AssistantPanel {
                         .into_any_element()
                 }
             }
-            ActiveView::PromptEditor { context_editor } => {
-                let title = SharedString::from(context_editor.read(cx).title(cx).to_string());
-                Label::new(title).ml_2().truncate().into_any_element()
+            ActiveView::PromptEditor {
+                title_editor,
+                context_editor,
+                ..
+            } => {
+                let context_editor = context_editor.read(cx);
+                let summary = context_editor.context().read(cx).summary();
+
+                match summary {
+                    None => Label::new(AssistantContext::DEFAULT_SUMMARY.clone())
+                        .truncate()
+                        .ml_2()
+                        .into_any_element(),
+                    Some(summary) => {
+                        if summary.done {
+                            div()
+                                .ml_2()
+                                .w_full()
+                                .child(title_editor.clone())
+                                .into_any_element()
+                        } else {
+                            Label::new(LOADING_SUMMARY_PLACEHOLDER)
+                                .ml_2()
+                                .truncate()
+                                .into_any_element()
+                        }
+                    }
+                }
             }
             ActiveView::History => Label::new("History").truncate().into_any_element(),
             ActiveView::Configuration => Label::new("Settings").truncate().into_any_element(),
@@ -1122,7 +1249,7 @@ impl AssistantPanel {
                                                     "New Text Thread",
                                                     NewTextThread.boxed_clone(),
                                                 )
-                                                .action("Prompt Library", Box::new(OpenPromptLibrary::default()))
+                                                .action("Rules Library", Box::new(OpenRulesLibrary::default()))
                                                 .action("Settings", Box::new(OpenConfiguration))
                                                 .separator()
                                                 .header("MCPs")
@@ -1238,7 +1365,7 @@ impl AssistantPanel {
 
                 Some(token_count)
             }
-            ActiveView::PromptEditor { context_editor } => {
+            ActiveView::PromptEditor { context_editor, .. } => {
                 let element = render_remaining_tokens(context_editor, cx)?;
 
                 Some(element.into_any_element())
@@ -1548,9 +1675,19 @@ impl AssistantPanel {
     }
 
     fn render_usage_banner(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
+        let plan = self
+            .user_store
+            .read(cx)
+            .current_plan()
+            .map(|plan| match plan {
+                Plan::Free => zed_llm_client::Plan::Free,
+                Plan::ZedPro => zed_llm_client::Plan::ZedPro,
+                Plan::ZedProTrial => zed_llm_client::Plan::ZedProTrial,
+            })
+            .unwrap_or(zed_llm_client::Plan::Free);
         let usage = self.thread.read(cx).last_usage()?;
 
-        Some(UsageBanner::new(zed_llm_client::Plan::ZedProTrial, usage).into_any_element())
+        Some(UsageBanner::new(plan, usage).into_any_element())
     }
 
     fn render_last_error(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
@@ -1605,6 +1742,8 @@ impl AssistantPanel {
                 h_flex()
                     .justify_end()
                     .mt_1()
+                    .gap_1()
+                    .child(self.create_copy_button(ERROR_MESSAGE))
                     .child(Button::new("subscribe", "Subscribe").on_click(cx.listener(
                         |this, _, _, cx| {
                             this.thread.update(cx, |this, _cx| {
@@ -1651,6 +1790,8 @@ impl AssistantPanel {
                 h_flex()
                     .justify_end()
                     .mt_1()
+                    .gap_1()
+                    .child(self.create_copy_button(ERROR_MESSAGE))
                     .child(
                         Button::new("subscribe", "Update Monthly Spend Limit").on_click(
                             cx.listener(|this, _, _, cx| {
@@ -1716,6 +1857,8 @@ impl AssistantPanel {
                 h_flex()
                     .justify_end()
                     .mt_1()
+                    .gap_1()
+                    .child(self.create_copy_button(error_message))
                     .child(
                         Button::new("subscribe", call_to_action).on_click(cx.listener(
                             |this, _, _, cx| {
@@ -1747,6 +1890,7 @@ impl AssistantPanel {
         message: SharedString,
         cx: &mut Context<Self>,
     ) -> AnyElement {
+        let message_with_header = format!("{}\n{}", header, message);
         v_flex()
             .gap_0p5()
             .child(
@@ -1761,12 +1905,14 @@ impl AssistantPanel {
                     .id("error-message")
                     .max_h_32()
                     .overflow_y_scroll()
-                    .child(Label::new(message)),
+                    .child(Label::new(message.clone())),
             )
             .child(
                 h_flex()
                     .justify_end()
                     .mt_1()
+                    .gap_1()
+                    .child(self.create_copy_button(message_with_header))
                     .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
                         |this, _, _, cx| {
                             this.thread.update(cx, |this, _cx| {
@@ -1780,6 +1926,15 @@ impl AssistantPanel {
             .into_any()
     }
 
+    fn create_copy_button(&self, message: impl Into<String>) -> impl IntoElement {
+        let message = message.into();
+        IconButton::new("copy", IconName::Copy)
+            .on_click(move |_, _, cx| {
+                cx.write_to_clipboard(ClipboardItem::new_string(message.clone()))
+            })
+            .tooltip(Tooltip::text("Copy Error Message"))
+    }
+
     fn key_context(&self) -> KeyContext {
         let mut key_context = KeyContext::new_with_defaults();
         key_context.add("AgentPanel");
@@ -1807,7 +1962,7 @@ impl Render for AssistantPanel {
                 this.open_configuration(window, cx);
             }))
             .on_action(cx.listener(Self::open_active_thread_as_markdown))
-            .on_action(cx.listener(Self::deploy_prompt_library))
+            .on_action(cx.listener(Self::deploy_rules_library))
             .on_action(cx.listener(Self::open_agent_diff))
             .on_action(cx.listener(Self::go_back))
             .child(self.render_toolbar(window, cx))
@@ -1818,7 +1973,9 @@ impl Render for AssistantPanel {
                     .child(h_flex().child(self.message_editor.clone()))
                     .children(self.render_last_error(cx)),
                 ActiveView::History => parent.child(self.history.clone()),
-                ActiveView::PromptEditor { context_editor } => parent.child(context_editor.clone()),
+                ActiveView::PromptEditor { context_editor, .. } => {
+                    parent.child(context_editor.clone())
+                }
                 ActiveView::Configuration => parent.children(self.configuration.clone()),
             })
     }
@@ -1834,13 +1991,13 @@ impl PromptLibraryInlineAssist {
     }
 }
 
-impl prompt_library::InlineAssistDelegate for PromptLibraryInlineAssist {
+impl rules_library::InlineAssistDelegate for PromptLibraryInlineAssist {
     fn assist(
         &self,
         prompt_editor: &Entity<Editor>,
         _initial_prompt: Option<String>,
         window: &mut Window,
-        cx: &mut Context<PromptLibrary>,
+        cx: &mut Context<RulesLibrary>,
     ) {
         InlineAssistant::update_global(cx, |assistant, cx| {
             let Some(project) = self
@@ -1850,11 +2007,14 @@ impl prompt_library::InlineAssistDelegate for PromptLibraryInlineAssist {
             else {
                 return;
             };
+            let prompt_store = None;
+            let thread_store = None;
             assistant.assist(
                 &prompt_editor,
                 self.workspace.clone(),
                 project,
-                None,
+                prompt_store,
+                thread_store,
                 window,
                 cx,
             )
@@ -1933,8 +2093,8 @@ impl AssistantPanelDelegate for ConcreteAssistantPanelDelegate {
             // being updated.
             cx.defer_in(window, move |panel, window, cx| {
                 if panel.has_active_thread() {
-                    panel.thread.update(cx, |thread, cx| {
-                        thread.context_store().update(cx, |store, cx| {
+                    panel.message_editor.update(cx, |message_editor, cx| {
+                        message_editor.context_store().update(cx, |store, cx| {
                             let buffer = buffer.read(cx);
                             let selection_ranges = selection_ranges
                                 .into_iter()
@@ -1951,9 +2111,7 @@ impl AssistantPanelDelegate for ConcreteAssistantPanelDelegate {
                                 .collect::<Vec<_>>();
 
                             for (buffer, range) in selection_ranges {
-                                store
-                                    .add_selection(buffer, range, cx)
-                                    .detach_and_log_err(cx);
+                                store.add_selection(buffer, range, cx);
                             }
                         })
                     })

crates/agent/src/buffer_codegen.rs

@@ -1,12 +1,14 @@
-use crate::context::attach_context_to_message;
-use crate::context_store::ContextStore;
+use crate::context::ContextLoadResult;
 use crate::inline_prompt_editor::CodegenStatus;
+use crate::{context::load_context, context_store::ContextStore};
 use anyhow::Result;
 use client::telemetry::Telemetry;
 use collections::HashSet;
 use editor::{Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset as _, ToPoint};
-use futures::{SinkExt, Stream, StreamExt, channel::mpsc, future::LocalBoxFuture, join};
-use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Subscription, Task};
+use futures::{
+    SinkExt, Stream, StreamExt, TryStreamExt as _, channel::mpsc, future::LocalBoxFuture, join,
+};
+use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Subscription, Task, WeakEntity};
 use language::{Buffer, IndentKind, Point, TransactionId, line_diff};
 use language_model::{
     LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
@@ -14,7 +16,9 @@ use language_model::{
 };
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
+use project::Project;
 use prompt_store::PromptBuilder;
+use prompt_store::PromptStore;
 use rope::Rope;
 use smol::future::FutureExt;
 use std::{
@@ -39,6 +43,8 @@ pub struct BufferCodegen {
     range: Range<Anchor>,
     initial_transaction_id: Option<TransactionId>,
     context_store: Entity<ContextStore>,
+    project: WeakEntity<Project>,
+    prompt_store: Option<Entity<PromptStore>>,
     telemetry: Arc<Telemetry>,
     builder: Arc<PromptBuilder>,
     pub is_insertion: bool,
@@ -50,6 +56,8 @@ impl BufferCodegen {
         range: Range<Anchor>,
         initial_transaction_id: Option<TransactionId>,
         context_store: Entity<ContextStore>,
+        project: WeakEntity<Project>,
+        prompt_store: Option<Entity<PromptStore>>,
         telemetry: Arc<Telemetry>,
         builder: Arc<PromptBuilder>,
         cx: &mut Context<Self>,
@@ -60,6 +68,8 @@ impl BufferCodegen {
                 range.clone(),
                 false,
                 Some(context_store.clone()),
+                project.clone(),
+                prompt_store.clone(),
                 Some(telemetry.clone()),
                 builder.clone(),
                 cx,
@@ -75,6 +85,8 @@ impl BufferCodegen {
             range,
             initial_transaction_id,
             context_store,
+            project,
+            prompt_store,
             telemetry,
             builder,
         };
@@ -153,6 +165,8 @@ impl BufferCodegen {
                     self.range.clone(),
                     false,
                     Some(self.context_store.clone()),
+                    self.project.clone(),
+                    self.prompt_store.clone(),
                     Some(self.telemetry.clone()),
                     self.builder.clone(),
                     cx,
@@ -229,13 +243,14 @@ pub struct CodegenAlternative {
     generation: Task<()>,
     diff: Diff,
     context_store: Option<Entity<ContextStore>>,
+    project: WeakEntity<Project>,
+    prompt_store: Option<Entity<PromptStore>>,
     telemetry: Option<Arc<Telemetry>>,
     _subscription: gpui::Subscription,
     builder: Arc<PromptBuilder>,
     active: bool,
     edits: Vec<(Range<Anchor>, String)>,
     line_operations: Vec<LineOperation>,
-    request: Option<LanguageModelRequest>,
     elapsed_time: Option<f64>,
     completion: Option<String>,
     pub message_id: Option<String>,
@@ -249,6 +264,8 @@ impl CodegenAlternative {
         range: Range<Anchor>,
         active: bool,
         context_store: Option<Entity<ContextStore>>,
+        project: WeakEntity<Project>,
+        prompt_store: Option<Entity<PromptStore>>,
         telemetry: Option<Arc<Telemetry>>,
         builder: Arc<PromptBuilder>,
         cx: &mut Context<Self>,
@@ -290,6 +307,8 @@ impl CodegenAlternative {
             generation: Task::ready(()),
             diff: Diff::default(),
             context_store,
+            project,
+            prompt_store,
             telemetry,
             _subscription: cx.subscribe(&buffer, Self::handle_buffer_event),
             builder,
@@ -297,7 +316,6 @@ impl CodegenAlternative {
             edits: Vec::new(),
             line_operations: Vec::new(),
             range,
-            request: None,
             elapsed_time: None,
             completion: None,
         }
@@ -366,16 +384,18 @@ impl CodegenAlternative {
                 async { Ok(LanguageModelTextStream::default()) }.boxed_local()
             } else {
                 let request = self.build_request(user_prompt, cx)?;
-                self.request = Some(request.clone());
-
-                cx.spawn(async move |_, cx| model.stream_completion_text(request, &cx).await)
+                cx.spawn(async move |_, cx| model.stream_completion_text(request.await, &cx).await)
                     .boxed_local()
             };
         self.handle_stream(telemetry_id, provider_id.to_string(), api_key, stream, cx);
         Ok(())
     }
 
-    fn build_request(&self, user_prompt: String, cx: &mut App) -> Result<LanguageModelRequest> {
+    fn build_request(
+        &self,
+        user_prompt: String,
+        cx: &mut App,
+    ) -> Result<Task<LanguageModelRequest>> {
         let buffer = self.buffer.read(cx).snapshot(cx);
         let language = buffer.language_at(self.range.start);
         let language_name = if let Some(language) = language.as_ref() {
@@ -408,30 +428,45 @@ impl CodegenAlternative {
             .generate_inline_transformation_prompt(user_prompt, language_name, buffer, range)
             .map_err(|e| anyhow::anyhow!("Failed to generate content prompt: {}", e))?;
 
-        let mut request_message = LanguageModelRequestMessage {
-            role: Role::User,
-            content: Vec::new(),
-            cache: false,
-        };
+        let context_task = self.context_store.as_ref().map(|context_store| {
+            if let Some(project) = self.project.upgrade() {
+                let context = context_store
+                    .read(cx)
+                    .context()
+                    .cloned()
+                    .collect::<Vec<_>>();
+                load_context(context, &project, &self.prompt_store, cx)
+            } else {
+                Task::ready(ContextLoadResult::default())
+            }
+        });
 
-        if let Some(context_store) = &self.context_store {
-            attach_context_to_message(
-                &mut request_message,
-                context_store.read(cx).context().iter(),
-                cx,
-            );
-        }
+        Ok(cx.spawn(async move |_cx| {
+            let mut request_message = LanguageModelRequestMessage {
+                role: Role::User,
+                content: Vec::new(),
+                cache: false,
+            };
 
-        request_message.content.push(prompt.into());
+            if let Some(context_task) = context_task {
+                context_task
+                    .await
+                    .loaded_context
+                    .add_to_request_message(&mut request_message);
+            }
 
-        Ok(LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
-            tools: Vec::new(),
-            stop: Vec::new(),
-            temperature: None,
-            messages: vec![request_message],
-        })
+            request_message.content.push(prompt.into());
+
+            LanguageModelRequest {
+                thread_id: None,
+                prompt_id: None,
+                mode: None,
+                tools: Vec::new(),
+                stop: Vec::new(),
+                temperature: None,
+                messages: vec![request_message],
+            }
+        }))
     }
 
     pub fn handle_stream(
@@ -508,7 +543,9 @@ impl CodegenAlternative {
                         let mut response_latency = None;
                         let request_start = Instant::now();
                         let diff = async {
-                            let chunks = StripInvalidSpans::new(stream?.stream);
+                            let chunks = StripInvalidSpans::new(
+                                stream?.stream.map_err(|error| error.into()),
+                            );
                             futures::pin_mut!(chunks);
                             let mut diff = StreamingDiff::new(selected_text.to_string());
                             let mut line_diff = LineDiff::default();
@@ -1034,6 +1071,7 @@ impl Diff {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use fs::FakeFs;
     use futures::{
         Stream,
         stream::{self},
@@ -1076,12 +1114,16 @@ mod tests {
             snapshot.anchor_before(Point::new(1, 0))..snapshot.anchor_after(Point::new(4, 5))
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, vec![], cx).await;
         let codegen = cx.new(|cx| {
             CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
                 true,
                 None,
+                project.downgrade(),
+                None,
                 None,
                 prompt_builder,
                 cx,
@@ -1140,12 +1182,16 @@ mod tests {
             snapshot.anchor_before(Point::new(1, 6))..snapshot.anchor_after(Point::new(1, 6))
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, vec![], cx).await;
         let codegen = cx.new(|cx| {
             CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
                 true,
                 None,
+                project.downgrade(),
+                None,
                 None,
                 prompt_builder,
                 cx,
@@ -1207,12 +1253,16 @@ mod tests {
             snapshot.anchor_before(Point::new(1, 2))..snapshot.anchor_after(Point::new(1, 2))
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, vec![], cx).await;
         let codegen = cx.new(|cx| {
             CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
                 true,
                 None,
+                project.downgrade(),
+                None,
                 None,
                 prompt_builder,
                 cx,
@@ -1274,12 +1324,16 @@ mod tests {
             snapshot.anchor_before(Point::new(0, 0))..snapshot.anchor_after(Point::new(4, 2))
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, vec![], cx).await;
         let codegen = cx.new(|cx| {
             CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
                 true,
                 None,
+                project.downgrade(),
+                None,
                 None,
                 prompt_builder,
                 cx,
@@ -1329,12 +1383,16 @@ mod tests {
             snapshot.anchor_before(Point::new(1, 0))..snapshot.anchor_after(Point::new(1, 14))
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, vec![], cx).await;
         let codegen = cx.new(|cx| {
             CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
                 false,
                 None,
+                project.downgrade(),
+                None,
                 None,
                 prompt_builder,
                 cx,

crates/agent/src/context_picker.rs

@@ -10,8 +10,11 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use anyhow::{Result, anyhow};
+pub use completion_provider::ContextPickerCompletionProvider;
 use editor::display_map::{Crease, FoldId};
 use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
+use fetch_context_picker::FetchContextPicker;
+use file_context_picker::FileContextPicker;
 use file_context_picker::render_file_context_entry;
 use gpui::{
     App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Subscription, Task,
@@ -20,10 +23,10 @@ use gpui::{
 use language::Buffer;
 use multi_buffer::MultiBufferRow;
 use project::{Entry, ProjectPath};
-use prompt_store::UserPromptId;
-use rules_context_picker::RulesContextEntry;
+use prompt_store::{PromptStore, UserPromptId};
+use rules_context_picker::{RulesContextEntry, RulesContextPicker};
 use symbol_context_picker::SymbolContextPicker;
-use thread_context_picker::{ThreadContextEntry, render_thread_context_entry};
+use thread_context_picker::{ThreadContextEntry, ThreadContextPicker, render_thread_context_entry};
 use ui::{
     ButtonLike, ContextMenu, ContextMenuEntry, ContextMenuItem, Disclosure, TintColor, prelude::*,
 };
@@ -32,11 +35,6 @@ use workspace::{Workspace, notifications::NotifyResultExt};
 
 use crate::AssistantPanel;
 use crate::context::RULES_ICON;
-pub use crate::context_picker::completion_provider::ContextPickerCompletionProvider;
-use crate::context_picker::fetch_context_picker::FetchContextPicker;
-use crate::context_picker::file_context_picker::FileContextPicker;
-use crate::context_picker::rules_context_picker::RulesContextPicker;
-use crate::context_picker::thread_context_picker::ThreadContextPicker;
 use crate::context_store::ContextStore;
 use crate::thread::ThreadId;
 use crate::thread_store::ThreadStore;
@@ -166,6 +164,7 @@ pub(super) struct ContextPicker {
     workspace: WeakEntity<Workspace>,
     context_store: WeakEntity<ContextStore>,
     thread_store: Option<WeakEntity<ThreadStore>>,
+    prompt_store: Option<Entity<PromptStore>>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -193,6 +192,13 @@ impl ContextPicker {
             )
             .collect::<Vec<Subscription>>();
 
+        let prompt_store = thread_store.as_ref().and_then(|thread_store| {
+            thread_store
+                .read_with(cx, |thread_store, _cx| thread_store.prompt_store().clone())
+                .ok()
+                .flatten()
+        });
+
         ContextPicker {
             mode: ContextPickerState::Default(ContextMenu::build(
                 window,
@@ -202,6 +208,7 @@ impl ContextPicker {
             workspace,
             context_store,
             thread_store,
+            prompt_store,
             _subscriptions: subscriptions,
         }
     }
@@ -226,7 +233,12 @@ impl ContextPicker {
                 .workspace
                 .upgrade()
                 .map(|workspace| {
-                    available_context_picker_entries(&self.thread_store, &workspace, cx)
+                    available_context_picker_entries(
+                        &self.prompt_store,
+                        &self.thread_store,
+                        &workspace,
+                        cx,
+                    )
                 })
                 .unwrap_or_default();
 
@@ -304,10 +316,10 @@ impl ContextPicker {
                     }));
                 }
                 ContextPickerMode::Rules => {
-                    if let Some(thread_store) = self.thread_store.as_ref() {
+                    if let Some(prompt_store) = self.prompt_store.as_ref() {
                         self.mode = ContextPickerState::Rules(cx.new(|cx| {
                             RulesContextPicker::new(
-                                thread_store.clone(),
+                                prompt_store.clone(),
                                 context_picker.clone(),
                                 self.context_store.clone(),
                                 window,
@@ -376,7 +388,7 @@ impl ContextPicker {
                 ContextMenuItem::custom_entry(
                     move |_window, cx| {
                         render_file_context_entry(
-                            ElementId::NamedInteger("ctx-recent".into(), ix),
+                            ElementId::named_usize("ctx-recent", ix),
                             worktree_id,
                             &path,
                             &path_prefix,
@@ -526,6 +538,7 @@ enum RecentEntry {
 }
 
 fn available_context_picker_entries(
+    prompt_store: &Option<Entity<PromptStore>>,
     thread_store: &Option<WeakEntity<ThreadStore>>,
     workspace: &Entity<Workspace>,
     cx: &mut App,
@@ -550,6 +563,9 @@ fn available_context_picker_entries(
 
     if thread_store.is_some() {
         entries.push(ContextPickerEntry::Mode(ContextPickerMode::Thread));
+    }
+
+    if prompt_store.is_some() {
         entries.push(ContextPickerEntry::Mode(ContextPickerMode::Rules));
     }
 
@@ -585,22 +601,21 @@ fn recent_context_picker_entries(
             }),
     );
 
-    let mut current_threads = context_store.read(cx).thread_ids();
+    let current_threads = context_store.read(cx).thread_ids();
 
-    if let Some(active_thread) = workspace
+    let active_thread_id = workspace
         .panel::<AssistantPanel>(cx)
-        .map(|panel| panel.read(cx).active_thread(cx))
-    {
-        current_threads.insert(active_thread.read(cx).id().clone());
-    }
+        .map(|panel| panel.read(cx).active_thread(cx).read(cx).id());
 
     if let Some(thread_store) = thread_store.and_then(|thread_store| thread_store.upgrade()) {
         recent.extend(
             thread_store
                 .read(cx)
-                .threads()
+                .reverse_chronological_threads()
                 .into_iter()
-                .filter(|thread| !current_threads.contains(&thread.id))
+                .filter(|thread| {
+                    Some(&thread.id) != active_thread_id && !current_threads.contains(&thread.id)
+                })
                 .take(2)
                 .map(|thread| {
                     RecentEntry::Thread(ThreadContextEntry {
@@ -622,9 +637,7 @@ fn add_selections_as_context(
     let selection_ranges = selection_ranges(workspace, cx);
     context_store.update(cx, |context_store, cx| {
         for (buffer, range) in selection_ranges {
-            context_store
-                .add_selection(buffer, range, cx)
-                .detach_and_log_err(cx);
+            context_store.add_selection(buffer, range, cx);
         }
     })
 }

crates/agent/src/context_picker/completion_provider.rs

@@ -15,22 +15,21 @@ use itertools::Itertools;
 use language::{Buffer, CodeLabel, HighlightId};
 use lsp::CompletionContext;
 use project::{Completion, CompletionIntent, ProjectPath, Symbol, WorktreeId};
-use prompt_store::PromptId;
+use prompt_store::PromptStore;
 use rope::Point;
 use text::{Anchor, OffsetRangeExt, ToPoint};
 use ui::prelude::*;
 use workspace::Workspace;
 
 use crate::context::RULES_ICON;
-use crate::context_picker::file_context_picker::search_files;
-use crate::context_picker::symbol_context_picker::search_symbols;
 use crate::context_store::ContextStore;
 use crate::thread_store::ThreadStore;
 
 use super::fetch_context_picker::fetch_url_content;
-use super::file_context_picker::FileMatch;
+use super::file_context_picker::{FileMatch, search_files};
 use super::rules_context_picker::{RulesContextEntry, search_rules};
 use super::symbol_context_picker::SymbolMatch;
+use super::symbol_context_picker::search_symbols;
 use super::thread_context_picker::{ThreadContextEntry, ThreadMatch, search_threads};
 use super::{
     ContextPickerAction, ContextPickerEntry, ContextPickerMode, MentionLink, RecentEntry,
@@ -38,8 +37,8 @@ use super::{
 };
 
 pub(crate) enum Match {
-    Symbol(SymbolMatch),
     File(FileMatch),
+    Symbol(SymbolMatch),
     Thread(ThreadMatch),
     Fetch(SharedString),
     Rules(RulesContextEntry),
@@ -69,6 +68,7 @@ fn search(
     query: String,
     cancellation_flag: Arc<AtomicBool>,
     recent_entries: Vec<RecentEntry>,
+    prompt_store: Option<Entity<PromptStore>>,
     thread_store: Option<WeakEntity<ThreadStore>>,
     workspace: Entity<Workspace>,
     cx: &mut App,
@@ -85,6 +85,7 @@ fn search(
                     .collect()
             })
         }
+
         Some(ContextPickerMode::Symbol) => {
             let search_symbols_task =
                 search_symbols(query.clone(), cancellation_flag.clone(), &workspace, cx);
@@ -96,6 +97,7 @@ fn search(
                     .collect()
             })
         }
+
         Some(ContextPickerMode::Thread) => {
             if let Some(thread_store) = thread_store.as_ref().and_then(|t| t.upgrade()) {
                 let search_threads_task =
@@ -111,6 +113,7 @@ fn search(
                 Task::ready(Vec::new())
             }
         }
+
         Some(ContextPickerMode::Fetch) => {
             if !query.is_empty() {
                 Task::ready(vec![Match::Fetch(query.into())])
@@ -118,10 +121,11 @@ fn search(
                 Task::ready(Vec::new())
             }
         }
+
         Some(ContextPickerMode::Rules) => {
-            if let Some(thread_store) = thread_store.as_ref().and_then(|t| t.upgrade()) {
+            if let Some(prompt_store) = prompt_store.as_ref() {
                 let search_rules_task =
-                    search_rules(query.clone(), cancellation_flag.clone(), thread_store, cx);
+                    search_rules(query.clone(), cancellation_flag.clone(), prompt_store, cx);
                 cx.background_spawn(async move {
                     search_rules_task
                         .await
@@ -133,6 +137,7 @@ fn search(
                 Task::ready(Vec::new())
             }
         }
+
         None => {
             if query.is_empty() {
                 let mut matches = recent_entries
@@ -163,7 +168,7 @@ fn search(
                     .collect::<Vec<_>>();
 
                 matches.extend(
-                    available_context_picker_entries(&thread_store, &workspace, cx)
+                    available_context_picker_entries(&prompt_store, &thread_store, &workspace, cx)
                         .into_iter()
                         .map(|mode| {
                             Match::Entry(EntryMatch {
@@ -180,7 +185,8 @@ fn search(
                 let search_files_task =
                     search_files(query.clone(), cancellation_flag.clone(), &workspace, cx);
 
-                let entries = available_context_picker_entries(&thread_store, &workspace, cx);
+                let entries =
+                    available_context_picker_entries(&prompt_store, &thread_store, &workspace, cx);
                 let entry_candidates = entries
                     .iter()
                     .enumerate()
@@ -307,9 +313,11 @@ impl ContextPickerCompletionProvider {
                             move |_, _: &mut Window, cx: &mut App| {
                                 context_store.update(cx, |context_store, cx| {
                                     for (buffer, range) in &selections {
-                                        context_store
-                                            .add_selection(buffer.clone(), range.clone(), cx)
-                                            .detach_and_log_err(cx)
+                                        context_store.add_selection(
+                                            buffer.clone(),
+                                            range.clone(),
+                                            cx,
+                                        );
                                     }
                                 });
 
@@ -437,7 +445,6 @@ impl ContextPickerCompletionProvider {
         source_range: Range<Anchor>,
         editor: Entity<Editor>,
         context_store: Entity<ContextStore>,
-        thread_store: Entity<ThreadStore>,
     ) -> Completion {
         let new_text = MentionLink::for_rules(&rules);
         let new_text_len = new_text.len();
@@ -457,29 +464,10 @@ impl ContextPickerCompletionProvider {
                 new_text_len,
                 editor.clone(),
                 move |cx| {
-                    let prompt_uuid = rules.prompt_id;
-                    let prompt_id = PromptId::User { uuid: prompt_uuid };
-                    let context_store = context_store.clone();
-                    let Some(prompt_store) = thread_store.read(cx).prompt_store() else {
-                        log::error!("Can't add user rules as prompt store is missing.");
-                        return;
-                    };
-                    let prompt_store = prompt_store.read(cx);
-                    let Some(metadata) = prompt_store.metadata(prompt_id) else {
-                        return;
-                    };
-                    let Some(title) = metadata.title else {
-                        return;
-                    };
-                    let text_task = prompt_store.load(prompt_id, cx);
-
-                    cx.spawn(async move |cx| {
-                        let text = text_task.await?;
-                        context_store.update(cx, |context_store, cx| {
-                            context_store.add_rules(prompt_uuid, title, text, false, cx)
-                        })
-                    })
-                    .detach_and_log_err(cx);
+                    let user_prompt_id = rules.prompt_id;
+                    context_store.update(cx, |context_store, cx| {
+                        context_store.add_rules(user_prompt_id, false, cx);
+                    });
                 },
             )),
         }
@@ -516,7 +504,7 @@ impl ContextPickerCompletionProvider {
                     let url_to_fetch = url_to_fetch.clone();
                     cx.spawn(async move |cx| {
                         if context_store.update(cx, |context_store, _| {
-                            context_store.includes_url(&url_to_fetch).is_some()
+                            context_store.includes_url(&url_to_fetch)
                         })? {
                             return Ok(());
                         }
@@ -592,7 +580,7 @@ impl ContextPickerCompletionProvider {
                 move |cx| {
                     context_store.update(cx, |context_store, cx| {
                         let task = if is_directory {
-                            context_store.add_directory(project_path.clone(), false, cx)
+                            Task::ready(context_store.add_directory(&project_path, false, cx))
                         } else {
                             context_store.add_file_from_path(project_path.clone(), false, cx)
                         };
@@ -732,11 +720,19 @@ impl CompletionProvider for ContextPickerCompletionProvider {
             cx,
         );
 
+        let prompt_store = thread_store.as_ref().and_then(|thread_store| {
+            thread_store
+                .read_with(cx, |thread_store, _cx| thread_store.prompt_store().clone())
+                .ok()
+                .flatten()
+        });
+
         let search_task = search(
             mode,
             query,
             Arc::<AtomicBool>::default(),
             recent_entries,
+            prompt_store,
             thread_store.clone(),
             workspace.clone(),
             cx,
@@ -768,6 +764,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
                                 cx,
                             ))
                         }
+
                         Match::Symbol(SymbolMatch { symbol, .. }) => Self::completion_for_symbol(
                             symbol,
                             excerpt_id,
@@ -777,6 +774,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
                             workspace.clone(),
                             cx,
                         ),
+
                         Match::Thread(ThreadMatch {
                             thread, is_recent, ..
                         }) => {
@@ -791,17 +789,15 @@ impl CompletionProvider for ContextPickerCompletionProvider {
                                 thread_store,
                             ))
                         }
-                        Match::Rules(user_rules) => {
-                            let thread_store = thread_store.as_ref().and_then(|t| t.upgrade())?;
-                            Some(Self::completion_for_rules(
-                                user_rules,
-                                excerpt_id,
-                                source_range.clone(),
-                                editor.clone(),
-                                context_store.clone(),
-                                thread_store,
-                            ))
-                        }
+
+                        Match::Rules(user_rules) => Some(Self::completion_for_rules(
+                            user_rules,
+                            excerpt_id,
+                            source_range.clone(),
+                            editor.clone(),
+                            context_store.clone(),
+                        )),
+
                         Match::Fetch(url) => Some(Self::completion_for_fetch(
                             source_range.clone(),
                             url,
@@ -810,6 +806,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
                             context_store.clone(),
                             http_client.clone(),
                         )),
+
                         Match::Entry(EntryMatch { entry, .. }) => Self::completion_for_entry(
                             entry,
                             excerpt_id,

crates/agent/src/context_picker/fetch_context_picker.rs

@@ -227,7 +227,7 @@ impl PickerDelegate for FetchContextPickerDelegate {
         cx: &mut Context<Picker<Self>>,
     ) -> Option<Self::ListItem> {
         let added = self.context_store.upgrade().map_or(false, |context_store| {
-            context_store.read(cx).includes_url(&self.url).is_some()
+            context_store.read(cx).includes_url(&self.url)
         });
 
         Some(

crates/agent/src/context_picker/file_context_picker.rs

@@ -134,9 +134,9 @@ impl PickerDelegate for FileContextPickerDelegate {
             .context_store
             .update(cx, |context_store, cx| {
                 if is_directory {
-                    context_store.add_directory(project_path, true, cx)
+                    Task::ready(context_store.add_directory(&project_path, true, cx))
                 } else {
-                    context_store.add_file_from_path(project_path, true, cx)
+                    context_store.add_file_from_path(project_path.clone(), true, cx)
                 }
             })
             .ok()
@@ -169,7 +169,7 @@ impl PickerDelegate for FileContextPickerDelegate {
                 .inset(true)
                 .toggle_state(selected)
                 .child(render_file_context_entry(
-                    ElementId::NamedInteger("file-ctx-picker".into(), ix),
+                    ElementId::named_usize("file-ctx-picker", ix),
                     WorktreeId::from_usize(mat.worktree_id),
                     &mat.path,
                     &mat.path_prefix,
@@ -325,11 +325,11 @@ pub fn render_file_context_entry(
             path: path.clone(),
         };
         if is_directory {
-            context_store.read(cx).includes_directory(&project_path)
-        } else {
             context_store
                 .read(cx)
-                .will_include_file_path(&project_path, cx)
+                .path_included_in_directory(&project_path, cx)
+        } else {
+            context_store.read(cx).file_path_included(&project_path, cx)
         }
     });
 
@@ -357,7 +357,7 @@ pub fn render_file_context_entry(
                 })),
         )
         .when_some(added, |el, added| match added {
-            FileInclusion::Direct(_) => el.child(
+            FileInclusion::Direct => el.child(
                 h_flex()
                     .w_full()
                     .justify_end()
@@ -369,9 +369,8 @@ pub fn render_file_context_entry(
                     )
                     .child(Label::new("Added").size(LabelSize::Small)),
             ),
-            FileInclusion::InDirectory(directory_project_path) => {
-                // TODO: Consider using worktree full_path to include worktree name.
-                let directory_path = directory_project_path.path.to_string_lossy().into_owned();
+            FileInclusion::InDirectory { full_path } => {
+                let directory_full_path = full_path.to_string_lossy().into_owned();
 
                 el.child(
                     h_flex()
@@ -385,7 +384,7 @@ pub fn render_file_context_entry(
                         )
                         .child(Label::new("Included").size(LabelSize::Small)),
                 )
-                .tooltip(Tooltip::text(format!("in {directory_path}")))
+                .tooltip(Tooltip::text(format!("in {directory_full_path}")))
             }
         })
 }

crates/agent/src/context_picker/rules_context_picker.rs

@@ -1,16 +1,15 @@
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 
-use anyhow::anyhow;
 use gpui::{App, DismissEvent, Entity, FocusHandle, Focusable, Task, WeakEntity};
 use picker::{Picker, PickerDelegate};
-use prompt_store::{PromptId, UserPromptId};
+use prompt_store::{PromptId, PromptStore, UserPromptId};
 use ui::{ListItem, prelude::*};
+use util::ResultExt as _;
 
 use crate::context::RULES_ICON;
 use crate::context_picker::ContextPicker;
 use crate::context_store::{self, ContextStore};
-use crate::thread_store::ThreadStore;
 
 pub struct RulesContextPicker {
     picker: Entity<Picker<RulesContextPickerDelegate>>,
@@ -18,13 +17,13 @@ pub struct RulesContextPicker {
 
 impl RulesContextPicker {
     pub fn new(
-        thread_store: WeakEntity<ThreadStore>,
+        prompt_store: Entity<PromptStore>,
         context_picker: WeakEntity<ContextPicker>,
         context_store: WeakEntity<context_store::ContextStore>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let delegate = RulesContextPickerDelegate::new(thread_store, context_picker, context_store);
+        let delegate = RulesContextPickerDelegate::new(prompt_store, context_picker, context_store);
         let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
 
         RulesContextPicker { picker }
@@ -50,7 +49,7 @@ pub struct RulesContextEntry {
 }
 
 pub struct RulesContextPickerDelegate {
-    thread_store: WeakEntity<ThreadStore>,
+    prompt_store: Entity<PromptStore>,
     context_picker: WeakEntity<ContextPicker>,
     context_store: WeakEntity<context_store::ContextStore>,
     matches: Vec<RulesContextEntry>,
@@ -59,12 +58,12 @@ pub struct RulesContextPickerDelegate {
 
 impl RulesContextPickerDelegate {
     pub fn new(
-        thread_store: WeakEntity<ThreadStore>,
+        prompt_store: Entity<PromptStore>,
         context_picker: WeakEntity<ContextPicker>,
         context_store: WeakEntity<context_store::ContextStore>,
     ) -> Self {
         RulesContextPickerDelegate {
-            thread_store,
+            prompt_store,
             context_picker,
             context_store,
             matches: Vec::new(),
@@ -103,11 +102,12 @@ impl PickerDelegate for RulesContextPickerDelegate {
         window: &mut Window,
         cx: &mut Context<Picker<Self>>,
     ) -> Task<()> {
-        let Some(thread_store) = self.thread_store.upgrade() else {
-            return Task::ready(());
-        };
-
-        let search_task = search_rules(query, Arc::new(AtomicBool::default()), thread_store, cx);
+        let search_task = search_rules(
+            query,
+            Arc::new(AtomicBool::default()),
+            &self.prompt_store,
+            cx,
+        );
         cx.spawn_in(window, async move |this, cx| {
             let matches = search_task.await;
             this.update(cx, |this, cx| {
@@ -124,31 +124,11 @@ impl PickerDelegate for RulesContextPickerDelegate {
             return;
         };
 
-        let Some(thread_store) = self.thread_store.upgrade() else {
-            return;
-        };
-
-        let prompt_id = entry.prompt_id;
-
-        let load_rules_task = thread_store.update(cx, |thread_store, cx| {
-            thread_store.load_rules(prompt_id, cx)
-        });
-
-        cx.spawn(async move |this, cx| {
-            let (metadata, text) = load_rules_task.await?;
-            let Some(title) = metadata.title else {
-                return Err(anyhow!("Encountered user rule with no title when attempting to add it to agent context."));
-            };
-            this.update(cx, |this, cx| {
-                this.delegate
-                    .context_store
-                    .update(cx, |context_store, cx| {
-                        context_store.add_rules(prompt_id, title, text, true, cx)
-                    })
-                    .ok();
+        self.context_store
+            .update(cx, |context_store, cx| {
+                context_store.add_rules(entry.prompt_id, true, cx)
             })
-        })
-        .detach_and_log_err(cx);
+            .log_err();
     }
 
     fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
@@ -179,11 +159,10 @@ pub fn render_thread_context_entry(
     context_store: WeakEntity<ContextStore>,
     cx: &mut App,
 ) -> Div {
-    let added = context_store.upgrade().map_or(false, |ctx_store| {
-        ctx_store
+    let added = context_store.upgrade().map_or(false, |context_store| {
+        context_store
             .read(cx)
-            .includes_user_rules(&user_rules.prompt_id)
-            .is_some()
+            .includes_user_rules(user_rules.prompt_id)
     });
 
     h_flex()
@@ -218,12 +197,9 @@ pub fn render_thread_context_entry(
 pub(crate) fn search_rules(
     query: String,
     cancellation_flag: Arc<AtomicBool>,
-    thread_store: Entity<ThreadStore>,
+    prompt_store: &Entity<PromptStore>,
     cx: &mut App,
 ) -> Task<Vec<RulesContextEntry>> {
-    let Some(prompt_store) = thread_store.read(cx).prompt_store() else {
-        return Task::ready(vec![]);
-    };
     let search_task = prompt_store.read(cx).search(query, cancellation_flag, cx);
     cx.background_spawn(async move {
         search_task

crates/agent/src/context_picker/symbol_context_picker.rs

@@ -10,7 +10,6 @@ use gpui::{
 use ordered_float::OrderedFloat;
 use picker::{Picker, PickerDelegate};
 use project::{DocumentSymbol, Symbol};
-use text::OffsetRangeExt;
 use ui::{ListItem, prelude::*};
 use util::ResultExt as _;
 use workspace::Workspace;
@@ -172,10 +171,7 @@ impl PickerDelegate for SymbolContextPickerDelegate {
         let mat = &self.matches[ix];
 
         Some(ListItem::new(ix).inset(true).toggle_state(selected).child(
-            render_symbol_context_entry(
-                ElementId::NamedInteger("symbol-ctx-picker".into(), ix),
-                mat,
-            ),
+            render_symbol_context_entry(ElementId::named_usize("symbol-ctx-picker", ix), mat),
         ))
     }
 }
@@ -228,18 +224,16 @@ pub(crate) fn add_symbol(
             )
         })?;
 
-        context_store
-            .update(cx, move |context_store, cx| {
-                context_store.add_symbol(
-                    buffer,
-                    name.into(),
-                    range,
-                    enclosing_range,
-                    remove_if_exists,
-                    cx,
-                )
-            })?
-            .await
+        context_store.update(cx, move |context_store, cx| {
+            context_store.add_symbol(
+                buffer,
+                name.into(),
+                range,
+                enclosing_range,
+                remove_if_exists,
+                cx,
+            )
+        })
     })
 }
 
@@ -353,38 +347,13 @@ fn compute_symbol_entries(
     context_store: &ContextStore,
     cx: &App,
 ) -> Vec<SymbolEntry> {
-    let mut symbol_entries = Vec::with_capacity(symbols.len());
-    for SymbolMatch { symbol, .. } in symbols {
-        let symbols_for_path = context_store.included_symbols_by_path().get(&symbol.path);
-        let is_included = if let Some(symbols_for_path) = symbols_for_path {
-            let mut is_included = false;
-            for included_symbol_id in symbols_for_path {
-                if included_symbol_id.name.as_ref() == symbol.name.as_str() {
-                    if let Some(buffer) = context_store.buffer_for_symbol(included_symbol_id) {
-                        let snapshot = buffer.read(cx).snapshot();
-                        let included_symbol_range =
-                            included_symbol_id.range.to_point_utf16(&snapshot);
-
-                        if included_symbol_range.start == symbol.range.start.0
-                            && included_symbol_range.end == symbol.range.end.0
-                        {
-                            is_included = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            is_included
-        } else {
-            false
-        };
-
-        symbol_entries.push(SymbolEntry {
+    symbols
+        .into_iter()
+        .map(|SymbolMatch { symbol, .. }| SymbolEntry {
+            is_included: context_store.includes_symbol(&symbol, cx),
             symbol,
-            is_included,
         })
-    }
-    symbol_entries
+        .collect::<Vec<_>>()
 }
 
 pub fn render_symbol_context_entry(id: ElementId, entry: &SymbolEntry) -> Stateful<Div> {

crates/agent/src/context_picker/thread_context_picker.rs

@@ -173,7 +173,7 @@ pub fn render_thread_context_entry(
     cx: &mut App,
 ) -> Div {
     let added = context_store.upgrade().map_or(false, |ctx_store| {
-        ctx_store.read(cx).includes_thread(&thread.id).is_some()
+        ctx_store.read(cx).includes_thread(&thread.id)
     });
 
     h_flex()
@@ -219,7 +219,7 @@ pub(crate) fn search_threads(
 ) -> Task<Vec<ThreadMatch>> {
     let threads = thread_store
         .read(cx)
-        .threads()
+        .reverse_chronological_threads()
         .into_iter()
         .map(|thread| ThreadContextEntry {
             id: thread.id,

crates/agent/src/context_strip.rs

@@ -12,9 +12,9 @@ use itertools::Itertools;
 use language::Buffer;
 use project::ProjectItem;
 use ui::{KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
-use workspace::{Workspace, notifications::NotifyResultExt};
+use workspace::Workspace;
 
-use crate::context::{ContextId, ContextKind};
+use crate::context::{AgentContextHandle, ContextKind};
 use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
 use crate::thread::Thread;
@@ -32,6 +32,7 @@ pub struct ContextStrip {
     focus_handle: FocusHandle,
     suggest_context_kind: SuggestContextKind,
     workspace: WeakEntity<Workspace>,
+    thread_store: Option<WeakEntity<ThreadStore>>,
     _subscriptions: Vec<Subscription>,
     focused_index: Option<usize>,
     children_bounds: Option<Vec<Bounds<Pixels>>>,
@@ -73,12 +74,33 @@ impl ContextStrip {
             focus_handle,
             suggest_context_kind,
             workspace,
+            thread_store,
             _subscriptions: subscriptions,
             focused_index: None,
             children_bounds: None,
         }
     }
 
+    fn added_contexts(&self, cx: &App) -> Vec<AddedContext> {
+        if let Some(workspace) = self.workspace.upgrade() {
+            let project = workspace.read(cx).project().read(cx);
+            let prompt_store = self
+                .thread_store
+                .as_ref()
+                .and_then(|thread_store| thread_store.upgrade())
+                .and_then(|thread_store| thread_store.read(cx).prompt_store().as_ref());
+            self.context_store
+                .read(cx)
+                .context()
+                .flat_map(|context| {
+                    AddedContext::new_pending(context.clone(), prompt_store, project, cx)
+                })
+                .collect::<Vec<_>>()
+        } else {
+            Vec::new()
+        }
+    }
+
     fn suggested_context(&self, cx: &Context<Self>) -> Option<SuggestedContext> {
         match self.suggest_context_kind {
             SuggestContextKind::File => self.suggested_file(cx),
@@ -93,22 +115,19 @@ impl ContextStrip {
         let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
         let active_buffer_entity = editor.buffer().read(cx).as_singleton()?;
         let active_buffer = active_buffer_entity.read(cx);
-
         let project_path = active_buffer.project_path(cx)?;
 
         if self
             .context_store
             .read(cx)
-            .will_include_buffer(active_buffer.remote_id(), &project_path)
+            .file_path_included(&project_path, cx)
             .is_some()
         {
             return None;
         }
 
         let file_name = active_buffer.file()?.file_name(cx);
-
         let icon_path = FileIcons::get_icon(&Path::new(&file_name), cx);
-
         Some(SuggestedContext::File {
             name: file_name.to_string_lossy().into_owned().into(),
             buffer: active_buffer_entity.downgrade(),
@@ -135,7 +154,6 @@ impl ContextStrip {
             .context_store
             .read(cx)
             .includes_thread(active_thread.id())
-            .is_some()
         {
             return None;
         }
@@ -272,12 +290,12 @@ impl ContextStrip {
         best.map(|(index, _, _)| index)
     }
 
-    fn open_context(&mut self, id: ContextId, window: &mut Window, cx: &mut App) {
+    fn open_context(&mut self, context: &AgentContextHandle, window: &mut Window, cx: &mut App) {
         let Some(workspace) = self.workspace.upgrade() else {
             return;
         };
 
-        crate::active_thread::open_context(id, self.context_store.clone(), workspace, window, cx);
+        crate::active_thread::open_context(context, workspace, window, cx);
     }
 
     fn remove_focused_context(
@@ -287,17 +305,17 @@ impl ContextStrip {
         cx: &mut Context<Self>,
     ) {
         if let Some(index) = self.focused_index {
-            let mut is_empty = false;
+            let added_contexts = self.added_contexts(cx);
+            let Some(context) = added_contexts.get(index) else {
+                return;
+            };
 
             self.context_store.update(cx, |this, cx| {
-                if let Some(item) = this.context().get(index) {
-                    this.remove_context(item.id(), cx);
-                }
-
-                is_empty = this.context().is_empty();
+                this.remove_context(&context.handle, cx);
             });
 
-            if is_empty {
+            let is_now_empty = added_contexts.len() == 1;
+            if is_now_empty {
                 cx.emit(ContextStripEvent::BlurredEmpty);
             } else {
                 self.focused_index = Some(index.saturating_sub(1));
@@ -306,49 +324,28 @@ impl ContextStrip {
         }
     }
 
-    fn is_suggested_focused<T>(&self, context: &Vec<T>) -> bool {
+    fn is_suggested_focused(&self, added_contexts: &Vec<AddedContext>) -> bool {
         // We only suggest one item after the actual context
-        self.focused_index == Some(context.len())
+        self.focused_index == Some(added_contexts.len())
     }
 
     fn accept_suggested_context(
         &mut self,
         _: &AcceptSuggestedContext,
-        window: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
         if let Some(suggested) = self.suggested_context(cx) {
-            let context_store = self.context_store.read(cx);
-
-            if self.is_suggested_focused(context_store.context()) {
-                self.add_suggested_context(&suggested, window, cx);
+            if self.is_suggested_focused(&self.added_contexts(cx)) {
+                self.add_suggested_context(&suggested, cx);
             }
         }
     }
 
-    fn add_suggested_context(
-        &mut self,
-        suggested: &SuggestedContext,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let task = self.context_store.update(cx, |context_store, cx| {
-            context_store.accept_suggested_context(&suggested, cx)
+    fn add_suggested_context(&mut self, suggested: &SuggestedContext, cx: &mut Context<Self>) {
+        self.context_store.update(cx, |context_store, cx| {
+            context_store.add_suggested_context(&suggested, cx)
         });
-
-        cx.spawn_in(window, async move |this, cx| {
-            match task.await.notify_async_err(cx) {
-                None => {}
-                Some(()) => {
-                    if let Some(this) = this.upgrade() {
-                        this.update(cx, |_, cx| cx.notify())?;
-                    }
-                }
-            }
-            anyhow::Ok(())
-        })
-        .detach_and_log_err(cx);
-
         cx.notify();
     }
 }
@@ -361,17 +358,10 @@ impl Focusable for ContextStrip {
 
 impl Render for ContextStrip {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let context_store = self.context_store.read(cx);
-        let context = context_store.context();
         let context_picker = self.context_picker.clone();
         let focus_handle = self.focus_handle.clone();
 
-        let suggested_context = self.suggested_context(cx);
-
-        let added_contexts = context
-            .iter()
-            .map(|c| AddedContext::new(c, cx))
-            .collect::<Vec<_>>();
+        let added_contexts = self.added_contexts(cx);
         let dupe_names = added_contexts
             .iter()
             .map(|c| c.name.clone())
@@ -380,6 +370,14 @@ impl Render for ContextStrip {
             .filter(|(a, b)| a == b)
             .map(|(a, _)| a)
             .collect::<HashSet<SharedString>>();
+        let no_added_context = added_contexts.is_empty();
+
+        let suggested_context = self.suggested_context(cx).map(|suggested_context| {
+            (
+                suggested_context,
+                self.is_suggested_focused(&added_contexts),
+            )
+        });
 
         h_flex()
             .flex_wrap()
@@ -436,7 +434,7 @@ impl Render for ContextStrip {
                     })
                     .with_handle(self.context_picker_menu_handle.clone()),
             )
-            .when(context.is_empty() && suggested_context.is_none(), {
+            .when(no_added_context && suggested_context.is_none(), {
                 |parent| {
                     parent.child(
                         h_flex()
@@ -466,16 +464,17 @@ impl Render for ContextStrip {
                     .enumerate()
                     .map(|(i, added_context)| {
                         let name = added_context.name.clone();
-                        let id = added_context.id;
+                        let context = added_context.handle.clone();
                         ContextPill::added(
                             added_context,
                             dupe_names.contains(&name),
                             self.focused_index == Some(i),
                             Some({
+                                let context = context.clone();
                                 let context_store = self.context_store.clone();
                                 Rc::new(cx.listener(move |_this, _event, _window, cx| {
                                     context_store.update(cx, |this, cx| {
-                                        this.remove_context(id, cx);
+                                        this.remove_context(&context, cx);
                                     });
                                     cx.notify();
                                 }))
@@ -484,7 +483,7 @@ impl Render for ContextStrip {
                         .on_click({
                             Rc::new(cx.listener(move |this, event: &ClickEvent, window, cx| {
                                 if event.down.click_count > 1 {
-                                    this.open_context(id, window, cx);
+                                    this.open_context(&context, window, cx);
                                 } else {
                                     this.focused_index = Some(i);
                                 }
@@ -493,22 +492,22 @@ impl Render for ContextStrip {
                         })
                     }),
             )
-            .when_some(suggested_context, |el, suggested| {
+            .when_some(suggested_context, |el, (suggested, focused)| {
                 el.child(
                     ContextPill::suggested(
                         suggested.name().clone(),
                         suggested.icon_path(),
                         suggested.kind(),
-                        self.is_suggested_focused(&context),
+                        focused,
                     )
                     .on_click(Rc::new(cx.listener(
-                        move |this, _event, window, cx| {
-                            this.add_suggested_context(&suggested, window, cx);
+                        move |this, _event, _window, cx| {
+                            this.add_suggested_context(&suggested, cx);
                         },
                     ))),
                 )
             })
-            .when(!context.is_empty(), {
+            .when(!no_added_context, {
                 move |parent| {
                     parent.child(
                         IconButton::new("remove-all-context", IconName::Eraser)
@@ -534,6 +533,7 @@ impl Render for ContextStrip {
                     )
                 }
             })
+            .into_any()
     }
 }
 

crates/agent/src/history_store.rs

@@ -51,7 +51,10 @@ impl HistoryStore {
             return history_entries;
         }
 
-        for thread in self.thread_store.update(cx, |this, _cx| this.threads()) {
+        for thread in self
+            .thread_store
+            .update(cx, |this, _cx| this.reverse_chronological_threads())
+        {
             history_entries.push(HistoryEntry::Thread(thread));
         }
 

crates/agent/src/inline_assistant.rs

@@ -32,6 +32,7 @@ use project::LspAction;
 use project::Project;
 use project::{CodeAction, ProjectTransaction};
 use prompt_store::PromptBuilder;
+use prompt_store::PromptStore;
 use settings::{Settings, SettingsStore};
 use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use terminal_view::{TerminalView, terminal_panel::TerminalPanel};
@@ -245,9 +246,13 @@ impl InlineAssistant {
                 .map_or(false, |model| model.provider.is_authenticated(cx))
         };
 
-        let thread_store = workspace
+        let assistant_panel = workspace
             .panel::<AssistantPanel>(cx)
-            .map(|assistant_panel| assistant_panel.read(cx).thread_store().downgrade());
+            .map(|assistant_panel| assistant_panel.read(cx));
+        let prompt_store = assistant_panel
+            .and_then(|assistant_panel| assistant_panel.prompt_store().as_ref().cloned());
+        let thread_store =
+            assistant_panel.map(|assistant_panel| assistant_panel.thread_store().downgrade());
 
         let handle_assist =
             |window: &mut Window, cx: &mut Context<Workspace>| match inline_assist_target {
@@ -257,6 +262,7 @@ impl InlineAssistant {
                             &active_editor,
                             cx.entity().downgrade(),
                             workspace.project().downgrade(),
+                            prompt_store,
                             thread_store,
                             window,
                             cx,
@@ -269,6 +275,7 @@ impl InlineAssistant {
                             &active_terminal,
                             cx.entity().downgrade(),
                             workspace.project().downgrade(),
+                            prompt_store,
                             thread_store,
                             window,
                             cx,
@@ -323,6 +330,7 @@ impl InlineAssistant {
         editor: &Entity<Editor>,
         workspace: WeakEntity<Workspace>,
         project: WeakEntity<Project>,
+        prompt_store: Option<Entity<PromptStore>>,
         thread_store: Option<WeakEntity<ThreadStore>>,
         window: &mut Window,
         cx: &mut App,
@@ -437,6 +445,8 @@ impl InlineAssistant {
                     range.clone(),
                     None,
                     context_store.clone(),
+                    project.clone(),
+                    prompt_store.clone(),
                     self.telemetry.clone(),
                     self.prompt_builder.clone(),
                     cx,
@@ -525,6 +535,7 @@ impl InlineAssistant {
         initial_transaction_id: Option<TransactionId>,
         focus: bool,
         workspace: Entity<Workspace>,
+        prompt_store: Option<Entity<PromptStore>>,
         thread_store: Option<WeakEntity<ThreadStore>>,
         window: &mut Window,
         cx: &mut App,
@@ -543,7 +554,7 @@ impl InlineAssistant {
         }
 
         let project = workspace.read(cx).project().downgrade();
-        let context_store = cx.new(|_cx| ContextStore::new(project, thread_store.clone()));
+        let context_store = cx.new(|_cx| ContextStore::new(project.clone(), thread_store.clone()));
 
         let codegen = cx.new(|cx| {
             BufferCodegen::new(
@@ -551,6 +562,8 @@ impl InlineAssistant {
                 range.clone(),
                 initial_transaction_id,
                 context_store.clone(),
+                project,
+                prompt_store,
                 self.telemetry.clone(),
                 self.prompt_builder.clone(),
                 cx,
@@ -1789,6 +1802,7 @@ impl CodeActionProvider for AssistantCodeActionProvider {
         let editor = self.editor.clone();
         let workspace = self.workspace.clone();
         let thread_store = self.thread_store.clone();
+        let prompt_store = PromptStore::global(cx);
         window.spawn(cx, async move |cx| {
             let workspace = workspace.upgrade().context("workspace was released")?;
             let editor = editor.upgrade().context("editor was released")?;
@@ -1829,6 +1843,7 @@ impl CodeActionProvider for AssistantCodeActionProvider {
                 })?
                 .context("invalid range")?;
 
+            let prompt_store = prompt_store.await.ok();
             cx.update_global(|assistant: &mut InlineAssistant, window, cx| {
                 let assist_id = assistant.suggest_assist(
                     &editor,
@@ -1837,6 +1852,7 @@ impl CodeActionProvider for AssistantCodeActionProvider {
                     None,
                     true,
                     workspace,
+                    prompt_store,
                     thread_store,
                     window,
                     cx,

crates/agent/src/inline_prompt_editor.rs

@@ -13,7 +13,7 @@ use editor::{
     Editor, EditorElement, EditorEvent, EditorMode, EditorStyle, GutterDimensions, MultiBuffer,
     actions::{MoveDown, MoveUp},
 };
-use feature_flags::{FeatureFlagAppExt as _, ZedPro};
+use feature_flags::{FeatureFlagAppExt as _, ZedProFeatureFlag};
 use fs::Fs;
 use gpui::{
     AnyElement, App, ClickEvent, Context, CursorStyle, Entity, EventEmitter, FocusHandle,
@@ -132,7 +132,7 @@ impl<T: 'static> Render for PromptEditor<T> {
 
                                 let error_message = SharedString::from(error.to_string());
                                 if error.error_code() == proto::ErrorCode::RateLimitExceeded
-                                    && cx.has_flag::<ZedPro>()
+                                    && cx.has_flag::<ZedProFeatureFlag>()
                                 {
                                     el.child(
                                         v_flex()
@@ -931,7 +931,7 @@ impl PromptEditor<BufferCodegen> {
                     .update(cx, |editor, _| editor.set_read_only(false));
             }
             CodegenStatus::Error(error) => {
-                if cx.has_flag::<ZedPro>()
+                if cx.has_flag::<ZedProFeatureFlag>()
                     && error.error_code() == proto::ErrorCode::RateLimitExceeded
                     && !dismissed_rate_limit_notice()
                 {

crates/agent/src/message_editor.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use crate::assistant_model_selector::ModelType;
-use crate::context::{AssistantContext, format_context_as_string};
+use crate::context::{ContextLoadResult, load_context};
 use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip};
 use buffer_diff::BufferDiff;
 use collections::HashSet;
@@ -11,27 +11,34 @@ use editor::{
     ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorEvent, EditorMode,
     EditorStyle, MultiBuffer,
 };
+use feature_flags::{FeatureFlagAppExt, NewBillingFeatureFlag};
 use file_icons::FileIcons;
 use fs::Fs;
+use futures::future::Shared;
+use futures::{FutureExt as _, future};
 use gpui::{
     Animation, AnimationExt, App, ClipboardEntry, Entity, EventEmitter, Focusable, Subscription,
     Task, TextStyle, WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between,
 };
 use language::{Buffer, Language};
-use language_model::{ConfiguredModel, LanguageModelRegistry, LanguageModelRequestMessage};
+use language_model::{
+    ConfiguredModel, LanguageModelRegistry, LanguageModelRequestMessage, MessageContent,
+};
 use language_model_selector::ToggleModelSelector;
 use multi_buffer;
 use project::Project;
+use prompt_store::PromptStore;
 use settings::Settings;
 use std::time::Duration;
 use theme::ThemeSettings;
 use ui::{Disclosure, KeyBinding, PopoverMenuHandle, Tooltip, prelude::*};
 use util::ResultExt as _;
 use workspace::Workspace;
+use zed_llm_client::CompletionMode;
 
 use crate::assistant_model_selector::AssistantModelSelector;
 use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider};
-use crate::context_store::{ContextStore, refresh_context_store_text};
+use crate::context_store::ContextStore;
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
 use crate::profile_selector::ProfileSelector;
 use crate::thread::{Thread, TokenUsageRatio};
@@ -45,13 +52,15 @@ pub struct MessageEditor {
     thread: Entity<Thread>,
     incompatible_tools_state: Entity<IncompatibleToolsState>,
     editor: Entity<Editor>,
-    #[allow(dead_code)]
     workspace: WeakEntity<Workspace>,
     project: Entity<Project>,
     context_store: Entity<ContextStore>,
+    prompt_store: Option<Entity<PromptStore>>,
     context_strip: Entity<ContextStrip>,
     context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
     model_selector: Entity<AssistantModelSelector>,
+    last_loaded_context: Option<ContextLoadResult>,
+    context_load_task: Option<Shared<Task<()>>>,
     profile_selector: Entity<ProfileSelector>,
     edits_expanded: bool,
     editor_is_expanded: bool,
@@ -68,6 +77,7 @@ impl MessageEditor {
         fs: Arc<dyn Fs>,
         workspace: WeakEntity<Workspace>,
         context_store: Entity<ContextStore>,
+        prompt_store: Option<Entity<PromptStore>>,
         thread_store: WeakEntity<ThreadStore>,
         thread: Entity<Thread>,
         window: &mut Window,
@@ -135,13 +145,11 @@ impl MessageEditor {
         let subscriptions = vec![
             cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
             cx.subscribe(&editor, |this, _, event, cx| match event {
-                EditorEvent::BufferEdited => {
-                    this.message_or_context_changed(true, cx);
-                }
+                EditorEvent::BufferEdited => this.handle_message_changed(cx),
                 _ => {}
             }),
             cx.observe(&context_store, |this, _, cx| {
-                this.message_or_context_changed(false, cx);
+                let _ = this.start_context_load(cx);
             }),
         ];
 
@@ -152,8 +160,11 @@ impl MessageEditor {
             incompatible_tools_state: incompatible_tools.clone(),
             workspace,
             context_store,
+            prompt_store,
             context_strip,
             context_picker_menu_handle,
+            context_load_task: None,
+            last_loaded_context: None,
             model_selector: cx.new(|cx| {
                 AssistantModelSelector::new(
                     fs.clone(),
@@ -175,6 +186,10 @@ impl MessageEditor {
         }
     }
 
+    pub fn context_store(&self) -> &Entity<ContextStore> {
+        &self.context_store
+    }
+
     fn toggle_chat_mode(&mut self, _: &ChatMode, _window: &mut Window, cx: &mut Context<Self>) {
         cx.notify();
     }
@@ -195,6 +210,7 @@ impl MessageEditor {
                 editor.set_mode(EditorMode::Full {
                     scale_ui_elements_with_buffer_font_size: false,
                     show_active_line_background: false,
+                    sized_by_content: false,
                 })
             } else {
                 editor.set_mode(EditorMode::AutoHeight {
@@ -213,6 +229,7 @@ impl MessageEditor {
     ) {
         self.context_picker_menu_handle.toggle(window, cx);
     }
+
     pub fn remove_all_context(
         &mut self,
         _: &RemoveAllContext,
@@ -269,56 +286,44 @@ impl MessageEditor {
         self.last_estimated_token_count.take();
         cx.emit(MessageEditorEvent::EstimatedTokenCount);
 
-        let refresh_task =
-            refresh_context_store_text(self.context_store.clone(), &HashSet::default(), cx);
-        let wait_for_images = self.context_store.read(cx).wait_for_images(cx);
-
         let thread = self.thread.clone();
-        let context_store = self.context_store.clone();
         let git_store = self.project.read(cx).git_store().clone();
         let checkpoint = git_store.update(cx, |git_store, cx| git_store.checkpoint(cx));
+        let context_task = self.load_context(cx);
+        let window_handle = window.window_handle();
 
-        cx.spawn(async move |this, cx| {
-            let checkpoint = checkpoint.await.ok();
-            refresh_task.await;
-            wait_for_images.await;
+        cx.spawn(async move |_this, cx| {
+            let (checkpoint, loaded_context) = future::join(checkpoint, context_task).await;
+            let loaded_context = loaded_context.unwrap_or_default();
 
             thread
                 .update(cx, |thread, cx| {
-                    let context = context_store.read(cx).context().clone();
-                    thread.insert_user_message(user_message, context, checkpoint, cx);
+                    thread.insert_user_message(user_message, loaded_context, checkpoint.ok(), cx);
                 })
                 .log_err();
 
-            context_store
-                .update(cx, |context_store, cx| {
-                    let excerpt_ids = context_store
-                        .context()
-                        .iter()
-                        .filter(|ctx| {
-                            matches!(
-                                ctx,
-                                AssistantContext::Selection(_) | AssistantContext::Image(_)
-                            )
-                        })
-                        .map(|ctx| ctx.id())
-                        .collect::<Vec<_>>();
-
-                    for id in excerpt_ids {
-                        context_store.remove_context(id, cx);
-                    }
+            thread
+                .update(cx, |thread, cx| {
+                    thread.advance_prompt_id();
+                    thread.send_to_model(model, Some(window_handle), cx);
                 })
                 .log_err();
+        })
+        .detach();
+    }
 
+    fn wait_for_summaries(&mut self, cx: &mut Context<Self>) -> Task<()> {
+        let context_store = self.context_store.clone();
+        cx.spawn(async move |this, cx| {
             if let Some(wait_for_summaries) = context_store
                 .update(cx, |context_store, cx| context_store.wait_for_summaries(cx))
-                .log_err()
+                .ok()
             {
                 this.update(cx, |this, cx| {
                     this.waiting_for_summaries_to_send = true;
                     cx.notify();
                 })
-                .log_err();
+                .ok();
 
                 wait_for_summaries.await;
 
@@ -326,24 +331,15 @@ impl MessageEditor {
                     this.waiting_for_summaries_to_send = false;
                     cx.notify();
                 })
-                .log_err();
+                .ok();
             }
-
-            // Send to model after summaries are done
-            thread
-                .update(cx, |thread, cx| {
-                    thread.advance_prompt_id();
-                    thread.send_to_model(model, cx);
-                })
-                .log_err();
         })
-        .detach();
     }
 
     fn stop_current_and_send_new_message(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let cancelled = self
-            .thread
-            .update(cx, |thread, cx| thread.cancel_last_completion(cx));
+        let cancelled = self.thread.update(cx, |thread, cx| {
+            thread.cancel_last_completion(Some(window.window_handle()), cx)
+        });
 
         if cancelled {
             self.set_editor_is_expanded(false, cx);
@@ -400,7 +396,7 @@ impl MessageEditor {
 
         self.context_store.update(cx, |store, cx| {
             for image in images {
-                store.add_image(Arc::new(image), cx);
+                store.add_image_instance(Arc::new(image), cx);
             }
         });
     }
@@ -424,6 +420,37 @@ impl MessageEditor {
         }
     }
 
+    fn render_max_mode_toggle(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
+        if !cx.has_flag::<NewBillingFeatureFlag>() {
+            return None;
+        }
+
+        let model = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.model.clone())?;
+        if !model.supports_max_mode() {
+            return None;
+        }
+
+        let active_completion_mode = self.thread.read(cx).completion_mode();
+
+        Some(
+            IconButton::new("max-mode", IconName::ZedMaxMode)
+                .icon_size(IconSize::Small)
+                .toggle_state(active_completion_mode == Some(CompletionMode::Max))
+                .on_click(cx.listener(move |this, _event, _window, cx| {
+                    this.thread.update(cx, |thread, _cx| {
+                        thread.set_completion_mode(match active_completion_mode {
+                            Some(CompletionMode::Max) => Some(CompletionMode::Normal),
+                            Some(CompletionMode::Normal) | None => Some(CompletionMode::Max),
+                        });
+                    });
+                }))
+                .tooltip(Tooltip::text("Toggle Max Mode"))
+                .into_any_element(),
+        )
+    }
+
     fn render_editor(
         &self,
         font_size: Rems,
@@ -584,6 +611,7 @@ impl MessageEditor {
                                             }),
                                         )
                                     })
+                                    .children(self.render_max_mode_toggle(cx))
                                     .child(self.model_selector.clone())
                                     .map({
                                         let focus_handle = focus_handle.clone();
@@ -1013,6 +1041,48 @@ impl MessageEditor {
         self.update_token_count_task.is_some()
     }
 
+    fn handle_message_changed(&mut self, cx: &mut Context<Self>) {
+        self.message_or_context_changed(true, cx);
+    }
+
+    fn start_context_load(&mut self, cx: &mut Context<Self>) -> Shared<Task<()>> {
+        let summaries_task = self.wait_for_summaries(cx);
+        let load_task = cx.spawn(async move |this, cx| {
+            // Waits for detailed summaries before `load_context`, as it directly reads these from
+            // the thread. TODO: Would be cleaner to have context loading await on summarization.
+            summaries_task.await;
+            let Ok(load_task) = this.update(cx, |this, cx| {
+                let new_context = this.context_store.read_with(cx, |context_store, cx| {
+                    context_store.new_context_for_thread(this.thread.read(cx))
+                });
+                load_context(new_context, &this.project, &this.prompt_store, cx)
+            }) else {
+                return;
+            };
+            let result = load_task.await;
+            this.update(cx, |this, cx| {
+                this.last_loaded_context = Some(result);
+                this.context_load_task = None;
+                this.message_or_context_changed(false, cx);
+            })
+            .ok();
+        });
+        // Replace existing load task, if any, causing it to be cancelled.
+        let load_task = load_task.shared();
+        self.context_load_task = Some(load_task.clone());
+        load_task
+    }
+
+    fn load_context(&mut self, cx: &mut Context<Self>) -> Task<Option<ContextLoadResult>> {
+        let context_load_task = self.start_context_load(cx);
+        cx.spawn(async move |this, cx| {
+            context_load_task.await;
+            this.read_with(cx, |this, _cx| this.last_loaded_context.clone())
+                .ok()
+                .flatten()
+        })
+    }
+
     fn message_or_context_changed(&mut self, debounce: bool, cx: &mut Context<Self>) {
         cx.emit(MessageEditorEvent::Changed);
         self.update_token_count_task.take();
@@ -1022,9 +1092,7 @@ impl MessageEditor {
             return;
         };
 
-        let context_store = self.context_store.clone();
         let editor = self.editor.clone();
-        let thread = self.thread.clone();
 
         self.update_token_count_task = Some(cx.spawn(async move |this, cx| {
             if debounce {
@@ -1033,27 +1101,40 @@ impl MessageEditor {
                     .await;
             }
 
-            let token_count = if let Some(task) = cx.update(|cx| {
-                let context = context_store.read(cx).context().iter();
-                let new_context = thread.read(cx).filter_new_context(context);
-                let context_text =
-                    format_context_as_string(new_context, cx).unwrap_or(String::new());
+            let token_count = if let Some(task) = this.update(cx, |this, cx| {
+                let loaded_context = this
+                    .last_loaded_context
+                    .as_ref()
+                    .map(|context_load_result| &context_load_result.loaded_context);
                 let message_text = editor.read(cx).text(cx);
 
-                let content = context_text + &message_text;
-
-                if content.is_empty() {
+                if message_text.is_empty()
+                    && loaded_context.map_or(true, |loaded_context| loaded_context.is_empty())
+                {
                     return None;
                 }
 
+                let mut request_message = LanguageModelRequestMessage {
+                    role: language_model::Role::User,
+                    content: Vec::new(),
+                    cache: false,
+                };
+
+                if let Some(loaded_context) = loaded_context {
+                    loaded_context.add_to_request_message(&mut request_message);
+                }
+
+                if !message_text.is_empty() {
+                    request_message
+                        .content
+                        .push(MessageContent::Text(message_text));
+                }
+
                 let request = language_model::LanguageModelRequest {
                     thread_id: None,
                     prompt_id: None,
-                    messages: vec![LanguageModelRequestMessage {
-                        role: language_model::Role::User,
-                        content: vec![content.into()],
-                        cache: false,
-                    }],
+                    mode: None,
+                    messages: vec![request_message],
                     tools: vec![],
                     stop: vec![],
                     temperature: None,

crates/agent/src/terminal_codegen.rs

@@ -32,7 +32,7 @@ impl TerminalCodegen {
         }
     }
 
-    pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
+    pub fn start(&mut self, prompt_task: Task<LanguageModelRequest>, cx: &mut Context<Self>) {
         let Some(ConfiguredModel { model, .. }) =
             LanguageModelRegistry::read_global(cx).inline_assistant_model()
         else {
@@ -45,6 +45,7 @@ impl TerminalCodegen {
         self.status = CodegenStatus::Pending;
         self.transaction = Some(TerminalTransaction::start(self.terminal.clone()));
         self.generation = cx.spawn(async move |this, cx| {
+            let prompt = prompt_task.await;
             let model_telemetry_id = model.telemetry_id();
             let model_provider_id = model.provider_id();
             let response = model.stream_completion_text(prompt, &cx).await;

crates/agent/src/terminal_inline_assistant.rs

@@ -1,4 +1,4 @@
-use crate::context::attach_context_to_message;
+use crate::context::load_context;
 use crate::context_store::ContextStore;
 use crate::inline_prompt_editor::{
     CodegenStatus, PromptEditor, PromptEditorEvent, TerminalInlineAssistId,
@@ -10,14 +10,14 @@ use client::telemetry::Telemetry;
 use collections::{HashMap, VecDeque};
 use editor::{MultiBuffer, actions::SelectAll};
 use fs::Fs;
-use gpui::{App, Entity, Focusable, Global, Subscription, UpdateGlobal, WeakEntity};
+use gpui::{App, Entity, Focusable, Global, Subscription, Task, UpdateGlobal, WeakEntity};
 use language::Buffer;
 use language_model::{
     ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
     Role, report_assistant_event,
 };
 use project::Project;
-use prompt_store::PromptBuilder;
+use prompt_store::{PromptBuilder, PromptStore};
 use std::sync::Arc;
 use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use terminal_view::TerminalView;
@@ -69,6 +69,7 @@ impl TerminalInlineAssistant {
         terminal_view: &Entity<TerminalView>,
         workspace: WeakEntity<Workspace>,
         project: WeakEntity<Project>,
+        prompt_store: Option<Entity<PromptStore>>,
         thread_store: Option<WeakEntity<ThreadStore>>,
         window: &mut Window,
         cx: &mut App,
@@ -109,6 +110,7 @@ impl TerminalInlineAssistant {
             prompt_editor,
             workspace.clone(),
             context_store,
+            prompt_store,
             window,
             cx,
         );
@@ -196,11 +198,11 @@ impl TerminalInlineAssistant {
             .log_err();
 
         let codegen = assist.codegen.clone();
-        let Some(request) = self.request_for_inline_assist(assist_id, cx).log_err() else {
+        let Some(request_task) = self.request_for_inline_assist(assist_id, cx).log_err() else {
             return;
         };
 
-        codegen.update(cx, |codegen, cx| codegen.start(request, cx));
+        codegen.update(cx, |codegen, cx| codegen.start(request_task, cx));
     }
 
     fn stop_assist(&mut self, assist_id: TerminalInlineAssistId, cx: &mut App) {
@@ -217,7 +219,7 @@ impl TerminalInlineAssistant {
         &self,
         assist_id: TerminalInlineAssistId,
         cx: &mut App,
-    ) -> Result<LanguageModelRequest> {
+    ) -> Result<Task<LanguageModelRequest>> {
         let assist = self.assists.get(&assist_id).context("invalid assist")?;
 
         let shell = std::env::var("SHELL").ok();
@@ -246,28 +248,41 @@ impl TerminalInlineAssistant {
             &latest_output,
         )?;
 
-        let mut request_message = LanguageModelRequestMessage {
-            role: Role::User,
-            content: vec![],
-            cache: false,
-        };
+        let contexts = assist
+            .context_store
+            .read(cx)
+            .context()
+            .cloned()
+            .collect::<Vec<_>>();
+        let context_load_task = assist.workspace.update(cx, |workspace, cx| {
+            let project = workspace.project();
+            load_context(contexts, project, &assist.prompt_store, cx)
+        })?;
 
-        attach_context_to_message(
-            &mut request_message,
-            assist.context_store.read(cx).context().iter(),
-            cx,
-        );
+        Ok(cx.background_spawn(async move {
+            let mut request_message = LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![],
+                cache: false,
+            };
 
-        request_message.content.push(prompt.into());
+            context_load_task
+                .await
+                .loaded_context
+                .add_to_request_message(&mut request_message);
 
-        Ok(LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
-            messages: vec![request_message],
-            tools: Vec::new(),
-            stop: Vec::new(),
-            temperature: None,
-        })
+            request_message.content.push(prompt.into());
+
+            LanguageModelRequest {
+                thread_id: None,
+                prompt_id: None,
+                mode: None,
+                messages: vec![request_message],
+                tools: Vec::new(),
+                stop: Vec::new(),
+                temperature: None,
+            }
+        }))
     }
 
     fn finish_assist(
@@ -380,6 +395,7 @@ struct TerminalInlineAssist {
     codegen: Entity<TerminalCodegen>,
     workspace: WeakEntity<Workspace>,
     context_store: Entity<ContextStore>,
+    prompt_store: Option<Entity<PromptStore>>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -390,6 +406,7 @@ impl TerminalInlineAssist {
         prompt_editor: Entity<PromptEditor<TerminalCodegen>>,
         workspace: WeakEntity<Workspace>,
         context_store: Entity<ContextStore>,
+        prompt_store: Option<Entity<PromptStore>>,
         window: &mut Window,
         cx: &mut App,
     ) -> Self {
@@ -400,6 +417,7 @@ impl TerminalInlineAssist {
             codegen: codegen.clone(),
             workspace: workspace.clone(),
             context_store,
+            prompt_store,
             _subscriptions: vec![
                 window.subscribe(&prompt_editor, cx, |prompt_editor, event, window, cx| {
                     TerminalInlineAssistant::update_global(cx, |this, cx| {

crates/agent/src/thread_store.rs

@@ -11,7 +11,6 @@ use chrono::{DateTime, Utc};
 use collections::HashMap;
 use context_server::manager::ContextServerManager;
 use context_server::{ContextServerFactoryRegistry, ContextServerTool};
-use fs::Fs;
 use futures::channel::{mpsc, oneshot};
 use futures::future::{self, BoxFuture, Shared};
 use futures::{FutureExt as _, StreamExt as _};
@@ -22,10 +21,10 @@ use gpui::{
 use heed::Database;
 use heed::types::SerdeBincode;
 use language_model::{LanguageModelToolUseId, Role, TokenUsage};
-use project::{Project, Worktree};
+use project::{Project, ProjectItem, ProjectPath, Worktree};
 use prompt_store::{
-    ProjectContext, PromptBuilder, PromptId, PromptMetadata, PromptStore, PromptsUpdatedEvent,
-    RulesFileContext, UserPromptId, UserRulesContext, WorktreeContext,
+    ProjectContext, PromptBuilder, PromptId, PromptStore, PromptsUpdatedEvent, RulesFileContext,
+    UserRulesContext, WorktreeContext,
 };
 use serde::{Deserialize, Serialize};
 use settings::{Settings as _, SettingsStore};
@@ -82,12 +81,11 @@ impl ThreadStore {
     pub fn load(
         project: Entity<Project>,
         tools: Entity<ToolWorkingSet>,
+        prompt_store: Option<Entity<PromptStore>>,
         prompt_builder: Arc<PromptBuilder>,
         cx: &mut App,
     ) -> Task<Result<Entity<Self>>> {
-        let prompt_store = PromptStore::global(cx);
         cx.spawn(async move |cx| {
-            let prompt_store = prompt_store.await.ok();
             let (thread_store, ready_rx) = cx.update(|cx| {
                 let mut option_ready_rx = None;
                 let thread_store = cx.new(|cx| {
@@ -208,15 +206,15 @@ impl ThreadStore {
         prompt_store: Option<Entity<PromptStore>>,
         cx: &mut Context<Self>,
     ) -> Task<()> {
-        let project = self.project.read(cx);
-        let worktree_tasks = project
+        let worktrees = self
+            .project
+            .read(cx)
             .visible_worktrees(cx)
+            .collect::<Vec<_>>();
+        let worktree_tasks = worktrees
+            .into_iter()
             .map(|worktree| {
-                Self::load_worktree_info_for_system_prompt(
-                    project.fs().clone(),
-                    worktree.read(cx),
-                    cx,
-                )
+                Self::load_worktree_info_for_system_prompt(worktree, self.project.clone(), cx)
             })
             .collect::<Vec<_>>();
         let default_user_rules_task = match prompt_store {
@@ -277,13 +275,13 @@ impl ThreadStore {
     }
 
     fn load_worktree_info_for_system_prompt(
-        fs: Arc<dyn Fs>,
-        worktree: &Worktree,
-        cx: &App,
+        worktree: Entity<Worktree>,
+        project: Entity<Project>,
+        cx: &mut App,
     ) -> Task<(WorktreeContext, Option<RulesLoadingError>)> {
-        let root_name = worktree.root_name().into();
+        let root_name = worktree.read(cx).root_name().into();
 
-        let rules_task = Self::load_worktree_rules_file(fs, worktree, cx);
+        let rules_task = Self::load_worktree_rules_file(worktree, project, cx);
         let Some(rules_task) = rules_task else {
             return Task::ready((
                 WorktreeContext {
@@ -313,33 +311,44 @@ impl ThreadStore {
     }
 
     fn load_worktree_rules_file(
-        fs: Arc<dyn Fs>,
-        worktree: &Worktree,
-        cx: &App,
+        worktree: Entity<Worktree>,
+        project: Entity<Project>,
+        cx: &mut App,
     ) -> Option<Task<Result<RulesFileContext>>> {
+        let worktree_ref = worktree.read(cx);
+        let worktree_id = worktree_ref.id();
         let selected_rules_file = RULES_FILE_NAMES
             .into_iter()
             .filter_map(|name| {
-                worktree
+                worktree_ref
                     .entry_for_path(name)
                     .filter(|entry| entry.is_file())
-                    .map(|entry| (entry.path.clone(), worktree.absolutize(&entry.path)))
+                    .map(|entry| entry.path.clone())
             })
             .next();
 
         // Note that Cline supports `.clinerules` being a directory, but that is not currently
         // supported. This doesn't seem to occur often in GitHub repositories.
-        selected_rules_file.map(|(path_in_worktree, abs_path)| {
-            let fs = fs.clone();
+        selected_rules_file.map(|path_in_worktree| {
+            let project_path = ProjectPath {
+                worktree_id,
+                path: path_in_worktree.clone(),
+            };
+            let buffer_task =
+                project.update(cx, |project, cx| project.open_buffer(project_path, cx));
+            let rope_task = cx.spawn(async move |cx| {
+                buffer_task.await?.read_with(cx, |buffer, cx| {
+                    let project_entry_id = buffer.entry_id(cx).context("buffer has no file")?;
+                    anyhow::Ok((project_entry_id, buffer.as_rope().clone()))
+                })?
+            });
+            // Build a string from the rope on a background thread.
             cx.background_spawn(async move {
-                let abs_path = abs_path?;
-                let text = fs.load(&abs_path).await.with_context(|| {
-                    format!("Failed to load assistant rules file {:?}", abs_path)
-                })?;
+                let (project_entry_id, rope) = rope_task.await?;
                 anyhow::Ok(RulesFileContext {
                     path_in_worktree,
-                    abs_path: abs_path.into(),
-                    text: text.trim().to_string(),
+                    text: rope.to_string().trim().to_string(),
+                    project_entry_id: project_entry_id.to_usize(),
                 })
             })
         })
@@ -349,25 +358,8 @@ impl ThreadStore {
         self.context_server_manager.clone()
     }
 
-    pub fn prompt_store(&self) -> Option<Entity<PromptStore>> {
-        self.prompt_store.clone()
-    }
-
-    pub fn load_rules(
-        &self,
-        prompt_id: UserPromptId,
-        cx: &App,
-    ) -> Task<Result<(PromptMetadata, String)>> {
-        let prompt_id = PromptId::User { uuid: prompt_id };
-        let Some(prompt_store) = self.prompt_store.as_ref() else {
-            return Task::ready(Err(anyhow!("Prompt store unexpectedly missing.")));
-        };
-        let prompt_store = prompt_store.read(cx);
-        let Some(metadata) = prompt_store.metadata(prompt_id) else {
-            return Task::ready(Err(anyhow!("User rules not found in library.")));
-        };
-        let text_task = prompt_store.load(prompt_id, cx);
-        cx.background_spawn(async move { Ok((metadata, text_task.await?)) })
+    pub fn prompt_store(&self) -> &Option<Entity<PromptStore>> {
+        &self.prompt_store
     }
 
     pub fn tools(&self) -> Entity<ToolWorkingSet> {
@@ -379,16 +371,12 @@ impl ThreadStore {
         self.threads.len()
     }
 
-    pub fn threads(&self) -> Vec<SerializedThreadMetadata> {
+    pub fn reverse_chronological_threads(&self) -> Vec<SerializedThreadMetadata> {
         let mut threads = self.threads.iter().cloned().collect::<Vec<_>>();
         threads.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.updated_at));
         threads
     }
 
-    pub fn recent_threads(&self, limit: usize) -> Vec<SerializedThreadMetadata> {
-        self.threads().into_iter().take(limit).collect()
-    }
-
     pub fn create_thread(&mut self, cx: &mut Context<Self>) -> Entity<Thread> {
         cx.new(|cx| {
             Thread::new(
@@ -516,6 +504,22 @@ impl ThreadStore {
                     );
                 });
             }
+            // Enable all the tools from all context servers, but disable the ones that are explicitly disabled
+            for (context_server_id, preset) in &profile.context_servers {
+                self.tools.update(cx, |tools, cx| {
+                    tools.disable(
+                        ToolSource::ContextServer {
+                            id: context_server_id.clone().into(),
+                        },
+                        &preset
+                            .tools
+                            .iter()
+                            .filter_map(|(tool, enabled)| (!enabled).then(|| tool.clone()))
+                            .collect::<Vec<_>>(),
+                        cx,
+                    )
+                })
+            }
         } else {
             for (context_server_id, preset) in &profile.context_servers {
                 self.tools.update(cx, |tools, cx| {
@@ -639,12 +643,17 @@ pub struct SerializedThread {
 }
 
 impl SerializedThread {
-    pub const VERSION: &'static str = "0.1.0";
+    pub const VERSION: &'static str = "0.2.0";
 
     pub fn from_json(json: &[u8]) -> Result<Self> {
         let saved_thread_json = serde_json::from_slice::<serde_json::Value>(json)?;
         match saved_thread_json.get("version") {
             Some(serde_json::Value::String(version)) => match version.as_str() {
+                SerializedThreadV0_1_0::VERSION => {
+                    let saved_thread =
+                        serde_json::from_value::<SerializedThreadV0_1_0>(saved_thread_json)?;
+                    Ok(saved_thread.upgrade())
+                }
                 SerializedThread::VERSION => Ok(serde_json::from_value::<SerializedThread>(
                     saved_thread_json,
                 )?),
@@ -666,6 +675,38 @@ impl SerializedThread {
     }
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct SerializedThreadV0_1_0(
+    // The structure did not change, so we are reusing the latest SerializedThread.
+    // When making the next version, make sure this points to SerializedThreadV0_2_0
+    SerializedThread,
+);
+
+impl SerializedThreadV0_1_0 {
+    pub const VERSION: &'static str = "0.1.0";
+
+    pub fn upgrade(self) -> SerializedThread {
+        debug_assert_eq!(SerializedThread::VERSION, "0.2.0");
+
+        let mut messages: Vec<SerializedMessage> = Vec::with_capacity(self.0.messages.len());
+
+        for message in self.0.messages {
+            if message.role == Role::User && !message.tool_results.is_empty() {
+                if let Some(last_message) = messages.last_mut() {
+                    debug_assert!(last_message.role == Role::Assistant);
+
+                    last_message.tool_results = message.tool_results;
+                    continue;
+                }
+            }
+
+            messages.push(message);
+        }
+
+        SerializedThread { messages, ..self.0 }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct SerializedMessage {
     pub id: MessageId,

crates/agent/src/tool_use.rs

@@ -30,7 +30,6 @@ pub struct ToolUse {
 pub struct ToolUseState {
     tools: Entity<ToolWorkingSet>,
     tool_uses_by_assistant_message: HashMap<MessageId, Vec<LanguageModelToolUse>>,
-    tool_uses_by_user_message: HashMap<MessageId, Vec<LanguageModelToolUseId>>,
     tool_results: HashMap<LanguageModelToolUseId, LanguageModelToolResult>,
     pending_tool_uses_by_id: HashMap<LanguageModelToolUseId, PendingToolUse>,
     tool_result_cards: HashMap<LanguageModelToolUseId, AnyToolCard>,
@@ -42,7 +41,6 @@ impl ToolUseState {
         Self {
             tools,
             tool_uses_by_assistant_message: HashMap::default(),
-            tool_uses_by_user_message: HashMap::default(),
             tool_results: HashMap::default(),
             pending_tool_uses_by_id: HashMap::default(),
             tool_result_cards: HashMap::default(),
@@ -56,7 +54,6 @@ impl ToolUseState {
     pub fn from_serialized_messages(
         tools: Entity<ToolWorkingSet>,
         messages: &[SerializedMessage],
-        mut filter_by_tool_name: impl FnMut(&str) -> bool,
     ) -> Self {
         let mut this = Self::new(tools);
         let mut tool_names_by_id = HashMap::default();
@@ -68,10 +65,10 @@ impl ToolUseState {
                         let tool_uses = message
                             .tool_uses
                             .iter()
-                            .filter(|tool_use| (filter_by_tool_name)(tool_use.name.as_ref()))
                             .map(|tool_use| LanguageModelToolUse {
                                 id: tool_use.id.clone(),
                                 name: tool_use.name.clone().into(),
+                                raw_input: tool_use.input.to_string(),
                                 input: tool_use.input.clone(),
                                 is_input_complete: true,
                             })
@@ -85,14 +82,6 @@ impl ToolUseState {
 
                         this.tool_uses_by_assistant_message
                             .insert(message.id, tool_uses);
-                    }
-                }
-                Role::User => {
-                    if !message.tool_results.is_empty() {
-                        let tool_uses_by_user_message = this
-                            .tool_uses_by_user_message
-                            .entry(message.id)
-                            .or_default();
 
                         for tool_result in &message.tool_results {
                             let tool_use_id = tool_result.tool_use_id.clone();
@@ -101,11 +90,6 @@ impl ToolUseState {
                                 continue;
                             };
 
-                            if !(filter_by_tool_name)(tool_use.as_ref()) {
-                                continue;
-                            }
-
-                            tool_uses_by_user_message.push(tool_use_id.clone());
                             this.tool_results.insert(
                                 tool_use_id.clone(),
                                 LanguageModelToolResult {
@@ -118,7 +102,7 @@ impl ToolUseState {
                         }
                     }
                 }
-                Role::System => {}
+                Role::System | Role::User => {}
             }
         }
 
@@ -228,20 +212,26 @@ impl ToolUseState {
         }
     }
 
-    pub fn tool_results_for_message(&self, message_id: MessageId) -> Vec<&LanguageModelToolResult> {
-        let empty = Vec::new();
+    pub fn tool_results_for_message(
+        &self,
+        assistant_message_id: MessageId,
+    ) -> Vec<&LanguageModelToolResult> {
+        let Some(tool_uses) = self
+            .tool_uses_by_assistant_message
+            .get(&assistant_message_id)
+        else {
+            return Vec::new();
+        };
 
-        self.tool_uses_by_user_message
-            .get(&message_id)
-            .unwrap_or(&empty)
+        tool_uses
             .iter()
-            .filter_map(|tool_use_id| self.tool_results.get(&tool_use_id))
+            .filter_map(|tool_use| self.tool_results.get(&tool_use.id))
             .collect()
     }
 
-    pub fn message_has_tool_results(&self, message_id: MessageId) -> bool {
-        self.tool_uses_by_user_message
-            .get(&message_id)
+    pub fn message_has_tool_results(&self, assistant_message_id: MessageId) -> bool {
+        self.tool_uses_by_assistant_message
+            .get(&assistant_message_id)
             .map_or(false, |results| !results.is_empty())
     }
 
@@ -293,14 +283,6 @@ impl ToolUseState {
             self.tool_use_metadata_by_id
                 .insert(tool_use.id.clone(), metadata);
 
-            // The tool use is being requested by the Assistant, so we want to
-            // attach the tool results to the next user message.
-            let next_user_message_id = MessageId(assistant_message_id.0 + 1);
-            self.tool_uses_by_user_message
-                .entry(next_user_message_id)
-                .or_default()
-                .push(tool_use.id.clone());
-
             PendingToolUseStatus::Idle
         } else {
             PendingToolUseStatus::InputStillStreaming
@@ -466,31 +448,49 @@ impl ToolUseState {
         }
     }
 
-    pub fn attach_tool_results(
+    pub fn has_tool_results(&self, assistant_message_id: MessageId) -> bool {
+        self.tool_uses_by_assistant_message
+            .contains_key(&assistant_message_id)
+    }
+
+    pub fn tool_results_message(
         &self,
-        message_id: MessageId,
-        request_message: &mut LanguageModelRequestMessage,
-    ) {
-        if let Some(tool_uses) = self.tool_uses_by_user_message.get(&message_id) {
-            for tool_use_id in tool_uses {
-                if let Some(tool_result) = self.tool_results.get(tool_use_id) {
-                    request_message.content.push(MessageContent::ToolResult(
-                        LanguageModelToolResult {
-                            tool_use_id: tool_use_id.clone(),
-                            tool_name: tool_result.tool_name.clone(),
-                            is_error: tool_result.is_error,
-                            content: if tool_result.content.is_empty() {
-                                // Surprisingly, the API fails if we return an empty string here.
-                                // It thinks we are sending a tool use without a tool result.
-                                "<Tool returned an empty string>".into()
-                            } else {
-                                tool_result.content.clone()
-                            },
+        assistant_message_id: MessageId,
+    ) -> Option<LanguageModelRequestMessage> {
+        let tool_uses = self
+            .tool_uses_by_assistant_message
+            .get(&assistant_message_id)?;
+
+        if tool_uses.is_empty() {
+            return None;
+        }
+
+        let mut request_message = LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec![],
+            cache: false,
+        };
+
+        for tool_use in tool_uses {
+            if let Some(tool_result) = self.tool_results.get(&tool_use.id) {
+                request_message
+                    .content
+                    .push(MessageContent::ToolResult(LanguageModelToolResult {
+                        tool_use_id: tool_use.id.clone(),
+                        tool_name: tool_result.tool_name.clone(),
+                        is_error: tool_result.is_error,
+                        content: if tool_result.content.is_empty() {
+                            // Surprisingly, the API fails if we return an empty string here.
+                            // It thinks we are sending a tool use without a tool result.
+                            "<Tool returned an empty string>".into()
+                        } else {
+                            tool_result.content.clone()
                         },
-                    ));
-                }
+                    }));
             }
         }
+
+        Some(request_message)
     }
 }
 

crates/agent/src/ui/animated_label.rs

@@ -73,6 +73,11 @@ impl LabelCommon for AnimatedLabel {
         self.base = self.base.buffer_font(cx);
         self
     }
+
+    fn inline_code(mut self, cx: &App) -> Self {
+        self.base = self.base.inline_code(cx);
+        self
+    }
 }
 
 impl RenderOnce for AnimatedLabel {

crates/agent/src/ui/context_pill.rs

@@ -1,14 +1,23 @@
-use std::sync::Arc;
-use std::{rc::Rc, time::Duration};
+use std::{ops::Range, path::Path, rc::Rc, sync::Arc, time::Duration};
 
 use file_icons::FileIcons;
-use futures::FutureExt;
-use gpui::{Animation, AnimationExt as _, Image, MouseButton, pulsating_between};
-use gpui::{ClickEvent, Task};
+use futures::FutureExt as _;
+use gpui::{
+    Animation, AnimationExt as _, AnyView, ClickEvent, Entity, Image, MouseButton, Task,
+    pulsating_between,
+};
 use language_model::LanguageModelImage;
+use project::Project;
+use prompt_store::PromptStore;
+use rope::Point;
 use ui::{IconButtonShape, Tooltip, prelude::*, tooltip_container};
 
-use crate::context::{AssistantContext, ContextId, ContextKind, ImageContext};
+use crate::context::{
+    AgentContext, AgentContextHandle, ContextId, ContextKind, DirectoryContext,
+    DirectoryContextHandle, FetchedUrlContext, FileContext, FileContextHandle, ImageContext,
+    ImageStatus, RulesContext, RulesContextHandle, SelectionContext, SelectionContextHandle,
+    SymbolContext, SymbolContextHandle, ThreadContext, ThreadContextHandle,
+};
 
 #[derive(IntoElement)]
 pub enum ContextPill {
@@ -73,9 +82,7 @@ impl ContextPill {
 
     pub fn id(&self) -> ElementId {
         match self {
-            Self::Added { context, .. } => {
-                ElementId::NamedInteger("context-pill".into(), context.id.0)
-            }
+            Self::Added { context, .. } => context.handle.element_id("context-pill".into()),
             Self::Suggested { .. } => "suggested-context-pill".into(),
         }
     }
@@ -168,16 +175,11 @@ impl RenderOnce for ContextPill {
                             .map(|element| match &context.status {
                                 ContextStatus::Ready => element
                                     .when_some(
-                                        context.render_preview.as_ref(),
-                                        |element, render_preview| {
-                                            element.hoverable_tooltip({
-                                                let render_preview = render_preview.clone();
-                                                move |_, cx| {
-                                                    cx.new(|_| ContextPillPreview {
-                                                        render_preview: render_preview.clone(),
-                                                    })
-                                                    .into()
-                                                }
+                                        context.render_hover.as_ref(),
+                                        |element, render_hover| {
+                                            let render_hover = render_hover.clone();
+                                            element.hoverable_tooltip(move |window, cx| {
+                                                render_hover(window, cx)
                                             })
                                         },
                                     )
@@ -199,14 +201,17 @@ impl RenderOnce for ContextPill {
                     )
                     .when_some(on_remove.as_ref(), |element, on_remove| {
                         element.child(
-                            IconButton::new(("remove", context.id.0), IconName::Close)
-                                .shape(IconButtonShape::Square)
-                                .icon_size(IconSize::XSmall)
-                                .tooltip(Tooltip::text("Remove Context"))
-                                .on_click({
-                                    let on_remove = on_remove.clone();
-                                    move |event, window, cx| on_remove(event, window, cx)
-                                }),
+                            IconButton::new(
+                                context.handle.element_id("remove".into()),
+                                IconName::Close,
+                            )
+                            .shape(IconButtonShape::Square)
+                            .icon_size(IconSize::XSmall)
+                            .tooltip(Tooltip::text("Remove Context"))
+                            .on_click({
+                                let on_remove = on_remove.clone();
+                                move |event, window, cx| on_remove(event, window, cx)
+                            }),
                         )
                     })
                     .when_some(on_click.as_ref(), |element, on_click| {
@@ -264,216 +269,441 @@ pub enum ContextStatus {
 
 #[derive(RegisterComponent)]
 pub struct AddedContext {
-    pub id: ContextId,
+    pub handle: AgentContextHandle,
     pub kind: ContextKind,
     pub name: SharedString,
     pub parent: Option<SharedString>,
     pub tooltip: Option<SharedString>,
     pub icon_path: Option<SharedString>,
     pub status: ContextStatus,
-    pub render_preview: Option<Rc<dyn Fn(&mut Window, &mut App) -> AnyElement + 'static>>,
+    pub render_hover: Option<Rc<dyn Fn(&mut Window, &mut App) -> AnyView + 'static>>,
 }
 
 impl AddedContext {
-    pub fn new(context: &AssistantContext, cx: &App) -> AddedContext {
+    /// Creates an `AddedContext` by retrieving relevant details of `AgentContext`. This returns a
+    /// `None` if `DirectoryContext` or `RulesContext` no longer exist.
+    ///
+    /// TODO: `None` cases are unremovable from `ContextStore` and so are a very minor memory leak.
+    pub fn new_pending(
+        handle: AgentContextHandle,
+        prompt_store: Option<&Entity<PromptStore>>,
+        project: &Project,
+        cx: &App,
+    ) -> Option<AddedContext> {
+        match handle {
+            AgentContextHandle::File(handle) => Self::pending_file(handle, cx),
+            AgentContextHandle::Directory(handle) => Self::pending_directory(handle, project, cx),
+            AgentContextHandle::Symbol(handle) => Self::pending_symbol(handle, cx),
+            AgentContextHandle::Selection(handle) => Self::pending_selection(handle, cx),
+            AgentContextHandle::FetchedUrl(handle) => Some(Self::fetched_url(handle)),
+            AgentContextHandle::Thread(handle) => Some(Self::pending_thread(handle, cx)),
+            AgentContextHandle::Rules(handle) => Self::pending_rules(handle, prompt_store, cx),
+            AgentContextHandle::Image(handle) => Some(Self::image(handle)),
+        }
+    }
+
+    pub fn new_attached(context: &AgentContext, cx: &App) -> AddedContext {
         match context {
-            AssistantContext::File(file_context) => {
-                let full_path = file_context.context_buffer.full_path(cx);
-                let full_path_string: SharedString =
-                    full_path.to_string_lossy().into_owned().into();
-                let name = full_path
-                    .file_name()
-                    .map(|n| n.to_string_lossy().into_owned().into())
-                    .unwrap_or_else(|| full_path_string.clone());
-                let parent = full_path
-                    .parent()
-                    .and_then(|p| p.file_name())
-                    .map(|n| n.to_string_lossy().into_owned().into());
-                AddedContext {
-                    id: file_context.id,
-                    kind: ContextKind::File,
-                    name,
-                    parent,
-                    tooltip: Some(full_path_string),
-                    icon_path: FileIcons::get_icon(&full_path, cx),
-                    status: ContextStatus::Ready,
-                    render_preview: None,
-                }
-            }
+            AgentContext::File(context) => Self::attached_file(context, cx),
+            AgentContext::Directory(context) => Self::attached_directory(context),
+            AgentContext::Symbol(context) => Self::attached_symbol(context, cx),
+            AgentContext::Selection(context) => Self::attached_selection(context, cx),
+            AgentContext::FetchedUrl(context) => Self::fetched_url(context.clone()),
+            AgentContext::Thread(context) => Self::attached_thread(context),
+            AgentContext::Rules(context) => Self::attached_rules(context),
+            AgentContext::Image(context) => Self::image(context.clone()),
+        }
+    }
 
-            AssistantContext::Directory(directory_context) => {
-                let worktree = directory_context.worktree.read(cx);
-                // If the directory no longer exists, use its last known path.
-                let full_path = worktree
-                    .entry_for_id(directory_context.entry_id)
-                    .map_or_else(
-                        || directory_context.last_path.clone(),
-                        |entry| worktree.full_path(&entry.path).into(),
-                    );
-                let full_path_string: SharedString =
-                    full_path.to_string_lossy().into_owned().into();
-                let name = full_path
-                    .file_name()
-                    .map(|n| n.to_string_lossy().into_owned().into())
-                    .unwrap_or_else(|| full_path_string.clone());
-                let parent = full_path
-                    .parent()
-                    .and_then(|p| p.file_name())
-                    .map(|n| n.to_string_lossy().into_owned().into());
-                AddedContext {
-                    id: directory_context.id,
-                    kind: ContextKind::Directory,
-                    name,
-                    parent,
-                    tooltip: Some(full_path_string),
-                    icon_path: None,
-                    status: ContextStatus::Ready,
-                    render_preview: None,
-                }
-            }
+    fn pending_file(handle: FileContextHandle, cx: &App) -> Option<AddedContext> {
+        let full_path = handle.buffer.read(cx).file()?.full_path(cx);
+        Some(Self::file(handle, &full_path, cx))
+    }
 
-            AssistantContext::Symbol(symbol_context) => AddedContext {
-                id: symbol_context.id,
-                kind: ContextKind::Symbol,
-                name: symbol_context.context_symbol.id.name.clone(),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                status: ContextStatus::Ready,
-                render_preview: None,
+    fn attached_file(context: &FileContext, cx: &App) -> AddedContext {
+        Self::file(context.handle.clone(), &context.full_path, cx)
+    }
+
+    fn file(handle: FileContextHandle, full_path: &Path, cx: &App) -> AddedContext {
+        let full_path_string: SharedString = full_path.to_string_lossy().into_owned().into();
+        let name = full_path
+            .file_name()
+            .map(|n| n.to_string_lossy().into_owned().into())
+            .unwrap_or_else(|| full_path_string.clone());
+        let parent = full_path
+            .parent()
+            .and_then(|p| p.file_name())
+            .map(|n| n.to_string_lossy().into_owned().into());
+        AddedContext {
+            kind: ContextKind::File,
+            name,
+            parent,
+            tooltip: Some(full_path_string),
+            icon_path: FileIcons::get_icon(&full_path, cx),
+            status: ContextStatus::Ready,
+            render_hover: None,
+            handle: AgentContextHandle::File(handle),
+        }
+    }
+
+    fn pending_directory(
+        handle: DirectoryContextHandle,
+        project: &Project,
+        cx: &App,
+    ) -> Option<AddedContext> {
+        let worktree = project.worktree_for_entry(handle.entry_id, cx)?.read(cx);
+        let entry = worktree.entry_for_id(handle.entry_id)?;
+        let full_path = worktree.full_path(&entry.path);
+        Some(Self::directory(handle, &full_path))
+    }
+
+    fn attached_directory(context: &DirectoryContext) -> AddedContext {
+        Self::directory(context.handle.clone(), &context.full_path)
+    }
+
+    fn directory(handle: DirectoryContextHandle, full_path: &Path) -> AddedContext {
+        let full_path_string: SharedString = full_path.to_string_lossy().into_owned().into();
+        let name = full_path
+            .file_name()
+            .map(|n| n.to_string_lossy().into_owned().into())
+            .unwrap_or_else(|| full_path_string.clone());
+        let parent = full_path
+            .parent()
+            .and_then(|p| p.file_name())
+            .map(|n| n.to_string_lossy().into_owned().into());
+        AddedContext {
+            kind: ContextKind::Directory,
+            name,
+            parent,
+            tooltip: Some(full_path_string),
+            icon_path: None,
+            status: ContextStatus::Ready,
+            render_hover: None,
+            handle: AgentContextHandle::Directory(handle),
+        }
+    }
+
+    fn pending_symbol(handle: SymbolContextHandle, cx: &App) -> Option<AddedContext> {
+        let excerpt =
+            ContextFileExcerpt::new(&handle.full_path(cx)?, handle.enclosing_line_range(cx), cx);
+        Some(AddedContext {
+            kind: ContextKind::Symbol,
+            name: handle.symbol.clone(),
+            parent: Some(excerpt.file_name_and_range.clone()),
+            tooltip: None,
+            icon_path: None,
+            status: ContextStatus::Ready,
+            render_hover: {
+                let handle = handle.clone();
+                Some(Rc::new(move |_, cx| {
+                    excerpt.hover_view(handle.text(cx), cx).into()
+                }))
             },
+            handle: AgentContextHandle::Symbol(handle),
+        })
+    }
 
-            AssistantContext::Selection(selection_context) => {
-                let full_path = selection_context.context_buffer.full_path(cx);
-                let mut full_path_string = full_path.to_string_lossy().into_owned();
-                let mut name = full_path
-                    .file_name()
-                    .map(|n| n.to_string_lossy().into_owned())
-                    .unwrap_or_else(|| full_path_string.clone());
-
-                let line_range_text = format!(
-                    " ({}-{})",
-                    selection_context.line_range.start.row + 1,
-                    selection_context.line_range.end.row + 1
-                );
-
-                full_path_string.push_str(&line_range_text);
-                name.push_str(&line_range_text);
-
-                let parent = full_path
-                    .parent()
-                    .and_then(|p| p.file_name())
-                    .map(|n| n.to_string_lossy().into_owned().into());
-
-                AddedContext {
-                    id: selection_context.id,
-                    kind: ContextKind::Selection,
-                    name: name.into(),
-                    parent,
-                    tooltip: None,
-                    icon_path: FileIcons::get_icon(&full_path, cx),
-                    status: ContextStatus::Ready,
-                    render_preview: Some(Rc::new({
-                        let content = selection_context.context_buffer.text.clone();
-                        move |_, cx| {
-                            div()
-                                .id("context-pill-selection-preview")
-                                .overflow_scroll()
-                                .max_w_128()
-                                .max_h_96()
-                                .child(Label::new(content.clone()).buffer_font(cx))
-                                .into_any_element()
-                        }
-                    })),
-                }
-            }
-
-            AssistantContext::FetchedUrl(fetched_url_context) => AddedContext {
-                id: fetched_url_context.id,
-                kind: ContextKind::FetchedUrl,
-                name: fetched_url_context.url.clone(),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                status: ContextStatus::Ready,
-                render_preview: None,
+    fn attached_symbol(context: &SymbolContext, cx: &App) -> AddedContext {
+        let excerpt = ContextFileExcerpt::new(&context.full_path, context.line_range.clone(), cx);
+        AddedContext {
+            kind: ContextKind::Symbol,
+            name: context.handle.symbol.clone(),
+            parent: Some(excerpt.file_name_and_range.clone()),
+            tooltip: None,
+            icon_path: None,
+            status: ContextStatus::Ready,
+            render_hover: {
+                let text = context.text.clone();
+                Some(Rc::new(move |_, cx| {
+                    excerpt.hover_view(text.clone(), cx).into()
+                }))
             },
+            handle: AgentContextHandle::Symbol(context.handle.clone()),
+        }
+    }
 
-            AssistantContext::Thread(thread_context) => AddedContext {
-                id: thread_context.id,
-                kind: ContextKind::Thread,
-                name: thread_context.summary(cx),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                status: if thread_context
-                    .thread
-                    .read(cx)
-                    .is_generating_detailed_summary()
-                {
-                    ContextStatus::Loading {
-                        message: "Summarizing…".into(),
-                    }
-                } else {
-                    ContextStatus::Ready
+    fn pending_selection(handle: SelectionContextHandle, cx: &App) -> Option<AddedContext> {
+        let excerpt = ContextFileExcerpt::new(&handle.full_path(cx)?, handle.line_range(cx), cx);
+        Some(AddedContext {
+            kind: ContextKind::Selection,
+            name: excerpt.file_name_and_range.clone(),
+            parent: excerpt.parent_name.clone(),
+            tooltip: None,
+            icon_path: excerpt.icon_path.clone(),
+            status: ContextStatus::Ready,
+            render_hover: {
+                let handle = handle.clone();
+                Some(Rc::new(move |_, cx| {
+                    excerpt.hover_view(handle.text(cx), cx).into()
+                }))
+            },
+            handle: AgentContextHandle::Selection(handle),
+        })
+    }
+
+    fn attached_selection(context: &SelectionContext, cx: &App) -> AddedContext {
+        let excerpt = ContextFileExcerpt::new(&context.full_path, context.line_range.clone(), cx);
+        AddedContext {
+            kind: ContextKind::Selection,
+            name: excerpt.file_name_and_range.clone(),
+            parent: excerpt.parent_name.clone(),
+            tooltip: None,
+            icon_path: excerpt.icon_path.clone(),
+            status: ContextStatus::Ready,
+            render_hover: {
+                let text = context.text.clone();
+                Some(Rc::new(move |_, cx| {
+                    excerpt.hover_view(text.clone(), cx).into()
+                }))
+            },
+            handle: AgentContextHandle::Selection(context.handle.clone()),
+        }
+    }
+
+    fn fetched_url(context: FetchedUrlContext) -> AddedContext {
+        AddedContext {
+            kind: ContextKind::FetchedUrl,
+            name: context.url.clone(),
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            status: ContextStatus::Ready,
+            render_hover: None,
+            handle: AgentContextHandle::FetchedUrl(context),
+        }
+    }
+
+    fn pending_thread(handle: ThreadContextHandle, cx: &App) -> AddedContext {
+        AddedContext {
+            kind: ContextKind::Thread,
+            name: handle.title(cx),
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            status: if handle.thread.read(cx).is_generating_detailed_summary() {
+                ContextStatus::Loading {
+                    message: "Summarizing…".into(),
+                }
+            } else {
+                ContextStatus::Ready
+            },
+            render_hover: {
+                let thread = handle.thread.clone();
+                Some(Rc::new(move |_, cx| {
+                    let text = thread.read(cx).latest_detailed_summary_or_text();
+                    text_hover_view(text.clone(), cx).into()
+                }))
+            },
+            handle: AgentContextHandle::Thread(handle),
+        }
+    }
+
+    fn attached_thread(context: &ThreadContext) -> AddedContext {
+        AddedContext {
+            kind: ContextKind::Thread,
+            name: context.title.clone(),
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            status: ContextStatus::Ready,
+            render_hover: {
+                let text = context.text.clone();
+                Some(Rc::new(move |_, cx| {
+                    text_hover_view(text.clone(), cx).into()
+                }))
+            },
+            handle: AgentContextHandle::Thread(context.handle.clone()),
+        }
+    }
+
+    fn pending_rules(
+        handle: RulesContextHandle,
+        prompt_store: Option<&Entity<PromptStore>>,
+        cx: &App,
+    ) -> Option<AddedContext> {
+        let title = prompt_store
+            .as_ref()?
+            .read(cx)
+            .metadata(handle.prompt_id.into())?
+            .title
+            .unwrap_or_else(|| "Unnamed Rule".into());
+        Some(AddedContext {
+            kind: ContextKind::Rules,
+            name: title.clone(),
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            status: ContextStatus::Ready,
+            render_hover: None,
+            handle: AgentContextHandle::Rules(handle),
+        })
+    }
+
+    fn attached_rules(context: &RulesContext) -> AddedContext {
+        let title = context
+            .title
+            .clone()
+            .unwrap_or_else(|| "Unnamed Rule".into());
+        AddedContext {
+            kind: ContextKind::Rules,
+            name: title,
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            status: ContextStatus::Ready,
+            render_hover: {
+                let text = context.text.clone();
+                Some(Rc::new(move |_, cx| {
+                    text_hover_view(text.clone(), cx).into()
+                }))
+            },
+            handle: AgentContextHandle::Rules(context.handle.clone()),
+        }
+    }
+
+    fn image(context: ImageContext) -> AddedContext {
+        AddedContext {
+            kind: ContextKind::Image,
+            name: "Image".into(),
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            status: match context.status() {
+                ImageStatus::Loading => ContextStatus::Loading {
+                    message: "Loading…".into(),
                 },
-                render_preview: None,
-            },
-
-            AssistantContext::Rules(user_rules_context) => AddedContext {
-                id: user_rules_context.id,
-                kind: ContextKind::Rules,
-                name: user_rules_context.title.clone(),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                status: ContextStatus::Ready,
-                render_preview: None,
-            },
-
-            AssistantContext::Image(image_context) => AddedContext {
-                id: image_context.id,
-                kind: ContextKind::Image,
-                name: "Image".into(),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                status: if image_context.is_loading() {
-                    ContextStatus::Loading {
-                        message: "Loading…".into(),
-                    }
-                } else if image_context.is_error() {
-                    ContextStatus::Error {
-                        message: "Failed to load image".into(),
-                    }
-                } else {
-                    ContextStatus::Ready
+                ImageStatus::Error => ContextStatus::Error {
+                    message: "Failed to load image".into(),
                 },
-                render_preview: Some(Rc::new({
-                    let image = image_context.original_image.clone();
-                    move |_, _| {
+                ImageStatus::Ready => ContextStatus::Ready,
+            },
+            render_hover: Some(Rc::new({
+                let image = context.original_image.clone();
+                move |_, cx| {
+                    let image = image.clone();
+                    ContextPillHover::new(cx, move |_, _| {
                         gpui::img(image.clone())
                             .max_w_96()
                             .max_h_96()
                             .into_any_element()
-                    }
-                })),
-            },
+                    })
+                    .into()
+                }
+            })),
+            handle: AgentContextHandle::Image(context),
         }
     }
 }
 
-struct ContextPillPreview {
-    render_preview: Rc<dyn Fn(&mut Window, &mut App) -> AnyElement>,
+#[derive(Debug, Clone)]
+struct ContextFileExcerpt {
+    pub file_name_and_range: SharedString,
+    pub full_path_and_range: SharedString,
+    pub parent_name: Option<SharedString>,
+    pub icon_path: Option<SharedString>,
 }
 
-impl Render for ContextPillPreview {
+impl ContextFileExcerpt {
+    pub fn new(full_path: &Path, line_range: Range<Point>, cx: &App) -> Self {
+        let full_path_string = full_path.to_string_lossy().into_owned();
+        let file_name = full_path
+            .file_name()
+            .map(|n| n.to_string_lossy().into_owned())
+            .unwrap_or_else(|| full_path_string.clone());
+
+        let line_range_text = format!(" ({}-{})", line_range.start.row + 1, line_range.end.row + 1);
+        let mut full_path_and_range = full_path_string;
+        full_path_and_range.push_str(&line_range_text);
+        let mut file_name_and_range = file_name;
+        file_name_and_range.push_str(&line_range_text);
+
+        let parent_name = full_path
+            .parent()
+            .and_then(|p| p.file_name())
+            .map(|n| n.to_string_lossy().into_owned().into());
+
+        let icon_path = FileIcons::get_icon(&full_path, cx);
+
+        ContextFileExcerpt {
+            file_name_and_range: file_name_and_range.into(),
+            full_path_and_range: full_path_and_range.into(),
+            parent_name,
+            icon_path,
+        }
+    }
+
+    fn hover_view(&self, text: SharedString, cx: &mut App) -> Entity<ContextPillHover> {
+        let icon_path = self.icon_path.clone();
+        let full_path_and_range = self.full_path_and_range.clone();
+        ContextPillHover::new(cx, move |_, cx| {
+            v_flex()
+                .child(
+                    h_flex()
+                        .gap_0p5()
+                        .w_full()
+                        .max_w_full()
+                        .border_b_1()
+                        .border_color(cx.theme().colors().border.opacity(0.6))
+                        .children(
+                            icon_path
+                                .clone()
+                                .map(Icon::from_path)
+                                .map(|icon| icon.color(Color::Muted).size(IconSize::XSmall)),
+                        )
+                        .child(
+                            // TODO: make this truncate on the left.
+                            Label::new(full_path_and_range.clone())
+                                .size(LabelSize::Small)
+                                .ml_1(),
+                        ),
+                )
+                .child(
+                    div()
+                        .id("context-pill-hover-contents")
+                        .overflow_scroll()
+                        .max_w_128()
+                        .max_h_96()
+                        .child(Label::new(text.clone()).buffer_font(cx)),
+                )
+                .into_any_element()
+        })
+    }
+}
+
+fn text_hover_view(content: SharedString, cx: &mut App) -> Entity<ContextPillHover> {
+    ContextPillHover::new(cx, move |_, _| {
+        div()
+            .id("context-pill-hover-contents")
+            .overflow_scroll()
+            .max_w_128()
+            .max_h_96()
+            .child(content.clone())
+            .into_any_element()
+    })
+}
+
+struct ContextPillHover {
+    render_hover: Box<dyn Fn(&mut Window, &mut App) -> AnyElement>,
+}
+
+impl ContextPillHover {
+    fn new(
+        cx: &mut App,
+        render_hover: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
+    ) -> Entity<Self> {
+        cx.new(|_| Self {
+            render_hover: Box::new(render_hover),
+        })
+    }
+}
+
+impl Render for ContextPillHover {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         tooltip_container(window, cx, move |this, window, cx| {
             this.occlude()
                 .on_mouse_move(|_, _, cx| cx.stop_propagation())
                 .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
-                .child((self.render_preview)(window, cx))
+                .child((self.render_hover)(window, cx))
         })
     }
 }
@@ -488,45 +718,40 @@ impl Component for AddedContext {
     }
 
     fn preview(_window: &mut Window, cx: &mut App) -> Option<AnyElement> {
+        let mut next_context_id = ContextId::zero();
         let image_ready = (
             "Ready",
-            AddedContext::new(
-                &AssistantContext::Image(ImageContext {
-                    id: ContextId(0),
-                    original_image: Arc::new(Image::empty()),
-                    image_task: Task::ready(Some(LanguageModelImage::empty())).shared(),
-                }),
-                cx,
-            ),
+            AddedContext::image(ImageContext {
+                context_id: next_context_id.post_inc(),
+                project_path: None,
+                original_image: Arc::new(Image::empty()),
+                image_task: Task::ready(Some(LanguageModelImage::empty())).shared(),
+            }),
         );
 
         let image_loading = (
             "Loading",
-            AddedContext::new(
-                &AssistantContext::Image(ImageContext {
-                    id: ContextId(1),
-                    original_image: Arc::new(Image::empty()),
-                    image_task: cx
-                        .background_spawn(async move {
-                            smol::Timer::after(Duration::from_secs(60 * 5)).await;
-                            Some(LanguageModelImage::empty())
-                        })
-                        .shared(),
-                }),
-                cx,
-            ),
+            AddedContext::image(ImageContext {
+                context_id: next_context_id.post_inc(),
+                project_path: None,
+                original_image: Arc::new(Image::empty()),
+                image_task: cx
+                    .background_spawn(async move {
+                        smol::Timer::after(Duration::from_secs(60 * 5)).await;
+                        Some(LanguageModelImage::empty())
+                    })
+                    .shared(),
+            }),
         );
 
         let image_error = (
             "Error",
-            AddedContext::new(
-                &AssistantContext::Image(ImageContext {
-                    id: ContextId(2),
-                    original_image: Arc::new(Image::empty()),
-                    image_task: Task::ready(None).shared(),
-                }),
-                cx,
-            ),
+            AddedContext::image(ImageContext {
+                context_id: next_context_id.post_inc(),
+                project_path: None,
+                original_image: Arc::new(Image::empty()),
+                image_task: Task::ready(None).shared(),
+            }),
         );
 
         Some(

crates/askpass/Cargo.toml

@@ -15,6 +15,7 @@ path = "src/askpass.rs"
 anyhow.workspace = true
 futures.workspace = true
 gpui.workspace = true
+shlex.workspace = true
 smol.workspace = true
 tempfile.workspace = true
 util.workspace = true

crates/askpass/src/askpass.rs

@@ -72,8 +72,7 @@ impl AskPassSession {
         let (askpass_opened_tx, askpass_opened_rx) = oneshot::channel::<()>();
         let listener =
             UnixListener::bind(&askpass_socket).context("failed to create askpass socket")?;
-        let zed_path = std::env::current_exe()
-            .context("Failed to figure out current executable path for use in askpass")?;
+        let zed_path = get_shell_safe_zed_path()?;
 
         let (askpass_kill_master_tx, askpass_kill_master_rx) = oneshot::channel::<()>();
         let mut kill_tx = Some(askpass_kill_master_tx);
@@ -115,7 +114,7 @@ impl AskPassSession {
         // Create an askpass script that communicates back to this process.
         let askpass_script = format!(
             "{shebang}\n{print_args} | {zed_exe} --askpass={askpass_socket} 2> /dev/null \n",
-            zed_exe = zed_path.display(),
+            zed_exe = zed_path,
             askpass_socket = askpass_socket.display(),
             print_args = "printf '%s\\0' \"$@\"",
             shebang = "#!/bin/sh",
@@ -161,6 +160,32 @@ impl AskPassSession {
     }
 }
 
+#[cfg(unix)]
+fn get_shell_safe_zed_path() -> anyhow::Result<String> {
+    let zed_path = std::env::current_exe()
+        .context("Failed to figure out current executable path for use in askpass")?
+        .to_string_lossy()
+        .to_string();
+
+    // sanity check on unix systems that the path exists and is executable
+    // todo(windows): implement this check for windows (or just use `is-executable` crate)
+    use std::os::unix::fs::MetadataExt;
+    let metadata = std::fs::metadata(&zed_path)
+        .context("Failed to check metadata of Zed executable path for use in askpass")?;
+    let is_executable = metadata.is_file() && metadata.mode() & 0o111 != 0;
+    anyhow::ensure!(
+        is_executable,
+        "Failed to verify Zed executable path for use in askpass"
+    );
+    // As of writing, this can only be fail if the path contains a null byte, which shouldn't be possible
+    // but shlex has annotated the error as #[non_exhaustive] so we can't make it a compile error if other
+    // errors are introduced in the future :(
+    let zed_path_escaped = shlex::try_quote(&zed_path)
+        .context("Failed to shell-escape Zed executable path for use in askpass")?;
+
+    return Ok(zed_path_escaped.to_string());
+}
+
 /// The main function for when Zed is running in netcat mode for use in askpass.
 /// Called from both the remote server binary and the zed binary in their respective main functions.
 #[cfg(unix)]

crates/assistant/Cargo.toml

@@ -49,7 +49,7 @@ menu.workspace = true
 multi_buffer.workspace = true
 parking_lot.workspace = true
 project.workspace = true
-prompt_library.workspace = true
+rules_library.workspace = true
 prompt_store.workspace = true
 proto.workspace = true
 rope.workspace = true

crates/assistant/src/assistant.rs

@@ -101,7 +101,7 @@ pub fn init(
     SlashCommandSettings::register(cx);
 
     assistant_context_editor::init(client.clone(), cx);
-    prompt_library::init(cx);
+    rules_library::init(cx);
     init_language_model_settings(cx);
     assistant_slash_command::init(cx);
     assistant_tool::init(cx);

crates/assistant/src/assistant_panel.rs

@@ -25,8 +25,8 @@ use language_model::{
     AuthenticateError, ConfiguredModel, LanguageModelProviderId, LanguageModelRegistry,
 };
 use project::Project;
-use prompt_library::{PromptLibrary, open_prompt_library};
-use prompt_store::{PromptBuilder, PromptId, UserPromptId};
+use prompt_store::{PromptBuilder, UserPromptId};
+use rules_library::{RulesLibrary, open_rules_library};
 
 use search::{BufferSearchBar, buffer_search::DivRegistrar};
 use settings::{Settings, update_settings_file};
@@ -43,7 +43,7 @@ use workspace::{
     dock::{DockPosition, Panel, PanelEvent},
     pane,
 };
-use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ShowConfiguration, ToggleFocus};
+use zed_actions::assistant::{InlineAssist, OpenRulesLibrary, ShowConfiguration, ToggleFocus};
 
 pub fn init(cx: &mut App) {
     workspace::FollowableViewRegistry::register::<ContextEditor>(cx);
@@ -57,11 +57,11 @@ pub fn init(cx: &mut App) {
                 .register_action(AssistantPanel::show_configuration)
                 .register_action(AssistantPanel::create_new_context)
                 .register_action(AssistantPanel::restart_context_servers)
-                .register_action(|workspace, action: &OpenPromptLibrary, window, cx| {
+                .register_action(|workspace, action: &OpenRulesLibrary, window, cx| {
                     if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
                         workspace.focus_panel::<AssistantPanel>(window, cx);
                         panel.update(cx, |panel, cx| {
-                            panel.deploy_prompt_library(action, window, cx)
+                            panel.deploy_rules_library(action, window, cx)
                         });
                     }
                 });
@@ -272,8 +272,8 @@ impl AssistantPanel {
                                         .action("New Chat", Box::new(NewChat))
                                         .action("History", Box::new(DeployHistory))
                                         .action(
-                                            "Prompt Library",
-                                            Box::new(OpenPromptLibrary::default()),
+                                            "Rules Library",
+                                            Box::new(OpenRulesLibrary::default()),
                                         )
                                         .action("Configure", Box::new(ShowConfiguration))
                                         .action(zoom_label, Box::new(ToggleZoom))
@@ -476,7 +476,7 @@ impl AssistantPanel {
                         {
                             return;
                         }
-                        context.custom_summary(new_summary, cx)
+                        context.set_custom_summary(new_summary, cx)
                     });
                 });
             }
@@ -1043,13 +1043,13 @@ impl AssistantPanel {
         }
     }
 
-    fn deploy_prompt_library(
+    fn deploy_rules_library(
         &mut self,
-        action: &OpenPromptLibrary,
+        action: &OpenRulesLibrary,
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        open_prompt_library(
+        open_rules_library(
             self.languages.clone(),
             Box::new(PromptLibraryInlineAssist),
             Arc::new(|| {
@@ -1059,9 +1059,9 @@ impl AssistantPanel {
                     None,
                 ))
             }),
-            action.prompt_to_select.map(|uuid| PromptId::User {
-                uuid: UserPromptId(uuid),
-            }),
+            action
+                .prompt_to_select
+                .map(|uuid| UserPromptId(uuid).into()),
             cx,
         )
         .detach_and_log_err(cx);
@@ -1235,7 +1235,7 @@ impl Render for AssistantPanel {
                 this.show_configuration_tab(window, cx)
             }))
             .on_action(cx.listener(AssistantPanel::deploy_history))
-            .on_action(cx.listener(AssistantPanel::deploy_prompt_library))
+            .on_action(cx.listener(AssistantPanel::deploy_rules_library))
             .child(registrar.size_full().child(self.pane.clone()))
             .into_any_element()
     }
@@ -1350,13 +1350,13 @@ impl Focusable for AssistantPanel {
 
 struct PromptLibraryInlineAssist;
 
-impl prompt_library::InlineAssistDelegate for PromptLibraryInlineAssist {
+impl rules_library::InlineAssistDelegate for PromptLibraryInlineAssist {
     fn assist(
         &self,
         prompt_editor: &Entity<Editor>,
         initial_prompt: Option<String>,
         window: &mut Window,
-        cx: &mut Context<PromptLibrary>,
+        cx: &mut Context<RulesLibrary>,
     ) {
         InlineAssistant::update_global(cx, |assistant, cx| {
             assistant.assist(&prompt_editor, None, None, initial_prompt, window, cx)

crates/assistant/src/inline_assistant.rs

@@ -18,11 +18,11 @@ use editor::{
     },
 };
 use feature_flags::{
-    Assistant2FeatureFlag, FeatureFlagAppExt as _, FeatureFlagViewExt as _, ZedPro,
+    Assistant2FeatureFlag, FeatureFlagAppExt as _, FeatureFlagViewExt as _, ZedProFeatureFlag,
 };
 use fs::Fs;
 use futures::{
-    SinkExt, Stream, StreamExt,
+    SinkExt, Stream, StreamExt, TryStreamExt as _,
     channel::mpsc,
     future::{BoxFuture, LocalBoxFuture},
     join,
@@ -1652,7 +1652,7 @@ impl Render for PromptEditor {
 
                         let error_message = SharedString::from(error.to_string());
                         if error.error_code() == proto::ErrorCode::RateLimitExceeded
-                            && cx.has_flag::<ZedPro>()
+                            && cx.has_flag::<ZedProFeatureFlag>()
                         {
                             el.child(
                                 v_flex()
@@ -1966,7 +1966,7 @@ impl PromptEditor {
                     .update(cx, |editor, _| editor.set_read_only(false));
             }
             CodegenStatus::Error(error) => {
-                if cx.has_flag::<ZedPro>()
+                if cx.has_flag::<ZedProFeatureFlag>()
                     && error.error_code() == proto::ErrorCode::RateLimitExceeded
                     && !dismissed_rate_limit_notice()
                 {
@@ -2981,6 +2981,7 @@ impl CodegenAlternative {
         Ok(LanguageModelRequest {
             thread_id: None,
             prompt_id: None,
+            mode: None,
             messages,
             tools: Vec::new(),
             stop: Vec::new(),
@@ -3056,7 +3057,8 @@ impl CodegenAlternative {
                         let mut response_latency = None;
                         let request_start = Instant::now();
                         let diff = async {
-                            let chunks = StripInvalidSpans::new(stream?.stream);
+                            let chunks =
+                                StripInvalidSpans::new(stream?.stream.map_err(|e| e.into()));
                             futures::pin_mut!(chunks);
                             let mut diff = StreamingDiff::new(selected_text.to_string());
                             let mut line_diff = LineDiff::default();

crates/assistant/src/terminal_inline_assistant.rs

@@ -294,6 +294,7 @@ impl TerminalInlineAssistant {
         Ok(LanguageModelRequest {
             thread_id: None,
             prompt_id: None,
+            mode: None,
             messages,
             tools: Vec::new(),
             stop: Vec::new(),

crates/assistant_context_editor/src/context.rs

@@ -459,6 +459,7 @@ pub enum ContextEvent {
     ShowMaxMonthlySpendReachedError,
     MessagesEdited,
     SummaryChanged,
+    SummaryGenerated,
     StreamedCompletion,
     StartedThoughtProcess(Range<language::Anchor>),
     EndedThoughtProcess(language::Anchor),
@@ -482,7 +483,7 @@ pub enum ContextEvent {
 #[derive(Clone, Default, Debug)]
 pub struct ContextSummary {
     pub text: String,
-    done: bool,
+    pub done: bool,
     timestamp: clock::Lamport,
 }
 
@@ -640,7 +641,7 @@ pub struct AssistantContext {
     contents: Vec<Content>,
     messages_metadata: HashMap<MessageId, MessageMetadata>,
     summary: Option<ContextSummary>,
-    pending_summary: Task<Option<()>>,
+    summary_task: Task<Option<()>>,
     completion_count: usize,
     pending_completions: Vec<PendingCompletion>,
     token_count: Option<usize>,
@@ -741,7 +742,7 @@ impl AssistantContext {
             thought_process_output_sections: Vec::new(),
             edits_since_last_parse: edits_since_last_slash_command_parse,
             summary: None,
-            pending_summary: Task::ready(None),
+            summary_task: Task::ready(None),
             completion_count: Default::default(),
             pending_completions: Default::default(),
             token_count: None,
@@ -951,7 +952,7 @@ impl AssistantContext {
 
     fn flush_ops(&mut self, cx: &mut Context<AssistantContext>) {
         let mut changed_messages = HashSet::default();
-        let mut summary_changed = false;
+        let mut summary_generated = false;
 
         self.pending_ops.sort_unstable_by_key(|op| op.timestamp());
         for op in mem::take(&mut self.pending_ops) {
@@ -993,7 +994,7 @@ impl AssistantContext {
                         .map_or(true, |summary| new_summary.timestamp > summary.timestamp)
                     {
                         self.summary = Some(new_summary);
-                        summary_changed = true;
+                        summary_generated = true;
                     }
                 }
                 ContextOperation::SlashCommandStarted {
@@ -1072,8 +1073,9 @@ impl AssistantContext {
             cx.notify();
         }
 
-        if summary_changed {
+        if summary_generated {
             cx.emit(ContextEvent::SummaryChanged);
+            cx.emit(ContextEvent::SummaryGenerated);
             cx.notify();
         }
     }
@@ -2557,6 +2559,7 @@ impl AssistantContext {
         let mut completion_request = LanguageModelRequest {
             thread_id: None,
             prompt_id: None,
+            mode: None,
             messages: Vec::new(),
             tools: Vec::new(),
             stop: Vec::new(),
@@ -2611,7 +2614,9 @@ impl AssistantContext {
                     .map(MessageContent::Text),
             );
 
-            completion_request.messages.push(request_message);
+            if !request_message.contents_empty() {
+                completion_request.messages.push(request_message);
+            }
         }
 
         if let RequestType::SuggestEdits = request_type {
@@ -2945,7 +2950,7 @@ impl AssistantContext {
         self.message_anchors.insert(insertion_ix, new_anchor);
     }
 
-    pub fn summarize(&mut self, replace_old: bool, cx: &mut Context<Self>) {
+    pub fn summarize(&mut self, mut replace_old: bool, cx: &mut Context<Self>) {
         let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
             return;
         };
@@ -2965,7 +2970,18 @@ impl AssistantContext {
                 cache: false,
             });
 
-            self.pending_summary = cx.spawn(async move |this, cx| {
+            // If there is no summary, it is set with `done: false` so that "Loading Summary…" can
+            // be displayed.
+            if self.summary.is_none() {
+                self.summary = Some(ContextSummary {
+                    text: "".to_string(),
+                    done: false,
+                    timestamp: clock::Lamport::default(),
+                });
+                replace_old = true;
+            }
+
+            self.summary_task = cx.spawn(async move |this, cx| {
                 async move {
                     let stream = model.model.stream_completion_text(request, &cx);
                     let mut messages = stream.await?;
@@ -2990,6 +3006,7 @@ impl AssistantContext {
                             };
                             this.push_op(operation, cx);
                             cx.emit(ContextEvent::SummaryChanged);
+                            cx.emit(ContextEvent::SummaryGenerated);
                         })?;
 
                         // Stop if the LLM generated multiple lines.
@@ -3010,6 +3027,7 @@ impl AssistantContext {
                             };
                             this.push_op(operation, cx);
                             cx.emit(ContextEvent::SummaryChanged);
+                            cx.emit(ContextEvent::SummaryGenerated);
                         }
                     })?;
 
@@ -3182,7 +3200,7 @@ impl AssistantContext {
         });
     }
 
-    pub fn custom_summary(&mut self, custom_summary: String, cx: &mut Context<Self>) {
+    pub fn set_custom_summary(&mut self, custom_summary: String, cx: &mut Context<Self>) {
         let timestamp = self.next_timestamp();
         let summary = self.summary.get_or_insert(ContextSummary::default());
         summary.timestamp = timestamp;
@@ -3190,6 +3208,15 @@ impl AssistantContext {
         summary.text = custom_summary;
         cx.emit(ContextEvent::SummaryChanged);
     }
+
+    pub const DEFAULT_SUMMARY: SharedString = SharedString::new_static("New Text Thread");
+
+    pub fn summary_or_default(&self) -> SharedString {
+        self.summary
+            .as_ref()
+            .map(|summary| summary.text.clone().into())
+            .unwrap_or(Self::DEFAULT_SUMMARY)
+    }
 }
 
 fn trimmed_text_in_range(buffer: &BufferSnapshot, range: Range<text::Anchor>) -> String {

crates/assistant_context_editor/src/context_editor.rs

@@ -48,7 +48,7 @@ use project::{Project, Worktree};
 use rope::Point;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsStore, update_settings_file};
-use std::{any::TypeId, borrow::Cow, cmp, ops::Range, path::PathBuf, sync::Arc, time::Duration};
+use std::{any::TypeId, cmp, ops::Range, path::PathBuf, sync::Arc, time::Duration};
 use text::SelectionGoal;
 use ui::{
     ButtonLike, Disclosure, ElevationIndex, KeyBinding, PopoverMenuHandle, TintColor, Tooltip,
@@ -618,6 +618,7 @@ impl ContextEditor {
                     context.save(Some(Duration::from_millis(500)), self.fs.clone(), cx);
                 });
             }
+            ContextEvent::SummaryGenerated => {}
             ContextEvent::StartedThoughtProcess(range) => {
                 let creases = self.insert_thought_process_output_sections(
                     [(
@@ -2179,13 +2180,8 @@ impl ContextEditor {
         });
     }
 
-    pub fn title(&self, cx: &App) -> Cow<str> {
-        self.context
-            .read(cx)
-            .summary()
-            .map(|summary| summary.text.clone())
-            .map(Cow::Owned)
-            .unwrap_or_else(|| Cow::Borrowed(DEFAULT_TAB_TITLE))
+    pub fn title(&self, cx: &App) -> SharedString {
+        self.context.read(cx).summary_or_default()
     }
 
     fn render_patch_block(

crates/assistant_tool/Cargo.toml

@@ -28,6 +28,7 @@ serde.workspace = true
 serde_json.workspace = true
 text.workspace = true
 util.workspace = true
+workspace.workspace = true
 workspace-hack.workspace = true
 
 [dev-dependencies]

crates/assistant_tool/src/assistant_tool.rs

@@ -10,14 +10,16 @@ use std::sync::Arc;
 
 use anyhow::Result;
 use gpui::AnyElement;
+use gpui::AnyWindowHandle;
 use gpui::Context;
 use gpui::IntoElement;
 use gpui::Window;
-use gpui::{App, Entity, SharedString, Task};
+use gpui::{App, Entity, SharedString, Task, WeakEntity};
 use icons::IconName;
 use language_model::LanguageModelRequestMessage;
 use language_model::LanguageModelToolSchemaFormat;
 use project::Project;
+use workspace::Workspace;
 
 pub use crate::action_log::*;
 pub use crate::tool_registry::*;
@@ -49,6 +51,13 @@ impl ToolUseStatus {
             ToolUseStatus::Error(out) => out.clone(),
         }
     }
+
+    pub fn error(&self) -> Option<SharedString> {
+        match self {
+            ToolUseStatus::Error(out) => Some(out.clone()),
+            _ => None,
+        }
+    }
 }
 
 /// The result of running a tool, containing both the asynchronous output
@@ -65,6 +74,7 @@ pub trait ToolCard: 'static + Sized {
         &mut self,
         status: &ToolUseStatus,
         window: &mut Window,
+        workspace: WeakEntity<Workspace>,
         cx: &mut Context<Self>,
     ) -> impl IntoElement;
 }
@@ -76,6 +86,7 @@ pub struct AnyToolCard {
         entity: gpui::AnyEntity,
         status: &ToolUseStatus,
         window: &mut Window,
+        workspace: WeakEntity<Workspace>,
         cx: &mut App,
     ) -> AnyElement,
 }
@@ -86,11 +97,14 @@ impl<T: ToolCard> From<Entity<T>> for AnyToolCard {
             entity: gpui::AnyEntity,
             status: &ToolUseStatus,
             window: &mut Window,
+            workspace: WeakEntity<Workspace>,
             cx: &mut App,
         ) -> AnyElement {
             let entity = entity.downcast::<T>().unwrap();
             entity.update(cx, |entity, cx| {
-                entity.render(status, window, cx).into_any_element()
+                entity
+                    .render(status, window, workspace, cx)
+                    .into_any_element()
             })
         }
 
@@ -102,8 +116,14 @@ impl<T: ToolCard> From<Entity<T>> for AnyToolCard {
 }
 
 impl AnyToolCard {
-    pub fn render(&self, status: &ToolUseStatus, window: &mut Window, cx: &mut App) -> AnyElement {
-        (self.render)(self.entity.clone(), status, window, cx)
+    pub fn render(
+        &self,
+        status: &ToolUseStatus,
+        window: &mut Window,
+        workspace: WeakEntity<Workspace>,
+        cx: &mut App,
+    ) -> AnyElement {
+        (self.render)(self.entity.clone(), status, window, workspace, cx)
     }
 }
 
@@ -163,6 +183,7 @@ pub trait Tool: 'static + Send + Sync {
         messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult;
 }

crates/assistant_tool/src/tool_schema.rs

@@ -10,6 +10,11 @@ pub fn adapt_schema_to_format(
     json: &mut Value,
     format: LanguageModelToolSchemaFormat,
 ) -> Result<()> {
+    if let Value::Object(obj) = json {
+        obj.remove("$schema");
+        obj.remove("title");
+    }
+
     match format {
         LanguageModelToolSchemaFormat::JsonSchema => Ok(()),
         LanguageModelToolSchemaFormat::JsonSchemaSubset => adapt_to_json_schema_subset(json),
@@ -30,7 +35,12 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
             }
         }
 
-        const KEYS_TO_REMOVE: [&str; 2] = ["format", "$schema"];
+        const KEYS_TO_REMOVE: [&str; 4] = [
+            "format",
+            "additionalProperties",
+            "exclusiveMinimum",
+            "exclusiveMaximum",
+        ];
         for key in KEYS_TO_REMOVE {
             obj.remove(key);
         }
@@ -45,7 +55,7 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
         }
 
         // If a type is not specified for an input parameter, add a default type
-        if obj.contains_key("description")
+        if matches!(obj.get("description"), Some(Value::String(_)))
             && !obj.contains_key("type")
             && !(obj.contains_key("anyOf")
                 || obj.contains_key("oneOf")
@@ -117,14 +127,37 @@ mod tests {
                 "type": "string"
             })
         );
+
+        // Ensure that we do not add a type if it is an object
+        let mut json = json!({
+            "description": {
+                "value": "abc",
+                "type": "string"
+            }
+        });
+
+        adapt_to_json_schema_subset(&mut json).unwrap();
+
+        assert_eq!(
+            json,
+            json!({
+                "description": {
+                    "value": "abc",
+                    "type": "string"
+                }
+            })
+        );
     }
 
     #[test]
-    fn test_transform_removes_format() {
+    fn test_transform_removes_unsupported_keys() {
         let mut json = json!({
             "description": "A test field",
             "type": "integer",
-            "format": "uint32"
+            "format": "uint32",
+            "exclusiveMinimum": 0,
+            "exclusiveMaximum": 100,
+            "additionalProperties": false
         });
 
         adapt_to_json_schema_subset(&mut json).unwrap();

crates/assistant_tools/Cargo.toml

@@ -14,9 +14,11 @@ path = "src/assistant_tools.rs"
 [dependencies]
 anyhow.workspace = true
 assistant_tool.workspace = true
+buffer_diff.workspace = true
 chrono.workspace = true
 collections.workspace = true
 component.workspace = true
+editor.workspace = true
 futures.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
@@ -32,11 +34,14 @@ regex.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+task.workspace = true
+terminal.workspace = true
+terminal_view.workspace = true
 ui.workspace = true
 util.workspace = true
 web_search.workspace = true
 workspace-hack.workspace = true
-worktree.workspace = true
+workspace.workspace = true
 zed_llm_client.workspace = true
 
 [dev-dependencies]
@@ -49,6 +54,7 @@ project = { workspace = true, features = ["test-support"] }
 rand.workspace = true
 pretty_assertions.workspace = true
 settings = { workspace = true, features = ["test-support"] }
+task = { workspace = true, features = ["test-support"]}
 tree-sitter-rust.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
 unindent.workspace = true

crates/assistant_tools/src/assistant_tools.rs

@@ -9,12 +9,12 @@ mod delete_path_tool;
 mod diagnostics_tool;
 mod edit_file_tool;
 mod fetch_tool;
+mod find_path_tool;
 mod grep_tool;
 mod list_directory_tool;
 mod move_path_tool;
 mod now_tool;
 mod open_tool;
-mod path_search_tool;
 mod read_file_tool;
 mod rename_tool;
 mod replace;
@@ -45,18 +45,21 @@ use crate::delete_path_tool::DeletePathTool;
 use crate::diagnostics_tool::DiagnosticsTool;
 use crate::edit_file_tool::EditFileTool;
 use crate::fetch_tool::FetchTool;
+use crate::find_path_tool::FindPathTool;
 use crate::grep_tool::GrepTool;
 use crate::list_directory_tool::ListDirectoryTool;
 use crate::now_tool::NowTool;
 use crate::open_tool::OpenTool;
-use crate::path_search_tool::PathSearchTool;
 use crate::read_file_tool::ReadFileTool;
 use crate::rename_tool::RenameTool;
 use crate::symbol_info_tool::SymbolInfoTool;
 use crate::terminal_tool::TerminalTool;
 use crate::thinking_tool::ThinkingTool;
 
-pub use path_search_tool::PathSearchToolInput;
+pub use create_file_tool::CreateFileToolInput;
+pub use edit_file_tool::EditFileToolInput;
+pub use find_path_tool::FindPathToolInput;
+pub use read_file_tool::ReadFileToolInput;
 
 pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     assistant_tool::init(cx);
@@ -78,7 +81,7 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     registry.register_tool(OpenTool);
     registry.register_tool(CodeSymbolsTool);
     registry.register_tool(ContentsTool);
-    registry.register_tool(PathSearchTool);
+    registry.register_tool(FindPathTool);
     registry.register_tool(ReadFileTool);
     registry.register_tool(GrepTool);
     registry.register_tool(RenameTool);
@@ -107,11 +110,38 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use client::Client;
     use clock::FakeSystemClock;
     use http_client::FakeHttpClient;
+    use schemars::JsonSchema;
+    use serde::Serialize;
 
-    use super::*;
+    #[test]
+    fn test_json_schema() {
+        #[derive(Serialize, JsonSchema)]
+        struct GetWeatherTool {
+            location: String,
+        }
+
+        let schema = schema::json_schema_for::<GetWeatherTool>(
+            language_model::LanguageModelToolSchemaFormat::JsonSchema,
+        )
+        .unwrap();
+
+        assert_eq!(
+            schema,
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string"
+                    }
+                },
+                "required": ["location"],
+            })
+        );
+    }
 
     #[gpui::test]
     fn test_builtin_tool_schema_compatibility(cx: &mut App) {

crates/assistant_tools/src/batch_tool.rs

@@ -2,7 +2,7 @@ use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult, ToolWorkingSet};
 use futures::future::join_all;
-use gpui::{App, AppContext, Entity, Task};
+use gpui::{AnyWindowHandle, App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
@@ -97,7 +97,7 @@ pub struct BatchToolInput {
     ///       }
     ///     },
     ///     {
-    ///       "name": "path_search",
+    ///       "name": "find_path",
     ///       "input": {
     ///         "glob": "**/*test*.rs"
     ///       }
@@ -218,6 +218,7 @@ impl Tool for BatchTool {
         messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<BatchToolInput>(input) {
@@ -258,7 +259,9 @@ impl Tool for BatchTool {
                     let action_log = action_log.clone();
                     let messages = messages.clone();
                     let tool_result = cx
-                        .update(|cx| tool.run(invocation.input, &messages, project, action_log, cx))
+                        .update(|cx| {
+                            tool.run(invocation.input, &messages, project, action_log, window, cx)
+                        })
                         .map_err(|err| anyhow!("Failed to start tool '{}': {}", tool_name, err))?;
 
                     tasks.push(tool_result.output);

crates/assistant_tools/src/code_action_tool.rs

@@ -1,6 +1,6 @@
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use language::{self, Anchor, Buffer, ToPointUtf16};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::{self, LspAction, Project};
@@ -140,6 +140,7 @@ impl Tool for CodeActionTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<CodeActionToolInput>(input) {

crates/assistant_tools/src/code_symbols_tool.rs

@@ -6,7 +6,7 @@ use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
 use collections::IndexMap;
-use gpui::{App, AsyncApp, Entity, Task};
+use gpui::{AnyWindowHandle, App, AsyncApp, Entity, Task};
 use language::{OutlineItem, ParseStatus, Point};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::{Project, Symbol};
@@ -14,7 +14,7 @@ use regex::{Regex, RegexBuilder};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CodeSymbolsInput {
@@ -102,7 +102,7 @@ impl Tool for CodeSymbolsTool {
 
                 match &input.path {
                     Some(path) => {
-                        let path = MarkdownString::inline_code(path);
+                        let path = MarkdownInlineCode(path);
                         if page > 1 {
                             format!("List page {page} of code symbols for {path}")
                         } else {
@@ -128,6 +128,7 @@ impl Tool for CodeSymbolsTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<CodeSymbolsInput>(input) {

crates/assistant_tools/src/contents_tool.rs

@@ -3,7 +3,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, ToolResult};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use itertools::Itertools;
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -11,7 +11,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Write, path::Path};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 /// If the model requests to read a file whose size exceeds this, then
 /// the tool will return the file's symbol outline instead of its contents,
@@ -82,7 +82,7 @@ impl Tool for ContentsTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<ContentsToolInput>(input.clone()) {
             Ok(input) => {
-                let path = MarkdownString::inline_code(&input.path);
+                let path = MarkdownInlineCode(&input.path);
 
                 match (input.start, input.end) {
                     (Some(start), None) => format!("Read {path} (from line {start})"),
@@ -102,6 +102,7 @@ impl Tool for ContentsTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<ContentsToolInput>(input) {

crates/assistant_tools/src/copy_path_tool.rs

@@ -1,6 +1,7 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
+use gpui::AnyWindowHandle;
 use gpui::{App, AppContext, Entity, Task};
 use language_model::LanguageModelRequestMessage;
 use language_model::LanguageModelToolSchemaFormat;
@@ -9,7 +10,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CopyPathToolInput {
@@ -62,8 +63,8 @@ impl Tool for CopyPathTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<CopyPathToolInput>(input.clone()) {
             Ok(input) => {
-                let src = MarkdownString::inline_code(&input.source_path);
-                let dest = MarkdownString::inline_code(&input.destination_path);
+                let src = MarkdownInlineCode(&input.source_path);
+                let dest = MarkdownInlineCode(&input.destination_path);
                 format!("Copy {src} to {dest}")
             }
             Err(_) => "Copy path".to_string(),
@@ -76,6 +77,7 @@ impl Tool for CopyPathTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<CopyPathToolInput>(input) {

crates/assistant_tools/src/create_directory_tool.rs

@@ -1,6 +1,7 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
+use gpui::AnyWindowHandle;
 use gpui::{App, Entity, Task};
 use language_model::LanguageModelRequestMessage;
 use language_model::LanguageModelToolSchemaFormat;
@@ -9,7 +10,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CreateDirectoryToolInput {
@@ -52,10 +53,7 @@ impl Tool for CreateDirectoryTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<CreateDirectoryToolInput>(input.clone()) {
             Ok(input) => {
-                format!(
-                    "Create directory {}",
-                    MarkdownString::inline_code(&input.path)
-                )
+                format!("Create directory {}", MarkdownInlineCode(&input.path))
             }
             Err(_) => "Create directory".to_string(),
         }
@@ -67,6 +65,7 @@ impl Tool for CreateDirectoryTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<CreateDirectoryToolInput>(input) {

crates/assistant_tools/src/create_file_tool.rs

@@ -1,6 +1,7 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
+use gpui::AnyWindowHandle;
 use gpui::{App, Entity, Task};
 use language_model::LanguageModelRequestMessage;
 use language_model::LanguageModelToolSchemaFormat;
@@ -9,7 +10,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CreateFileToolInput {
@@ -23,6 +24,9 @@ pub struct CreateFileToolInput {
     ///
     /// You can create a new file by providing a path of "directory1/new_file.txt"
     /// </example>
+    ///
+    /// Make sure to include this field before the `contents` field in the input object
+    /// so that we can display it immediately.
     pub path: String,
 
     /// The text contents of the file to create.
@@ -69,7 +73,7 @@ impl Tool for CreateFileTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<CreateFileToolInput>(input.clone()) {
             Ok(input) => {
-                let path = MarkdownString::inline_code(&input.path);
+                let path = MarkdownInlineCode(&input.path);
                 format!("Create file {path}")
             }
             Err(_) => DEFAULT_UI_TEXT.to_string(),
@@ -89,6 +93,7 @@ impl Tool for CreateFileTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<CreateFileToolInput>(input) {

crates/assistant_tools/src/delete_path_tool.rs

@@ -2,7 +2,7 @@ use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
 use futures::{SinkExt, StreamExt, channel::mpsc};
-use gpui::{App, AppContext, Entity, Task};
+use gpui::{AnyWindowHandle, App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::{Project, ProjectPath};
 use schemars::JsonSchema;
@@ -62,6 +62,7 @@ impl Tool for DeletePathTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let path_str = match serde_json::from_value::<DeletePathToolInput>(input) {

crates/assistant_tools/src/diagnostics_tool.rs

@@ -1,7 +1,7 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use language::{DiagnosticSeverity, OffsetRangeExt};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -9,7 +9,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Write, path::Path, sync::Arc};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct DiagnosticsToolInput {
@@ -66,11 +66,11 @@ impl Tool for DiagnosticsTool {
         if let Some(path) = serde_json::from_value::<DiagnosticsToolInput>(input.clone())
             .ok()
             .and_then(|input| match input.path {
-                Some(path) if !path.is_empty() => Some(MarkdownString::inline_code(&path)),
+                Some(path) if !path.is_empty() => Some(path),
                 _ => None,
             })
         {
-            format!("Check diagnostics for {path}")
+            format!("Check diagnostics for {}", MarkdownInlineCode(&path))
         } else {
             "Check project diagnostics".to_string()
         }
@@ -82,6 +82,7 @@ impl Tool for DiagnosticsTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         match serde_json::from_value::<DiagnosticsToolInput>(input)

crates/assistant_tools/src/edit_file_tool.rs

@@ -1,18 +1,42 @@
-use crate::{replace::replace_with_flexible_indent, schema::json_schema_for};
+use crate::{
+    replace::{replace_exact, replace_with_flexible_indent},
+    schema::json_schema_for,
+};
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, AppContext, AsyncApp, Entity, Task};
+use assistant_tool::{ActionLog, AnyToolCard, Tool, ToolCard, ToolResult, ToolUseStatus};
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
+use editor::{Editor, EditorMode, MultiBuffer, PathKey};
+use gpui::{
+    AnyWindowHandle, App, AppContext, AsyncApp, Context, Entity, EntityId, Task, WeakEntity,
+};
+use language::{
+    Anchor, Buffer, Capability, LanguageRegistry, LineEnding, OffsetRangeExt, Rope, TextBuffer,
+};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::{path::PathBuf, sync::Arc};
-use ui::IconName;
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use ui::{Disclosure, Tooltip, Window, prelude::*};
+use util::ResultExt;
+use workspace::Workspace;
 
-use crate::replace::replace_exact;
+pub struct EditFileTool;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct EditFileToolInput {
+    /// A user-friendly markdown description of what's being replaced. This will be shown in the UI.
+    ///
+    /// <example>Fix API endpoint URLs</example>
+    /// <example>Update copyright year in `page_footer`</example>
+    ///
+    /// Make sure to include this field before all the others in the input object
+    /// so that we can display it immediately.
+    pub display_description: String,
+
     /// The full path of the file to modify in the project.
     ///
     /// WARNING: When specifying which file path need changing, you MUST
@@ -34,12 +58,6 @@ pub struct EditFileToolInput {
     /// </example>
     pub path: PathBuf,
 
-    /// A user-friendly markdown description of what's being replaced. This will be shown in the UI.
-    ///
-    /// <example>Fix API endpoint URLs</example>
-    /// <example>Update copyright year in `page_footer`</example>
-    pub display_description: String,
-
     /// The text to replace.
     pub old_string: String,
 
@@ -59,8 +77,6 @@ struct PartialInput {
     new_string: String,
 }
 
-pub struct EditFileTool;
-
 const DEFAULT_UI_TEXT: &str = "Editing file";
 
 impl Tool for EditFileTool {
@@ -113,6 +129,7 @@ impl Tool for EditFileTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<EditFileToolInput>(input) {
@@ -120,7 +137,18 @@ impl Tool for EditFileTool {
             Err(err) => return Task::ready(Err(anyhow!(err))).into(),
         };
 
-        cx.spawn(async move |cx: &mut AsyncApp| {
+        let card = window.and_then(|window| {
+            window
+                .update(cx, |_, window, cx| {
+                    cx.new(|cx| {
+                        EditFileToolCard::new(input.path.clone(), project.clone(), window, cx)
+                    })
+                })
+                .ok()
+        });
+
+        let card_clone = card.clone();
+        let task = cx.spawn(async move |cx: &mut AsyncApp| {
             let project_path = project.read_with(cx, |project, cx| {
                 project
                     .find_project_path(&input.path, cx)
@@ -128,26 +156,38 @@ impl Tool for EditFileTool {
             })??;
 
             let buffer = project
-                .update(cx, |project, cx| project.open_buffer(project_path, cx))?
+                .update(cx, |project, cx| {
+                    project.open_buffer(project_path.clone(), cx)
+                })?
                 .await?;
 
             let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
 
             if input.old_string.is_empty() {
-                return Err(anyhow!("`old_string` cannot be empty. Use a different tool if you want to create a file."));
+                return Err(anyhow!(
+                    "`old_string` can't be empty, use another tool if you want to create a file."
+                ));
             }
 
             if input.old_string == input.new_string {
-                return Err(anyhow!("The `old_string` and `new_string` are identical, so no changes would be made."));
+                return Err(anyhow!(
+                    "The `old_string` and `new_string` are identical, so no changes would be made."
+                ));
             }
 
             let result = cx
                 .background_spawn(async move {
                     // Try to match exactly
                     let diff = replace_exact(&input.old_string, &input.new_string, &snapshot)
-                    .await
-                    // If that fails, try being flexible about indentation
-                    .or_else(|| replace_with_flexible_indent(&input.old_string, &input.new_string, &snapshot))?;
+                        .await
+                        // If that fails, try being flexible about indentation
+                        .or_else(|| {
+                            replace_with_flexible_indent(
+                                &input.old_string,
+                                &input.new_string,
+                                &snapshot,
+                            )
+                        })?;
 
                     if diff.edits.is_empty() {
                         return None;
@@ -177,41 +217,409 @@ impl Tool for EditFileTool {
                     }
                 })?;
 
-                return Err(err)
+                return Err(err);
             };
 
             let snapshot = cx.update(|cx| {
-                action_log.update(cx, |log, cx| {
-                    log.track_buffer(buffer.clone(), cx)
-                });
+                action_log.update(cx, |log, cx| log.track_buffer(buffer.clone(), cx));
+
                 let snapshot = buffer.update(cx, |buffer, cx| {
                     buffer.finalize_last_transaction();
                     buffer.apply_diff(diff, cx);
                     buffer.finalize_last_transaction();
                     buffer.snapshot()
                 });
-                action_log.update(cx, |log, cx| {
-                    log.buffer_edited(buffer.clone(), cx)
-                });
+                action_log.update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
                 snapshot
             })?;
 
-            project.update( cx, |project, cx| {
-                project.save_buffer(buffer, cx)
-            })?.await?;
+            project
+                .update(cx, |project, cx| project.save_buffer(buffer, cx))?
+                .await?;
 
-            let diff_str = cx.background_spawn(async move {
-                let new_text = snapshot.text();
-                language::unified_diff(&old_text, &new_text)
-            }).await;
+            let new_text = snapshot.text();
+            let diff_str = cx
+                .background_spawn({
+                    let old_text = old_text.clone();
+                    let new_text = new_text.clone();
+                    async move { language::unified_diff(&old_text, &new_text) }
+                })
+                .await;
 
+            if let Some(card) = card_clone {
+                card.update(cx, |card, cx| {
+                    card.set_diff(project_path.path.clone(), old_text, new_text, cx);
+                })
+                .log_err();
+            }
 
-            Ok(format!("Edited {}:\n\n```diff\n{}\n```", input.path.display(), diff_str))
+            Ok(format!(
+                "Edited {}:\n\n```diff\n{}\n```",
+                input.path.display(),
+                diff_str
+            ))
+        });
 
-        }).into()
+        ToolResult {
+            output: task,
+            card: card.map(AnyToolCard::from),
+        }
     }
 }
 
+pub struct EditFileToolCard {
+    path: PathBuf,
+    editor: Entity<Editor>,
+    multibuffer: Entity<MultiBuffer>,
+    project: Entity<Project>,
+    diff_task: Option<Task<Result<()>>>,
+    preview_expanded: bool,
+    full_height_expanded: bool,
+    editor_unique_id: EntityId,
+}
+
+impl EditFileToolCard {
+    fn new(path: PathBuf, project: Entity<Project>, window: &mut Window, cx: &mut App) -> Self {
+        let multibuffer = cx.new(|_| MultiBuffer::without_headers(Capability::ReadOnly));
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::new(
+                EditorMode::Full {
+                    scale_ui_elements_with_buffer_font_size: false,
+                    show_active_line_background: false,
+                    sized_by_content: true,
+                },
+                multibuffer.clone(),
+                Some(project.clone()),
+                window,
+                cx,
+            );
+            editor.set_show_scrollbars(false, cx);
+            editor.set_show_gutter(false, cx);
+            editor.disable_inline_diagnostics();
+            editor.disable_scrolling(cx);
+            editor.disable_expand_excerpt_buttons(cx);
+            editor.set_show_breakpoints(false, cx);
+            editor.set_show_code_actions(false, cx);
+            editor.set_show_git_diff_gutter(false, cx);
+            editor.set_expand_all_diff_hunks(cx);
+            editor
+        });
+        Self {
+            editor_unique_id: editor.entity_id(),
+            path,
+            project,
+            editor,
+            multibuffer,
+            diff_task: None,
+            preview_expanded: true,
+            full_height_expanded: false,
+        }
+    }
+
+    fn set_diff(
+        &mut self,
+        path: Arc<Path>,
+        old_text: String,
+        new_text: String,
+        cx: &mut Context<Self>,
+    ) {
+        let language_registry = self.project.read(cx).languages().clone();
+        self.diff_task = Some(cx.spawn(async move |this, cx| {
+            let buffer = build_buffer(new_text, path.clone(), &language_registry, cx).await?;
+            let buffer_diff = build_buffer_diff(old_text, &buffer, &language_registry, cx).await?;
+
+            this.update(cx, |this, cx| {
+                this.multibuffer.update(cx, |multibuffer, cx| {
+                    let snapshot = buffer.read(cx).snapshot();
+                    let diff = buffer_diff.read(cx);
+                    let diff_hunk_ranges = diff
+                        .hunks_intersecting_range(Anchor::MIN..Anchor::MAX, &snapshot, cx)
+                        .map(|diff_hunk| diff_hunk.buffer_range.to_point(&snapshot))
+                        .collect::<Vec<_>>();
+                    let (_, is_newly_added) = multibuffer.set_excerpts_for_path(
+                        PathKey::for_buffer(&buffer, cx),
+                        buffer,
+                        diff_hunk_ranges,
+                        editor::DEFAULT_MULTIBUFFER_CONTEXT,
+                        cx,
+                    );
+                    debug_assert!(is_newly_added);
+                    multibuffer.add_diff(buffer_diff, cx);
+                });
+                cx.notify();
+            })
+        }));
+    }
+}
+
+impl ToolCard for EditFileToolCard {
+    fn render(
+        &mut self,
+        status: &ToolUseStatus,
+        window: &mut Window,
+        workspace: WeakEntity<Workspace>,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let failed = matches!(status, ToolUseStatus::Error(_));
+
+        let path_label_button = h_flex()
+            .id(("edit-tool-path-label-button", self.editor_unique_id))
+            .w_full()
+            .max_w_full()
+            .px_1()
+            .gap_0p5()
+            .cursor_pointer()
+            .rounded_sm()
+            .opacity(0.8)
+            .hover(|label| {
+                label
+                    .opacity(1.)
+                    .bg(cx.theme().colors().element_hover.opacity(0.5))
+            })
+            .tooltip(Tooltip::text("Jump to File"))
+            .child(
+                h_flex()
+                    .child(
+                        Icon::new(IconName::Pencil)
+                            .size(IconSize::XSmall)
+                            .color(Color::Muted),
+                    )
+                    .child(
+                        div()
+                            .text_size(rems(0.8125))
+                            .child(self.path.display().to_string())
+                            .ml_1p5()
+                            .mr_0p5(),
+                    )
+                    .child(
+                        Icon::new(IconName::ArrowUpRight)
+                            .size(IconSize::XSmall)
+                            .color(Color::Ignored),
+                    ),
+            )
+            .on_click({
+                let path = self.path.clone();
+                let workspace = workspace.clone();
+                move |_, window, cx| {
+                    workspace
+                        .update(cx, {
+                            |workspace, cx| {
+                                let Some(project_path) =
+                                    workspace.project().read(cx).find_project_path(&path, cx)
+                                else {
+                                    return;
+                                };
+                                let open_task =
+                                    workspace.open_path(project_path, None, true, window, cx);
+                                window
+                                    .spawn(cx, async move |cx| {
+                                        let item = open_task.await?;
+                                        if let Some(active_editor) = item.downcast::<Editor>() {
+                                            active_editor
+                                                .update_in(cx, |editor, window, cx| {
+                                                    editor.go_to_singleton_buffer_point(
+                                                        language::Point::new(0, 0),
+                                                        window,
+                                                        cx,
+                                                    );
+                                                })
+                                                .log_err();
+                                        }
+                                        anyhow::Ok(())
+                                    })
+                                    .detach_and_log_err(cx);
+                            }
+                        })
+                        .ok();
+                }
+            })
+            .into_any_element();
+
+        let codeblock_header_bg = cx
+            .theme()
+            .colors()
+            .element_background
+            .blend(cx.theme().colors().editor_foreground.opacity(0.025));
+
+        let codeblock_header = h_flex()
+            .flex_none()
+            .p_1()
+            .gap_1()
+            .justify_between()
+            .rounded_t_md()
+            .when(!failed, |header| header.bg(codeblock_header_bg))
+            .child(path_label_button)
+            .map(|container| {
+                if failed {
+                    container.child(
+                        Icon::new(IconName::Close)
+                            .size(IconSize::Small)
+                            .color(Color::Error),
+                    )
+                } else {
+                    container.child(
+                        Disclosure::new(
+                            ("edit-file-disclosure", self.editor_unique_id),
+                            self.preview_expanded,
+                        )
+                        .opened_icon(IconName::ChevronUp)
+                        .closed_icon(IconName::ChevronDown)
+                        .on_click(cx.listener(
+                            move |this, _event, _window, _cx| {
+                                this.preview_expanded = !this.preview_expanded;
+                            },
+                        )),
+                    )
+                }
+            });
+
+        let editor = self.editor.update(cx, |editor, cx| {
+            editor.render(window, cx).into_any_element()
+        });
+
+        let (full_height_icon, full_height_tooltip_label) = if self.full_height_expanded {
+            (IconName::ChevronUp, "Collapse Code Block")
+        } else {
+            (IconName::ChevronDown, "Expand Code Block")
+        };
+
+        let gradient_overlay = div()
+            .absolute()
+            .bottom_0()
+            .left_0()
+            .w_full()
+            .h_2_5()
+            .rounded_b_lg()
+            .bg(gpui::linear_gradient(
+                0.,
+                gpui::linear_color_stop(cx.theme().colors().editor_background, 0.),
+                gpui::linear_color_stop(cx.theme().colors().editor_background.opacity(0.), 1.),
+            ));
+
+        let border_color = cx.theme().colors().border.opacity(0.6);
+
+        v_flex()
+            .mb_2()
+            .border_1()
+            .when(failed, |card| card.border_dashed())
+            .border_color(border_color)
+            .rounded_lg()
+            .overflow_hidden()
+            .child(codeblock_header)
+            .when(!failed && self.preview_expanded, |card| {
+                card.child(
+                    v_flex()
+                        .relative()
+                        .overflow_hidden()
+                        .border_t_1()
+                        .border_color(border_color)
+                        .bg(cx.theme().colors().editor_background)
+                        .map(|editor_container| {
+                            if self.full_height_expanded {
+                                editor_container.h_full()
+                            } else {
+                                editor_container.max_h_64()
+                            }
+                        })
+                        .child(div().pl_1().child(editor))
+                        .when(!self.full_height_expanded, |editor_container| {
+                            editor_container.child(gradient_overlay)
+                        }),
+                )
+            })
+            .when(!failed && self.preview_expanded, |card| {
+                card.child(
+                    h_flex()
+                        .id(("edit-tool-card-inner-hflex", self.editor_unique_id))
+                        .flex_none()
+                        .cursor_pointer()
+                        .h_5()
+                        .justify_center()
+                        .rounded_b_md()
+                        .border_t_1()
+                        .border_color(border_color)
+                        .bg(cx.theme().colors().editor_background)
+                        .hover(|style| style.bg(cx.theme().colors().element_hover.opacity(0.1)))
+                        .child(
+                            Icon::new(full_height_icon)
+                                .size(IconSize::Small)
+                                .color(Color::Muted),
+                        )
+                        .tooltip(Tooltip::text(full_height_tooltip_label))
+                        .on_click(cx.listener(move |this, _event, _window, _cx| {
+                            this.full_height_expanded = !this.full_height_expanded;
+                        })),
+                )
+            })
+    }
+}
+
+async fn build_buffer(
+    mut text: String,
+    path: Arc<Path>,
+    language_registry: &Arc<language::LanguageRegistry>,
+    cx: &mut AsyncApp,
+) -> Result<Entity<Buffer>> {
+    let line_ending = LineEnding::detect(&text);
+    LineEnding::normalize(&mut text);
+    let text = Rope::from(text);
+    let language = cx
+        .update(|_cx| language_registry.language_for_file_path(&path))?
+        .await
+        .ok();
+    let buffer = cx.new(|cx| {
+        let buffer = TextBuffer::new_normalized(
+            0,
+            cx.entity_id().as_non_zero_u64().into(),
+            line_ending,
+            text,
+        );
+        let mut buffer = Buffer::build(buffer, None, Capability::ReadWrite);
+        buffer.set_language(language, cx);
+        buffer
+    })?;
+    Ok(buffer)
+}
+
+async fn build_buffer_diff(
+    mut old_text: String,
+    buffer: &Entity<Buffer>,
+    language_registry: &Arc<LanguageRegistry>,
+    cx: &mut AsyncApp,
+) -> Result<Entity<BufferDiff>> {
+    LineEnding::normalize(&mut old_text);
+
+    let buffer = cx.update(|cx| buffer.read(cx).snapshot())?;
+
+    let base_buffer = cx
+        .update(|cx| {
+            Buffer::build_snapshot(
+                old_text.clone().into(),
+                buffer.language().cloned(),
+                Some(language_registry.clone()),
+                cx,
+            )
+        })?
+        .await;
+
+    let diff_snapshot = cx
+        .update(|cx| {
+            BufferDiffSnapshot::new_with_base_buffer(
+                buffer.text.clone(),
+                Some(old_text.into()),
+                base_buffer,
+                cx,
+            )
+        })?
+        .await;
+
+    cx.new(|cx| {
+        let mut diff = BufferDiff::new(&buffer.text, cx);
+        diff.set_snapshot(diff_snapshot, &buffer.text, cx);
+        diff
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -219,7 +627,6 @@ mod tests {
 
     #[test]
     fn still_streaming_ui_text_with_path() {
-        let tool = EditFileTool;
         let input = json!({
             "path": "src/main.rs",
             "display_description": "",
@@ -227,12 +634,11 @@ mod tests {
             "new_string": "new code"
         });
 
-        assert_eq!(tool.still_streaming_ui_text(&input), "src/main.rs");
+        assert_eq!(EditFileTool.still_streaming_ui_text(&input), "src/main.rs");
     }
 
     #[test]
     fn still_streaming_ui_text_with_description() {
-        let tool = EditFileTool;
         let input = json!({
             "path": "",
             "display_description": "Fix error handling",
@@ -240,12 +646,14 @@ mod tests {
             "new_string": "new code"
         });
 
-        assert_eq!(tool.still_streaming_ui_text(&input), "Fix error handling");
+        assert_eq!(
+            EditFileTool.still_streaming_ui_text(&input),
+            "Fix error handling",
+        );
     }
 
     #[test]
     fn still_streaming_ui_text_with_path_and_description() {
-        let tool = EditFileTool;
         let input = json!({
             "path": "src/main.rs",
             "display_description": "Fix error handling",
@@ -253,12 +661,14 @@ mod tests {
             "new_string": "new code"
         });
 
-        assert_eq!(tool.still_streaming_ui_text(&input), "Fix error handling");
+        assert_eq!(
+            EditFileTool.still_streaming_ui_text(&input),
+            "Fix error handling",
+        );
     }
 
     #[test]
     fn still_streaming_ui_text_no_path_or_description() {
-        let tool = EditFileTool;
         let input = json!({
             "path": "",
             "display_description": "",
@@ -266,14 +676,19 @@ mod tests {
             "new_string": "new code"
         });
 
-        assert_eq!(tool.still_streaming_ui_text(&input), DEFAULT_UI_TEXT);
+        assert_eq!(
+            EditFileTool.still_streaming_ui_text(&input),
+            DEFAULT_UI_TEXT,
+        );
     }
 
     #[test]
     fn still_streaming_ui_text_with_null() {
-        let tool = EditFileTool;
         let input = serde_json::Value::Null;
 
-        assert_eq!(tool.still_streaming_ui_text(&input), DEFAULT_UI_TEXT);
+        assert_eq!(
+            EditFileTool.still_streaming_ui_text(&input),
+            DEFAULT_UI_TEXT,
+        );
     }
 }

crates/assistant_tools/src/fetch_tool.rs

@@ -6,7 +6,7 @@ use crate::schema::json_schema_for;
 use anyhow::{Context as _, Result, anyhow, bail};
 use assistant_tool::{ActionLog, Tool, ToolResult};
 use futures::AsyncReadExt as _;
-use gpui::{App, AppContext as _, Entity, Task};
+use gpui::{AnyWindowHandle, App, AppContext as _, Entity, Task};
 use html_to_markdown::{TagHandler, convert_html_to_markdown, markdown};
 use http_client::{AsyncBody, HttpClientWithUrl};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -14,7 +14,7 @@ use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownEscaped;
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
 enum ContentType {
@@ -134,7 +134,7 @@ impl Tool for FetchTool {
 
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<FetchToolInput>(input.clone()) {
-            Ok(input) => format!("Fetch {}", MarkdownString::escape(&input.url)),
+            Ok(input) => format!("Fetch {}", MarkdownEscaped(&input.url)),
             Err(_) => "Fetch URL".to_string(),
         }
     }
@@ -145,6 +145,7 @@ impl Tool for FetchTool {
         _messages: &[LanguageModelRequestMessage],
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<FetchToolInput>(input) {

crates/assistant_tools/src/find_path_tool.rs

@@ -0,0 +1,421 @@
+use crate::{schema::json_schema_for, ui::ToolCallCardHeader};
+use anyhow::{Result, anyhow};
+use assistant_tool::{ActionLog, Tool, ToolCard, ToolResult, ToolUseStatus};
+use editor::Editor;
+use futures::channel::oneshot::{self, Receiver};
+use gpui::{
+    AnyWindowHandle, App, AppContext, Context, Entity, IntoElement, Task, WeakEntity, Window,
+};
+use language;
+use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::fmt::Write;
+use std::{cmp, path::PathBuf, sync::Arc};
+use ui::{Disclosure, Tooltip, prelude::*};
+use util::{ResultExt, paths::PathMatcher};
+use workspace::Workspace;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct FindPathToolInput {
+    /// The glob to match against every path in the project.
+    ///
+    /// <example>
+    /// If the project has the following root directories:
+    ///
+    /// - directory1/a/something.txt
+    /// - directory2/a/things.txt
+    /// - directory3/a/other.txt
+    ///
+    /// You can get back the first two paths by providing a glob of "*thing*.txt"
+    /// </example>
+    pub glob: String,
+
+    /// Optional starting position for paginated results (0-based).
+    /// When not provided, starts from the beginning.
+    #[serde(default)]
+    pub offset: usize,
+}
+
+const RESULTS_PER_PAGE: usize = 50;
+
+pub struct FindPathTool;
+
+impl Tool for FindPathTool {
+    fn name(&self) -> String {
+        "find_path".into()
+    }
+
+    fn needs_confirmation(&self, _: &serde_json::Value, _: &App) -> bool {
+        false
+    }
+
+    fn description(&self) -> String {
+        include_str!("./find_path_tool/description.md").into()
+    }
+
+    fn icon(&self) -> IconName {
+        IconName::SearchCode
+    }
+
+    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
+        json_schema_for::<FindPathToolInput>(format)
+    }
+
+    fn ui_text(&self, input: &serde_json::Value) -> String {
+        match serde_json::from_value::<FindPathToolInput>(input.clone()) {
+            Ok(input) => format!("Find paths matching “`{}`”", input.glob),
+            Err(_) => "Search paths".to_string(),
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
+        cx: &mut App,
+    ) -> ToolResult {
+        let (offset, glob) = match serde_json::from_value::<FindPathToolInput>(input) {
+            Ok(input) => (input.offset, input.glob),
+            Err(err) => return Task::ready(Err(anyhow!(err))).into(),
+        };
+
+        let (sender, receiver) = oneshot::channel();
+
+        let card = cx.new(|cx| FindPathToolCard::new(glob.clone(), receiver, cx));
+
+        let search_paths_task = search_paths(&glob, project, cx);
+
+        let task = cx.background_spawn(async move {
+            let matches = search_paths_task.await?;
+            let paginated_matches: &[PathBuf] = &matches[cmp::min(offset, matches.len())
+                ..cmp::min(offset + RESULTS_PER_PAGE, matches.len())];
+
+            sender.send(paginated_matches.to_vec()).log_err();
+
+            if matches.is_empty() {
+                Ok("No matches found".to_string())
+            } else {
+                let mut message = format!("Found {} total matches.", matches.len());
+                if matches.len() > RESULTS_PER_PAGE {
+                    write!(
+                        &mut message,
+                        "\nShowing results {}-{} (provide 'offset' parameter for more results):",
+                        offset + 1,
+                        offset + paginated_matches.len()
+                    )
+                    .unwrap();
+                }
+                for mat in matches.into_iter().skip(offset).take(RESULTS_PER_PAGE) {
+                    write!(&mut message, "\n{}", mat.display()).unwrap();
+                }
+                Ok(message)
+            }
+        });
+
+        ToolResult {
+            output: task,
+            card: Some(card.into()),
+        }
+    }
+}
+
+fn search_paths(glob: &str, project: Entity<Project>, cx: &mut App) -> Task<Result<Vec<PathBuf>>> {
+    let path_matcher = match PathMatcher::new([
+        // Sometimes models try to search for "". In this case, return all paths in the project.
+        if glob.is_empty() { "*" } else { glob },
+    ]) {
+        Ok(matcher) => matcher,
+        Err(err) => return Task::ready(Err(anyhow!("Invalid glob: {err}"))),
+    };
+    let snapshots: Vec<_> = project
+        .read(cx)
+        .worktrees(cx)
+        .map(|worktree| worktree.read(cx).snapshot())
+        .collect();
+
+    cx.background_spawn(async move {
+        Ok(snapshots
+            .iter()
+            .flat_map(|snapshot| {
+                let root_name = PathBuf::from(snapshot.root_name());
+                snapshot
+                    .entries(false, 0)
+                    .map(move |entry| root_name.join(&entry.path))
+                    .filter(|path| path_matcher.is_match(&path))
+            })
+            .collect())
+    })
+}
+
+struct FindPathToolCard {
+    paths: Vec<PathBuf>,
+    expanded: bool,
+    glob: String,
+    _receiver_task: Option<Task<Result<()>>>,
+}
+
+impl FindPathToolCard {
+    fn new(glob: String, receiver: Receiver<Vec<PathBuf>>, cx: &mut Context<Self>) -> Self {
+        let _receiver_task = cx.spawn(async move |this, cx| {
+            let paths = receiver.await?;
+
+            this.update(cx, |this, _cx| {
+                this.paths = paths;
+            })
+            .log_err();
+
+            Ok(())
+        });
+
+        Self {
+            paths: Vec::new(),
+            expanded: false,
+            glob,
+            _receiver_task: Some(_receiver_task),
+        }
+    }
+}
+
+impl ToolCard for FindPathToolCard {
+    fn render(
+        &mut self,
+        _status: &ToolUseStatus,
+        _window: &mut Window,
+        workspace: WeakEntity<Workspace>,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let matches_label: SharedString = if self.paths.len() == 0 {
+            "No matches".into()
+        } else if self.paths.len() == 1 {
+            "1 match".into()
+        } else {
+            format!("{} matches", self.paths.len()).into()
+        };
+
+        let glob_label = self.glob.to_string();
+
+        let content = if !self.paths.is_empty() && self.expanded {
+            Some(
+                v_flex()
+                    .relative()
+                    .ml_1p5()
+                    .px_1p5()
+                    .gap_0p5()
+                    .border_l_1()
+                    .border_color(cx.theme().colors().border_variant)
+                    .children(self.paths.iter().enumerate().map(|(index, path)| {
+                        let path_clone = path.clone();
+                        let workspace_clone = workspace.clone();
+                        let button_label = path.to_string_lossy().to_string();
+
+                        Button::new(("path", index), button_label)
+                            .icon(IconName::ArrowUpRight)
+                            .icon_size(IconSize::XSmall)
+                            .icon_position(IconPosition::End)
+                            .label_size(LabelSize::Small)
+                            .color(Color::Muted)
+                            .tooltip(Tooltip::text("Jump to File"))
+                            .on_click(move |_, window, cx| {
+                                workspace_clone
+                                    .update(cx, |workspace, cx| {
+                                        let path = PathBuf::from(&path_clone);
+                                        let Some(project_path) = workspace
+                                            .project()
+                                            .read(cx)
+                                            .find_project_path(&path, cx)
+                                        else {
+                                            return;
+                                        };
+                                        let open_task = workspace.open_path(
+                                            project_path,
+                                            None,
+                                            true,
+                                            window,
+                                            cx,
+                                        );
+                                        window
+                                            .spawn(cx, async move |cx| {
+                                                let item = open_task.await?;
+                                                if let Some(active_editor) =
+                                                    item.downcast::<Editor>()
+                                                {
+                                                    active_editor
+                                                        .update_in(cx, |editor, window, cx| {
+                                                            editor.go_to_singleton_buffer_point(
+                                                                language::Point::new(0, 0),
+                                                                window,
+                                                                cx,
+                                                            );
+                                                        })
+                                                        .log_err();
+                                                }
+                                                anyhow::Ok(())
+                                            })
+                                            .detach_and_log_err(cx);
+                                    })
+                                    .ok();
+                            })
+                    }))
+                    .into_any(),
+            )
+        } else {
+            None
+        };
+
+        v_flex()
+            .mb_2()
+            .gap_1()
+            .child(
+                ToolCallCardHeader::new(IconName::SearchCode, matches_label)
+                    .with_code_path(glob_label)
+                    .disclosure_slot(
+                        Disclosure::new("path-search-disclosure", self.expanded)
+                            .opened_icon(IconName::ChevronUp)
+                            .closed_icon(IconName::ChevronDown)
+                            .disabled(self.paths.is_empty())
+                            .on_click(cx.listener(move |this, _, _, _cx| {
+                                this.expanded = !this.expanded;
+                            })),
+                    ),
+            )
+            .children(content)
+    }
+}
+
+impl Component for FindPathTool {
+    fn scope() -> ComponentScope {
+        ComponentScope::Agent
+    }
+
+    fn sort_name() -> &'static str {
+        "FindPathTool"
+    }
+
+    fn preview(window: &mut Window, cx: &mut App) -> Option<AnyElement> {
+        let successful_card = cx.new(|_| FindPathToolCard {
+            paths: vec![
+                PathBuf::from("src/main.rs"),
+                PathBuf::from("src/lib.rs"),
+                PathBuf::from("tests/test.rs"),
+            ],
+            expanded: true,
+            glob: "*.rs".to_string(),
+            _receiver_task: None,
+        });
+
+        let empty_card = cx.new(|_| FindPathToolCard {
+            paths: Vec::new(),
+            expanded: false,
+            glob: "*.nonexistent".to_string(),
+            _receiver_task: None,
+        });
+
+        Some(
+            v_flex()
+                .gap_6()
+                .children(vec![example_group(vec![
+                    single_example(
+                        "With Paths",
+                        div()
+                            .size_full()
+                            .child(successful_card.update(cx, |tool, cx| {
+                                tool.render(
+                                    &ToolUseStatus::Finished("".into()),
+                                    window,
+                                    WeakEntity::new_invalid(),
+                                    cx,
+                                )
+                                .into_any_element()
+                            }))
+                            .into_any_element(),
+                    ),
+                    single_example(
+                        "No Paths",
+                        div()
+                            .size_full()
+                            .child(empty_card.update(cx, |tool, cx| {
+                                tool.render(
+                                    &ToolUseStatus::Finished("".into()),
+                                    window,
+                                    WeakEntity::new_invalid(),
+                                    cx,
+                                )
+                                .into_any_element()
+                            }))
+                            .into_any_element(),
+                    ),
+                ])])
+                .into_any_element(),
+        )
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use gpui::TestAppContext;
+    use project::{FakeFs, Project};
+    use settings::SettingsStore;
+    use util::path;
+
+    #[gpui::test]
+    async fn test_find_path_tool(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            "/root",
+            serde_json::json!({
+                "apple": {
+                    "banana": {
+                        "carrot": "1",
+                    },
+                    "bandana": {
+                        "carbonara": "2",
+                    },
+                    "endive": "3"
+                }
+            }),
+        )
+        .await;
+        let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
+
+        let matches = cx
+            .update(|cx| search_paths("root/**/car*", project.clone(), cx))
+            .await
+            .unwrap();
+        assert_eq!(
+            matches,
+            &[
+                PathBuf::from("root/apple/banana/carrot"),
+                PathBuf::from("root/apple/bandana/carbonara")
+            ]
+        );
+
+        let matches = cx
+            .update(|cx| search_paths("**/car*", project.clone(), cx))
+            .await
+            .unwrap();
+        assert_eq!(
+            matches,
+            &[
+                PathBuf::from("root/apple/banana/carrot"),
+                PathBuf::from("root/apple/bandana/carbonara")
+            ]
+        );
+    }
+
+    fn init_test(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            language::init(cx);
+            Project::init_settings(cx);
+        });
+    }
+}

crates/assistant_tools/src/find_path_tool/description.md

@@ -1,4 +1,4 @@
-Fast file pattern matching tool that works with any codebase size
+Fast file path pattern matching tool that works with any codebase size
 
 - Supports glob patterns like "**/*.js" or "src/**/*.ts"
 - Returns matching file paths sorted alphabetically

crates/assistant_tools/src/grep_tool.rs

@@ -2,8 +2,8 @@ use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
 use futures::StreamExt;
-use gpui::{App, Entity, Task};
-use language::OffsetRangeExt;
+use gpui::{AnyWindowHandle, App, Entity, Task};
+use language::{OffsetRangeExt, ParseStatus, Point};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::{
     Project,
@@ -13,13 +13,16 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{cmp, fmt::Write, sync::Arc};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::RangeExt;
+use util::markdown::MarkdownInlineCode;
 use util::paths::PathMatcher;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct GrepToolInput {
     /// A regex pattern to search for in the entire project. Note that the regex
     /// will be parsed by the Rust `regex` crate.
+    ///
+    /// Do NOT specify a path here! This will only be matched against the code **content**.
     pub regex: String,
 
     /// A glob pattern for the paths of files to include in the search.
@@ -73,7 +76,7 @@ impl Tool for GrepTool {
         match serde_json::from_value::<GrepToolInput>(input.clone()) {
             Ok(input) => {
                 let page = input.page();
-                let regex_str = MarkdownString::inline_code(&input.regex);
+                let regex_str = MarkdownInlineCode(&input.regex);
                 let case_info = if input.case_sensitive {
                     " (case-sensitive)"
                 } else {
@@ -96,9 +99,11 @@ impl Tool for GrepTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         const CONTEXT_LINES: u32 = 2;
+        const MAX_ANCESTOR_LINES: u32 = 10;
 
         let input = match serde_json::from_value::<GrepToolInput>(input) {
             Ok(input) => input,
@@ -137,7 +142,7 @@ impl Tool for GrepTool {
 
         let results = project.update(cx, |project, cx| project.search(query, cx));
 
-        cx.spawn(async move|cx|  {
+        cx.spawn(async move |cx|  {
             futures::pin_mut!(results);
 
             let mut output = String::new();
@@ -145,68 +150,113 @@ impl Tool for GrepTool {
             let mut matches_found = 0;
             let mut has_more_matches = false;
 
-            while let Some(SearchResult::Buffer { buffer, ranges }) = results.next().await {
+            'outer: while let Some(SearchResult::Buffer { buffer, ranges }) = results.next().await {
                 if ranges.is_empty() {
                     continue;
                 }
 
-                buffer.read_with(cx, |buffer, cx| -> Result<(), anyhow::Error> {
-                    if let Some(path) = buffer.file().map(|file| file.full_path(cx)) {
-                        let mut file_header_written = false;
-                        let mut ranges = ranges
-                            .into_iter()
-                            .map(|range| {
-                                let mut point_range = range.to_point(buffer);
-                                point_range.start.row =
-                                    point_range.start.row.saturating_sub(CONTEXT_LINES);
-                                point_range.start.column = 0;
-                                point_range.end.row = cmp::min(
-                                    buffer.max_point().row,
-                                    point_range.end.row + CONTEXT_LINES,
-                                );
-                                point_range.end.column = buffer.line_len(point_range.end.row);
-                                point_range
-                            })
-                            .peekable();
+                let (Some(path), mut parse_status) = buffer.read_with(cx, |buffer, cx| {
+                    (buffer.file().map(|file| file.full_path(cx)), buffer.parse_status())
+                })? else {
+                    continue;
+                };
 
-                        while let Some(mut range) = ranges.next() {
-                            if skips_remaining > 0 {
-                                skips_remaining -= 1;
-                                continue;
+
+                while *parse_status.borrow() != ParseStatus::Idle {
+                    parse_status.changed().await?;
+                }
+
+                let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
+
+                let mut ranges = ranges
+                    .into_iter()
+                    .map(|range| {
+                        let matched = range.to_point(&snapshot);
+                        let matched_end_line_len = snapshot.line_len(matched.end.row);
+                        let full_lines = Point::new(matched.start.row, 0)..Point::new(matched.end.row, matched_end_line_len);
+                        let symbols = snapshot.symbols_containing(matched.start, None);
+
+                        if let Some(ancestor_node) = snapshot.syntax_ancestor(full_lines.clone()) {
+                            let full_ancestor_range = ancestor_node.byte_range().to_point(&snapshot);
+                            let end_row = full_ancestor_range.end.row.min(full_ancestor_range.start.row + MAX_ANCESTOR_LINES);
+                            let end_col = snapshot.line_len(end_row);
+                            let capped_ancestor_range = Point::new(full_ancestor_range.start.row, 0)..Point::new(end_row, end_col);
+
+                            if capped_ancestor_range.contains_inclusive(&full_lines) {
+                                return (capped_ancestor_range, Some(full_ancestor_range), symbols)
                             }
+                        }
 
-                            // We'd already found a full page of matches, and we just found one more.
-                            if matches_found >= RESULTS_PER_PAGE {
-                                has_more_matches = true;
-                                return Ok(());
-                            }
+                        let mut matched = matched;
+                        matched.start.column = 0;
+                        matched.start.row =
+                            matched.start.row.saturating_sub(CONTEXT_LINES);
+                        matched.end.row = cmp::min(
+                            snapshot.max_point().row,
+                            matched.end.row + CONTEXT_LINES,
+                        );
+                        matched.end.column = snapshot.line_len(matched.end.row);
 
-                            while let Some(next_range) = ranges.peek() {
-                                if range.end.row >= next_range.start.row {
-                                    range.end = next_range.end;
-                                    ranges.next();
-                                } else {
-                                    break;
-                                }
-                            }
+                        (matched, None, symbols)
+                    })
+                    .peekable();
 
-                            if !file_header_written {
-                                writeln!(output, "\n## Matches in {}", path.display())?;
-                                file_header_written = true;
-                            }
+                let mut file_header_written = false;
 
-                            let start_line = range.start.row + 1;
-                            let end_line = range.end.row + 1;
-                            writeln!(output, "\n### Lines {start_line}-{end_line}\n```")?;
-                            output.extend(buffer.text_for_range(range));
-                            output.push_str("\n```\n");
+                while let Some((mut range, ancestor_range, parent_symbols)) = ranges.next(){
+                    if skips_remaining > 0 {
+                        skips_remaining -= 1;
+                        continue;
+                    }
 
-                            matches_found += 1;
+                    // We'd already found a full page of matches, and we just found one more.
+                    if matches_found >= RESULTS_PER_PAGE {
+                        has_more_matches = true;
+                        break 'outer;
+                    }
+
+                    while let Some((next_range, _, _)) = ranges.peek() {
+                        if range.end.row >= next_range.start.row {
+                            range.end = next_range.end;
+                            ranges.next();
+                        } else {
+                            break;
                         }
                     }
 
-                    Ok(())
-                })??;
+                    if !file_header_written {
+                        writeln!(output, "\n## Matches in {}", path.display())?;
+                        file_header_written = true;
+                    }
+
+                    let end_row = range.end.row;
+                    output.push_str("\n### ");
+
+                    if let Some(parent_symbols) = &parent_symbols {
+                        for symbol in parent_symbols {
+                            write!(output, "{} › ", symbol.text)?;
+                        }
+                    }
+
+                    if range.start.row == end_row {
+                        writeln!(output, "L{}", range.start.row + 1)?;
+                    } else {
+                        writeln!(output, "L{}-{}", range.start.row + 1, end_row + 1)?;
+                    }
+
+                    output.push_str("```\n");
+                    output.extend(snapshot.text_for_range(range));
+                    output.push_str("\n```\n");
+
+                    if let Some(ancestor_range) = ancestor_range {
+                        if end_row < ancestor_range.end.row {
+                            let remaining_lines = ancestor_range.end.row - end_row;
+                            writeln!(output, "\n{} lines remaining in ancestor node. Read the file to see all.", remaining_lines)?;
+                        }
+                    }
+
+                    matches_found += 1;
+                }
             }
 
             if matches_found == 0 {
@@ -230,13 +280,16 @@ mod tests {
     use super::*;
     use assistant_tool::Tool;
     use gpui::{AppContext, TestAppContext};
+    use language::{Language, LanguageConfig, LanguageMatcher};
     use project::{FakeFs, Project};
     use settings::SettingsStore;
+    use unindent::Unindent;
     use util::path;
 
     #[gpui::test]
     async fn test_grep_tool_with_include_pattern(cx: &mut TestAppContext) {
         init_test(cx);
+        cx.executor().allow_parking();
 
         let fs = FakeFs::new(cx.executor().clone());
         fs.insert_tree(
@@ -324,6 +377,7 @@ mod tests {
     #[gpui::test]
     async fn test_grep_tool_with_case_sensitivity(cx: &mut TestAppContext) {
         init_test(cx);
+        cx.executor().allow_parking();
 
         let fs = FakeFs::new(cx.executor().clone());
         fs.insert_tree(
@@ -398,6 +452,290 @@ mod tests {
         );
     }
 
+    /// Helper function to set up a syntax test environment
+    async fn setup_syntax_test(cx: &mut TestAppContext) -> Entity<Project> {
+        use unindent::Unindent;
+        init_test(cx);
+        cx.executor().allow_parking();
+
+        let fs = FakeFs::new(cx.executor().clone());
+
+        // Create test file with syntax structures
+        fs.insert_tree(
+            "/root",
+            serde_json::json!({
+                "test_syntax.rs": r#"
+                    fn top_level_function() {
+                        println!("This is at the top level");
+                    }
+
+                    mod feature_module {
+                        pub mod nested_module {
+                            pub fn nested_function(
+                                first_arg: String,
+                                second_arg: i32,
+                            ) {
+                                println!("Function in nested module");
+                                println!("{first_arg}");
+                                println!("{second_arg}");
+                            }
+                        }
+                    }
+
+                    struct MyStruct {
+                        field1: String,
+                        field2: i32,
+                    }
+
+                    impl MyStruct {
+                        fn method_with_block() {
+                            let condition = true;
+                            if condition {
+                                println!("Inside if block");
+                            }
+                        }
+
+                        fn long_function() {
+                            println!("Line 1");
+                            println!("Line 2");
+                            println!("Line 3");
+                            println!("Line 4");
+                            println!("Line 5");
+                            println!("Line 6");
+                            println!("Line 7");
+                            println!("Line 8");
+                            println!("Line 9");
+                            println!("Line 10");
+                            println!("Line 11");
+                            println!("Line 12");
+                        }
+                    }
+
+                    trait Processor {
+                        fn process(&self, input: &str) -> String;
+                    }
+
+                    impl Processor for MyStruct {
+                        fn process(&self, input: &str) -> String {
+                            format!("Processed: {}", input)
+                        }
+                    }
+                "#.unindent().trim(),
+            }),
+        )
+        .await;
+
+        let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
+
+        project.update(cx, |project, _cx| {
+            project.languages().add(rust_lang().into())
+        });
+
+        project
+    }
+
+    #[gpui::test]
+    async fn test_grep_top_level_function(cx: &mut TestAppContext) {
+        let project = setup_syntax_test(cx).await;
+
+        // Test: Line at the top level of the file
+        let input = serde_json::to_value(GrepToolInput {
+            regex: "This is at the top level".to_string(),
+            include_pattern: Some("**/*.rs".to_string()),
+            offset: 0,
+            case_sensitive: false,
+        })
+        .unwrap();
+
+        let result = run_grep_tool(input, project.clone(), cx).await;
+        let expected = r#"
+            Found 1 matches:
+
+            ## Matches in root/test_syntax.rs
+
+            ### fn top_level_function › L1-3
+            ```
+            fn top_level_function() {
+                println!("This is at the top level");
+            }
+            ```
+            "#
+        .unindent();
+        assert_eq!(result, expected);
+    }
+
+    #[gpui::test]
+    async fn test_grep_function_body(cx: &mut TestAppContext) {
+        let project = setup_syntax_test(cx).await;
+
+        // Test: Line inside a function body
+        let input = serde_json::to_value(GrepToolInput {
+            regex: "Function in nested module".to_string(),
+            include_pattern: Some("**/*.rs".to_string()),
+            offset: 0,
+            case_sensitive: false,
+        })
+        .unwrap();
+
+        let result = run_grep_tool(input, project.clone(), cx).await;
+        let expected = r#"
+            Found 1 matches:
+
+            ## Matches in root/test_syntax.rs
+
+            ### mod feature_module › pub mod nested_module › pub fn nested_function › L10-14
+            ```
+                    ) {
+                        println!("Function in nested module");
+                        println!("{first_arg}");
+                        println!("{second_arg}");
+                    }
+            ```
+            "#
+        .unindent();
+        assert_eq!(result, expected);
+    }
+
+    #[gpui::test]
+    async fn test_grep_function_args_and_body(cx: &mut TestAppContext) {
+        let project = setup_syntax_test(cx).await;
+
+        // Test: Line with a function argument
+        let input = serde_json::to_value(GrepToolInput {
+            regex: "second_arg".to_string(),
+            include_pattern: Some("**/*.rs".to_string()),
+            offset: 0,
+            case_sensitive: false,
+        })
+        .unwrap();
+
+        let result = run_grep_tool(input, project.clone(), cx).await;
+        let expected = r#"
+            Found 1 matches:
+
+            ## Matches in root/test_syntax.rs
+
+            ### mod feature_module › pub mod nested_module › pub fn nested_function › L7-14
+            ```
+                    pub fn nested_function(
+                        first_arg: String,
+                        second_arg: i32,
+                    ) {
+                        println!("Function in nested module");
+                        println!("{first_arg}");
+                        println!("{second_arg}");
+                    }
+            ```
+            "#
+        .unindent();
+        assert_eq!(result, expected);
+    }
+
+    #[gpui::test]
+    async fn test_grep_if_block(cx: &mut TestAppContext) {
+        use unindent::Unindent;
+        let project = setup_syntax_test(cx).await;
+
+        // Test: Line inside an if block
+        let input = serde_json::to_value(GrepToolInput {
+            regex: "Inside if block".to_string(),
+            include_pattern: Some("**/*.rs".to_string()),
+            offset: 0,
+            case_sensitive: false,
+        })
+        .unwrap();
+
+        let result = run_grep_tool(input, project.clone(), cx).await;
+        let expected = r#"
+            Found 1 matches:
+
+            ## Matches in root/test_syntax.rs
+
+            ### impl MyStruct › fn method_with_block › L26-28
+            ```
+                    if condition {
+                        println!("Inside if block");
+                    }
+            ```
+            "#
+        .unindent();
+        assert_eq!(result, expected);
+    }
+
+    #[gpui::test]
+    async fn test_grep_long_function_top(cx: &mut TestAppContext) {
+        use unindent::Unindent;
+        let project = setup_syntax_test(cx).await;
+
+        // Test: Line in the middle of a long function - should show message about remaining lines
+        let input = serde_json::to_value(GrepToolInput {
+            regex: "Line 5".to_string(),
+            include_pattern: Some("**/*.rs".to_string()),
+            offset: 0,
+            case_sensitive: false,
+        })
+        .unwrap();
+
+        let result = run_grep_tool(input, project.clone(), cx).await;
+        let expected = r#"
+            Found 1 matches:
+
+            ## Matches in root/test_syntax.rs
+
+            ### impl MyStruct › fn long_function › L31-41
+            ```
+                fn long_function() {
+                    println!("Line 1");
+                    println!("Line 2");
+                    println!("Line 3");
+                    println!("Line 4");
+                    println!("Line 5");
+                    println!("Line 6");
+                    println!("Line 7");
+                    println!("Line 8");
+                    println!("Line 9");
+                    println!("Line 10");
+            ```
+
+            3 lines remaining in ancestor node. Read the file to see all.
+            "#
+        .unindent();
+        assert_eq!(result, expected);
+    }
+
+    #[gpui::test]
+    async fn test_grep_long_function_bottom(cx: &mut TestAppContext) {
+        use unindent::Unindent;
+        let project = setup_syntax_test(cx).await;
+
+        // Test: Line in the long function
+        let input = serde_json::to_value(GrepToolInput {
+            regex: "Line 12".to_string(),
+            include_pattern: Some("**/*.rs".to_string()),
+            offset: 0,
+            case_sensitive: false,
+        })
+        .unwrap();
+
+        let result = run_grep_tool(input, project.clone(), cx).await;
+        let expected = r#"
+            Found 1 matches:
+
+            ## Matches in root/test_syntax.rs
+
+            ### impl MyStruct › fn long_function › L41-45
+            ```
+                    println!("Line 10");
+                    println!("Line 11");
+                    println!("Line 12");
+                }
+            }
+            ```
+            "#
+        .unindent();
+        assert_eq!(result, expected);
+    }
+
     async fn run_grep_tool(
         input: serde_json::Value,
         project: Entity<Project>,
@@ -405,10 +743,16 @@ mod tests {
     ) -> String {
         let tool = Arc::new(GrepTool);
         let action_log = cx.new(|_cx| ActionLog::new(project.clone()));
-        let task = cx.update(|cx| tool.run(input, &[], project, action_log, cx));
+        let task = cx.update(|cx| tool.run(input, &[], project, action_log, None, cx));
 
         match task.output.await {
-            Ok(result) => result,
+            Ok(result) => {
+                if cfg!(windows) {
+                    result.replace("root\\", "root/")
+                } else {
+                    result
+                }
+            }
             Err(e) => panic!("Failed to run grep tool: {}", e),
         }
     }
@@ -421,4 +765,20 @@ mod tests {
             Project::init_settings(cx);
         });
     }
+
+    fn rust_lang() -> Language {
+        Language::new(
+            LanguageConfig {
+                name: "Rust".into(),
+                matcher: LanguageMatcher {
+                    path_suffixes: vec!["rs".to_string()],
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            Some(tree_sitter_rust::LANGUAGE.into()),
+        )
+        .with_outline_query(include_str!("../../languages/src/rust/outline.scm"))
+        .unwrap()
+    }
 }

crates/assistant_tools/src/list_directory_tool.rs

@@ -1,14 +1,14 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Write, path::Path, sync::Arc};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ListDirectoryToolInput {
@@ -63,7 +63,7 @@ impl Tool for ListDirectoryTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<ListDirectoryToolInput>(input.clone()) {
             Ok(input) => {
-                let path = MarkdownString::inline_code(&input.path);
+                let path = MarkdownInlineCode(&input.path);
                 format!("List the {path} directory's contents")
             }
             Err(_) => "List directory".to_string(),
@@ -76,6 +76,7 @@ impl Tool for ListDirectoryTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<ListDirectoryToolInput>(input) {

crates/assistant_tools/src/list_directory_tool/description.md

@@ -1 +1 @@
-Lists files and directories in a given path. Prefer the `grep` or `path_search` tools when searching the codebase.
+Lists files and directories in a given path. Prefer the `grep` or `find_path` tools when searching the codebase.

crates/assistant_tools/src/move_path_tool.rs

@@ -1,14 +1,14 @@
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, AppContext, Entity, Task};
+use gpui::{AnyWindowHandle, App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{path::Path, sync::Arc};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct MovePathToolInput {
@@ -61,8 +61,8 @@ impl Tool for MovePathTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<MovePathToolInput>(input.clone()) {
             Ok(input) => {
-                let src = MarkdownString::inline_code(&input.source_path);
-                let dest = MarkdownString::inline_code(&input.destination_path);
+                let src = MarkdownInlineCode(&input.source_path);
+                let dest = MarkdownInlineCode(&input.destination_path);
                 let src_path = Path::new(&input.source_path);
                 let dest_path = Path::new(&input.destination_path);
 
@@ -71,7 +71,7 @@ impl Tool for MovePathTool {
                     .and_then(|os_str| os_str.to_os_string().into_string().ok())
                 {
                     Some(filename) if src_path.parent() == dest_path.parent() => {
-                        let filename = MarkdownString::inline_code(&filename);
+                        let filename = MarkdownInlineCode(&filename);
                         format!("Rename {src} to {filename}")
                     }
                     _ => {
@@ -89,6 +89,7 @@ impl Tool for MovePathTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<MovePathToolInput>(input) {

crates/assistant_tools/src/now_tool.rs

@@ -4,7 +4,7 @@ use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
 use chrono::{Local, Utc};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
@@ -59,6 +59,7 @@ impl Tool for NowTool {
         _messages: &[LanguageModelRequestMessage],
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         _cx: &mut App,
     ) -> ToolResult {
         let input: NowToolInput = match serde_json::from_value(input) {

crates/assistant_tools/src/open_tool.rs

@@ -1,14 +1,14 @@
 use crate::schema::json_schema_for;
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, AppContext, Entity, Task};
+use gpui::{AnyWindowHandle, 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;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownEscaped;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct OpenToolInput {
@@ -41,7 +41,7 @@ impl Tool for OpenTool {
 
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<OpenToolInput>(input.clone()) {
-            Ok(input) => format!("Open `{}`", MarkdownString::escape(&input.path_or_url)),
+            Ok(input) => format!("Open `{}`", MarkdownEscaped(&input.path_or_url)),
             Err(_) => "Open file or URL".to_string(),
         }
     }
@@ -52,6 +52,7 @@ impl Tool for OpenTool {
         _messages: &[LanguageModelRequestMessage],
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input: OpenToolInput = match serde_json::from_value(input) {

crates/assistant_tools/src/path_search_tool.rs

@@ -1,200 +0,0 @@
-use crate::schema::json_schema_for;
-use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, AppContext, Entity, Task};
-use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
-use project::Project;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::{cmp, fmt::Write as _, path::PathBuf, sync::Arc};
-use ui::IconName;
-use util::paths::PathMatcher;
-use worktree::Snapshot;
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct PathSearchToolInput {
-    /// The glob to match against every path in the project.
-    ///
-    /// <example>
-    /// If the project has the following root directories:
-    ///
-    /// - directory1/a/something.txt
-    /// - directory2/a/things.txt
-    /// - directory3/a/other.txt
-    ///
-    /// You can get back the first two paths by providing a glob of "*thing*.txt"
-    /// </example>
-    pub glob: String,
-
-    /// Optional starting position for paginated results (0-based).
-    /// When not provided, starts from the beginning.
-    #[serde(default)]
-    pub offset: u32,
-}
-
-const RESULTS_PER_PAGE: usize = 50;
-
-pub struct PathSearchTool;
-
-impl Tool for PathSearchTool {
-    fn name(&self) -> String {
-        "path_search".into()
-    }
-
-    fn needs_confirmation(&self, _: &serde_json::Value, _: &App) -> bool {
-        false
-    }
-
-    fn description(&self) -> String {
-        include_str!("./path_search_tool/description.md").into()
-    }
-
-    fn icon(&self) -> IconName {
-        IconName::SearchCode
-    }
-
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
-        json_schema_for::<PathSearchToolInput>(format)
-    }
-
-    fn ui_text(&self, input: &serde_json::Value) -> String {
-        match serde_json::from_value::<PathSearchToolInput>(input.clone()) {
-            Ok(input) => format!("Find paths matching “`{}`”", input.glob),
-            Err(_) => "Search paths".to_string(),
-        }
-    }
-
-    fn run(
-        self: Arc<Self>,
-        input: serde_json::Value,
-        _messages: &[LanguageModelRequestMessage],
-        project: Entity<Project>,
-        _action_log: Entity<ActionLog>,
-        cx: &mut App,
-    ) -> ToolResult {
-        let (offset, glob) = match serde_json::from_value::<PathSearchToolInput>(input) {
-            Ok(input) => (input.offset, input.glob),
-            Err(err) => return Task::ready(Err(anyhow!(err))).into(),
-        };
-        let offset = offset as usize;
-        let task = search_paths(&glob, project, cx);
-        cx.background_spawn(async move {
-            let matches = task.await?;
-            let paginated_matches = &matches[cmp::min(offset, matches.len())
-                ..cmp::min(offset + RESULTS_PER_PAGE, matches.len())];
-
-            if matches.is_empty() {
-                Ok("No matches found".to_string())
-            } else {
-                let mut message = format!("Found {} total matches.", matches.len());
-                if matches.len() > RESULTS_PER_PAGE {
-                    write!(
-                        &mut message,
-                        "\nShowing results {}-{} (provide 'offset' parameter for more results):",
-                        offset + 1,
-                        offset + paginated_matches.len()
-                    )
-                    .unwrap();
-                }
-                for mat in matches.into_iter().skip(offset).take(RESULTS_PER_PAGE) {
-                    write!(&mut message, "\n{}", mat.display()).unwrap();
-                }
-                Ok(message)
-            }
-        })
-        .into()
-    }
-}
-
-fn search_paths(glob: &str, project: Entity<Project>, cx: &mut App) -> Task<Result<Vec<PathBuf>>> {
-    let path_matcher = match PathMatcher::new([
-        // Sometimes models try to search for "". In this case, return all paths in the project.
-        if glob.is_empty() { "*" } else { glob },
-    ]) {
-        Ok(matcher) => matcher,
-        Err(err) => return Task::ready(Err(anyhow!("Invalid glob: {err}"))),
-    };
-    let snapshots: Vec<Snapshot> = project
-        .read(cx)
-        .worktrees(cx)
-        .map(|worktree| worktree.read(cx).snapshot())
-        .collect();
-
-    cx.background_spawn(async move {
-        Ok(snapshots
-            .iter()
-            .flat_map(|snapshot| {
-                let root_name = PathBuf::from(snapshot.root_name());
-                snapshot
-                    .entries(false, 0)
-                    .map(move |entry| root_name.join(&entry.path))
-                    .filter(|path| path_matcher.is_match(&path))
-            })
-            .collect())
-    })
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use gpui::TestAppContext;
-    use project::{FakeFs, Project};
-    use settings::SettingsStore;
-    use util::path;
-
-    #[gpui::test]
-    async fn test_path_search_tool(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        let fs = FakeFs::new(cx.executor());
-        fs.insert_tree(
-            "/root",
-            serde_json::json!({
-                "apple": {
-                    "banana": {
-                        "carrot": "1",
-                    },
-                    "bandana": {
-                        "carbonara": "2",
-                    },
-                    "endive": "3"
-                }
-            }),
-        )
-        .await;
-        let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
-
-        let matches = cx
-            .update(|cx| search_paths("root/**/car*", project.clone(), cx))
-            .await
-            .unwrap();
-        assert_eq!(
-            matches,
-            &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
-            ]
-        );
-
-        let matches = cx
-            .update(|cx| search_paths("**/car*", project.clone(), cx))
-            .await
-            .unwrap();
-        assert_eq!(
-            matches,
-            &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
-            ]
-        );
-    }
-
-    fn init_test(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            language::init(cx);
-            Project::init_settings(cx);
-        });
-    }
-}

crates/assistant_tools/src/read_file_tool.rs

@@ -1,7 +1,8 @@
 use crate::{code_symbols_tool::file_outline, schema::json_schema_for};
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
+
 use indoc::formatdoc;
 use itertools::Itertools;
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
@@ -10,7 +11,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 /// If the model requests to read a file whose size exceeds this, then
 /// the tool will return an error along with the model's symbol outline,
@@ -39,7 +40,7 @@ pub struct ReadFileToolInput {
     #[serde(default)]
     pub start_line: Option<usize>,
 
-    /// Optional line number to end reading on (1-based index)
+    /// Optional line number to end reading on (1-based index, inclusive)
     #[serde(default)]
     pub end_line: Option<usize>,
 }
@@ -70,7 +71,7 @@ impl Tool for ReadFileTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<ReadFileToolInput>(input.clone()) {
             Ok(input) => {
-                let path = MarkdownString::inline_code(&input.path);
+                let path = MarkdownInlineCode(&input.path);
                 match (input.start_line, input.end_line) {
                     (Some(start), None) => format!("Read file {path} (from line {start})"),
                     (Some(start), Some(end)) => format!("Read file {path} (lines {start}-{end})"),
@@ -87,6 +88,7 @@ impl Tool for ReadFileTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<ReadFileToolInput>(input) {
@@ -126,7 +128,7 @@ impl Tool for ReadFileTool {
                     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
+                        let count = end.saturating_sub(start).saturating_add(1); // Ensure at least 1 line
                         Itertools::intersperse(lines.take(count), "\n").collect()
                     } else {
                         Itertools::intersperse(lines, "\n").collect()
@@ -193,7 +195,7 @@ mod test {
                     "path": "root/nonexistent_file.txt"
                 });
                 Arc::new(ReadFileTool)
-                    .run(input, &[], project.clone(), action_log, cx)
+                    .run(input, &[], project.clone(), action_log, None, cx)
                     .output
             })
             .await;
@@ -223,7 +225,7 @@ mod test {
                     "path": "root/small_file.txt"
                 });
                 Arc::new(ReadFileTool)
-                    .run(input, &[], project.clone(), action_log, cx)
+                    .run(input, &[], project.clone(), action_log, None, cx)
                     .output
             })
             .await;
@@ -253,7 +255,7 @@ mod test {
                     "path": "root/large_file.rs"
                 });
                 Arc::new(ReadFileTool)
-                    .run(input, &[], project.clone(), action_log.clone(), cx)
+                    .run(input, &[], project.clone(), action_log.clone(), None, cx)
                     .output
             })
             .await;
@@ -277,7 +279,7 @@ mod test {
                     "offset": 1
                 });
                 Arc::new(ReadFileTool)
-                    .run(input, &[], project.clone(), action_log, cx)
+                    .run(input, &[], project.clone(), action_log, None, cx)
                     .output
             })
             .await;
@@ -323,11 +325,11 @@ mod test {
                     "end_line": 4
                 });
                 Arc::new(ReadFileTool)
-                    .run(input, &[], project.clone(), action_log, cx)
+                    .run(input, &[], project.clone(), action_log, None, cx)
                     .output
             })
             .await;
-        assert_eq!(result.unwrap(), "Line 2\nLine 3");
+        assert_eq!(result.unwrap(), "Line 2\nLine 3\nLine 4");
     }
 
     fn init_test(cx: &mut TestAppContext) {

crates/assistant_tools/src/rename_tool.rs

@@ -1,6 +1,6 @@
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use language::{self, Buffer, ToPointUtf16};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -87,6 +87,7 @@ impl Tool for RenameTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<RenameToolInput>(input) {

crates/assistant_tools/src/symbol_info_tool.rs

@@ -1,6 +1,6 @@
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, AsyncApp, Entity, Task};
+use gpui::{AnyWindowHandle, App, AsyncApp, Entity, Task};
 use language::{self, Anchor, Buffer, BufferSnapshot, Location, Point, ToPoint, ToPointUtf16};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -8,7 +8,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Write, ops::Range, sync::Arc};
 use ui::IconName;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownInlineCode;
 
 use crate::schema::json_schema_for;
 
@@ -91,7 +91,7 @@ impl Tool for SymbolInfoTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         match serde_json::from_value::<SymbolInfoToolInput>(input.clone()) {
             Ok(input) => {
-                let symbol = MarkdownString::inline_code(&input.symbol);
+                let symbol = MarkdownInlineCode(&input.symbol);
 
                 match input.command {
                     Info::Definition => {
@@ -121,6 +121,7 @@ impl Tool for SymbolInfoTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<SymbolInfoToolInput>(input) {

crates/assistant_tools/src/terminal_tool.rs

@@ -1,23 +1,32 @@
 use crate::schema::json_schema_for;
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool, ToolResult};
-use futures::io::BufReader;
-use futures::{AsyncBufReadExt, AsyncReadExt, FutureExt};
-use gpui::{App, AppContext, Entity, Task};
+use assistant_tool::{ActionLog, Tool, ToolCard, ToolResult, ToolUseStatus};
+use gpui::{
+    Animation, AnimationExt, AnyWindowHandle, App, AppContext, Empty, Entity, EntityId, Task,
+    Transformation, WeakEntity, Window, percentage,
+};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
-use project::Project;
+use project::{Project, terminals::TerminalKind};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::future;
-use util::get_system_shell;
+use std::{
+    env,
+    path::{Path, PathBuf},
+    process::ExitStatus,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+use terminal_view::TerminalView;
+use ui::{Disclosure, IconName, Tooltip, prelude::*};
+use util::{
+    get_system_shell, markdown::MarkdownInlineCode, size::format_file_size,
+    time::duration_alt_display,
+};
+use workspace::Workspace;
 
-use std::path::Path;
-use std::sync::Arc;
-use ui::IconName;
-use util::command::new_smol_command;
-use util::markdown::MarkdownString;
+const COMMAND_OUTPUT_LIMIT: usize = 16 * 1024;
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct TerminalToolInput {
     /// The one-liner command to execute.
     command: String,
@@ -55,17 +64,14 @@ impl Tool for TerminalTool {
                 let first_line = lines.next().unwrap_or_default();
                 let remaining_line_count = lines.count();
                 match remaining_line_count {
-                    0 => MarkdownString::inline_code(&first_line).0,
-                    1 => {
-                        MarkdownString::inline_code(&format!(
-                            "{} - {} more line",
-                            first_line, remaining_line_count
-                        ))
-                        .0
-                    }
-                    n => {
-                        MarkdownString::inline_code(&format!("{} - {} more lines", first_line, n)).0
-                    }
+                    0 => MarkdownInlineCode(&first_line).to_string(),
+                    1 => MarkdownInlineCode(&format!(
+                        "{} - {} more line",
+                        first_line, remaining_line_count
+                    ))
+                    .to_string(),
+                    n => MarkdownInlineCode(&format!("{} - {} more lines", first_line, n))
+                        .to_string(),
                 }
             }
             Err(_) => "Run terminal command".to_string(),
@@ -78,294 +84,426 @@ impl Tool for TerminalTool {
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
+        let Some(window) = window else {
+            return Task::ready(Err(anyhow!("no window options"))).into();
+        };
+
         let input: TerminalToolInput = match serde_json::from_value(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))).into(),
         };
 
-        let project = project.read(cx);
         let input_path = Path::new(&input.cd);
-        let working_dir = if input.cd == "." {
-            // Accept "." as meaning "the one worktree" if we only have one worktree.
-            let mut worktrees = project.worktrees(cx);
-
-            let only_worktree = match worktrees.next() {
-                Some(worktree) => worktree,
-                None => {
-                    return Task::ready(Err(anyhow!("No worktrees found in the project"))).into();
-                }
-            };
-
-            if worktrees.next().is_some() {
-                return Task::ready(Err(anyhow!(
-                    "'.' is ambiguous in multi-root workspaces. Please specify a root directory explicitly."
-                ))).into();
-            }
-
-            only_worktree.read(cx).abs_path()
-        } else if input_path.is_absolute() {
-            // Absolute paths are allowed, but only if they're in one of the project's worktrees.
-            if !project
-                .worktrees(cx)
-                .any(|worktree| input_path.starts_with(&worktree.read(cx).abs_path()))
-            {
-                return Task::ready(Err(anyhow!(
-                    "The absolute path must be within one of the project's worktrees"
-                )))
-                .into();
-            }
-
-            input_path.into()
-        } else {
-            let Some(worktree) = project.worktree_for_root_name(&input.cd, cx) else {
-                return Task::ready(Err(anyhow!(
-                    "`cd` directory {} not found in the project",
-                    &input.cd
-                )))
-                .into();
-            };
-
-            worktree.read(cx).abs_path()
+        let working_dir = match working_dir(cx, &input, &project, input_path) {
+            Ok(dir) => dir,
+            Err(err) => return Task::ready(Err(anyhow!(err))).into(),
         };
+        let terminal = project.update(cx, |project, cx| {
+            project.create_terminal(
+                TerminalKind::Task(task::SpawnInTerminal {
+                    command: get_system_shell(),
+                    args: vec!["-c".into(), input.command.clone()],
+                    cwd: working_dir.clone(),
+                    ..Default::default()
+                }),
+                window,
+                cx,
+            )
+        });
 
-        cx.background_spawn(run_command_limited(working_dir, input.command))
-            .into()
+        let card = cx.new(|cx| {
+            TerminalToolCard::new(input.command.clone(), working_dir.clone(), cx.entity_id())
+        });
+
+        let output = cx.spawn({
+            let card = card.clone();
+            async move |cx| {
+                let terminal = terminal.await?;
+                let workspace = window
+                    .downcast::<Workspace>()
+                    .and_then(|handle| handle.entity(cx).ok())
+                    .context("no workspace entity in root of window")?;
+
+                let terminal_view = window.update(cx, |_, window, cx| {
+                    cx.new(|cx| {
+                        TerminalView::new(
+                            terminal.clone(),
+                            workspace.downgrade(),
+                            None,
+                            project.downgrade(),
+                            window,
+                            cx,
+                        )
+                    })
+                })?;
+                let _ = card.update(cx, |card, _| {
+                    card.terminal = Some(terminal_view.clone());
+                    card.start_instant = Instant::now();
+                });
+
+                let exit_status = terminal
+                    .update(cx, |terminal, cx| terminal.wait_for_completed_task(cx))?
+                    .await;
+                let (content, content_line_count) = terminal.update(cx, |terminal, _| {
+                    (terminal.get_content(), terminal.total_lines())
+                })?;
+
+                let previous_len = content.len();
+                let (processed_content, finished_with_empty_output) =
+                    process_content(content, &input.command, exit_status);
+
+                let _ = card.update(cx, |card, _| {
+                    card.command_finished = true;
+                    card.exit_status = exit_status;
+                    card.was_content_truncated = processed_content.len() < previous_len;
+                    card.original_content_len = previous_len;
+                    card.content_line_count = content_line_count;
+                    card.finished_with_empty_output = finished_with_empty_output;
+                    card.elapsed_time = Some(card.start_instant.elapsed());
+                });
+
+                Ok(processed_content)
+            }
+        });
+
+        ToolResult {
+            output,
+            card: Some(card.into()),
+        }
     }
 }
 
-const LIMIT: usize = 16 * 1024;
+fn process_content(
+    content: String,
+    command: &str,
+    exit_status: Option<ExitStatus>,
+) -> (String, bool) {
+    let should_truncate = content.len() > COMMAND_OUTPUT_LIMIT;
 
-async fn run_command_limited(working_dir: Arc<Path>, command: String) -> Result<String> {
-    let shell = get_system_shell();
+    let content = if should_truncate {
+        let mut end_ix = COMMAND_OUTPUT_LIMIT.min(content.len());
+        while !content.is_char_boundary(end_ix) {
+            end_ix -= 1;
+        }
+        // Don't truncate mid-line, clear the remainder of the last line
+        end_ix = content[..end_ix].rfind('\n').unwrap_or(end_ix);
+        &content[..end_ix]
+    } else {
+        content.as_str()
+    };
+    let is_empty = content.trim().is_empty();
 
-    let mut cmd = new_smol_command(&shell)
-        .arg("-c")
-        .arg(&command)
-        .current_dir(working_dir)
-        .stdout(std::process::Stdio::piped())
-        .stderr(std::process::Stdio::piped())
-        .spawn()
-        .context("Failed to execute terminal command")?;
-
-    let mut combined_buffer = String::with_capacity(LIMIT + 1);
-
-    let mut out_reader = BufReader::new(cmd.stdout.take().context("Failed to get stdout")?);
-    let mut out_tmp_buffer = String::with_capacity(512);
-    let mut err_reader = BufReader::new(cmd.stderr.take().context("Failed to get stderr")?);
-    let mut err_tmp_buffer = String::with_capacity(512);
-
-    let mut out_line = Box::pin(
-        out_reader
-            .read_line(&mut out_tmp_buffer)
-            .left_future()
-            .fuse(),
-    );
-    let mut err_line = Box::pin(
-        err_reader
-            .read_line(&mut err_tmp_buffer)
-            .left_future()
-            .fuse(),
+    let content = format!(
+        "```\n{}{}```",
+        content,
+        if content.ends_with('\n') { "" } else { "\n" }
     );
 
-    let mut has_stdout = true;
-    let mut has_stderr = true;
-    while (has_stdout || has_stderr) && combined_buffer.len() < LIMIT + 1 {
-        futures::select_biased! {
-            read = out_line => {
-                drop(out_line);
-                combined_buffer.extend(out_tmp_buffer.drain(..));
-                if read? == 0 {
-                    out_line = Box::pin(future::pending().right_future().fuse());
-                    has_stdout = false;
-                } else {
-                    out_line = Box::pin(out_reader.read_line(&mut out_tmp_buffer).left_future().fuse());
-                }
-            }
-            read = err_line => {
-                drop(err_line);
-                combined_buffer.extend(err_tmp_buffer.drain(..));
-                if read? == 0 {
-                    err_line = Box::pin(future::pending().right_future().fuse());
-                    has_stderr = false;
-                } else {
-                    err_line = Box::pin(err_reader.read_line(&mut err_tmp_buffer).left_future().fuse());
-                }
-            }
-        };
-    }
-
-    drop((out_line, err_line));
-
-    let truncated = combined_buffer.len() > LIMIT;
-    combined_buffer.truncate(LIMIT);
-
-    consume_reader(out_reader, truncated).await?;
-    consume_reader(err_reader, truncated).await?;
-
-    let status = cmd.status().await.context("Failed to get command status")?;
-
-    let output_string = if truncated {
-        // Valid to find `\n` in UTF-8 since 0-127 ASCII characters are not used in
-        // multi-byte characters.
-        let last_line_ix = combined_buffer.bytes().rposition(|b| b == b'\n');
-        let combined_buffer = &combined_buffer[..last_line_ix.unwrap_or(combined_buffer.len())];
-
+    let content = if should_truncate {
         format!(
             "Command output too long. The first {} bytes:\n\n{}",
-            combined_buffer.len(),
-            output_block(&combined_buffer),
+            content.len(),
+            content,
         )
     } else {
-        output_block(&combined_buffer)
+        content
     };
 
-    let output_with_status = if status.success() {
-        if output_string.is_empty() {
-            "Command executed successfully.".to_string()
-        } else {
-            output_string.to_string()
+    let content = match exit_status {
+        Some(exit_status) if exit_status.success() => {
+            if is_empty {
+                "Command executed successfully.".to_string()
+            } else {
+                content.to_string()
+            }
         }
+        Some(exit_status) => {
+            let code = exit_status.code().unwrap_or(-1);
+            if is_empty {
+                format!("Command \"{command}\" failed with exit code {code}.")
+            } else {
+                format!("Command \"{command}\" failed with exit code {code}.\n\n{content}")
+            }
+        }
+        None => {
+            format!(
+                "Command failed or was interrupted.\nPartial output captured:\n\n{}",
+                content,
+            )
+        }
+    };
+    (content, is_empty)
+}
+
+fn working_dir(
+    cx: &mut App,
+    input: &TerminalToolInput,
+    project: &Entity<Project>,
+    input_path: &Path,
+) -> Result<Option<PathBuf>, &'static str> {
+    let project = project.read(cx);
+
+    if input.cd == "." {
+        // Accept "." as meaning "the one worktree" if we only have one worktree.
+        let mut worktrees = project.worktrees(cx);
+
+        match worktrees.next() {
+            Some(worktree) => {
+                if worktrees.next().is_some() {
+                    return Err(
+                        "'.' is ambiguous in multi-root workspaces. Please specify a root directory explicitly.",
+                    );
+                }
+                Ok(Some(worktree.read(cx).abs_path().to_path_buf()))
+            }
+            None => Ok(None),
+        }
+    } else if input_path.is_absolute() {
+        // Absolute paths are allowed, but only if they're in one of the project's worktrees.
+        if !project
+            .worktrees(cx)
+            .any(|worktree| input_path.starts_with(&worktree.read(cx).abs_path()))
+        {
+            return Err("The absolute path must be within one of the project's worktrees");
+        }
+
+        Ok(Some(input_path.into()))
     } else {
-        format!(
-            "Command failed with exit code {} (shell: {}).\n\n{}",
-            status.code().unwrap_or(-1),
-            shell,
-            output_string,
-        )
-    };
+        let Some(worktree) = project.worktree_for_root_name(&input.cd, cx) else {
+            return Err("`cd` directory {} not found in the project");
+        };
 
-    Ok(output_with_status)
+        Ok(Some(worktree.read(cx).abs_path().to_path_buf()))
+    }
 }
 
-async fn consume_reader<T: AsyncReadExt + Unpin>(
-    mut reader: BufReader<T>,
-    truncated: bool,
-) -> Result<(), std::io::Error> {
-    loop {
-        let skipped_bytes = reader.fill_buf().await?;
-        if skipped_bytes.is_empty() {
-            break;
+struct TerminalToolCard {
+    input_command: String,
+    working_dir: Option<PathBuf>,
+    entity_id: EntityId,
+    exit_status: Option<ExitStatus>,
+    terminal: Option<Entity<TerminalView>>,
+    command_finished: bool,
+    was_content_truncated: bool,
+    finished_with_empty_output: bool,
+    content_line_count: usize,
+    original_content_len: usize,
+    preview_expanded: bool,
+    start_instant: Instant,
+    elapsed_time: Option<Duration>,
+}
+
+impl TerminalToolCard {
+    pub fn new(input_command: String, working_dir: Option<PathBuf>, entity_id: EntityId) -> Self {
+        Self {
+            input_command,
+            working_dir,
+            entity_id,
+            exit_status: None,
+            terminal: None,
+            command_finished: false,
+            was_content_truncated: false,
+            finished_with_empty_output: false,
+            original_content_len: 0,
+            content_line_count: 0,
+            preview_expanded: true,
+            start_instant: Instant::now(),
+            elapsed_time: None,
         }
-        let skipped_bytes_len = skipped_bytes.len();
-        reader.consume_unpin(skipped_bytes_len);
-
-        // Should only skip if we went over the limit
-        debug_assert!(truncated);
-    }
-    Ok(())
-}
-
-fn output_block(output: &str) -> String {
-    format!(
-        "```\n{}{}```",
-        output,
-        if output.ends_with('\n') { "" } else { "\n" }
-    )
-}
-
-#[cfg(test)]
-#[cfg(not(windows))]
-mod tests {
-    use gpui::TestAppContext;
-
-    use super::*;
-
-    #[gpui::test(iterations = 10)]
-    async fn test_run_command_simple(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        let result =
-            run_command_limited(Path::new(".").into(), "echo 'Hello, World!'".to_string()).await;
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "```\nHello, World!\n```");
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_interleaved_stdout_stderr(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        let command = "echo 'stdout 1' && sleep 0.01 && echo 'stderr 1' >&2 && sleep 0.01 && echo 'stdout 2' && sleep 0.01 && echo 'stderr 2' >&2";
-        let result = run_command_limited(Path::new(".").into(), command.to_string()).await;
-
-        assert!(result.is_ok());
-        assert_eq!(
-            result.unwrap(),
-            "```\nstdout 1\nstderr 1\nstdout 2\nstderr 2\n```"
-        );
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_multiple_output_reads(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        // Command with multiple outputs that might require multiple reads
-        let result = run_command_limited(
-            Path::new(".").into(),
-            "echo '1'; sleep 0.01; echo '2'; sleep 0.01; echo '3'".to_string(),
-        )
-        .await;
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "```\n1\n2\n3\n```");
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_output_truncation_single_line(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        let cmd = format!("echo '{}'; sleep 0.01;", "X".repeat(LIMIT * 2));
-
-        let result = run_command_limited(Path::new(".").into(), cmd).await;
-
-        assert!(result.is_ok());
-        let output = result.unwrap();
-
-        let content_start = output.find("```\n").map(|i| i + 4).unwrap_or(0);
-        let content_end = output.rfind("\n```").unwrap_or(output.len());
-        let content_length = content_end - content_start;
-
-        // Output should be exactly the limit
-        assert_eq!(content_length, LIMIT);
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_output_truncation_multiline(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        let cmd = format!("echo '{}'; ", "X".repeat(120)).repeat(160);
-        let result = run_command_limited(Path::new(".").into(), cmd).await;
-
-        assert!(result.is_ok());
-        let output = result.unwrap();
-
-        assert!(output.starts_with("Command output too long. The first 16334 bytes:\n\n"));
-
-        let content_start = output.find("```\n").map(|i| i + 4).unwrap_or(0);
-        let content_end = output.rfind("\n```").unwrap_or(output.len());
-        let content_length = content_end - content_start;
-
-        assert!(content_length <= LIMIT);
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_command_failure(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        let result = run_command_limited(Path::new(".").into(), "exit 42".to_string()).await;
-
-        assert!(result.is_ok());
-        let output = result.unwrap();
-
-        // Extract the shell name from path for cleaner test output
-        let shell_path = std::env::var("SHELL").unwrap_or("bash".to_string());
-
-        let expected_output = format!(
-            "Command failed with exit code 42 (shell: {}).\n\n```\n\n```",
-            shell_path
-        );
-        assert_eq!(output, expected_output);
+    }
+}
+
+impl ToolCard for TerminalToolCard {
+    fn render(
+        &mut self,
+        status: &ToolUseStatus,
+        _window: &mut Window,
+        _workspace: WeakEntity<Workspace>,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let Some(terminal) = self.terminal.as_ref() else {
+            return Empty.into_any();
+        };
+
+        let tool_failed = matches!(status, ToolUseStatus::Error(_));
+        let command_failed =
+            self.command_finished && self.exit_status.is_none_or(|code| !code.success());
+        if (tool_failed || command_failed) && self.elapsed_time.is_none() {
+            self.elapsed_time = Some(self.start_instant.elapsed());
+        }
+        let time_elapsed = self
+            .elapsed_time
+            .unwrap_or_else(|| self.start_instant.elapsed());
+        let should_hide_terminal =
+            tool_failed || self.finished_with_empty_output || !self.preview_expanded;
+
+        let border_color = cx.theme().colors().border.opacity(0.6);
+        let header_bg = cx
+            .theme()
+            .colors()
+            .element_background
+            .blend(cx.theme().colors().editor_foreground.opacity(0.025));
+
+        let header_label = h_flex()
+            .w_full()
+            .max_w_full()
+            .px_1()
+            .gap_0p5()
+            .opacity(0.8)
+            .child(
+                h_flex()
+                    .child(
+                        Icon::new(IconName::Terminal)
+                            .size(IconSize::XSmall)
+                            .color(Color::Muted),
+                    )
+                    .child(
+                        div()
+                            .id(("terminal-tool-header-input-command", self.entity_id))
+                            .text_size(rems(0.8125))
+                            .font_buffer(cx)
+                            .child(self.input_command.clone())
+                            .ml_1p5()
+                            .mr_0p5()
+                            .tooltip({
+                                let path = self
+                                    .working_dir
+                                    .as_ref()
+                                    .cloned()
+                                    .or_else(|| env::current_dir().ok())
+                                    .map(|path| format!("\"{}\"", path.display()))
+                                    .unwrap_or_else(|| "current directory".to_string());
+                                Tooltip::text(if self.command_finished {
+                                    format!("Ran in {path}")
+                                } else {
+                                    format!("Running in {path}")
+                                })
+                            }),
+                    ),
+            )
+            .into_any_element();
+
+        let header = h_flex()
+            .flex_none()
+            .p_1()
+            .gap_1()
+            .justify_between()
+            .rounded_t_md()
+            .bg(header_bg)
+            .child(header_label)
+            .map(|header| {
+                let header = header
+                    .when(self.was_content_truncated, |header| {
+                        let tooltip =
+                            if self.content_line_count + 10 > terminal::MAX_SCROLL_HISTORY_LINES {
+                                "Output exceeded terminal max lines and was \
+                                truncated, the model received the first 16 KB."
+                                    .to_string()
+                            } else {
+                                format!(
+                                    "Output is {} long, to avoid unexpected token usage, \
+                                    only 16 KB was sent back to the model.",
+                                    format_file_size(self.original_content_len as u64, true),
+                                )
+                            };
+                        header.child(
+                            div()
+                                .id(("terminal-tool-truncated-label", self.entity_id))
+                                .tooltip(Tooltip::text(tooltip))
+                                .child(
+                                    Label::new("(truncated)")
+                                        .color(Color::Disabled)
+                                        .size(LabelSize::Small),
+                                ),
+                        )
+                    })
+                    .when(time_elapsed > Duration::from_secs(10), |header| {
+                        header.child(
+                            Label::new(format!("({})", duration_alt_display(time_elapsed)))
+                                .buffer_font(cx)
+                                .color(Color::Disabled)
+                                .size(LabelSize::Small),
+                        )
+                    });
+
+                if tool_failed || command_failed {
+                    header.child(
+                        div()
+                            .id(("terminal-tool-error-code-indicator", self.entity_id))
+                            .child(
+                                Icon::new(IconName::Close)
+                                    .size(IconSize::Small)
+                                    .color(Color::Error),
+                            )
+                            .when(command_failed && self.exit_status.is_some(), |this| {
+                                this.tooltip(Tooltip::text(format!(
+                                    "Exited with code {}",
+                                    self.exit_status
+                                        .and_then(|status| status.code())
+                                        .unwrap_or(-1),
+                                )))
+                            })
+                            .when(
+                                !command_failed && tool_failed && status.error().is_some(),
+                                |this| {
+                                    this.tooltip(Tooltip::text(format!(
+                                        "Error: {}",
+                                        status.error().unwrap(),
+                                    )))
+                                },
+                            ),
+                    )
+                } else if self.command_finished {
+                    header.child(
+                        Icon::new(IconName::Check)
+                            .size(IconSize::Small)
+                            .color(Color::Success),
+                    )
+                } else {
+                    header.child(
+                        Icon::new(IconName::ArrowCircle)
+                            .size(IconSize::Small)
+                            .color(Color::Info)
+                            .with_animation(
+                                "arrow-circle",
+                                Animation::new(Duration::from_secs(2)).repeat(),
+                                |icon, delta| {
+                                    icon.transform(Transformation::rotate(percentage(delta)))
+                                },
+                            ),
+                    )
+                }
+            })
+            .when(!tool_failed && !self.finished_with_empty_output, |header| {
+                header.child(
+                    Disclosure::new(
+                        ("terminal-tool-disclosure", self.entity_id),
+                        self.preview_expanded,
+                    )
+                    .opened_icon(IconName::ChevronUp)
+                    .closed_icon(IconName::ChevronDown)
+                    .on_click(cx.listener(
+                        move |this, _event, _window, _cx| {
+                            this.preview_expanded = !this.preview_expanded;
+                        },
+                    )),
+                )
+            });
+
+        v_flex()
+            .mb_2()
+            .border_1()
+            .when(tool_failed || command_failed, |card| card.border_dashed())
+            .border_color(border_color)
+            .rounded_lg()
+            .overflow_hidden()
+            .child(header)
+            .when(!should_hide_terminal, |this| {
+                this.child(div().child(terminal.clone()).min_h(px(250.0)))
+            })
+            .into_any()
     }
 }

crates/assistant_tools/src/terminal_tool/description.md

@@ -1,6 +1,8 @@
 Executes a shell one-liner and returns the combined output.
 
-This tool spawns a process using the user's current shell, combines stdout and stderr into one interleaved stream as they are produced (preserving the order of writes), and captures that stream into a string which is returned.
+This tool spawns a process using the user's shell, reads from stdout and stderr (preserving the order of writes), and returns a string with the combined output result.
+
+The output results will be shown to the user already, only list it again if necessary, avoid being redundant.
 
 Make sure you use the `cd` parameter to navigate to one of the root directories of the project. NEVER do it as part of the `command` itself, otherwise it will error.
 

crates/assistant_tools/src/thinking_tool.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolResult};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
@@ -50,6 +50,7 @@ impl Tool for ThinkingTool {
         _messages: &[LanguageModelRequestMessage],
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         _cx: &mut App,
     ) -> ToolResult {
         // This tool just "thinks out loud" and doesn't perform any actions.

crates/assistant_tools/src/ui/tool_call_card_header.rs

@@ -1,4 +1,4 @@
-use gpui::{Animation, AnimationExt, App, IntoElement, pulsating_between};
+use gpui::{Animation, AnimationExt, AnyElement, App, IntoElement, pulsating_between};
 use std::time::Duration;
 use ui::{Tooltip, prelude::*};
 
@@ -8,6 +8,8 @@ pub struct ToolCallCardHeader {
     icon: IconName,
     primary_text: SharedString,
     secondary_text: Option<SharedString>,
+    code_path: Option<SharedString>,
+    disclosure_slot: Option<AnyElement>,
     is_loading: bool,
     error: Option<String>,
 }
@@ -18,6 +20,8 @@ impl ToolCallCardHeader {
             icon,
             primary_text: primary_text.into(),
             secondary_text: None,
+            code_path: None,
+            disclosure_slot: None,
             is_loading: false,
             error: None,
         }
@@ -28,6 +32,16 @@ impl ToolCallCardHeader {
         self
     }
 
+    pub fn with_code_path(mut self, text: impl Into<SharedString>) -> Self {
+        self.code_path = Some(text.into());
+        self
+    }
+
+    pub fn disclosure_slot(mut self, element: impl IntoElement) -> Self {
+        self.disclosure_slot = Some(element.into_any_element());
+        self
+    }
+
     pub fn loading(mut self) -> Self {
         self.is_loading = true;
         self
@@ -42,26 +56,36 @@ impl ToolCallCardHeader {
 impl RenderOnce for ToolCallCardHeader {
     fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
         let font_size = rems(0.8125);
+        let line_height = window.line_height();
+
         let secondary_text = self.secondary_text;
+        let code_path = self.code_path;
+
+        let bullet_divider = || {
+            div()
+                .size(px(3.))
+                .rounded_full()
+                .bg(cx.theme().colors().text)
+        };
 
         h_flex()
             .id("tool-label-container")
-            .gap_1p5()
+            .gap_2()
             .max_w_full()
             .overflow_x_scroll()
             .opacity(0.8)
-            .child(
-                h_flex().h(window.line_height()).justify_center().child(
-                    Icon::new(self.icon)
-                        .size(IconSize::XSmall)
-                        .color(Color::Muted),
-                ),
-            )
             .child(
                 h_flex()
-                    .h(window.line_height())
+                    .h(line_height)
                     .gap_1p5()
                     .text_size(font_size)
+                    .child(
+                        h_flex().h(line_height).justify_center().child(
+                            Icon::new(self.icon)
+                                .size(IconSize::XSmall)
+                                .color(Color::Muted),
+                        ),
+                    )
                     .map(|this| {
                         if let Some(error) = &self.error {
                             this.child(format!("{} failed", self.primary_text)).child(
@@ -76,13 +100,15 @@ impl RenderOnce for ToolCallCardHeader {
                         }
                     })
                     .when_some(secondary_text, |this, secondary_text| {
-                        this.child(
-                            div()
-                                .size(px(3.))
-                                .rounded_full()
-                                .bg(cx.theme().colors().text),
+                        this.child(bullet_divider())
+                            .child(div().text_size(font_size).child(secondary_text.clone()))
+                    })
+                    .when_some(code_path, |this, code_path| {
+                        this.child(bullet_divider()).child(
+                            Label::new(code_path.clone())
+                                .size(LabelSize::Small)
+                                .inline_code(cx),
                         )
-                        .child(div().text_size(font_size).child(secondary_text.clone()))
                     })
                     .with_animation(
                         "loading-label",
@@ -98,5 +124,11 @@ impl RenderOnce for ToolCallCardHeader {
                         },
                     ),
             )
+            .when_some(self.disclosure_slot, |container, disclosure_slot| {
+                container
+                    .group("disclosure")
+                    .justify_between()
+                    .child(div().visible_on_hover("disclosure").child(disclosure_slot))
+            })
     }
 }

crates/assistant_tools/src/web_search_tool.rs

@@ -5,13 +5,16 @@ use crate::ui::ToolCallCardHeader;
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::{ActionLog, Tool, ToolCard, ToolResult, ToolUseStatus};
 use futures::{Future, FutureExt, TryFutureExt};
-use gpui::{App, AppContext, Context, Entity, IntoElement, Task, Window};
+use gpui::{
+    AnyWindowHandle, App, AppContext, Context, Entity, IntoElement, Task, WeakEntity, Window,
+};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use ui::{IconName, Tooltip, prelude::*};
 use web_search::WebSearchRegistry;
+use workspace::Workspace;
 use zed_llm_client::{WebSearchCitation, WebSearchResponse};
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -20,7 +23,6 @@ pub struct WebSearchToolInput {
     query: String,
 }
 
-#[derive(RegisterComponent)]
 pub struct WebSearchTool;
 
 impl Tool for WebSearchTool {
@@ -54,6 +56,7 @@ impl Tool for WebSearchTool {
         _messages: &[LanguageModelRequestMessage],
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         let input = match serde_json::from_value::<WebSearchToolInput>(input) {
@@ -80,6 +83,7 @@ impl Tool for WebSearchTool {
     }
 }
 
+#[derive(RegisterComponent)]
 struct WebSearchToolCard {
     response: Option<Result<WebSearchResponse>>,
     _task: Task<()>,
@@ -111,6 +115,7 @@ impl ToolCard for WebSearchToolCard {
         &mut self,
         _status: &ToolUseStatus,
         _window: &mut Window,
+        _workspace: WeakEntity<Workspace>,
         cx: &mut Context<Self>,
     ) -> impl IntoElement {
         let header = match self.response.as_ref() {
@@ -180,15 +185,11 @@ impl ToolCard for WebSearchToolCard {
     }
 }
 
-impl Component for WebSearchTool {
+impl Component for WebSearchToolCard {
     fn scope() -> ComponentScope {
         ComponentScope::Agent
     }
 
-    fn sort_name() -> &'static str {
-        "ToolWebSearch"
-    }
-
     fn preview(window: &mut Window, cx: &mut App) -> Option<AnyElement> {
         let in_progress_search = cx.new(|cx| WebSearchToolCard {
             response: None,
@@ -220,8 +221,13 @@ impl Component for WebSearchTool {
                         div()
                             .size_full()
                             .child(in_progress_search.update(cx, |tool, cx| {
-                                tool.render(&ToolUseStatus::Pending, window, cx)
-                                    .into_any_element()
+                                tool.render(
+                                    &ToolUseStatus::Pending,
+                                    window,
+                                    WeakEntity::new_invalid(),
+                                    cx,
+                                )
+                                .into_any_element()
                             }))
                             .into_any_element(),
                     ),
@@ -230,8 +236,13 @@ impl Component for WebSearchTool {
                         div()
                             .size_full()
                             .child(successful_search.update(cx, |tool, cx| {
-                                tool.render(&ToolUseStatus::Finished("".into()), window, cx)
-                                    .into_any_element()
+                                tool.render(
+                                    &ToolUseStatus::Finished("".into()),
+                                    window,
+                                    WeakEntity::new_invalid(),
+                                    cx,
+                                )
+                                .into_any_element()
                             }))
                             .into_any_element(),
                     ),
@@ -240,8 +251,13 @@ impl Component for WebSearchTool {
                         div()
                             .size_full()
                             .child(error_search.update(cx, |tool, cx| {
-                                tool.render(&ToolUseStatus::Error("".into()), window, cx)
-                                    .into_any_element()
+                                tool.render(
+                                    &ToolUseStatus::Error("".into()),
+                                    window,
+                                    WeakEntity::new_invalid(),
+                                    cx,
+                                )
+                                .into_any_element()
                             }))
                             .into_any_element(),
                     ),

crates/bedrock/src/bedrock.rs

@@ -11,12 +11,14 @@ pub use aws_sdk_bedrockruntime::types::{
     Tool as BedrockTool, ToolChoice as BedrockToolChoice, ToolConfiguration as BedrockToolConfig,
     ToolInputSchema as BedrockToolInputSchema, ToolSpecification as BedrockToolSpec,
 };
+pub use aws_smithy_types::Blob as BedrockBlob;
 use aws_smithy_types::{Document, Number as AwsNumber};
 pub use bedrock::operation::converse_stream::ConverseStreamInput as BedrockStreamingRequest;
 pub use bedrock::types::{
     ContentBlock as BedrockRequestContent, ConversationRole as BedrockRole,
     ConverseOutput as BedrockResponse, ConverseStreamOutput as BedrockStreamingResponse,
     ImageBlock as BedrockImageBlock, Message as BedrockMessage,
+    ReasoningContentBlock as BedrockThinkingBlock, ReasoningTextBlock as BedrockThinkingTextBlock,
     ResponseStream as BedrockResponseStream, ToolResultBlock as BedrockToolResultBlock,
     ToolResultContentBlock as BedrockToolResultContentBlock,
     ToolResultStatus as BedrockToolResultStatus, ToolUseBlock as BedrockToolUseBlock,

crates/collab/Cargo.toml

@@ -34,14 +34,12 @@ dashmap.workspace = true
 derive_more.workspace = true
 envy = "0.4.2"
 futures.workspace = true
-google_ai.workspace = true
 hex.workspace = true
 http_client.workspace = true
 jsonwebtoken.workspace = true
 livekit_api.workspace = true
 log.workspace = true
 nanoid.workspace = true
-open_ai.workspace = true
 parking_lot.workspace = true
 prometheus = "0.14"
 prost.workspace = true

crates/collab/src/rpc.rs

@@ -3,7 +3,7 @@ mod connection_pool;
 use crate::api::{CloudflareIpCountryHeader, SystemIdHeader};
 use crate::llm::LlmTokenClaims;
 use crate::{
-    AppState, Config, Error, RateLimit, Result, auth,
+    AppState, Error, Result, auth,
     db::{
         self, BufferId, Capability, Channel, ChannelId, ChannelRole, ChannelsForUser,
         CreatedChannelMessage, Database, InviteMemberResult, MembershipUpdated, MessageId,
@@ -33,11 +33,8 @@ use chrono::Utc;
 use collections::{HashMap, HashSet};
 pub use connection_pool::{ConnectionPool, ZedVersion};
 use core::fmt::{self, Debug, Formatter};
-use http_client::HttpClient;
-use open_ai::{OPEN_AI_API_URL, OpenAiEmbeddingModel};
 use reqwest_client::ReqwestClient;
 use rpc::proto::split_repository_update;
-use sha2::Digest;
 use supermaven_api::{CreateExternalUserRequest, SupermavenAdminApi};
 
 use futures::{
@@ -134,7 +131,6 @@ struct Session {
     connection_pool: Arc<parking_lot::Mutex<ConnectionPool>>,
     app_state: Arc<AppState>,
     supermaven_client: Option<Arc<SupermavenAdminApi>>,
-    http_client: Arc<dyn HttpClient>,
     /// The GeoIP country code for the user.
     #[allow(unused)]
     geoip_country_code: Option<String>,
@@ -427,29 +423,7 @@ impl Server {
             .add_request_handler(forward_mutating_project_request::<proto::GitChangeBranch>)
             .add_request_handler(forward_mutating_project_request::<proto::CheckForPushedCommits>)
             .add_message_handler(broadcast_project_message_from_host::<proto::AdvertiseContexts>)
-            .add_message_handler(update_context)
-            .add_request_handler({
-                let app_state = app_state.clone();
-                move |request, response, session| {
-                    let app_state = app_state.clone();
-                    async move {
-                        count_language_model_tokens(request, response, session, &app_state.config)
-                            .await
-                    }
-                }
-            })
-            .add_request_handler(get_cached_embeddings)
-            .add_request_handler({
-                let app_state = app_state.clone();
-                move |request, response, session| {
-                    compute_embeddings(
-                        request,
-                        response,
-                        session,
-                        app_state.config.openai_api_key.clone(),
-                    )
-                }
-            });
+            .add_message_handler(update_context);
 
         Arc::new(server)
     }
@@ -778,7 +752,6 @@ impl Server {
                 peer: this.peer.clone(),
                 connection_pool: this.connection_pool.clone(),
                 app_state: this.app_state.clone(),
-                http_client,
                 geoip_country_code,
                 system_id,
                 _executor: executor.clone(),
@@ -3697,223 +3670,6 @@ async fn acknowledge_buffer_version(
     Ok(())
 }
 
-async fn count_language_model_tokens(
-    request: proto::CountLanguageModelTokens,
-    response: Response<proto::CountLanguageModelTokens>,
-    session: Session,
-    config: &Config,
-) -> Result<()> {
-    authorize_access_to_legacy_llm_endpoints(&session).await?;
-
-    let rate_limit: Box<dyn RateLimit> = match session.current_plan(&session.db().await).await? {
-        proto::Plan::ZedPro => Box::new(ZedProCountLanguageModelTokensRateLimit),
-        proto::Plan::Free | proto::Plan::ZedProTrial => {
-            Box::new(FreeCountLanguageModelTokensRateLimit)
-        }
-    };
-
-    session
-        .app_state
-        .rate_limiter
-        .check(&*rate_limit, session.user_id())
-        .await?;
-
-    let result = match proto::LanguageModelProvider::from_i32(request.provider) {
-        Some(proto::LanguageModelProvider::Google) => {
-            let api_key = config
-                .google_ai_api_key
-                .as_ref()
-                .context("no Google AI API key configured on the server")?;
-            google_ai::count_tokens(
-                session.http_client.as_ref(),
-                google_ai::API_URL,
-                api_key,
-                serde_json::from_str(&request.request)?,
-            )
-            .await?
-        }
-        _ => return Err(anyhow!("unsupported provider"))?,
-    };
-
-    response.send(proto::CountLanguageModelTokensResponse {
-        token_count: result.total_tokens as u32,
-    })?;
-
-    Ok(())
-}
-
-struct ZedProCountLanguageModelTokensRateLimit;
-
-impl RateLimit for ZedProCountLanguageModelTokensRateLimit {
-    fn capacity(&self) -> usize {
-        std::env::var("COUNT_LANGUAGE_MODEL_TOKENS_RATE_LIMIT_PER_HOUR")
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(600) // Picked arbitrarily
-    }
-
-    fn refill_duration(&self) -> chrono::Duration {
-        chrono::Duration::hours(1)
-    }
-
-    fn db_name(&self) -> &'static str {
-        "zed-pro:count-language-model-tokens"
-    }
-}
-
-struct FreeCountLanguageModelTokensRateLimit;
-
-impl RateLimit for FreeCountLanguageModelTokensRateLimit {
-    fn capacity(&self) -> usize {
-        std::env::var("COUNT_LANGUAGE_MODEL_TOKENS_RATE_LIMIT_PER_HOUR_FREE")
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(600 / 10) // Picked arbitrarily
-    }
-
-    fn refill_duration(&self) -> chrono::Duration {
-        chrono::Duration::hours(1)
-    }
-
-    fn db_name(&self) -> &'static str {
-        "free:count-language-model-tokens"
-    }
-}
-
-struct ZedProComputeEmbeddingsRateLimit;
-
-impl RateLimit for ZedProComputeEmbeddingsRateLimit {
-    fn capacity(&self) -> usize {
-        std::env::var("EMBED_TEXTS_RATE_LIMIT_PER_HOUR")
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(5000) // Picked arbitrarily
-    }
-
-    fn refill_duration(&self) -> chrono::Duration {
-        chrono::Duration::hours(1)
-    }
-
-    fn db_name(&self) -> &'static str {
-        "zed-pro:compute-embeddings"
-    }
-}
-
-struct FreeComputeEmbeddingsRateLimit;
-
-impl RateLimit for FreeComputeEmbeddingsRateLimit {
-    fn capacity(&self) -> usize {
-        std::env::var("EMBED_TEXTS_RATE_LIMIT_PER_HOUR_FREE")
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(5000 / 10) // Picked arbitrarily
-    }
-
-    fn refill_duration(&self) -> chrono::Duration {
-        chrono::Duration::hours(1)
-    }
-
-    fn db_name(&self) -> &'static str {
-        "free:compute-embeddings"
-    }
-}
-
-async fn compute_embeddings(
-    request: proto::ComputeEmbeddings,
-    response: Response<proto::ComputeEmbeddings>,
-    session: Session,
-    api_key: Option<Arc<str>>,
-) -> Result<()> {
-    let api_key = api_key.context("no OpenAI API key configured on the server")?;
-    authorize_access_to_legacy_llm_endpoints(&session).await?;
-
-    let rate_limit: Box<dyn RateLimit> = match session.current_plan(&session.db().await).await? {
-        proto::Plan::ZedPro => Box::new(ZedProComputeEmbeddingsRateLimit),
-        proto::Plan::Free | proto::Plan::ZedProTrial => Box::new(FreeComputeEmbeddingsRateLimit),
-    };
-
-    session
-        .app_state
-        .rate_limiter
-        .check(&*rate_limit, session.user_id())
-        .await?;
-
-    let embeddings = match request.model.as_str() {
-        "openai/text-embedding-3-small" => {
-            open_ai::embed(
-                session.http_client.as_ref(),
-                OPEN_AI_API_URL,
-                &api_key,
-                OpenAiEmbeddingModel::TextEmbedding3Small,
-                request.texts.iter().map(|text| text.as_str()),
-            )
-            .await?
-        }
-        provider => return Err(anyhow!("unsupported embedding provider {:?}", provider))?,
-    };
-
-    let embeddings = request
-        .texts
-        .iter()
-        .map(|text| {
-            let mut hasher = sha2::Sha256::new();
-            hasher.update(text.as_bytes());
-            let result = hasher.finalize();
-            result.to_vec()
-        })
-        .zip(
-            embeddings
-                .data
-                .into_iter()
-                .map(|embedding| embedding.embedding),
-        )
-        .collect::<HashMap<_, _>>();
-
-    let db = session.db().await;
-    db.save_embeddings(&request.model, &embeddings)
-        .await
-        .context("failed to save embeddings")
-        .trace_err();
-
-    response.send(proto::ComputeEmbeddingsResponse {
-        embeddings: embeddings
-            .into_iter()
-            .map(|(digest, dimensions)| proto::Embedding { digest, dimensions })
-            .collect(),
-    })?;
-    Ok(())
-}
-
-async fn get_cached_embeddings(
-    request: proto::GetCachedEmbeddings,
-    response: Response<proto::GetCachedEmbeddings>,
-    session: Session,
-) -> Result<()> {
-    authorize_access_to_legacy_llm_endpoints(&session).await?;
-
-    let db = session.db().await;
-    let embeddings = db.get_embeddings(&request.model, &request.digests).await?;
-
-    response.send(proto::GetCachedEmbeddingsResponse {
-        embeddings: embeddings
-            .into_iter()
-            .map(|(digest, dimensions)| proto::Embedding { digest, dimensions })
-            .collect(),
-    })?;
-    Ok(())
-}
-
-/// This is leftover from before the LLM service.
-///
-/// The endpoints protected by this check will be moved there eventually.
-async fn authorize_access_to_legacy_llm_endpoints(session: &Session) -> Result<(), Error> {
-    if session.is_staff() {
-        Ok(())
-    } else {
-        Err(anyhow!("permission denied"))?
-    }
-}
-
 /// Get a Supermaven API key for the user
 async fn get_supermaven_api_key(
     _request: proto::GetSupermavenApiKey,

crates/collab/src/seed.rs

@@ -46,7 +46,7 @@ pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result
     let mut first_user = None;
     let mut others = vec![];
 
-    let flag_names = ["remoting", "language-models"];
+    let flag_names = ["language-models"];
     let mut flags = Vec::new();
 
     let existing_feature_flags = db.list_feature_flags().await?;

crates/context_server/src/context_server_tool.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use anyhow::{Result, anyhow, bail};
 use assistant_tool::{ActionLog, Tool, ToolResult, ToolSource};
-use gpui::{App, Entity, Task};
+use gpui::{AnyWindowHandle, App, Entity, Task};
 use icons::IconName;
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
@@ -77,6 +77,7 @@ impl Tool for ContextServerTool {
         _messages: &[LanguageModelRequestMessage],
         _project: Entity<Project>,
         _action_log: Entity<ActionLog>,
+        _window: Option<AnyWindowHandle>,
         cx: &mut App,
     ) -> ToolResult {
         if let Some(server) = self.server_manager.read(cx).get_server(&self.server_id) {

crates/debugger_ui/src/debugger_panel.rs

@@ -3,7 +3,7 @@ use crate::{
     StepInto, StepOut, StepOver, Stop, ToggleIgnoreBreakpoints, persistence,
 };
 use crate::{new_session_modal::NewSessionModal, session::DebugSession};
-use anyhow::{Result, anyhow};
+use anyhow::{Context as _, Result, anyhow};
 use collections::HashMap;
 use command_palette_hooks::CommandPaletteFilter;
 use dap::StartDebuggingRequestArguments;
@@ -547,7 +547,10 @@ impl DebugPanel {
         cx.background_spawn(async move {
             match terminal_task {
                 Ok(pid_task) => match pid_task.await {
-                    Ok(Some(pid)) => sender.send(Ok(pid.as_u32())).await?,
+                    Ok(Some(pid)) => sender
+                        .send(Ok(pid.as_u32()))
+                        .await
+                        .context("task cancelled")?,
                     Ok(None) => {
                         sender
                             .send(Err(anyhow!(

crates/debugger_ui/src/debugger_ui.rs

@@ -1,7 +1,7 @@
 use dap::debugger_settings::DebuggerSettings;
 use debugger_panel::{DebugPanel, ToggleFocus};
 use editor::Editor;
-use feature_flags::{Debugger, FeatureFlagViewExt};
+use feature_flags::{DebuggerFeatureFlag, FeatureFlagViewExt};
 use gpui::{App, EntityInputHandler, actions};
 use new_session_modal::NewSessionModal;
 use project::debugger::{self, breakpoint_store::SourceBreakpoint};
@@ -47,7 +47,7 @@ pub fn init(cx: &mut App) {
             return;
         };
 
-        cx.when_flag_enabled::<Debugger>(window, |workspace, _, _| {
+        cx.when_flag_enabled::<DebuggerFeatureFlag>(window, |workspace, _, _| {
             workspace
                 .register_action(|workspace, _: &ToggleFocus, window, cx| {
                     workspace.toggle_panel_focus::<DebugPanel>(window, cx);

crates/editor/src/code_completion_tests.rs

@@ -1,4 +1,7 @@
-use crate::code_context_menus::{CompletionsMenu, SortableMatch};
+use crate::{
+    code_context_menus::{CompletionsMenu, SortableMatch},
+    editor_settings::SnippetSortOrder,
+};
 use fuzzy::StringMatch;
 use gpui::TestAppContext;
 
@@ -74,7 +77,7 @@ fn test_sort_matches_local_variable_over_global_variable(_cx: &mut TestAppContex
             sort_key: (2, "floorf128"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "foo_bar_qux",
@@ -87,12 +90,12 @@ fn test_sort_matches_local_variable_over_global_variable(_cx: &mut TestAppContex
     );
     assert_eq!(
         matches[2].string_match.string.as_str(),
-        "floorf128",
+        "floorf16",
         "Match order not expected"
     );
     assert_eq!(
         matches[3].string_match.string.as_str(),
-        "floorf16",
+        "floorf32",
         "Match order not expected"
     );
 
@@ -122,7 +125,7 @@ fn test_sort_matches_local_variable_over_global_variable(_cx: &mut TestAppContex
             sort_key: (1, "foo_bar_qux"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "foo_bar_qux",
@@ -185,7 +188,7 @@ fn test_sort_matches_local_variable_over_global_enum(_cx: &mut TestAppContext) {
             sort_key: (0, "while let"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "element_type",
@@ -234,7 +237,7 @@ fn test_sort_matches_local_variable_over_global_enum(_cx: &mut TestAppContext) {
             sort_key: (2, "REPLACEMENT_CHARACTER"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "element_type",
@@ -272,7 +275,7 @@ fn test_sort_matches_local_variable_over_global_enum(_cx: &mut TestAppContext) {
             sort_key: (1, "element_type"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "ElementType",
@@ -335,7 +338,7 @@ fn test_sort_matches_for_unreachable(_cx: &mut TestAppContext) {
             sort_key: (2, "unreachable_unchecked"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "unreachable!(…)",
@@ -379,7 +382,7 @@ fn test_sort_matches_for_unreachable(_cx: &mut TestAppContext) {
             sort_key: (3, "unreachable_unchecked"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "unreachable!(…)",
@@ -423,14 +426,58 @@ fn test_sort_matches_for_unreachable(_cx: &mut TestAppContext) {
             sort_key: (2, "unreachable_unchecked"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "unreachable!(…)",
         "Match order not expected"
     );
 
-    // Case 4: "unreachable"
+    // Case 4: "unreachabl"
+    let query: Option<&str> = Some("unreachable");
+    let mut matches: Vec<SortableMatch<'_>> = vec![
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.9090909090909092,
+                positions: vec![],
+                string: "unreachable".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("80000000"),
+            sort_key: (3, "unreachable"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.6666666666666666,
+                positions: vec![],
+                string: "unreachable!(…)".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "unreachable!(…)"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.47619047619047616,
+                positions: vec![],
+                string: "unreachable_unchecked".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("80000000"),
+            sort_key: (3, "unreachable_unchecked"),
+        },
+    ];
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
+    assert_eq!(
+        matches[0].string_match.string.as_str(),
+        "unreachable!(…)",
+        "Match order not expected"
+    );
+
+    // Case 5: "unreachable"
     let query: Option<&str> = Some("unreachable");
     let mut matches: Vec<SortableMatch<'_>> = vec![
         SortableMatch {
@@ -467,7 +514,7 @@ fn test_sort_matches_for_unreachable(_cx: &mut TestAppContext) {
             sort_key: (2, "unreachable_unchecked"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "unreachable!(…)",
@@ -503,7 +550,7 @@ fn test_sort_matches_variable_and_constants_over_function(_cx: &mut TestAppConte
             sort_key: (1, "var"), // variable
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.candidate_id, 1,
         "Match order not expected"
@@ -539,7 +586,7 @@ fn test_sort_matches_variable_and_constants_over_function(_cx: &mut TestAppConte
             sort_key: (2, "var"), // constant
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.candidate_id, 1,
         "Match order not expected"
@@ -622,7 +669,7 @@ fn test_sort_matches_jsx_event_handler(_cx: &mut TestAppContext) {
             sort_key: (3, "className?"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches[0].string_match.string, "onCut?",
         "Match order not expected"
@@ -944,7 +991,7 @@ fn test_sort_matches_jsx_event_handler(_cx: &mut TestAppContext) {
             sort_key: (3, "onLoadedData?"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::default());
     assert_eq!(
         matches
             .iter()
@@ -953,17 +1000,17 @@ fn test_sort_matches_jsx_event_handler(_cx: &mut TestAppContext) {
             .collect::<Vec<&str>>(),
         vec![
             "onAbort?",
+            "onAuxClick?",
             "onAbortCapture?",
             "onAnimationEnd?",
-            "onAnimationEndCapture?",
-            "onAnimationIteration?",
             "onAnimationStart?",
-            "onAuxClick?",
             "onAuxClickCapture?",
-            "onCanPlay?",
-            "onChange?",
+            "onAnimationIteration?",
+            "onAnimationEndCapture?",
             "onDrag?",
-            "onDragEnd?",
+            "onLoad?",
+            "onPlay?",
+            "onPaste?",
         ]
     );
 }
@@ -982,7 +1029,7 @@ fn test_sort_matches_for_snippets(_cx: &mut TestAppContext) {
             },
             is_snippet: false,
             sort_text: Some("80000000"),
-            sort_key: (2, "unreachable"),
+            sort_key: (2, "println"),
         },
         SortableMatch {
             string_match: StringMatch {
@@ -996,10 +1043,291 @@ fn test_sort_matches_for_snippets(_cx: &mut TestAppContext) {
             sort_key: (2, "println!(…)"),
         },
     ];
-    CompletionsMenu::sort_matches(&mut matches, query);
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::Top);
     assert_eq!(
         matches[0].string_match.string.as_str(),
         "println!(…)",
         "Match order not expected"
     );
 }
+
+#[gpui::test]
+fn test_sort_matches_for_exact_match(_cx: &mut TestAppContext) {
+    // Case 1: "set_text"
+    let query: Option<&str> = Some("set_text");
+    let mut matches: Vec<SortableMatch<'_>> = vec![
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 1.0,
+                positions: vec![],
+                string: "set_text".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_text"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.32000000000000006,
+                positions: vec![],
+                string: "set_placeholder_text".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_placeholder_text"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.32,
+                positions: vec![],
+                string: "set_text_style_refinement".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_text_style_refinement"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.16666666666666666,
+                positions: vec![],
+                string: "set_context_menu_options".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_context_menu_options"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.08695652173913043,
+                positions: vec![],
+                string: "select_to_next_word_end".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_next_word_end"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.07692307692307693,
+                positions: vec![],
+                string: "select_to_next_subword_end".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_next_subword_end"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.06956521739130435,
+                positions: vec![],
+                string: "set_custom_context_menu".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_custom_context_menu"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.06,
+                positions: vec![],
+                string: "select_to_end_of_excerpt".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_end_of_excerpt"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.055384615384615386,
+                positions: vec![],
+                string: "select_to_start_of_excerpt".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_start_of_excerpt"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.0464516129032258,
+                positions: vec![],
+                string: "select_to_start_of_next_excerpt".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_start_of_next_excerpt"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.04363636363636363,
+                positions: vec![],
+                string: "select_to_end_of_previous_excerpt".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_end_of_previous_excerpt"),
+        },
+    ];
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::Top);
+    assert_eq!(
+        matches
+            .iter()
+            .map(|m| m.string_match.string.as_str())
+            .collect::<Vec<&str>>(),
+        vec![
+            "set_text",
+            "set_text_style_refinement",
+            "set_placeholder_text",
+            "set_context_menu_options",
+            "set_custom_context_menu",
+            "select_to_next_word_end",
+            "select_to_next_subword_end",
+            "select_to_end_of_excerpt",
+            "select_to_start_of_excerpt",
+            "select_to_start_of_next_excerpt",
+            "select_to_end_of_previous_excerpt",
+        ]
+    );
+}
+
+#[gpui::test]
+fn test_sort_matches_for_prefix_matches(_cx: &mut TestAppContext) {
+    // Case 1: "set"
+    let query: Option<&str> = Some("set");
+    let mut matches: Vec<SortableMatch<'_>> = vec![
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.12631578947368421,
+                positions: vec![],
+                string: "select_to_beginning".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_beginning"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.15000000000000002,
+                positions: vec![],
+                string: "set_collapse_matches".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_collapse_matches"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.21428571428571427,
+                positions: vec![],
+                string: "set_autoindent".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_autoindent"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.11538461538461539,
+                positions: vec![],
+                string: "set_all_diagnostics_active".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "set_all_diagnostics_active"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.1142857142857143,
+                positions: vec![],
+                string: "select_to_end_of_line".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_to_end_of_line"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.15000000000000002,
+                positions: vec![],
+                string: "select_all".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_all"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.13636363636363635,
+                positions: vec![],
+                string: "select_line".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_line"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.13636363636363635,
+                positions: vec![],
+                string: "select_left".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_left"),
+        },
+        SortableMatch {
+            string_match: StringMatch {
+                candidate_id: 0,
+                score: 0.13636363636363635,
+                positions: vec![],
+                string: "select_down".to_string(),
+            },
+            is_snippet: false,
+            sort_text: Some("7fffffff"),
+            sort_key: (3, "select_down"),
+        },
+    ];
+    CompletionsMenu::sort_matches(&mut matches, query, SnippetSortOrder::Top);
+    println!(
+        "{:?}",
+        matches
+            .iter()
+            .map(|m| m.string_match.string.as_str())
+            .collect::<Vec<&str>>(),
+    );
+    assert_eq!(
+        matches
+            .iter()
+            .map(|m| m.string_match.string.as_str())
+            .collect::<Vec<&str>>(),
+        vec![
+            "set_autoindent",
+            "set_collapse_matches",
+            "set_all_diagnostics_active",
+            "select_all",
+            "select_down",
+            "select_left",
+            "select_line",
+            "select_to_beginning",
+            "select_to_end_of_line",
+        ]
+    );
+}

crates/editor/src/code_context_menus.rs

@@ -1,4 +1,4 @@
-use feature_flags::{Debugger, FeatureFlagAppExt as _};
+use feature_flags::{DebuggerFeatureFlag, FeatureFlagAppExt as _};
 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
     AnyElement, BackgroundExecutor, Entity, Focusable, FontWeight, ListSizingBehavior,
@@ -25,6 +25,7 @@ use task::ResolvedTask;
 use ui::{Color, IntoElement, ListItem, Pixels, Popover, Styled, prelude::*};
 use util::ResultExt;
 
+use crate::editor_settings::SnippetSortOrder;
 use crate::hover_popover::{hover_markdown_style, open_markdown_url};
 use crate::{
     CodeActionProvider, CompletionId, CompletionItemKind, CompletionProvider, DisplayRow, Editor,
@@ -184,6 +185,7 @@ pub struct CompletionsMenu {
     pub(super) ignore_completion_provider: bool,
     last_rendered_range: Rc<RefCell<Option<Range<usize>>>>,
     markdown_element: Option<Entity<Markdown>>,
+    snippet_sort_order: SnippetSortOrder,
 }
 
 impl CompletionsMenu {
@@ -195,6 +197,7 @@ impl CompletionsMenu {
         initial_position: Anchor,
         buffer: Entity<Buffer>,
         completions: Box<[Completion]>,
+        snippet_sort_order: SnippetSortOrder,
     ) -> Self {
         let match_candidates = completions
             .iter()
@@ -217,6 +220,7 @@ impl CompletionsMenu {
             resolve_completions: true,
             last_rendered_range: RefCell::new(None).into(),
             markdown_element: None,
+            snippet_sort_order,
         }
     }
 
@@ -226,6 +230,7 @@ impl CompletionsMenu {
         choices: &Vec<String>,
         selection: Range<Anchor>,
         buffer: Entity<Buffer>,
+        snippet_sort_order: SnippetSortOrder,
     ) -> Self {
         let completions = choices
             .iter()
@@ -275,6 +280,7 @@ impl CompletionsMenu {
             ignore_completion_provider: false,
             last_rendered_range: RefCell::new(None).into(),
             markdown_element: None,
+            snippet_sort_order,
         }
     }
 
@@ -657,13 +663,18 @@ impl CompletionsMenu {
         )
     }
 
-    pub fn sort_matches(matches: &mut Vec<SortableMatch<'_>>, query: Option<&str>) {
+    pub fn sort_matches(
+        matches: &mut Vec<SortableMatch<'_>>,
+        query: Option<&str>,
+        snippet_sort_order: SnippetSortOrder,
+    ) {
         #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
         enum MatchTier<'a> {
             WordStartMatch {
-                sort_score_int: Reverse<i32>,
+                sort_prefix: Reverse<usize>,
                 sort_snippet: Reverse<i32>,
                 sort_text: Option<&'a str>,
+                sort_score: Reverse<OrderedFloat<f64>>,
                 sort_key: (usize, &'a str),
             },
             OtherMatch {
@@ -673,12 +684,6 @@ impl CompletionsMenu {
 
         // Our goal here is to intelligently sort completion suggestions. We want to
         // balance the raw fuzzy match score with hints from the language server
-        //
-        // We first primary sort using fuzzy score by putting matches into two buckets
-        // strong one and weak one. Among these buckets matches are then compared by
-        // various criteria like snippet, LSP hints, kind, label text etc.
-        //
-        const FUZZY_THRESHOLD: f64 = 0.1317;
 
         let query_start_lower = query
             .and_then(|q| q.chars().next())
@@ -686,8 +691,9 @@ impl CompletionsMenu {
 
         matches.sort_unstable_by_key(|mat| {
             let score = mat.string_match.score;
+            let sort_score = Reverse(OrderedFloat(score));
 
-            let is_other_match = query_start_lower
+            let query_start_doesnt_match_split_words = query_start_lower
                 .map(|query_char| {
                     !split_words(&mat.string_match.string).any(|word| {
                         word.chars()
@@ -698,16 +704,38 @@ impl CompletionsMenu {
                 })
                 .unwrap_or(false);
 
-            if is_other_match {
-                let sort_score = Reverse(OrderedFloat(score));
+            if query_start_doesnt_match_split_words {
                 MatchTier::OtherMatch { sort_score }
             } else {
-                let sort_score_int = Reverse(if score >= FUZZY_THRESHOLD { 1 } else { 0 });
-                let sort_snippet = Reverse(if mat.is_snippet { 1 } else { 0 });
+                let sort_snippet = match snippet_sort_order {
+                    SnippetSortOrder::Top => Reverse(if mat.is_snippet { 1 } else { 0 }),
+                    SnippetSortOrder::Bottom => Reverse(if mat.is_snippet { 0 } else { 1 }),
+                    SnippetSortOrder::Inline => Reverse(0),
+                };
+                let mixed_case_prefix_length = Reverse(
+                    query
+                        .map(|q| {
+                            q.chars()
+                                .zip(mat.string_match.string.chars())
+                                .enumerate()
+                                .take_while(|(i, (q_char, match_char))| {
+                                    if *i == 0 {
+                                        // Case-sensitive comparison for first character
+                                        q_char == match_char
+                                    } else {
+                                        // Case-insensitive comparison for other characters
+                                        q_char.to_lowercase().eq(match_char.to_lowercase())
+                                    }
+                                })
+                                .count()
+                        })
+                        .unwrap_or(0),
+                );
                 MatchTier::WordStartMatch {
-                    sort_score_int,
+                    sort_prefix: mixed_case_prefix_length,
                     sort_snippet,
                     sort_text: mat.sort_text,
+                    sort_score,
                     sort_key: mat.sort_key,
                 }
             }
@@ -770,7 +798,7 @@ impl CompletionsMenu {
                 })
                 .collect();
 
-            Self::sort_matches(&mut sortable_items, query);
+            Self::sort_matches(&mut sortable_items, query, self.snippet_sort_order);
 
             matches = sortable_items
                 .into_iter()
@@ -812,7 +840,7 @@ impl CodeActionContents {
         actions: Option<Rc<[AvailableCodeAction]>>,
         cx: &App,
     ) -> Self {
-        if !cx.has_flag::<Debugger>() {
+        if !cx.has_flag::<DebuggerFeatureFlag>() {
             if let Some(tasks) = &mut tasks {
                 tasks
                     .templates

crates/editor/src/display_map/block_map.rs

@@ -65,7 +65,7 @@ pub struct CustomBlockId(pub usize);
 
 impl From<CustomBlockId> for ElementId {
     fn from(val: CustomBlockId) -> Self {
-        ElementId::Integer(val.0)
+        val.0.into()
     }
 }
 

crates/editor/src/display_map/fold_map.rs

@@ -1065,7 +1065,7 @@ pub struct FoldId(usize);
 
 impl From<FoldId> for ElementId {
     fn from(val: FoldId) -> Self {
-        ElementId::Integer(val.0)
+        val.0.into()
     }
 }
 

crates/editor/src/editor.rs

@@ -71,7 +71,7 @@ use element::{AcceptEditPredictionBinding, LineWithInvisibles, PositionMap, layo
 pub use element::{
     CursorLayout, EditorElement, HighlightedRange, HighlightedRangeLine, PointForPosition,
 };
-use feature_flags::{Debugger, FeatureFlagAppExt};
+use feature_flags::{DebuggerFeatureFlag, FeatureFlagAppExt};
 use futures::{
     FutureExt,
     future::{self, Shared, join},
@@ -427,6 +427,8 @@ pub enum EditorMode {
         scale_ui_elements_with_buffer_font_size: bool,
         /// When set to `true`, the editor will render a background for the active line.
         show_active_line_background: bool,
+        /// When set to `true`, the editor's height will be determined by its content.
+        sized_by_content: bool,
     },
 }
 
@@ -435,6 +437,7 @@ impl EditorMode {
         Self::Full {
             scale_ui_elements_with_buffer_font_size: true,
             show_active_line_background: true,
+            sized_by_content: false,
         }
     }
 
@@ -788,6 +791,8 @@ pub struct Editor {
     show_breadcrumbs: bool,
     show_gutter: bool,
     show_scrollbars: bool,
+    disable_scrolling: bool,
+    disable_expand_excerpt_buttons: bool,
     show_line_numbers: Option<bool>,
     use_relative_line_numbers: Option<bool>,
     show_git_diff_gutter: Option<bool>,
@@ -1563,11 +1568,13 @@ impl Editor {
             blink_manager: blink_manager.clone(),
             show_local_selections: true,
             show_scrollbars: true,
+            disable_scrolling: false,
             mode,
             show_breadcrumbs: EditorSettings::get_global(cx).toolbar.breadcrumbs,
             show_gutter: mode.is_full(),
             show_line_numbers: None,
             use_relative_line_numbers: None,
+            disable_expand_excerpt_buttons: false,
             show_git_diff_gutter: None,
             show_code_actions: None,
             show_runnables: None,
@@ -4592,6 +4599,8 @@ impl Editor {
             .as_ref()
             .map_or(true, |provider| provider.filter_completions());
 
+        let snippet_sort_order = EditorSettings::get_global(cx).snippet_sort_order;
+
         let id = post_inc(&mut self.next_completion_id);
         let task = cx.spawn_in(window, async move |editor, cx| {
             async move {
@@ -4639,6 +4648,7 @@ impl Editor {
                         position,
                         buffer.clone(),
                         completions.into(),
+                        snippet_sort_order,
                     );
 
                     menu.filter(
@@ -5018,7 +5028,7 @@ impl Editor {
                                 Self::build_tasks_context(&project, &buffer, buffer_row, tasks, cx)
                             });
 
-                    let debugger_flag = cx.has_flag::<Debugger>();
+                    let debugger_flag = cx.has_flag::<DebuggerFeatureFlag>();
 
                     Some(cx.spawn_in(window, async move |editor, cx| {
                         let task_context = match task_context {
@@ -8009,10 +8019,18 @@ impl Editor {
         let buffer_id = selection.start.buffer_id.unwrap();
         let buffer = self.buffer().read(cx).buffer(buffer_id);
         let id = post_inc(&mut self.next_completion_id);
+        let snippet_sort_order = EditorSettings::get_global(cx).snippet_sort_order;
 
         if let Some(buffer) = buffer {
             *self.context_menu.borrow_mut() = Some(CodeContextMenu::Completions(
-                CompletionsMenu::new_snippet_choices(id, true, choices, selection, buffer),
+                CompletionsMenu::new_snippet_choices(
+                    id,
+                    true,
+                    choices,
+                    selection,
+                    buffer,
+                    snippet_sort_order,
+                ),
             ));
         }
     }
@@ -8930,7 +8948,7 @@ impl Editor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if !cx.has_flag::<Debugger>() {
+        if !cx.has_flag::<DebuggerFeatureFlag>() {
             return;
         }
         let source = self
@@ -16146,11 +16164,21 @@ impl Editor {
         cx.notify();
     }
 
+    pub fn disable_scrolling(&mut self, cx: &mut Context<Self>) {
+        self.disable_scrolling = true;
+        cx.notify();
+    }
+
     pub fn set_show_line_numbers(&mut self, show_line_numbers: bool, cx: &mut Context<Self>) {
         self.show_line_numbers = Some(show_line_numbers);
         cx.notify();
     }
 
+    pub fn disable_expand_excerpt_buttons(&mut self, cx: &mut Context<Self>) {
+        self.disable_expand_excerpt_buttons = true;
+        cx.notify();
+    }
+
     pub fn set_show_git_diff_gutter(&mut self, show_git_diff_gutter: bool, cx: &mut Context<Self>) {
         self.show_git_diff_gutter = Some(show_git_diff_gutter);
         cx.notify();

crates/editor/src/editor_settings.rs

@@ -39,6 +39,7 @@ pub struct EditorSettings {
     pub go_to_definition_fallback: GoToDefinitionFallback,
     pub jupyter: Jupyter,
     pub hide_mouse: Option<HideMouseMode>,
+    pub snippet_sort_order: SnippetSortOrder,
 }
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
@@ -239,6 +240,21 @@ pub enum HideMouseMode {
     OnTypingAndMovement,
 }
 
+/// Determines how snippets are sorted relative to other completion items.
+///
+/// Default: inline
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum SnippetSortOrder {
+    /// Place snippets at the top of the completion list
+    Top,
+    /// Sort snippets normally using the default comparison logic
+    #[default]
+    Inline,
+    /// Place snippets at the bottom of the completion list
+    Bottom,
+}
+
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct EditorSettingsContent {
     /// Whether the cursor blinks in the editor.
@@ -254,6 +270,10 @@ pub struct EditorSettingsContent {
     ///
     /// Default: on_typing_and_movement
     pub hide_mouse: Option<HideMouseMode>,
+    /// Determines how snippets are sorted relative to other completion items.
+    ///
+    /// Default: inline
+    pub snippet_sort_order: Option<SnippetSortOrder>,
     /// How to highlight the current line in the editor.
     ///
     /// Default: all

crates/editor/src/editor_tests.rs

@@ -10419,6 +10419,7 @@ async fn test_completion_in_multibuffer_with_replace_range(cx: &mut TestAppConte
                     EditorMode::Full {
                         scale_ui_elements_with_buffer_font_size: false,
                         show_active_line_background: false,
+                        sized_by_content: false,
                     },
                     multi_buffer.clone(),
                     Some(project.clone()),
@@ -10704,7 +10705,7 @@ async fn test_completion(cx: &mut TestAppContext) {
             .confirm_completion(&ConfirmCompletion::default(), window, cx)
             .unwrap()
     });
-    cx.assert_editor_state("editor.clobberˇ");
+    cx.assert_editor_state("editor.closeˇ");
     handle_resolve_completion_request(&mut cx, None).await;
     apply_additional_edits.await.unwrap();
 }
@@ -13994,7 +13995,7 @@ async fn test_completions_in_languages_with_extra_word_characters(cx: &mut TestA
         {
             assert_eq!(
                 completion_menu_entries(&menu),
-                &["bg-blue", "bg-red", "bg-yellow"]
+                &["bg-red", "bg-blue", "bg-yellow"]
             );
         } else {
             panic!("expected completion menu to be open");

crates/editor/src/element.rs

@@ -29,7 +29,7 @@ use crate::{
 use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind};
 use client::ParticipantIndex;
 use collections::{BTreeMap, HashMap};
-use feature_flags::{Debugger, FeatureFlagAppExt};
+use feature_flags::{DebuggerFeatureFlag, FeatureFlagAppExt};
 use file_icons::FileIcons;
 use git::{Oid, blame::BlameEntry, status::FileStatus};
 use gpui::{
@@ -541,7 +541,7 @@ impl EditorElement {
         register_action(editor, window, Editor::insert_uuid_v4);
         register_action(editor, window, Editor::insert_uuid_v7);
         register_action(editor, window, Editor::open_selections_in_multibuffer);
-        if cx.has_flag::<Debugger>() {
+        if cx.has_flag::<DebuggerFeatureFlag>() {
             register_action(editor, window, Editor::toggle_breakpoint);
             register_action(editor, window, Editor::edit_log_breakpoint);
             register_action(editor, window, Editor::enable_breakpoint);
@@ -2183,6 +2183,10 @@ impl EditorElement {
         window: &mut Window,
         cx: &mut App,
     ) -> Vec<Option<(AnyElement, gpui::Point<Pixels>)>> {
+        if self.editor.read(cx).disable_expand_excerpt_buttons {
+            return vec![];
+        }
+
         let editor_font_size = self.style.text.font_size.to_pixels(window.rem_size()) * 1.2;
 
         let scroll_top = scroll_position.y * line_height;
@@ -2657,19 +2661,21 @@ impl EditorElement {
                         text_x + layout.width,
                     ))
                 };
-                x_position = if rows.contains(&align_to.row()) {
-                    x_and_width(&line_layouts[align_to.row().minus(rows.start) as usize])
-                } else {
-                    x_and_width(&layout_line(
-                        align_to.row(),
-                        snapshot,
-                        &self.style,
-                        editor_width,
-                        is_row_soft_wrapped,
-                        window,
-                        cx,
-                    ))
-                };
+                let line_ix = align_to.row().0.checked_sub(rows.start.0);
+                x_position =
+                    if let Some(layout) = line_ix.and_then(|ix| line_layouts.get(ix as usize)) {
+                        x_and_width(&layout)
+                    } else {
+                        x_and_width(&layout_line(
+                            align_to.row(),
+                            snapshot,
+                            &self.style,
+                            editor_width,
+                            is_row_soft_wrapped,
+                            window,
+                            cx,
+                        ))
+                    };
 
                 let anchor_x = x_position.unwrap().0;
 
@@ -5512,7 +5518,9 @@ impl EditorElement {
     }
 
     fn paint_mouse_listeners(&mut self, layout: &EditorLayout, window: &mut Window, cx: &mut App) {
-        self.paint_scroll_wheel_listener(layout, window, cx);
+        if !self.editor.read(cx).disable_scrolling {
+            self.paint_scroll_wheel_listener(layout, window, cx);
+        }
 
         window.on_mouse_event({
             let position_map = layout.position_map.clone();
@@ -6563,10 +6571,21 @@ impl Element for EditorElement {
                             },
                         )
                     }
-                    EditorMode::Full { .. } => {
+                    EditorMode::Full {
+                        sized_by_content, ..
+                    } => {
                         let mut style = Style::default();
                         style.size.width = relative(1.).into();
-                        style.size.height = relative(1.).into();
+                        if sized_by_content {
+                            let snapshot = editor.snapshot(window, cx);
+                            let line_height =
+                                self.style.text.line_height_in_pixels(window.rem_size());
+                            let scroll_height =
+                                (snapshot.max_point().row().next_row().0 as f32) * line_height;
+                            style.size.height = scroll_height.into();
+                        } else {
+                            style.size.height = relative(1.).into();
+                        }
                         window.request_layout(style, None, cx)
                     }
                 };
@@ -6869,7 +6888,7 @@ impl Element for EditorElement {
                     let mut breakpoint_rows = self.editor.update(cx, |editor, cx| {
                         editor.active_breakpoints(start_row..end_row, window, cx)
                     });
-                    if cx.has_flag::<Debugger>() {
+                    if cx.has_flag::<DebuggerFeatureFlag>() {
                         for display_row in breakpoint_rows.keys() {
                             active_rows.entry(*display_row).or_default().breakpoint = true;
                         }
@@ -6892,7 +6911,7 @@ impl Element for EditorElement {
                     // We add the gutter breakpoint indicator to breakpoint_rows after painting
                     // line numbers so we don't paint a line number debug accent color if a user
                     // has their mouse over that line when a breakpoint isn't there
-                    if cx.has_flag::<Debugger>() {
+                    if cx.has_flag::<DebuggerFeatureFlag>() {
                         let gutter_breakpoint_indicator =
                             self.editor.read(cx).gutter_breakpoint_indicator.0;
                         if let Some((gutter_breakpoint_point, _)) =
@@ -7414,7 +7433,7 @@ impl Element for EditorElement {
                     let show_breakpoints = snapshot
                         .show_breakpoints
                         .unwrap_or(gutter_settings.breakpoints);
-                    let breakpoints = if cx.has_flag::<Debugger>() && show_breakpoints {
+                    let breakpoints = if cx.has_flag::<DebuggerFeatureFlag>() && show_breakpoints {
                         self.layout_breakpoints(
                             line_height,
                             start_row..end_row,

crates/eval/Cargo.toml

@@ -11,6 +11,7 @@ assistant_tool.workspace = true
 assistant_tools.workspace = true
 async-trait.workspace = true
 async-watch.workspace = true
+buffer_diff.workspace = true
 chrono.workspace = true
 clap.workspace = true
 client.workspace = true

crates/eval/src/example.rs

@@ -1,6 +1,7 @@
 use std::{
     error::Error,
     fmt::{self, Debug},
+    path::Path,
     sync::{Arc, Mutex},
     time::Duration,
 };
@@ -9,9 +10,11 @@ use crate::{
     ToolMetrics,
     assertions::{AssertionsReport, RanAssertion, RanAssertionResult},
 };
-use agent::ThreadEvent;
+use agent::{ContextLoadResult, ThreadEvent};
 use anyhow::{Result, anyhow};
 use async_trait::async_trait;
+use buffer_diff::DiffHunkStatus;
+use collections::HashMap;
 use futures::{FutureExt as _, StreamExt, channel::mpsc, select_biased};
 use gpui::{AppContext, AsyncApp, Entity};
 use language_model::{LanguageModel, Role, StopReason};
@@ -112,7 +115,12 @@ impl ExampleContext {
     pub fn push_user_message(&mut self, text: impl ToString) {
         self.app
             .update_entity(&self.agent_thread, |thread, cx| {
-                thread.insert_user_message(text.to_string(), vec![], None, cx);
+                thread.insert_user_message(
+                    text.to_string(),
+                    ContextLoadResult::default(),
+                    None,
+                    cx,
+                );
             })
             .unwrap();
     }
@@ -234,9 +242,9 @@ impl ExampleContext {
                             let mut tool_metrics = tool_metrics.lock().unwrap();
                             if let Some(tool_result) = thread.tool_result(&tool_use_id) {
                                 let message = if tool_result.is_error {
-                                    format!("TOOL FAILED: {}", tool_use.name)
+                                    format!("✖︎ {}", tool_use.name)
                                 } else {
-                                    format!("TOOL FINISHED: {}", tool_use.name)
+                                    format!("✔︎ {}", tool_use.name)
                                 };
                                 println!("{log_prefix}{message}");
                                 tool_metrics
@@ -250,6 +258,9 @@ impl ExampleContext {
                         }
                     });
                 }
+                ThreadEvent::InvalidToolInput { .. } => {
+                    println!("{log_prefix} invalid tool input");
+                }
                 ThreadEvent::ToolConfirmationNeeded => {
                     panic!(
                         "{}Bug: Tool confirmation should not be required in eval",
@@ -278,7 +289,7 @@ impl ExampleContext {
 
         let message_count_before = self.app.update_entity(&self.agent_thread, |thread, cx| {
             thread.set_remaining_turns(iterations);
-            thread.send_to_model(model, cx);
+            thread.send_to_model(model, None, cx);
             thread.messages().len()
         })?;
 
@@ -320,6 +331,36 @@ impl ExampleContext {
 
         Ok(response)
     }
+
+    pub fn edits(&self) -> HashMap<Arc<Path>, FileEdits> {
+        self.app
+            .read_entity(&self.agent_thread, |thread, cx| {
+                let action_log = thread.action_log().read(cx);
+                HashMap::from_iter(action_log.changed_buffers(cx).into_iter().map(
+                    |(buffer, diff)| {
+                        let snapshot = buffer.read(cx).snapshot();
+
+                        let file = snapshot.file().unwrap();
+                        let diff = diff.read(cx);
+                        let base_text = diff.base_text().text();
+
+                        let hunks = diff
+                            .hunks(&snapshot, cx)
+                            .map(|hunk| FileEditHunk {
+                                base_text: base_text[hunk.diff_base_byte_range.clone()].to_string(),
+                                text: snapshot
+                                    .text_for_range(hunk.range.clone())
+                                    .collect::<String>(),
+                                status: hunk.status(),
+                            })
+                            .collect();
+
+                        (file.path().clone(), FileEdits { hunks })
+                    },
+                ))
+            })
+            .unwrap()
+    }
 }
 
 #[derive(Debug)]
@@ -344,6 +385,11 @@ impl Response {
         });
         cx.assert_some(result, format!("called `{}`", tool_name))
     }
+
+    #[allow(dead_code)]
+    pub fn tool_uses(&self) -> impl Iterator<Item = &ToolUse> {
+        self.messages.iter().flat_map(|msg| &msg.tool_use)
+    }
 }
 
 #[derive(Debug)]
@@ -355,17 +401,37 @@ pub struct Message {
 
 #[derive(Debug)]
 pub struct ToolUse {
-    name: String,
+    pub name: String,
     value: serde_json::Value,
 }
 
 impl ToolUse {
-    pub fn expect_input<Input>(&self, cx: &mut ExampleContext) -> Result<Input>
+    pub fn parse_input<Input>(&self) -> Result<Input>
     where
         Input: for<'de> serde::Deserialize<'de>,
     {
-        let result =
-            serde_json::from_value::<Input>(self.value.clone()).map_err(|err| anyhow!(err));
-        cx.log_assertion(result, format!("valid `{}` input", &self.name))
+        serde_json::from_value::<Input>(self.value.clone()).map_err(|err| anyhow!(err))
+    }
+}
+
+#[derive(Debug)]
+pub struct FileEdits {
+    hunks: Vec<FileEditHunk>,
+}
+
+#[derive(Debug)]
+struct FileEditHunk {
+    base_text: String,
+    text: String,
+    status: DiffHunkStatus,
+}
+
+impl FileEdits {
+    pub fn has_added_line(&self, line: &str) -> bool {
+        self.hunks.iter().any(|hunk| {
+            hunk.status == DiffHunkStatus::added_none()
+                && hunk.base_text.is_empty()
+                && hunk.text.contains(line)
+        })
     }
 }

crates/eval/src/examples/add_arg_to_trait_method.rs

@@ -0,0 +1,114 @@
+use std::path::Path;
+
+use anyhow::Result;
+use async_trait::async_trait;
+
+use crate::example::{Example, ExampleContext, ExampleMetadata, JudgeAssertion, LanguageServer};
+
+pub struct AddArgToTraitMethod;
+
+#[async_trait(?Send)]
+impl Example for AddArgToTraitMethod {
+    fn meta(&self) -> ExampleMetadata {
+        ExampleMetadata {
+            name: "add_arg_to_trait_method".to_string(),
+            url: "https://github.com/zed-industries/zed.git".to_string(),
+            revision: "f69aeb6311dde3c0b8979c293d019d66498d54f2".to_string(),
+            language_server: Some(LanguageServer {
+                file_extension: "rs".to_string(),
+                allow_preexisting_diagnostics: false,
+            }),
+            max_assertions: None,
+        }
+    }
+
+    async fn conversation(&self, cx: &mut ExampleContext) -> Result<()> {
+        const FILENAME: &str = "assistant_tool.rs";
+        cx.push_user_message(format!(
+            r#"
+            Add a `window: Option<gpui::AnyWindowHandle>` argument to the `Tool::run` trait method in {FILENAME},
+            and update all the implementations of the trait and call sites accordingly.
+            "#
+        ));
+
+        let _ = cx.run_to_end().await?;
+
+        // Adds ignored argument to all but `batch_tool`
+
+        let add_ignored_window_paths = &[
+            "code_action_tool",
+            "code_symbols_tool",
+            "contents_tool",
+            "copy_path_tool",
+            "create_directory_tool",
+            "create_file_tool",
+            "delete_path_tool",
+            "diagnostics_tool",
+            "edit_file_tool",
+            "fetch_tool",
+            "grep_tool",
+            "list_directory_tool",
+            "move_path_tool",
+            "now_tool",
+            "open_tool",
+            "path_search_tool",
+            "read_file_tool",
+            "rename_tool",
+            "symbol_info_tool",
+            "terminal_tool",
+            "thinking_tool",
+            "web_search_tool",
+        ];
+
+        let edits = cx.edits();
+
+        for tool_name in add_ignored_window_paths {
+            let path_str = format!("crates/assistant_tools/src/{}.rs", tool_name);
+            let edits = edits.get(Path::new(&path_str));
+
+            let ignored = edits.map_or(false, |edits| {
+                edits.has_added_line("        _window: Option<gpui::AnyWindowHandle>,\n")
+            });
+            let uningored = edits.map_or(false, |edits| {
+                edits.has_added_line("        window: Option<gpui::AnyWindowHandle>,\n")
+            });
+
+            cx.assert(ignored || uningored, format!("Argument:   {}", tool_name))
+                .ok();
+
+            cx.assert(ignored, format!("`_` prefix: {}", tool_name))
+                .ok();
+        }
+
+        // Adds unignored argument to `batch_tool`
+
+        let batch_tool_edits = edits.get(Path::new("crates/assistant_tools/src/batch_tool.rs"));
+
+        cx.assert(
+            batch_tool_edits.map_or(false, |edits| {
+                edits.has_added_line("        window: Option<gpui::AnyWindowHandle>,\n")
+            }),
+            "Argument:   batch_tool",
+        )
+        .ok();
+
+        Ok(())
+    }
+
+    fn diff_assertions(&self) -> Vec<JudgeAssertion> {
+        vec![
+            JudgeAssertion {
+                id: "batch tool passes window to each".to_string(),
+                description:
+                    "batch_tool is modified to pass a clone of the window to each tool it calls."
+                        .to_string(),
+            },
+            JudgeAssertion {
+                id: "tool tests updated".to_string(),
+                description:
+                    "tool tests are updated to pass the new `window` argument (`None` is ok)."
+                        .to_string(),
+            },
+        ]
+    }
+}

crates/eval/src/examples/file_search.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use assistant_tools::PathSearchToolInput;
+use assistant_tools::FindPathToolInput;
 use async_trait::async_trait;
 use regex::Regex;
 
@@ -15,7 +15,7 @@ impl Example for FileSearchExample {
             url: "https://github.com/zed-industries/zed.git".to_string(),
             revision: "03ecb88fe30794873f191ddb728f597935b3101c".to_string(),
             language_server: None,
-            max_assertions: Some(4),
+            max_assertions: Some(3),
         }
     }
 
@@ -32,21 +32,18 @@ impl Example for FileSearchExample {
         ));
 
         let response = cx.run_turn().await?;
-        let tool_use = response.expect_tool("path_search", cx)?;
-        let input = tool_use.expect_input::<PathSearchToolInput>(cx)?;
+        let tool_use = response.expect_tool("find_path", cx)?;
+        let input = tool_use.parse_input::<FindPathToolInput>()?;
 
         let glob = input.glob;
-        cx.assert(
-            glob.ends_with(FILENAME),
-            format!("glob ends with `{FILENAME}`"),
-        )?;
+        cx.assert(glob.ends_with(FILENAME), "glob ends with file name")?;
 
         let without_filename = glob.replace(FILENAME, "");
         let matches = Regex::new("(\\*\\*|zed)/(\\*\\*?/)?")
             .unwrap()
             .is_match(&without_filename);
 
-        cx.assert(matches, "glob starts with either `**` or `zed`")?;
+        cx.assert(matches, "glob starts with `**` or project")?;
 
         Ok(())
     }

crates/eval/src/examples/mod.rs

@@ -11,10 +11,14 @@ use util::serde::default_true;
 
 use crate::example::{Example, ExampleContext, ExampleMetadata, JudgeAssertion};
 
+mod add_arg_to_trait_method;
 mod file_search;
 
 pub fn all(examples_dir: &Path) -> Vec<Rc<dyn Example>> {
-    let mut threads: Vec<Rc<dyn Example>> = vec![Rc::new(file_search::FileSearchExample)];
+    let mut threads: Vec<Rc<dyn Example>> = vec![
+        Rc::new(file_search::FileSearchExample),
+        Rc::new(add_arg_to_trait_method::AddArgToTraitMethod),
+    ];
 
     for example_path in list_declarative_examples(examples_dir).unwrap() {
         threads.push(Rc::new(DeclarativeExample::load(&example_path).unwrap()));

crates/eval/src/instance.rs

@@ -27,7 +27,7 @@ use std::time::Duration;
 use unindent::Unindent as _;
 use util::ResultExt as _;
 use util::command::new_smol_command;
-use util::markdown::MarkdownString;
+use util::markdown::MarkdownCodeBlock;
 
 use crate::assertions::{AssertionsReport, RanAssertion, RanAssertionResult};
 use crate::example::{Example, ExampleContext, FailedAssertion, JudgeAssertion};
@@ -218,8 +218,14 @@ impl ExampleInstance {
         });
 
         let tools = cx.new(|_| ToolWorkingSet::default());
-        let thread_store =
-            ThreadStore::load(project.clone(), tools, app_state.prompt_builder.clone(), cx);
+        let prompt_store = None;
+        let thread_store = ThreadStore::load(
+            project.clone(),
+            tools,
+            prompt_store,
+            app_state.prompt_builder.clone(),
+            cx,
+        );
         let meta = self.thread.meta();
         let this = self.clone();
 
@@ -567,6 +573,7 @@ impl ExampleInstance {
             let request = LanguageModelRequest {
                 thread_id: None,
                 prompt_id: None,
+                mode: None,
                 messages: vec![LanguageModelRequestMessage {
                     role: Role::User,
                     content: vec![MessageContent::Text(to_prompt(assertion.description))],
@@ -857,7 +864,10 @@ impl RequestMarkdown {
                 write!(
                     &mut tools,
                     "{}\n",
-                    MarkdownString::code_block("json", &format!("{:#}", tool.input_schema))
+                    MarkdownCodeBlock {
+                        tag: "json",
+                        text: &format!("{:#}", tool.input_schema)
+                    }
                 )
                 .unwrap();
             }
@@ -904,7 +914,10 @@ impl RequestMarkdown {
                         ));
                         messages.push_str(&format!(
                             "{}\n",
-                            MarkdownString::code_block("json", &format!("{:#}", tool_use.input))
+                            MarkdownCodeBlock {
+                                tag: "json",
+                                text: &format!("{:#}", tool_use.input)
+                            }
                         ));
                     }
                     MessageContent::ToolResult(tool_result) => {
@@ -966,7 +979,10 @@ pub fn response_events_to_markdown(
                 ));
                 response.push_str(&format!(
                     "{}\n",
-                    MarkdownString::code_block("json", &format!("{:#}", tool_use.input))
+                    MarkdownCodeBlock {
+                        tag: "json",
+                        text: &format!("{:#}", tool_use.input)
+                    }
                 ));
             }
             Ok(

crates/feature_flags/src/feature_flags.rs

@@ -59,28 +59,33 @@ impl FeatureFlag for Assistant2FeatureFlag {
     const NAME: &'static str = "assistant2";
 }
 
+pub struct NewBillingFeatureFlag;
+
+impl FeatureFlag for NewBillingFeatureFlag {
+    const NAME: &'static str = "new-billing";
+
+    fn enabled_for_staff() -> bool {
+        false
+    }
+}
+
 pub struct PredictEditsRateCompletionsFeatureFlag;
 impl FeatureFlag for PredictEditsRateCompletionsFeatureFlag {
     const NAME: &'static str = "predict-edits-rate-completions";
 }
 
-pub struct Remoting {}
-impl FeatureFlag for Remoting {
-    const NAME: &'static str = "remoting";
-}
-
-pub struct LanguageModels {}
-impl FeatureFlag for LanguageModels {
+pub struct LanguageModelsFeatureFlag {}
+impl FeatureFlag for LanguageModelsFeatureFlag {
     const NAME: &'static str = "language-models";
 }
 
-pub struct LlmClosedBeta {}
-impl FeatureFlag for LlmClosedBeta {
+pub struct LlmClosedBetaFeatureFlag {}
+impl FeatureFlag for LlmClosedBetaFeatureFlag {
     const NAME: &'static str = "llm-closed-beta";
 }
 
-pub struct ZedPro {}
-impl FeatureFlag for ZedPro {
+pub struct ZedProFeatureFlag {}
+impl FeatureFlag for ZedProFeatureFlag {
     const NAME: &'static str = "zed-pro";
 }
 
@@ -90,13 +95,13 @@ impl FeatureFlag for NotebookFeatureFlag {
     const NAME: &'static str = "notebooks";
 }
 
-pub struct Debugger {}
-impl FeatureFlag for Debugger {
+pub struct DebuggerFeatureFlag {}
+impl FeatureFlag for DebuggerFeatureFlag {
     const NAME: &'static str = "debugger";
 }
 
-pub struct ThreadAutoCapture {}
-impl FeatureFlag for ThreadAutoCapture {
+pub struct ThreadAutoCaptureFeatureFlag {}
+impl FeatureFlag for ThreadAutoCaptureFeatureFlag {
     const NAME: &'static str = "thread-auto-capture";
 
     fn enabled_for_staff() -> bool {