Remove log

I found a few more cases where the UI wasn't updated immediately after
an interaction.

Release Notes:

- agent: Fixed delay after removing threads from "Past Interactions"
- agent: Fixed delay after adding/remove context via keyboard

.config/hakari.toml

@@ -0,0 +1,43 @@
+# This file contains settings for `cargo hakari`.
+# See https://docs.rs/cargo-hakari/latest/cargo_hakari/config for a full list of options.
+
+hakari-package = "workspace-hack"
+
+resolver = "2"
+dep-format-version = "4"
+workspace-hack-line-style = "workspace-dotted"
+
+# this should be the same list as "targets" in ../rust-toolchain.toml
+platforms = [
+    "x86_64-apple-darwin",
+    "aarch64-apple-darwin",
+    "x86_64-unknown-linux-gnu",
+    "aarch64-unknown-linux-gnu",
+    "x86_64-pc-windows-msvc",
+    "x86_64-unknown-linux-musl", # remote server
+]
+
+[traversal-excludes]
+workspace-members = [
+    "remote_server",
+]
+third-party = [
+    { name = "reqwest", version = "0.11.27" },
+]
+
+[final-excludes]
+workspace-members = [
+    "zed_extension_api",
+
+    # exclude all extensions
+    "zed_emmet",
+    "zed_glsl",
+    "zed_html",
+    "perplexity",
+    "zed_proto",
+    "zed_ruff",
+    "slash_commands_example",
+    "zed_snippets",
+    "zed_test_extension",
+    "zed_toml",
+]

.github/workflows/ci.yml

@@ -110,6 +110,37 @@ jobs:
           input: "crates/proto/proto/"
           against: "https://github.com/${GITHUB_REPOSITORY}.git#branch=${BUF_BASE_BRANCH},subdir=crates/proto/proto/"
 
+  workspace_hack:
+    timeout-minutes: 60
+    name: Check workspace-hack crate
+    needs: [job_spec]
+    if: github.repository_owner == 'zed-industries'
+    runs-on:
+      - buildjet-8vcpu-ubuntu-2204
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: Add Rust to the PATH
+        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install cargo-hakari
+        uses: clechasseur/rs-cargo@8435b10f6e71c2e3d4d3b7573003a8ce4bfc6386 # v2
+        with:
+          command: install
+          args: cargo-hakari@0.9.35
+
+      - name: Check workspace-hack Cargo.toml is up-to-date
+        run: |
+          cargo hakari generate --diff || {
+            echo "To fix, run script/update-workspace-hack";
+            false
+          }
+      - name: Check all crates depend on workspace-hack
+        run: |
+          cargo hakari manage-deps --dry-run || {
+            echo "To fix, run script/update-workspace-hack"
+            false
+          }
+
   style:
     timeout-minutes: 60
     name: Check formatting and spelling
@@ -432,6 +463,7 @@ jobs:
       - job_spec
       - style
       - migration_checks
+      - workspace_hack
       - linux_tests
       - build_remote_server
       - macos_tests

Cargo.toml

@@ -192,6 +192,7 @@ members = [
     # Tooling
     #
 
+    "tooling/workspace-hack",
     "tooling/xtask",
 ]
 default-members = ["crates/zed"]
@@ -398,11 +399,11 @@ async-trait = "0.1"
 async-tungstenite = "0.28"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
-aws-config = { version = "1.5.16", features = ["behavior-version-latest"] }
-aws-credential-types = { version = "1.2.1", features = ["hardcoded-credentials"] }
-aws-sdk-bedrockruntime = { version = "1.73.0", features = ["behavior-version-latest"] }
-aws-smithy-runtime-api = { version = "1.7.3", features = ["http-1x", "client"] }
-aws-smithy-types = { version = "1.2.13", features = ["http-body-1-x"] }
+aws-config = { version = "1.6.1", features = ["behavior-version-latest"] }
+aws-credential-types = { version = "1.2.2", features = ["hardcoded-credentials"] }
+aws-sdk-bedrockruntime = { version = "1.80.0", features = ["behavior-version-latest"] }
+aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
+aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
 base64 = "0.22"
 bitflags = "2.6.0"
 blade-graphics = { git = "https://github.com/kvark/blade", rev = "b16f5c7bd873c7126f48c82c39e7ae64602ae74f" }
@@ -578,6 +579,7 @@ unicode-script = "0.5.7"
 url = "2.2"
 urlencoding = "2.1.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "v7", "serde"] }
+walkdir = "2.3"
 wasmparser = "0.221"
 wasm-encoder = "0.221"
 wasmtime = { version = "29", default-features = false, features = [
@@ -590,6 +592,7 @@ wasmtime = { version = "29", default-features = false, features = [
 wasmtime-wasi = "29"
 which = "6.0.0"
 wit-component = "0.221"
+workspace-hack = "0.1.0"
 zed_llm_client = "0.4"
 zstd = "0.11"
 metal = "0.29"
@@ -660,6 +663,9 @@ real-async-tls = { git = "https://github.com/zed-industries/async-tls", rev = "1
 notify = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" }
 notify-types = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" }
 
+# Makes the workspace hack crate refer to the local one, but only when you're building locally
+workspace-hack = { path = "tooling/workspace-hack" }
+
 [profile.dev]
 split-debuginfo = "unpacked"
 debug = "limited"
@@ -772,4 +778,4 @@ let_underscore_future = "allow"
 too_many_arguments = "allow"
 
 [workspace.metadata.cargo-machete]
-ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme"]
+ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme", "workspace-hack"]

assets/icons/forward_arrow.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-forward-icon lucide-forward"><polyline points="15 17 20 12 15 7"/><path d="M4 18v-2a4 4 0 0 1 4-4h12"/></svg>

assets/keymaps/default-linux.json

@@ -657,6 +657,15 @@
       "alt-enter": "editor::Newline"
     }
   },
+  {
+    "context": "AgentFeedbackMessageEditor > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline"
+    }
+  },
   {
     "context": "ContextStrip",
     "bindings": {

assets/keymaps/default-macos.json

@@ -317,6 +317,15 @@
       "alt-enter": "editor::Newline"
     }
   },
+  {
+    "context": "AgentFeedbackMessageEditor > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline"
+    }
+  },
   {
     "context": "ContextStrip",
     "use_key_equivalents": true,
@@ -330,9 +339,9 @@
     }
   },
   {
-    "context": "ThreadHistory",
+    "context": "ThreadHistory > Editor",
     "bindings": {
-      "backspace": "agent::RemoveSelectedThread"
+      "shift-backspace": "agent::RemoveSelectedThread"
     }
   },
   {

assets/prompts/assistant_system_prompt.hbs

@@ -15,6 +15,7 @@ Editing code:
 - You may only attempt to fix these up to 3 times. If you have tried 3 times to fix them, and there are still problems remaining, you must not continue trying to fix them, and must instead tell the user that there are problems remaining - and ask if the user would like you to attempt to solve them further.
 - Do not fix errors unrelated to your changes unless the user explicitly asks you to do so.
 - Prefer to move files over recreating them. The move can be followed by minor edits if required.
+- If you seem to be stuck, never go back and "simplify the implementation" by deleting the parts of the implementation you're stuck on and replacing them with comments. If you ever feel the urge to do this, instead immediately stop whatever you're doing (even if the code is in a broken state), report that you are stuck, explain what you're stuck on, and ask the user how to proceed.
 
 Tool use:
 - Make sure to adhere to the tools schema.

assets/settings/default.json

@@ -644,7 +644,7 @@
         "tools": {
           "diagnostics": true,
           "fetch": true,
-          "list_directory": true,
+          "list_directory": false,
           "now": true,
           "path_search": true,
           "read_file": true,
@@ -659,15 +659,14 @@
           "bash": true,
           "batch_tool": true,
           "code_symbols": true,
-          "copy_path": true,
+          "copy_path": false,
           "create_file": true,
-          "delete_path": true,
+          "delete_path": false,
           "diagnostics": true,
           "find_replace_file": true,
-          "edit_files": false,
           "fetch": true,
-          "list_directory": true,
-          "move_path": true,
+          "list_directory": false,
+          "move_path": false,
           "now": true,
           "path_search": true,
           "read_file": true,

crates/activity_indicator/Cargo.toml

@@ -25,6 +25,7 @@ smallvec.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }

crates/agent/Cargo.toml

@@ -81,11 +81,13 @@ theme.workspace = true
 time.workspace = true
 time_format.workspace = true
 ui.workspace = true
+ui_input.workspace = true
 util.workspace = true
 uuid.workspace = true
 vim_mode_setting.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 buffer_diff = { workspace = true, features = ["test-support"] }

crates/agent/src/agent_diff.rs

@@ -1,9 +1,9 @@
-use crate::{Thread, ThreadEvent};
+use crate::{Keep, Reject, Thread, ThreadEvent};
 use anyhow::Result;
 use buffer_diff::DiffHunkStatus;
 use collections::HashSet;
 use editor::{
-    AnchorRangeExt, Direction, Editor, EditorEvent, MultiBuffer, ToPoint,
+    Direction, Editor, EditorEvent, MultiBuffer, ToPoint,
     actions::{GoToHunk, GoToPreviousHunk},
     scroll::Autoscroll,
 };
@@ -26,6 +26,7 @@ use workspace::{
     item::{BreadcrumbText, ItemEvent, TabContentParams},
     searchable::SearchableItemHandle,
 };
+use zed_actions::assistant::ToggleFocus;
 
 pub struct AgentDiff {
     multibuffer: Entity<MultiBuffer>,
@@ -43,22 +44,29 @@ impl AgentDiff {
         workspace: WeakEntity<Workspace>,
         window: &mut Window,
         cx: &mut App,
-    ) -> Result<()> {
-        let existing_diff = workspace.update(cx, |workspace, cx| {
-            workspace
-                .items_of_type::<AgentDiff>(cx)
-                .find(|diff| diff.read(cx).thread == thread)
-        })?;
+    ) -> Result<Entity<Self>> {
+        workspace.update(cx, |workspace, cx| {
+            Self::deploy_in_workspace(thread, workspace, window, cx)
+        })
+    }
+
+    pub fn deploy_in_workspace(
+        thread: Entity<Thread>,
+        workspace: &mut Workspace,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) -> Entity<Self> {
+        let existing_diff = workspace
+            .items_of_type::<AgentDiff>(cx)
+            .find(|diff| diff.read(cx).thread == thread);
         if let Some(existing_diff) = existing_diff {
-            workspace.update(cx, |workspace, cx| {
-                workspace.activate_item(&existing_diff, true, true, window, cx);
-            })
+            workspace.activate_item(&existing_diff, true, true, window, cx);
+            existing_diff
         } else {
             let agent_diff =
-                cx.new(|cx| AgentDiff::new(thread.clone(), workspace.clone(), window, cx));
-            workspace.update(cx, |workspace, cx| {
-                workspace.add_item_to_center(Box::new(agent_diff), window, cx);
-            })
+                cx.new(|cx| AgentDiff::new(thread.clone(), workspace.weak_handle(), window, cx));
+            workspace.add_item_to_center(Box::new(agent_diff.clone()), window, cx);
+            agent_diff
         }
     }
 
@@ -133,11 +141,11 @@ impl AgentDiff {
         let mut paths_to_delete = self.multibuffer.read(cx).paths().collect::<HashSet<_>>();
 
         for (buffer, diff_handle) in changed_buffers {
-            let Some(file) = buffer.read(cx).file().cloned() else {
+            if buffer.read(cx).file().is_none() {
                 continue;
-            };
+            }
 
-            let path_key = PathKey::namespaced(0, file.full_path(cx).into());
+            let path_key = PathKey::for_buffer(&buffer, cx);
             paths_to_delete.remove(&path_key);
 
             let snapshot = buffer.read(cx).snapshot();
@@ -235,11 +243,31 @@ impl AgentDiff {
 
     fn handle_thread_event(&mut self, event: &ThreadEvent, cx: &mut Context<Self>) {
         match event {
-            ThreadEvent::SummaryChanged => self.update_title(cx),
+            ThreadEvent::SummaryGenerated => self.update_title(cx),
             _ => {}
         }
     }
 
+    pub fn move_to_path(&mut self, path_key: PathKey, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(position) = self.multibuffer.read(cx).location_for_path(&path_key, cx) {
+            self.editor.update(cx, |editor, cx| {
+                let first_hunk = editor
+                    .diff_hunks_in_ranges(
+                        &[position..editor::Anchor::max()],
+                        &self.multibuffer.read(cx).read(cx),
+                    )
+                    .next();
+
+                if let Some(first_hunk) = first_hunk {
+                    let first_hunk_start = first_hunk.multi_buffer_range().start;
+                    editor.change_selections(Some(Autoscroll::fit()), window, cx, |selections| {
+                        selections.select_anchor_ranges([first_hunk_start..first_hunk_start]);
+                    })
+                }
+            });
+        }
+    }
+
     fn keep(&mut self, _: &crate::Keep, window: &mut Window, cx: &mut Context<Self>) {
         let ranges = self
             .editor
@@ -327,13 +355,16 @@ impl AgentDiff {
             self.update_selection(&diff_hunks_in_ranges, window, cx);
         }
 
-        let point_ranges = ranges
-            .into_iter()
-            .map(|range| range.to_point(&snapshot))
-            .collect();
-        self.editor.update(cx, |editor, cx| {
-            editor.restore_hunks_in_ranges(point_ranges, window, cx)
-        });
+        for hunk in &diff_hunks_in_ranges {
+            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
+            if let Some(buffer) = buffer {
+                self.thread
+                    .update(cx, |thread, cx| {
+                        thread.reject_edits_in_range(buffer, hunk.buffer_range.clone(), cx)
+                    })
+                    .detach_and_log_err(cx);
+            }
+        }
     }
 
     fn update_selection(
@@ -553,11 +584,12 @@ impl Item for AgentDiff {
 }
 
 impl Render for AgentDiff {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let is_empty = self.multibuffer.read(cx).is_empty();
+        let focus_handle = &self.focus_handle;
 
         div()
-            .track_focus(&self.focus_handle)
+            .track_focus(focus_handle)
             .key_context(if is_empty { "EmptyPane" } else { "AgentDiff" })
             .on_action(cx.listener(Self::keep))
             .on_action(cx.listener(Self::reject))
@@ -568,7 +600,32 @@ impl Render for AgentDiff {
             .items_center()
             .justify_center()
             .size_full()
-            .when(is_empty, |el| el.child("No changes to review"))
+            .when(is_empty, |el| {
+                el.child(
+                    v_flex()
+                        .items_center()
+                        .gap_2()
+                        .child("No changes to review")
+                        .child(
+                            Button::new("continue-iterating", "Continue Iterating")
+                                .style(ButtonStyle::Filled)
+                                .icon(IconName::ForwardArrow)
+                                .icon_position(IconPosition::Start)
+                                .icon_size(IconSize::Small)
+                                .icon_color(Color::Muted)
+                                .full_width()
+                                .key_binding(KeyBinding::for_action_in(
+                                    &ToggleFocus,
+                                    &focus_handle.clone(),
+                                    window,
+                                    cx,
+                                ))
+                                .on_click(|_event, window, cx| {
+                                    window.dispatch_action(ToggleFocus.boxed_clone(), cx)
+                                }),
+                        ),
+                )
+            })
             .when(!is_empty, |el| el.child(self.editor.clone()))
     }
 }
@@ -604,7 +661,7 @@ fn render_diff_hunk_controls(
                 .disabled(is_created_file)
                 .key_binding(
                     KeyBinding::for_action_in(
-                        &crate::Reject,
+                        &Reject,
                         &editor.read(cx).focus_handle(cx),
                         window,
                         cx,
@@ -625,13 +682,8 @@ fn render_diff_hunk_controls(
                 }),
             Button::new(("keep", row as u64), "Keep")
                 .key_binding(
-                    KeyBinding::for_action_in(
-                        &crate::Keep,
-                        &editor.read(cx).focus_handle(cx),
-                        window,
-                        cx,
-                    )
-                    .map(|kb| kb.size(rems_from_px(12.))),
+                    KeyBinding::for_action_in(&Keep, &editor.read(cx).focus_handle(cx), window, cx)
+                        .map(|kb| kb.size(rems_from_px(12.))),
                 )
                 .on_click({
                     let agent_diff = agent_diff.clone();
@@ -942,7 +994,7 @@ mod tests {
             Point::new(3, 0)..Point::new(3, 0)
         );
 
-        // Restoring a hunk also moves the cursor to the next hunk, possibly cycling if it's at the end.
+        // Rejecting a hunk also moves the cursor to the next hunk, possibly cycling if it's at the end.
         editor.update_in(cx, |editor, window, cx| {
             editor.change_selections(None, window, cx, |selections| {
                 selections.select_ranges([Point::new(10, 0)..Point::new(10, 0)])

crates/agent/src/assistant.rs

@@ -51,7 +51,6 @@ actions!(
         ToggleProfileSelector,
         RemoveAllContext,
         OpenHistory,
-        OpenConfiguration,
         AddContextServer,
         RemoveSelectedThread,
         Chat,

crates/agent/src/assistant_configuration/add_context_server_modal.rs

@@ -1,17 +1,17 @@
 use context_server::{ContextServerSettings, ServerCommand, ServerConfig};
-use editor::Editor;
 use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, WeakEntity, prelude::*};
 use serde_json::json;
 use settings::update_settings_file;
 use ui::{Modal, ModalFooter, ModalHeader, Section, Tooltip, prelude::*};
+use ui_input::SingleLineInput;
 use workspace::{ModalView, Workspace};
 
 use crate::AddContextServer;
 
 pub struct AddContextServerModal {
     workspace: WeakEntity<Workspace>,
-    name_editor: Entity<Editor>,
-    command_editor: Entity<Editor>,
+    name_editor: Entity<SingleLineInput>,
+    command_editor: Entity<SingleLineInput>,
 }
 
 impl AddContextServerModal {
@@ -33,15 +33,10 @@ impl AddContextServerModal {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let name_editor = cx.new(|cx| Editor::single_line(window, cx));
-        let command_editor = cx.new(|cx| Editor::single_line(window, cx));
-
-        name_editor.update(cx, |editor, cx| {
-            editor.set_placeholder_text("Context server name", cx);
-        });
-
-        command_editor.update(cx, |editor, cx| {
-            editor.set_placeholder_text("Command to run the context server", cx);
+        let name_editor =
+            cx.new(|cx| SingleLineInput::new(window, cx, "Your server name").label("Name"));
+        let command_editor = cx.new(|cx| {
+            SingleLineInput::new(window, cx, "Command").label("Command to run the context server")
         });
 
         Self {
@@ -52,8 +47,22 @@ impl AddContextServerModal {
     }
 
     fn confirm(&mut self, cx: &mut Context<Self>) {
-        let name = self.name_editor.read(cx).text(cx).trim().to_string();
-        let command = self.command_editor.read(cx).text(cx).trim().to_string();
+        let name = self
+            .name_editor
+            .read(cx)
+            .editor()
+            .read(cx)
+            .text(cx)
+            .trim()
+            .to_string();
+        let command = self
+            .command_editor
+            .read(cx)
+            .editor()
+            .read(cx)
+            .text(cx)
+            .trim()
+            .to_string();
 
         if name.is_empty() || command.is_empty() {
             return;
@@ -104,8 +113,8 @@ impl EventEmitter<DismissEvent> for AddContextServerModal {}
 
 impl Render for AddContextServerModal {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let is_name_empty = self.name_editor.read(cx).text(cx).trim().is_empty();
-        let is_command_empty = self.command_editor.read(cx).text(cx).trim().is_empty();
+        let is_name_empty = self.name_editor.read(cx).is_empty(cx);
+        let is_command_empty = self.command_editor.read(cx).is_empty(cx);
 
         div()
             .elevation_3(cx)
@@ -122,18 +131,8 @@ impl Render for AddContextServerModal {
                     .header(ModalHeader::new().headline("Add Context Server"))
                     .section(
                         Section::new()
-                            .child(
-                                v_flex()
-                                    .gap_1()
-                                    .child(Label::new("Name"))
-                                    .child(self.name_editor.clone()),
-                            )
-                            .child(
-                                v_flex()
-                                    .gap_1()
-                                    .child(Label::new("Command"))
-                                    .child(self.command_editor.clone()),
-                            ),
+                            .child(self.name_editor.clone())
+                            .child(self.command_editor.clone()),
                     )
                     .footer(
                         ModalFooter::new()

crates/agent/src/assistant_configuration/tool_picker.rs

@@ -202,43 +202,43 @@ impl PickerDelegate for ToolPickerDelegate {
             let default_profile = self.profile.clone();
             let tool = tool.clone();
             move |settings, _cx| match settings {
-                AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(
-                    settings,
-                )) => {
-                    let profiles = settings.profiles.get_or_insert_default();
-                    let profile =
-                        profiles
-                            .entry(profile_id)
-                            .or_insert_with(|| AgentProfileContent {
-                                name: default_profile.name.into(),
-                                tools: default_profile.tools,
-                                enable_all_context_servers: Some(
-                                    default_profile.enable_all_context_servers,
-                                ),
-                                context_servers: default_profile
-                                    .context_servers
-                                    .into_iter()
-                                    .map(|(server_id, preset)| {
-                                        (
-                                            server_id,
-                                            ContextServerPresetContent {
-                                                tools: preset.tools,
-                                            },
-                                        )
-                                    })
-                                    .collect(),
-                            });
+                AssistantSettingsContent::Versioned(boxed) => {
+                    if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                        let profiles = settings.profiles.get_or_insert_default();
+                        let profile =
+                            profiles
+                                .entry(profile_id)
+                                .or_insert_with(|| AgentProfileContent {
+                                    name: default_profile.name.into(),
+                                    tools: default_profile.tools,
+                                    enable_all_context_servers: Some(
+                                        default_profile.enable_all_context_servers,
+                                    ),
+                                    context_servers: default_profile
+                                        .context_servers
+                                        .into_iter()
+                                        .map(|(server_id, preset)| {
+                                            (
+                                                server_id,
+                                                ContextServerPresetContent {
+                                                    tools: preset.tools,
+                                                },
+                                            )
+                                        })
+                                        .collect(),
+                                });
 
-                    match tool.source {
-                        ToolSource::Native => {
-                            *profile.tools.entry(tool.name).or_default() = is_enabled;
-                        }
-                        ToolSource::ContextServer { id } => {
-                            let preset = profile
-                                .context_servers
-                                .entry(id.clone().into())
-                                .or_default();
-                            *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
+                        match tool.source {
+                            ToolSource::Native => {
+                                *profile.tools.entry(tool.name).or_default() = is_enabled;
+                            }
+                            ToolSource::ContextServer { id } => {
+                                let preset = profile
+                                    .context_servers
+                                    .entry(id.clone().into())
+                                    .or_default();
+                                *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
+                            }
                         }
                     }
                 }

crates/agent/src/assistant_model_selector.rs

@@ -9,10 +9,17 @@ use settings::update_settings_file;
 use std::sync::Arc;
 use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*};
 
+#[derive(Clone, Copy)]
+pub enum ModelType {
+    Default,
+    InlineAssistant,
+}
+
 pub struct AssistantModelSelector {
     selector: Entity<LanguageModelSelector>,
     menu_handle: PopoverMenuHandle<LanguageModelSelector>,
     focus_handle: FocusHandle,
+    model_type: ModelType,
 }
 
 impl AssistantModelSelector {
@@ -20,6 +27,7 @@ impl AssistantModelSelector {
         fs: Arc<dyn Fs>,
         menu_handle: PopoverMenuHandle<LanguageModelSelector>,
         focus_handle: FocusHandle,
+        model_type: ModelType,
         window: &mut Window,
         cx: &mut App,
     ) -> Self {
@@ -28,11 +36,32 @@ impl AssistantModelSelector {
                 let fs = fs.clone();
                 LanguageModelSelector::new(
                     move |model, cx| {
-                        update_settings_file::<AssistantSettings>(
-                            fs.clone(),
-                            cx,
-                            move |settings, _cx| settings.set_model(model.clone()),
-                        );
+                        let provider = model.provider_id().0.to_string();
+                        let model_id = model.id().0.to_string();
+
+                        match model_type {
+                            ModelType::Default => {
+                                update_settings_file::<AssistantSettings>(
+                                    fs.clone(),
+                                    cx,
+                                    move |settings, _cx| {
+                                        settings.set_model(model.clone());
+                                    },
+                                );
+                            }
+                            ModelType::InlineAssistant => {
+                                update_settings_file::<AssistantSettings>(
+                                    fs.clone(),
+                                    cx,
+                                    move |settings, _cx| {
+                                        settings.set_inline_assistant_model(
+                                            provider.clone(),
+                                            model_id.clone(),
+                                        );
+                                    },
+                                );
+                            }
+                        }
                     },
                     window,
                     cx,
@@ -40,6 +69,7 @@ impl AssistantModelSelector {
             }),
             menu_handle,
             focus_handle,
+            model_type,
         }
     }
 
@@ -50,10 +80,16 @@ impl AssistantModelSelector {
 
 impl Render for AssistantModelSelector {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let active_model = LanguageModelRegistry::read_global(cx).active_model();
+        let model_registry = LanguageModelRegistry::read_global(cx);
+
+        let model = match self.model_type {
+            ModelType::Default => model_registry.default_model(),
+            ModelType::InlineAssistant => model_registry.inline_assistant_model(),
+        };
+
         let focus_handle = self.focus_handle.clone();
-        let model_name = match active_model {
-            Some(model) => model.name().0,
+        let model_name = match model {
+            Some(model) => model.model.name().0,
             _ => SharedString::from("No model selected"),
         };
 

crates/agent/src/assistant_panel.rs

@@ -1,5 +1,6 @@
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::time::Duration;
 
 use anyhow::{Result, anyhow};
 use assistant_context_editor::{
@@ -11,12 +12,12 @@ use assistant_slash_command::SlashCommandWorkingSet;
 use assistant_tool::ToolWorkingSet;
 
 use client::zed_urls;
-use editor::{Editor, MultiBuffer};
+use editor::{Editor, EditorEvent, MultiBuffer};
 use fs::Fs;
 use gpui::{
-    Action, AnyElement, App, AsyncWindowContext, Corner, Entity, EventEmitter, FocusHandle,
-    Focusable, FontWeight, KeyContext, Pixels, Subscription, Task, UpdateGlobal, WeakEntity,
-    action_with_deprecated_aliases, prelude::*,
+    Action, Animation, AnimationExt as _, AnyElement, App, AsyncWindowContext, Corner, Entity,
+    EventEmitter, FocusHandle, Focusable, FontWeight, KeyContext, Pixels, Subscription, Task,
+    UpdateGlobal, WeakEntity, prelude::*, pulsating_between,
 };
 use language::LanguageRegistry;
 use language_model::{LanguageModelProviderTosView, LanguageModelRegistry};
@@ -32,26 +33,21 @@ use ui::{
 use util::ResultExt as _;
 use workspace::Workspace;
 use workspace::dock::{DockPosition, Panel, PanelEvent};
-use zed_actions::assistant::ToggleFocus;
+use zed_actions::agent::OpenConfiguration;
+use zed_actions::assistant::{OpenPromptLibrary, ToggleFocus};
 
 use crate::active_thread::ActiveThread;
 use crate::assistant_configuration::{AssistantConfiguration, AssistantConfigurationEvent};
 use crate::history_store::{HistoryEntry, HistoryStore};
 use crate::message_editor::MessageEditor;
-use crate::thread::{Thread, ThreadError, ThreadId};
+use crate::thread::{Thread, ThreadError, ThreadId, TokenUsageRatio};
 use crate::thread_history::{PastContext, PastThread, ThreadHistory};
 use crate::thread_store::ThreadStore;
 use crate::{
     AgentDiff, InlineAssistant, NewPromptEditor, NewThread, OpenActiveThreadAsMarkdown,
-    OpenAgentDiff, OpenConfiguration, OpenHistory, ToggleContextPicker,
+    OpenAgentDiff, OpenHistory, ThreadEvent, ToggleContextPicker,
 };
 
-action_with_deprecated_aliases!(
-    assistant,
-    OpenPromptLibrary,
-    ["assistant::DeployPromptLibrary"]
-);
-
 pub fn init(cx: &mut App) {
     cx.observe_new(
         |workspace: &mut Workspace, _window, _cx: &mut Context<Workspace>| {
@@ -91,9 +87,8 @@ pub fn init(cx: &mut App) {
                 .register_action(|workspace, _: &OpenAgentDiff, window, cx| {
                     if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
                         workspace.focus_panel::<AssistantPanel>(window, cx);
-                        panel.update(cx, |panel, cx| {
-                            panel.open_agent_diff(&OpenAgentDiff, window, cx);
-                        });
+                        let thread = panel.read(cx).thread.read(cx).thread().clone();
+                        AgentDiff::deploy_in_workspace(thread, workspace, window, cx);
                     }
                 });
         },
@@ -102,12 +97,72 @@ pub fn init(cx: &mut App) {
 }
 
 enum ActiveView {
-    Thread,
+    Thread {
+        change_title_editor: Entity<Editor>,
+        _subscriptions: Vec<gpui::Subscription>,
+    },
     PromptEditor,
     History,
     Configuration,
 }
 
+impl ActiveView {
+    pub fn thread(thread: Entity<Thread>, window: &mut Window, cx: &mut App) -> Self {
+        let summary = thread.read(cx).summary_or_default();
+
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::single_line(window, cx);
+            editor.set_text(summary, window, cx);
+            editor
+        });
+
+        let subscriptions = vec![
+            window.subscribe(&editor, cx, {
+                {
+                    let thread = thread.clone();
+                    move |editor, event, window, cx| match event {
+                        EditorEvent::BufferEdited => {
+                            let new_summary = editor.read(cx).text(cx);
+
+                            thread.update(cx, |thread, cx| {
+                                thread.set_summary(new_summary, cx);
+                            })
+                        }
+                        EditorEvent::Blurred => {
+                            if editor.read(cx).text(cx).is_empty() {
+                                let summary = thread.read(cx).summary_or_default();
+
+                                editor.update(cx, |editor, cx| {
+                                    editor.set_text(summary, window, cx);
+                                });
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }),
+            window.subscribe(&thread, cx, {
+                let editor = editor.clone();
+                move |thread, event, window, cx| match event {
+                    ThreadEvent::SummaryGenerated => {
+                        let summary = thread.read(cx).summary_or_default();
+
+                        editor.update(cx, |editor, cx| {
+                            editor.set_text(summary, window, cx);
+                        })
+                    }
+                    _ => {}
+                }
+            }),
+        ];
+
+        Self::Thread {
+            change_title_editor: editor,
+            _subscriptions: subscriptions,
+        }
+    }
+}
+
 pub struct AssistantPanel {
     workspace: WeakEntity<Workspace>,
     project: Entity<Project>,
@@ -115,6 +170,7 @@ pub struct AssistantPanel {
     language_registry: Arc<LanguageRegistry>,
     thread_store: Entity<ThreadStore>,
     thread: Entity<ActiveThread>,
+    _thread_subscription: Subscription,
     message_editor: Entity<MessageEditor>,
     context_store: Entity<assistant_context_editor::ContextStore>,
     context_editor: Option<Entity<ContextEditor>>,
@@ -197,6 +253,15 @@ impl AssistantPanel {
         let history_store =
             cx.new(|cx| HistoryStore::new(thread_store.clone(), context_store.clone(), cx));
 
+        cx.observe(&history_store, |_, _, cx| cx.notify()).detach();
+
+        let active_view = ActiveView::thread(thread.clone(), window, cx);
+        let thread_subscription = cx.subscribe(&thread, |_, _, event, cx| {
+            if let ThreadEvent::MessageAdded(_) = &event {
+                // needed to leave empty state
+                cx.notify();
+            }
+        });
         let thread = cx.new(|cx| {
             ActiveThread::new(
                 thread.clone(),
@@ -210,13 +275,14 @@ impl AssistantPanel {
         });
 
         Self {
-            active_view: ActiveView::Thread,
+            active_view,
             workspace,
             project: project.clone(),
             fs: fs.clone(),
             language_registry,
             thread_store: thread_store.clone(),
             thread,
+            _thread_subscription: thread_subscription,
             message_editor,
             context_store,
             context_editor: None,
@@ -227,7 +293,7 @@ impl AssistantPanel {
             )
             .unwrap(),
             history_store: history_store.clone(),
-            history: cx.new(|cx| ThreadHistory::new(weak_self, history_store, cx)),
+            history: cx.new(|cx| ThreadHistory::new(weak_self, history_store, window, cx)),
             assistant_dropdown_menu_handle: PopoverMenuHandle::default(),
             width: None,
             height: None,
@@ -271,7 +337,7 @@ impl AssistantPanel {
             .thread_store
             .update(cx, |this, cx| this.create_thread(cx));
 
-        self.active_view = ActiveView::Thread;
+        self.active_view = ActiveView::thread(thread.clone(), window, cx);
 
         let message_editor_context_store = cx.new(|_cx| {
             crate::context_store::ContextStore::new(
@@ -311,6 +377,14 @@ impl AssistantPanel {
                 cx,
             )
         });
+
+        self._thread_subscription = cx.subscribe(&thread, |_, _, event, cx| {
+            if let ThreadEvent::MessageAdded(_) = &event {
+                // needed to leave empty state
+                cx.notify();
+            }
+        });
+
         self.message_editor = cx.new(|cx| {
             MessageEditor::new(
                 self.fs.clone(),
@@ -435,7 +509,7 @@ impl AssistantPanel {
         cx.spawn_in(window, async move |this, cx| {
             let thread = open_thread_task.await?;
             this.update_in(cx, |this, window, cx| {
-                this.active_view = ActiveView::Thread;
+                this.active_view = ActiveView::thread(thread.clone(), window, cx);
                 let message_editor_context_store = cx.new(|_cx| {
                     crate::context_store::ContextStore::new(
                         this.workspace.clone(),
@@ -476,7 +550,11 @@ impl AssistantPanel {
         cx: &mut Context<Self>,
     ) {
         let thread = self.thread.read(cx).thread().clone();
-        AgentDiff::deploy(thread, self.workspace.clone(), window, cx).log_err();
+        self.workspace
+            .update(cx, |workspace, cx| {
+                AgentDiff::deploy_in_workspace(thread, workspace, window, cx)
+            })
+            .log_err();
     }
 
     pub(crate) fn open_configuration(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -570,10 +648,8 @@ impl AssistantPanel {
         match event {
             AssistantConfigurationEvent::NewThread(provider) => {
                 if LanguageModelRegistry::read_global(cx)
-                    .active_provider()
-                    .map_or(true, |active_provider| {
-                        active_provider.id() != provider.id()
-                    })
+                    .default_model()
+                    .map_or(true, |model| model.provider.id() != provider.id())
                 {
                     if let Some(model) = provider.default_model(cx) {
                         update_settings_file::<AssistantSettings>(
@@ -593,27 +669,33 @@ impl AssistantPanel {
         self.thread.read(cx).thread().clone()
     }
 
-    pub(crate) fn delete_thread(&mut self, thread_id: &ThreadId, cx: &mut Context<Self>) {
+    pub(crate) fn delete_thread(
+        &mut self,
+        thread_id: &ThreadId,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
         self.thread_store
             .update(cx, |this, cx| this.delete_thread(thread_id, cx))
-            .detach_and_log_err(cx);
     }
 
     pub(crate) fn active_context_editor(&self) -> Option<Entity<ContextEditor>> {
         self.context_editor.clone()
     }
 
-    pub(crate) fn delete_context(&mut self, path: PathBuf, cx: &mut Context<Self>) {
+    pub(crate) fn delete_context(
+        &mut self,
+        path: PathBuf,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
         self.context_store
             .update(cx, |this, cx| this.delete_local_context(path, cx))
-            .detach_and_log_err(cx);
     }
 }
 
 impl Focusable for AssistantPanel {
     fn focus_handle(&self, cx: &App) -> FocusHandle {
         match self.active_view {
-            ActiveView::Thread => self.message_editor.focus_handle(cx),
+            ActiveView::Thread { .. } => self.message_editor.focus_handle(cx),
             ActiveView::History => self.history.focus_handle(cx),
             ActiveView::PromptEditor => {
                 if let Some(context_editor) = self.context_editor.as_ref() {
@@ -714,70 +796,159 @@ impl Panel for AssistantPanel {
 }
 
 impl AssistantPanel {
-    fn render_toolbar(&self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let thread = self.thread.read(cx);
-        let is_empty = thread.is_empty();
+    fn render_title_view(&self, _window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
+        const LOADING_SUMMARY_PLACEHOLDER: &str = "Loading Summary…";
 
-        let thread_id = thread.thread().read(cx).id().clone();
-        let focus_handle = self.focus_handle(cx);
+        let content = match &self.active_view {
+            ActiveView::Thread {
+                change_title_editor,
+                ..
+            } => {
+                let active_thread = self.thread.read(cx);
+                let is_empty = active_thread.is_empty();
+
+                let summary = active_thread.summary(cx);
 
-        let title = match self.active_view {
-            ActiveView::Thread => {
                 if is_empty {
-                    thread.summary_or_default(cx)
+                    Label::new(Thread::DEFAULT_SUMMARY.clone())
+                        .truncate()
+                        .into_any_element()
+                } else if summary.is_none() {
+                    Label::new(LOADING_SUMMARY_PLACEHOLDER)
+                        .truncate()
+                        .into_any_element()
                 } else {
-                    thread
-                        .summary(cx)
-                        .unwrap_or_else(|| SharedString::from("Loading Summary…"))
+                    change_title_editor.clone().into_any_element()
                 }
             }
-            ActiveView::PromptEditor => self
-                .context_editor
-                .as_ref()
-                .map(|context_editor| {
-                    SharedString::from(context_editor.read(cx).title(cx).to_string())
-                })
-                .unwrap_or_else(|| SharedString::from("Loading Summary…")),
-            ActiveView::History => "History".into(),
-            ActiveView::Configuration => "Settings".into(),
+            ActiveView::PromptEditor => {
+                let title = self
+                    .context_editor
+                    .as_ref()
+                    .map(|context_editor| {
+                        SharedString::from(context_editor.read(cx).title(cx).to_string())
+                    })
+                    .unwrap_or_else(|| SharedString::from(LOADING_SUMMARY_PLACEHOLDER));
+
+                Label::new(title).truncate().into_any_element()
+            }
+            ActiveView::History => Label::new("History").truncate().into_any_element(),
+            ActiveView::Configuration => Label::new("Settings").truncate().into_any_element(),
+        };
+
+        h_flex()
+            .key_context("TitleEditor")
+            .id("TitleEditor")
+            .pl_2()
+            .flex_grow()
+            .w_full()
+            .max_w_full()
+            .overflow_x_scroll()
+            .child(content)
+            .into_any()
+    }
+
+    fn render_toolbar(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let active_thread = self.thread.read(cx);
+        let thread = active_thread.thread().read(cx);
+        let token_usage = thread.total_token_usage(cx);
+        let thread_id = thread.id().clone();
+
+        let is_generating = thread.is_generating();
+        let is_empty = active_thread.is_empty();
+        let focus_handle = self.focus_handle(cx);
+
+        let show_token_count = match &self.active_view {
+            ActiveView::Thread { .. } => !is_empty,
+            ActiveView::PromptEditor => self.context_editor.is_some(),
+            _ => false,
         };
 
         h_flex()
             .id("assistant-toolbar")
             .h(Tab::container_height(cx))
+            .max_w_full()
             .flex_none()
             .justify_between()
-            .gap(DynamicSpacing::Base08.rems(cx))
+            .gap_2()
             .bg(cx.theme().colors().tab_bar_background)
             .border_b_1()
             .border_color(cx.theme().colors().border)
-            .child(
-                div()
-                    .id("title")
-                    .overflow_x_scroll()
-                    .px(DynamicSpacing::Base08.rems(cx))
-                    .child(Label::new(title).truncate()),
-            )
+            .child(self.render_title_view(window, cx))
             .child(
                 h_flex()
                     .h_full()
-                    .pl_2()
                     .gap_2()
-                    .bg(cx.theme().colors().tab_bar_background)
-                    .children(if matches!(self.active_view, ActiveView::PromptEditor) {
-                        self.context_editor
-                            .as_ref()
-                            .and_then(|editor| render_remaining_tokens(editor, cx))
-                    } else {
-                        None
+                    .when(show_token_count, |parent| match self.active_view {
+                        ActiveView::Thread { .. } => {
+                            if token_usage.total == 0 {
+                                return parent;
+                            }
+
+                            let token_color = match token_usage.ratio {
+                                TokenUsageRatio::Normal => Color::Muted,
+                                TokenUsageRatio::Warning => Color::Warning,
+                                TokenUsageRatio::Exceeded => Color::Error,
+                            };
+
+                            parent.child(
+                                h_flex()
+                                    .flex_shrink_0()
+                                    .gap_0p5()
+                                    .child(
+                                        Label::new(assistant_context_editor::humanize_token_count(
+                                            token_usage.total,
+                                        ))
+                                        .size(LabelSize::Small)
+                                        .color(token_color)
+                                        .map(|label| {
+                                            if is_generating {
+                                                label
+                                                    .with_animation(
+                                                        "used-tokens-label",
+                                                        Animation::new(Duration::from_secs(2))
+                                                            .repeat()
+                                                            .with_easing(pulsating_between(
+                                                                0.6, 1.,
+                                                            )),
+                                                        |label, delta| label.alpha(delta),
+                                                    )
+                                                    .into_any()
+                                            } else {
+                                                label.into_any_element()
+                                            }
+                                        }),
+                                    )
+                                    .child(
+                                        Label::new("/").size(LabelSize::Small).color(Color::Muted),
+                                    )
+                                    .child(
+                                        Label::new(assistant_context_editor::humanize_token_count(
+                                            token_usage.max,
+                                        ))
+                                        .size(LabelSize::Small)
+                                        .color(Color::Muted),
+                                    ),
+                            )
+                        }
+                        ActiveView::PromptEditor => {
+                            let Some(editor) = self.context_editor.as_ref() else {
+                                return parent;
+                            };
+                            let Some(element) = render_remaining_tokens(editor, cx) else {
+                                return parent;
+                            };
+                            parent.child(element)
+                        }
+                        _ => parent,
                     })
                     .child(
                         h_flex()
                             .h_full()
+                            .gap(DynamicSpacing::Base02.rems(cx))
                             .px(DynamicSpacing::Base08.rems(cx))
                             .border_l_1()
                             .border_color(cx.theme().colors().border)
-                            .gap(DynamicSpacing::Base02.rems(cx))
                             .child(
                                 IconButton::new("new", IconName::Plus)
                                     .icon_size(IconSize::Small)
@@ -857,16 +1028,18 @@ impl AssistantPanel {
     }
 
     fn configuration_error(&self, cx: &App) -> Option<ConfigurationError> {
-        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
             return Some(ConfigurationError::NoProvider);
         };
 
-        if !provider.is_authenticated(cx) {
+        if !model.provider.is_authenticated(cx) {
             return Some(ConfigurationError::ProviderNotAuthenticated);
         }
 
-        if provider.must_accept_terms(cx) {
-            return Some(ConfigurationError::ProviderPendingTermsAcceptance(provider));
+        if model.provider.must_accept_terms(cx) {
+            return Some(ConfigurationError::ProviderPendingTermsAcceptance(
+                model.provider,
+            ));
         }
 
         None
@@ -1069,11 +1242,11 @@ impl AssistantPanel {
                                     // TODO: Add keyboard navigation.
                                     match entry {
                                         HistoryEntry::Thread(thread) => {
-                                            PastThread::new(thread, cx.entity().downgrade(), false)
+                                            PastThread::new(thread, cx.entity().downgrade(), false, vec![])
                                                 .into_any_element()
                                         }
                                         HistoryEntry::Context(context) => {
-                                            PastContext::new(context, cx.entity().downgrade(), false)
+                                            PastContext::new(context, cx.entity().downgrade(), false, vec![])
                                                 .into_any_element()
                                         }
                                     }
@@ -1329,7 +1502,7 @@ impl Render for AssistantPanel {
             .on_action(cx.listener(Self::open_agent_diff))
             .child(self.render_toolbar(window, cx))
             .map(|parent| match self.active_view {
-                ActiveView::Thread => parent
+                ActiveView::Thread { .. } => parent
                     .child(self.render_active_thread_or_empty_state(window, cx))
                     .child(h_flex().child(self.message_editor.clone()))
                     .children(self.render_last_error(cx)),

crates/agent/src/buffer_codegen.rs

@@ -156,8 +156,9 @@ impl BufferCodegen {
         }
 
         let primary_model = LanguageModelRegistry::read_global(cx)
-            .active_model()
-            .context("no active model")?;
+            .default_model()
+            .context("no active model")?
+            .model;
 
         for (model, alternative) in iter::once(primary_model)
             .chain(alternative_models)

crates/agent/src/context.rs

@@ -146,11 +146,11 @@ pub struct ContextSymbolId {
     pub range: Range<Anchor>,
 }
 
-pub fn attach_context_to_message<'a>(
-    message: &mut LanguageModelRequestMessage,
+/// Formats a collection of contexts into a string representation
+pub fn format_context_as_string<'a>(
     contexts: impl Iterator<Item = &'a AssistantContext>,
     cx: &App,
-) {
+) -> Option<String> {
     let mut file_context = Vec::new();
     let mut directory_context = Vec::new();
     let mut symbol_context = Vec::new();
@@ -167,64 +167,78 @@ pub fn attach_context_to_message<'a>(
         }
     }
 
-    let mut context_chunks = Vec::new();
+    if file_context.is_empty()
+        && directory_context.is_empty()
+        && symbol_context.is_empty()
+        && fetch_context.is_empty()
+        && thread_context.is_empty()
+    {
+        return None;
+    }
+
+    let mut result = String::new();
+    result.push_str("\n<context>\n\
+        The following items were attached by the user. You don't need to use other tools to read them.\n\n");
 
     if !file_context.is_empty() {
-        context_chunks.push("<files>\n");
+        result.push_str("<files>\n");
         for context in file_context {
-            context_chunks.push(&context.context_buffer.text);
+            result.push_str(&context.context_buffer.text);
         }
-        context_chunks.push("\n</files>\n");
+        result.push_str("</files>\n");
     }
 
     if !directory_context.is_empty() {
-        context_chunks.push("<directories>\n");
+        result.push_str("<directories>\n");
         for context in directory_context {
             for context_buffer in &context.context_buffers {
-                context_chunks.push(&context_buffer.text);
+                result.push_str(&context_buffer.text);
             }
         }
-        context_chunks.push("\n</directories>\n");
+        result.push_str("</directories>\n");
     }
 
     if !symbol_context.is_empty() {
-        context_chunks.push("<symbols>\n");
+        result.push_str("<symbols>\n");
         for context in symbol_context {
-            context_chunks.push(&context.context_symbol.text);
+            result.push_str(&context.context_symbol.text);
+            result.push('\n');
         }
-        context_chunks.push("\n</symbols>\n");
+        result.push_str("</symbols>\n");
     }
 
     if !fetch_context.is_empty() {
-        context_chunks.push("<fetched_urls>\n");
+        result.push_str("<fetched_urls>\n");
         for context in &fetch_context {
-            context_chunks.push(&context.url);
-            context_chunks.push(&context.text);
+            result.push_str(&context.url);
+            result.push('\n');
+            result.push_str(&context.text);
+            result.push('\n');
         }
-        context_chunks.push("\n</fetched_urls>\n");
+        result.push_str("</fetched_urls>\n");
     }
 
-    // Need to own the SharedString for summary so that it can be referenced.
-    let mut thread_context_chunks = Vec::new();
     if !thread_context.is_empty() {
-        context_chunks.push("<conversation_threads>\n");
+        result.push_str("<conversation_threads>\n");
         for context in &thread_context {
-            thread_context_chunks.push(context.summary(cx));
-            thread_context_chunks.push(context.text.clone());
+            result.push_str(&context.summary(cx));
+            result.push('\n');
+            result.push_str(&context.text);
+            result.push('\n');
         }
-        context_chunks.push("\n</conversation_threads>\n");
+        result.push_str("</conversation_threads>\n");
     }
 
-    for chunk in &thread_context_chunks {
-        context_chunks.push(chunk);
-    }
+    result.push_str("</context>\n");
+    Some(result)
+}
 
-    if !context_chunks.is_empty() {
-        message.content.push(
-            "\n<context>\n\
-                The following items were attached by the user. You don't need to use other tools to read them.\n\n".into(),
-        );
-        message.content.push(context_chunks.join("\n").into());
-        message.content.push("\n</context>\n".into());
+pub fn attach_context_to_message<'a>(
+    message: &mut LanguageModelRequestMessage,
+    contexts: impl Iterator<Item = &'a AssistantContext>,
+    cx: &App,
+) {
+    if let Some(context_string) = format_context_as_string(contexts, cx) {
+        message.content.push(context_string.into());
     }
 }

crates/agent/src/context_picker.rs

@@ -13,7 +13,8 @@ use editor::display_map::{Crease, FoldId};
 use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
 use file_context_picker::render_file_context_entry;
 use gpui::{
-    App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
+    App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Subscription, Task,
+    WeakEntity,
 };
 use multi_buffer::MultiBufferRow;
 use project::{Entry, ProjectPath};
@@ -76,7 +77,7 @@ impl ContextPickerMode {
             Self::File => "Files & Directories",
             Self::Symbol => "Symbols",
             Self::Fetch => "Fetch",
-            Self::Thread => "Thread",
+            Self::Thread => "Threads",
         }
     }
 
@@ -105,6 +106,7 @@ pub(super) struct ContextPicker {
     context_store: WeakEntity<ContextStore>,
     thread_store: Option<WeakEntity<ThreadStore>>,
     confirm_behavior: ConfirmBehavior,
+    _subscriptions: Vec<Subscription>,
 }
 
 impl ContextPicker {
@@ -116,6 +118,22 @@ impl ContextPicker {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
+        let subscriptions = context_store
+            .upgrade()
+            .map(|context_store| {
+                cx.observe(&context_store, |this, _, cx| this.notify_current_picker(cx))
+            })
+            .into_iter()
+            .chain(
+                thread_store
+                    .as_ref()
+                    .and_then(|thread_store| thread_store.upgrade())
+                    .map(|thread_store| {
+                        cx.observe(&thread_store, |this, _, cx| this.notify_current_picker(cx))
+                    }),
+            )
+            .collect::<Vec<Subscription>>();
+
         ContextPicker {
             mode: ContextPickerState::Default(ContextMenu::build(
                 window,
@@ -126,6 +144,7 @@ impl ContextPicker {
             context_store,
             thread_store,
             confirm_behavior,
+            _subscriptions: subscriptions,
         }
     }
 
@@ -360,73 +379,25 @@ impl ContextPicker {
     }
 
     fn recent_entries(&self, cx: &mut App) -> Vec<RecentEntry> {
-        let Some(workspace) = self.workspace.upgrade().map(|w| w.read(cx)) else {
+        let Some(workspace) = self.workspace.upgrade() else {
             return vec![];
         };
 
-        let Some(context_store) = self.context_store.upgrade().map(|cs| cs.read(cx)) else {
+        let Some(context_store) = self.context_store.upgrade() else {
             return vec![];
         };
 
-        let mut recent = Vec::with_capacity(6);
+        recent_context_picker_entries(context_store, self.thread_store.clone(), workspace, cx)
+    }
 
-        let mut current_files = context_store.file_paths(cx);
-
-        if let Some(active_path) = active_singleton_buffer_path(&workspace, cx) {
-            current_files.insert(active_path);
+    fn notify_current_picker(&mut self, cx: &mut Context<Self>) {
+        match &self.mode {
+            ContextPickerState::Default(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::File(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::Symbol(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::Fetch(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::Thread(entity) => entity.update(cx, |_, cx| cx.notify()),
         }
-
-        let project = workspace.project().read(cx);
-
-        recent.extend(
-            workspace
-                .recent_navigation_history_iter(cx)
-                .filter(|(path, _)| !current_files.contains(&path.path.to_path_buf()))
-                .take(4)
-                .filter_map(|(project_path, _)| {
-                    project
-                        .worktree_for_id(project_path.worktree_id, cx)
-                        .map(|worktree| RecentEntry::File {
-                            project_path,
-                            path_prefix: worktree.read(cx).root_name().into(),
-                        })
-                }),
-        );
-
-        let mut current_threads = context_store.thread_ids();
-
-        if let Some(active_thread) = workspace
-            .panel::<AssistantPanel>(cx)
-            .map(|panel| panel.read(cx).active_thread(cx))
-        {
-            current_threads.insert(active_thread.read(cx).id().clone());
-        }
-
-        let Some(thread_store) = self
-            .thread_store
-            .as_ref()
-            .and_then(|thread_store| thread_store.upgrade())
-        else {
-            return recent;
-        };
-
-        thread_store.update(cx, |thread_store, _cx| {
-            recent.extend(
-                thread_store
-                    .threads()
-                    .into_iter()
-                    .filter(|thread| !current_threads.contains(&thread.id))
-                    .take(2)
-                    .map(|thread| {
-                        RecentEntry::Thread(ThreadContextEntry {
-                            id: thread.id,
-                            summary: thread.summary,
-                        })
-                    }),
-            )
-        });
-
-        recent
     }
 }
 
@@ -480,16 +451,6 @@ fn supported_context_picker_modes(
     modes
 }
 
-fn active_singleton_buffer_path(workspace: &Workspace, cx: &App) -> Option<PathBuf> {
-    let active_item = workspace.active_item(cx)?;
-
-    let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
-    let buffer = editor.buffer().read(cx).as_singleton()?;
-
-    let path = buffer.read(cx).file()?.path().to_path_buf();
-    Some(path)
-}
-
 fn recent_context_picker_entries(
     context_store: Entity<ContextStore>,
     thread_store: Option<WeakEntity<ThreadStore>>,
@@ -498,14 +459,8 @@ fn recent_context_picker_entries(
 ) -> Vec<RecentEntry> {
     let mut recent = Vec::with_capacity(6);
 
-    let mut current_files = context_store.read(cx).file_paths(cx);
-
+    let current_files = context_store.read(cx).file_paths(cx);
     let workspace = workspace.read(cx);
-
-    if let Some(active_path) = active_singleton_buffer_path(workspace, cx) {
-        current_files.insert(active_path);
-    }
-
     let project = workspace.project().read(cx);
 
     recent.extend(
@@ -683,24 +638,45 @@ fn fold_toggle(
 pub enum MentionLink {
     File(ProjectPath, Entry),
     Symbol(ProjectPath, String),
+    Fetch(String),
     Thread(ThreadId),
 }
 
 impl MentionLink {
+    const FILE: &str = "@file";
+    const SYMBOL: &str = "@symbol";
+    const THREAD: &str = "@thread";
+    const FETCH: &str = "@fetch";
+
+    const SEPARATOR: &str = ":";
+
+    pub fn is_valid(url: &str) -> bool {
+        url.starts_with(Self::FILE)
+            || url.starts_with(Self::SYMBOL)
+            || url.starts_with(Self::FETCH)
+            || url.starts_with(Self::THREAD)
+    }
+
     pub fn for_file(file_name: &str, full_path: &str) -> String {
-        format!("[@{}](file:{})", file_name, full_path)
+        format!("[@{}]({}:{})", file_name, Self::FILE, full_path)
     }
 
     pub fn for_symbol(symbol_name: &str, full_path: &str) -> String {
-        format!("[@{}](symbol:{}:{})", symbol_name, full_path, symbol_name)
+        format!(
+            "[@{}]({}:{}:{})",
+            symbol_name,
+            Self::SYMBOL,
+            full_path,
+            symbol_name
+        )
     }
 
     pub fn for_fetch(url: &str) -> String {
-        format!("[@{}]({})", url, url)
+        format!("[@{}]({}:{})", url, Self::FETCH, url)
     }
 
     pub fn for_thread(thread: &ThreadContextEntry) -> String {
-        format!("[@{}](thread:{})", thread.summary, thread.id)
+        format!("[@{}]({}:{})", thread.summary, Self::THREAD, thread.id)
     }
 
     pub fn try_parse(link: &str, workspace: &Entity<Workspace>, cx: &App) -> Option<Self> {
@@ -723,17 +699,10 @@ impl MentionLink {
             })
         }
 
-        let (prefix, link, target) = {
-            let mut parts = link.splitn(3, ':');
-            let prefix = parts.next();
-            let link = parts.next();
-            let target = parts.next();
-            (prefix, link, target)
-        };
-
-        match (prefix, link, target) {
-            (Some("file"), Some(path), _) => {
-                let project_path = extract_project_path_from_link(path, workspace, cx)?;
+        let (prefix, argument) = link.split_once(Self::SEPARATOR)?;
+        match prefix {
+            Self::FILE => {
+                let project_path = extract_project_path_from_link(argument, workspace, cx)?;
                 let entry = workspace
                     .read(cx)
                     .project()
@@ -741,14 +710,16 @@ impl MentionLink {
                     .entry_for_path(&project_path, cx)?;
                 Some(MentionLink::File(project_path, entry))
             }
-            (Some("symbol"), Some(path), Some(symbol_name)) => {
+            Self::SYMBOL => {
+                let (path, symbol) = argument.split_once(Self::SEPARATOR)?;
                 let project_path = extract_project_path_from_link(path, workspace, cx)?;
-                Some(MentionLink::Symbol(project_path, symbol_name.to_string()))
+                Some(MentionLink::Symbol(project_path, symbol.to_string()))
             }
-            (Some("thread"), Some(thread_id), _) => {
-                let thread_id = ThreadId::from(thread_id);
+            Self::THREAD => {
+                let thread_id = ThreadId::from(argument);
                 Some(MentionLink::Thread(thread_id))
             }
+            Self::FETCH => Some(MentionLink::Fetch(argument.to_string())),
             _ => None,
         }
     }

crates/agent/src/context_picker/completion_provider.rs

@@ -232,8 +232,8 @@ impl ContextPickerCompletionProvider {
                                 url_to_fetch.to_string(),
                             ))
                             .await?;
-                        context_store.update(cx, |context_store, _| {
-                            context_store.add_fetched_url(url_to_fetch.to_string(), content)
+                        context_store.update(cx, |context_store, cx| {
+                            context_store.add_fetched_url(url_to_fetch.to_string(), content, cx)
                         })
                     })
                     .detach_and_log_err(cx);
@@ -890,10 +890,10 @@ mod tests {
             assert_eq!(
                 current_completion_labels(editor),
                 &[
+                    "editor dir/",
                     "seven.txt dir/b/",
                     "six.txt dir/b/",
                     "five.txt dir/b/",
-                    "four.txt dir/a/",
                     "Files & Directories",
                     "Symbols",
                     "Fetch"
@@ -932,22 +932,22 @@ mod tests {
         });
 
         editor.update(&mut cx, |editor, cx| {
-            assert_eq!(editor.text(cx), "Lorem [@one.txt](file:dir/a/one.txt)",);
+            assert_eq!(editor.text(cx), "Lorem [@one.txt](@file:dir/a/one.txt)",);
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
         cx.simulate_input(" ");
 
         editor.update(&mut cx, |editor, cx| {
-            assert_eq!(editor.text(cx), "Lorem [@one.txt](file:dir/a/one.txt) ",);
+            assert_eq!(editor.text(cx), "Lorem [@one.txt](@file:dir/a/one.txt) ",);
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
@@ -956,12 +956,12 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum ",
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum ",
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
@@ -970,12 +970,12 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum @file ",
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum @file ",
             );
             assert!(editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
@@ -988,14 +988,14 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum [@seven.txt](file:dir/b/seven.txt)"
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)"
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 36),
-                    Point::new(0, 43)..Point::new(0, 77)
+                    Point::new(0, 6)..Point::new(0, 37),
+                    Point::new(0, 44)..Point::new(0, 71)
                 ]
             );
         });
@@ -1005,14 +1005,14 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum [@seven.txt](file:dir/b/seven.txt)\n@"
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)\n@"
             );
             assert!(editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 36),
-                    Point::new(0, 43)..Point::new(0, 77)
+                    Point::new(0, 6)..Point::new(0, 37),
+                    Point::new(0, 44)..Point::new(0, 71)
                 ]
             );
         });
@@ -1026,15 +1026,15 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum [@seven.txt](file:dir/b/seven.txt)\n[@six.txt](file:dir/b/six.txt)"
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)\n[@seven.txt](@file:dir/b/seven.txt)"
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 36),
-                    Point::new(0, 43)..Point::new(0, 77),
-                    Point::new(1, 0)..Point::new(1, 30)
+                    Point::new(0, 6)..Point::new(0, 37),
+                    Point::new(0, 44)..Point::new(0, 71),
+                    Point::new(1, 0)..Point::new(1, 35)
                 ]
             );
         });

crates/agent/src/context_picker/fetch_context_picker.rs

@@ -213,8 +213,8 @@ impl PickerDelegate for FetchContextPickerDelegate {
             this.update_in(cx, |this, window, cx| {
                 this.delegate
                     .context_store
-                    .update(cx, |context_store, _cx| {
-                        context_store.add_fetched_url(url, text);
+                    .update(cx, |context_store, cx| {
+                        context_store.add_fetched_url(url, text, cx)
                     })?;
 
                 match confirm_behavior {

crates/agent/src/context_store.rs

@@ -6,7 +6,7 @@ use anyhow::{Context as _, Result, anyhow};
 use collections::{BTreeMap, HashMap, HashSet};
 use futures::future::join_all;
 use futures::{self, Future, FutureExt, future};
-use gpui::{App, AppContext as _, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};
+use gpui::{App, AppContext as _, Context, Entity, SharedString, Task, WeakEntity};
 use language::{Buffer, File};
 use project::{ProjectItem, ProjectPath, Worktree};
 use rope::Rope;
@@ -95,14 +95,14 @@ impl ContextStore {
                 project.open_buffer(project_path.clone(), cx)
             })?;
 
-            let buffer_entity = open_buffer_task.await?;
-            let buffer_id = this.update(cx, |_, cx| buffer_entity.read(cx).remote_id())?;
+            let buffer = open_buffer_task.await?;
+            let buffer_id = this.update(cx, |_, cx| buffer.read(cx).remote_id())?;
 
-            let already_included = this.update(cx, |this, _cx| {
+            let already_included = this.update(cx, |this, cx| {
                 match this.will_include_buffer(buffer_id, &project_path.path) {
                     Some(FileInclusion::Direct(context_id)) => {
                         if remove_if_exists {
-                            this.remove_context(context_id);
+                            this.remove_context(context_id, cx);
                         }
                         true
                     }
@@ -115,21 +115,13 @@ impl ContextStore {
                 return anyhow::Ok(());
             }
 
-            let (buffer_info, text_task) = this.update(cx, |_, cx| {
-                let buffer = buffer_entity.read(cx);
-                collect_buffer_info_and_text(
-                    project_path.path.clone(),
-                    buffer_entity,
-                    buffer,
-                    None,
-                    cx.to_async(),
-                )
-            })??;
+            let (buffer_info, text_task) =
+                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, cx))??;
 
             let text = text_task.await;
 
-            this.update(cx, |this, _cx| {
-                this.insert_file(make_context_buffer(buffer_info, text));
+            this.update(cx, |this, cx| {
+                this.insert_file(make_context_buffer(buffer_info, text), cx);
             })?;
 
             anyhow::Ok(())
@@ -138,41 +130,29 @@ impl ContextStore {
 
     pub fn add_file_from_buffer(
         &mut self,
-        buffer_entity: Entity<Buffer>,
+        buffer: Entity<Buffer>,
         cx: &mut Context<Self>,
     ) -> Task<Result<()>> {
         cx.spawn(async move |this, cx| {
-            let (buffer_info, text_task) = this.update(cx, |_, cx| {
-                let buffer = buffer_entity.read(cx);
-                let Some(file) = buffer.file() else {
-                    return Err(anyhow!("Buffer has no path."));
-                };
-                collect_buffer_info_and_text(
-                    file.path().clone(),
-                    buffer_entity,
-                    buffer,
-                    None,
-                    cx.to_async(),
-                )
-            })??;
+            let (buffer_info, text_task) =
+                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, cx))??;
 
             let text = text_task.await;
 
-            this.update(cx, |this, _cx| {
-                this.insert_file(make_context_buffer(buffer_info, text))
+            this.update(cx, |this, cx| {
+                this.insert_file(make_context_buffer(buffer_info, text), cx)
             })?;
 
             anyhow::Ok(())
         })
     }
 
-    fn insert_file(&mut self, context_buffer: ContextBuffer) {
+    fn insert_file(&mut self, context_buffer: ContextBuffer, cx: &mut Context<Self>) {
         let id = self.next_context_id.post_inc();
         self.files.insert(context_buffer.id, id);
-        self.context.push(AssistantContext::File(FileContext {
-            id,
-            context_buffer: context_buffer,
-        }));
+        self.context
+            .push(AssistantContext::File(FileContext { id, context_buffer }));
+        cx.notify();
     }
 
     pub fn add_directory(
@@ -192,7 +172,7 @@ impl ContextStore {
         let already_included = match self.includes_directory(&project_path.path) {
             Some(FileInclusion::Direct(context_id)) => {
                 if remove_if_exists {
-                    self.remove_context(context_id);
+                    self.remove_context(context_id, cx);
                 }
                 true
             }
@@ -233,22 +213,13 @@ impl ContextStore {
             let mut buffer_infos = Vec::new();
             let mut text_tasks = Vec::new();
             this.update(cx, |_, cx| {
-                for (path, buffer_entity) in files.into_iter().zip(buffers) {
-                    // Skip all binary files and other non-UTF8 files
-                    if let Ok(buffer_entity) = buffer_entity {
-                        let buffer = buffer_entity.read(cx);
-                        if let Some((buffer_info, text_task)) = collect_buffer_info_and_text(
-                            path,
-                            buffer_entity,
-                            buffer,
-                            None,
-                            cx.to_async(),
-                        )
-                        .log_err()
-                        {
-                            buffer_infos.push(buffer_info);
-                            text_tasks.push(text_task);
-                        }
+                // Skip all binary files and other non-UTF8 files
+                for buffer in buffers.into_iter().flatten() {
+                    if let Some((buffer_info, text_task)) =
+                        collect_buffer_info_and_text(buffer, None, cx).log_err()
+                    {
+                        buffer_infos.push(buffer_info);
+                        text_tasks.push(text_task);
                     }
                 }
                 anyhow::Ok(())
@@ -268,15 +239,20 @@ impl ContextStore {
                 ));
             }
 
-            this.update(cx, |this, _| {
-                this.insert_directory(project_path, context_buffers);
+            this.update(cx, |this, cx| {
+                this.insert_directory(project_path, context_buffers, cx);
             })?;
 
             anyhow::Ok(())
         })
     }
 
-    fn insert_directory(&mut self, project_path: ProjectPath, context_buffers: Vec<ContextBuffer>) {
+    fn insert_directory(
+        &mut self,
+        project_path: ProjectPath,
+        context_buffers: Vec<ContextBuffer>,
+        cx: &mut Context<Self>,
+    ) {
         let id = self.next_context_id.post_inc();
         self.directories.insert(project_path.path.to_path_buf(), id);
 
@@ -286,6 +262,7 @@ impl ContextStore {
                 project_path,
                 context_buffers,
             }));
+        cx.notify();
     }
 
     pub fn add_symbol(
@@ -298,12 +275,8 @@ impl ContextStore {
         cx: &mut Context<Self>,
     ) -> Task<Result<bool>> {
         let buffer_ref = buffer.read(cx);
-        let Some(file) = buffer_ref.file() else {
-            return Task::ready(Err(anyhow!("Buffer has no path.")));
-        };
-
         let Some(project_path) = buffer_ref.project_path(cx) else {
-            return Task::ready(Err(anyhow!("Buffer has no project path.")));
+            return Task::ready(Err(anyhow!("buffer has no path")));
         };
 
         if let Some(symbols_for_path) = self.symbols_by_path.get(&project_path) {
@@ -320,41 +293,39 @@ impl ContextStore {
 
             if let Some(id) = matching_symbol_id {
                 if remove_if_exists {
-                    self.remove_context(id);
+                    self.remove_context(id, cx);
                 }
                 return Task::ready(Ok(false));
             }
         }
 
-        let (buffer_info, collect_content_task) = match collect_buffer_info_and_text(
-            file.path().clone(),
-            buffer,
-            buffer_ref,
-            Some(symbol_enclosing_range.clone()),
-            cx.to_async(),
-        ) {
-            Ok((buffer_info, collect_context_task)) => (buffer_info, collect_context_task),
-            Err(err) => return Task::ready(Err(err)),
-        };
+        let (buffer_info, collect_content_task) =
+            match collect_buffer_info_and_text(buffer, Some(symbol_enclosing_range.clone()), cx) {
+                Ok((buffer_info, collect_context_task)) => (buffer_info, collect_context_task),
+                Err(err) => return Task::ready(Err(err)),
+            };
 
         cx.spawn(async move |this, cx| {
             let content = collect_content_task.await;
 
-            this.update(cx, |this, _cx| {
-                this.insert_symbol(make_context_symbol(
-                    buffer_info,
-                    project_path,
-                    symbol_name,
-                    symbol_range,
-                    symbol_enclosing_range,
-                    content,
-                ))
+            this.update(cx, |this, cx| {
+                this.insert_symbol(
+                    make_context_symbol(
+                        buffer_info,
+                        project_path,
+                        symbol_name,
+                        symbol_range,
+                        symbol_enclosing_range,
+                        content,
+                    ),
+                    cx,
+                )
             })?;
             anyhow::Ok(true)
         })
     }
 
-    fn insert_symbol(&mut self, context_symbol: ContextSymbol) {
+    fn insert_symbol(&mut self, context_symbol: ContextSymbol, cx: &mut Context<Self>) {
         let id = self.next_context_id.post_inc();
         self.symbols.insert(context_symbol.id.clone(), id);
         self.symbols_by_path
@@ -367,6 +338,7 @@ impl ContextStore {
             id,
             context_symbol,
         }));
+        cx.notify();
     }
 
     pub fn add_thread(
@@ -377,7 +349,7 @@ impl ContextStore {
     ) {
         if let Some(context_id) = self.includes_thread(&thread.read(cx).id()) {
             if remove_if_exists {
-                self.remove_context(context_id);
+                self.remove_context(context_id, cx);
             }
         } else {
             self.insert_thread(thread, cx);
@@ -392,14 +364,14 @@ impl ContextStore {
         })
     }
 
-    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &mut App) {
+    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &mut Context<Self>) {
         if let Some(summary_task) =
             thread.update(cx, |thread, cx| thread.generate_detailed_summary(cx))
         {
             let thread = thread.clone();
             let thread_store = self.thread_store.clone();
 
-            self.thread_summary_tasks.push(cx.spawn(async move |cx| {
+            self.thread_summary_tasks.push(cx.spawn(async move |_, cx| {
                 summary_task.await;
 
                 if let Some(thread_store) = thread_store {
@@ -421,15 +393,26 @@ impl ContextStore {
         self.threads.insert(thread.read(cx).id().clone(), id);
         self.context
             .push(AssistantContext::Thread(ThreadContext { id, thread, text }));
+        cx.notify();
     }
 
-    pub fn add_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
+    pub fn add_fetched_url(
+        &mut self,
+        url: String,
+        text: impl Into<SharedString>,
+        cx: &mut Context<ContextStore>,
+    ) {
         if self.includes_url(&url).is_none() {
-            self.insert_fetched_url(url, text);
+            self.insert_fetched_url(url, text, cx);
         }
     }
 
-    fn insert_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
+    fn insert_fetched_url(
+        &mut self,
+        url: String,
+        text: impl Into<SharedString>,
+        cx: &mut Context<ContextStore>,
+    ) {
         let id = self.next_context_id.post_inc();
 
         self.fetched_urls.insert(url.clone(), id);
@@ -439,6 +422,7 @@ impl ContextStore {
                 url: url.into(),
                 text: text.into(),
             }));
+        cx.notify();
     }
 
     pub fn accept_suggested_context(
@@ -465,7 +449,7 @@ impl ContextStore {
         Task::ready(Ok(()))
     }
 
-    pub fn remove_context(&mut self, id: ContextId) {
+    pub fn remove_context(&mut self, id: ContextId, cx: &mut Context<Self>) {
         let Some(ix) = self.context.iter().position(|context| context.id() == id) else {
             return;
         };
@@ -497,6 +481,8 @@ impl ContextStore {
                 self.threads.retain(|_, context_id| *context_id != id);
             }
         }
+
+        cx.notify();
     }
 
     /// Returns whether the buffer is already included directly in the context, or if it will be
@@ -616,16 +602,16 @@ pub enum FileInclusion {
 
 // ContextBuffer without text.
 struct BufferInfo {
-    buffer_entity: Entity<Buffer>,
-    file: Arc<dyn File>,
     id: BufferId,
+    buffer: Entity<Buffer>,
+    file: Arc<dyn File>,
     version: clock::Global,
 }
 
 fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {
     ContextBuffer {
         id: info.id,
-        buffer: info.buffer_entity,
+        buffer: info.buffer,
         file: info.file,
         version: info.version,
         text,
@@ -644,34 +630,37 @@ fn make_context_symbol(
         id: ContextSymbolId { name, range, path },
         buffer_version: info.version,
         enclosing_range,
-        buffer: info.buffer_entity,
+        buffer: info.buffer,
         text,
     }
 }
 
 fn collect_buffer_info_and_text(
-    path: Arc<Path>,
-    buffer_entity: Entity<Buffer>,
-    buffer: &Buffer,
+    buffer: Entity<Buffer>,
     range: Option<Range<Anchor>>,
-    cx: AsyncApp,
+    cx: &App,
 ) -> Result<(BufferInfo, Task<SharedString>)> {
-    let buffer_info = BufferInfo {
-        id: buffer.remote_id(),
-        buffer_entity,
-        file: buffer
-            .file()
-            .context("buffer context must have a file")?
-            .clone(),
-        version: buffer.version(),
-    };
+    let buffer_ref = buffer.read(cx);
+    let file = buffer_ref.file().context("file context must have a path")?;
+
     // Important to collect version at the same time as content so that staleness logic is correct.
+    let version = buffer_ref.version();
     let content = if let Some(range) = range {
-        buffer.text_for_range(range).collect::<Rope>()
+        buffer_ref.text_for_range(range).collect::<Rope>()
     } else {
-        buffer.as_rope().clone()
+        buffer_ref.as_rope().clone()
     };
-    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&path, content) });
+
+    let buffer_info = BufferInfo {
+        buffer,
+        id: buffer_ref.remote_id(),
+        file: file.clone(),
+        version,
+    };
+
+    let full_path = file.full_path(cx);
+    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&full_path, content) });
+
     Ok((buffer_info, text_task))
 }
 
@@ -920,16 +909,9 @@ fn refresh_context_buffer(
     cx: &App,
 ) -> Option<impl Future<Output = ContextBuffer> + use<>> {
     let buffer = context_buffer.buffer.read(cx);
-    let path = buffer_path_log_err(buffer, cx)?;
     if buffer.version.changed_since(&context_buffer.version) {
-        let (buffer_info, text_task) = collect_buffer_info_and_text(
-            path,
-            context_buffer.buffer.clone(),
-            buffer,
-            None,
-            cx.to_async(),
-        )
-        .log_err()?;
+        let (buffer_info, text_task) =
+            collect_buffer_info_and_text(context_buffer.buffer.clone(), None, cx).log_err()?;
         Some(text_task.map(move |text| make_context_buffer(buffer_info, text)))
     } else {
         None
@@ -941,15 +923,12 @@ fn refresh_context_symbol(
     cx: &App,
 ) -> Option<impl Future<Output = ContextSymbol> + use<>> {
     let buffer = context_symbol.buffer.read(cx);
-    let path = buffer_path_log_err(buffer, cx)?;
     let project_path = buffer.project_path(cx)?;
     if buffer.version.changed_since(&context_symbol.buffer_version) {
         let (buffer_info, text_task) = collect_buffer_info_and_text(
-            path,
             context_symbol.buffer.clone(),
-            buffer,
             Some(context_symbol.enclosing_range.clone()),
-            cx.to_async(),
+            cx,
         )
         .log_err()?;
         let name = context_symbol.id.name.clone();

crates/agent/src/context_strip.rs

@@ -59,6 +59,7 @@ impl ContextStrip {
         let focus_handle = cx.focus_handle();
 
         let subscriptions = vec![
+            cx.observe(&context_store, |_, _, cx| cx.notify()),
             cx.subscribe_in(&context_picker, window, Self::handle_context_picker_event),
             cx.on_focus(&focus_handle, window, Self::handle_focus),
             cx.on_blur(&focus_handle, window, Self::handle_blur),
@@ -290,9 +291,9 @@ impl ContextStrip {
         if let Some(index) = self.focused_index {
             let mut is_empty = false;
 
-            self.context_store.update(cx, |this, _cx| {
+            self.context_store.update(cx, |this, cx| {
                 if let Some(item) = this.context().get(index) {
-                    this.remove_context(item.id());
+                    this.remove_context(item.id(), cx);
                 }
 
                 is_empty = this.context().is_empty();
@@ -475,8 +476,8 @@ impl Render for ContextStrip {
                             Some({
                                 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);
+                                    context_store.update(cx, |this, cx| {
+                                        this.remove_context(id, cx);
                                     });
                                     cx.notify();
                                 }))

crates/agent/src/history_store.rs

@@ -4,6 +4,7 @@ use gpui::{Entity, prelude::*};
 
 use crate::thread_store::{SerializedThreadMetadata, ThreadStore};
 
+#[derive(Debug)]
 pub enum HistoryEntry {
     Thread(SerializedThreadMetadata),
     Context(SavedContextMetadata),
@@ -21,25 +22,27 @@ impl HistoryEntry {
 pub struct HistoryStore {
     thread_store: Entity<ThreadStore>,
     context_store: Entity<assistant_context_editor::ContextStore>,
+    _subscriptions: Vec<gpui::Subscription>,
 }
 
 impl HistoryStore {
     pub fn new(
         thread_store: Entity<ThreadStore>,
         context_store: Entity<assistant_context_editor::ContextStore>,
-        _cx: &mut Context<Self>,
+        cx: &mut Context<Self>,
     ) -> Self {
+        let subscriptions = vec![
+            cx.observe(&thread_store, |_, _, cx| cx.notify()),
+            cx.observe(&context_store, |_, _, cx| cx.notify()),
+        ];
+
         Self {
             thread_store,
             context_store,
+            _subscriptions: subscriptions,
         }
     }
 
-    /// Returns the number of history entries.
-    pub fn entry_count(&self, cx: &mut Context<Self>) -> usize {
-        self.entries(cx).len()
-    }
-
     pub fn entries(&self, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
         let mut history_entries = Vec::new();
 

crates/agent/src/inline_assistant.rs

@@ -37,8 +37,8 @@ use text::{OffsetRangeExt, ToPoint as _};
 use ui::prelude::*;
 use util::RangeExt;
 use util::ResultExt;
-use workspace::{ItemHandle, Toast, Workspace, notifications::NotificationId};
-use workspace::{ShowConfiguration, dock::Panel};
+use workspace::{ItemHandle, Toast, Workspace, dock::Panel, notifications::NotificationId};
+use zed_actions::agent::OpenConfiguration;
 
 use crate::AssistantPanel;
 use crate::buffer_codegen::{BufferCodegen, CodegenAlternative, CodegenEvent};
@@ -239,8 +239,8 @@ impl InlineAssistant {
 
         let is_authenticated = || {
             LanguageModelRegistry::read_global(cx)
-                .active_provider()
-                .map_or(false, |provider| provider.is_authenticated(cx))
+                .inline_assistant_model()
+                .map_or(false, |model| model.provider.is_authenticated(cx))
         };
 
         let thread_store = workspace
@@ -279,8 +279,8 @@ impl InlineAssistant {
             cx.spawn_in(window, async move |_workspace, cx| {
                 let Some(task) = cx.update(|_, cx| {
                     LanguageModelRegistry::read_global(cx)
-                        .active_provider()
-                        .map_or(None, |provider| Some(provider.authenticate(cx)))
+                        .inline_assistant_model()
+                        .map_or(None, |model| Some(model.provider.authenticate(cx)))
                 })?
                 else {
                     let answer = cx
@@ -295,7 +295,7 @@ impl InlineAssistant {
                     if let Some(answer) = answer {
                         if answer == 0 {
                             cx.update(|window, cx| {
-                                window.dispatch_action(Box::new(ShowConfiguration), cx)
+                                window.dispatch_action(Box::new(OpenConfiguration), cx)
                             })
                             .ok();
                         }
@@ -401,14 +401,14 @@ impl InlineAssistant {
 
             codegen_ranges.push(anchor_range);
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).inline_assistant_model() {
                 self.telemetry.report_assistant_event(AssistantEvent {
                     conversation_id: None,
                     kind: AssistantKind::Inline,
                     phase: AssistantPhase::Invoked,
                     message_id: None,
-                    model: model.telemetry_id(),
-                    model_provider: model.provider_id().to_string(),
+                    model: model.model.telemetry_id(),
+                    model_provider: model.provider.id().to_string(),
                     response_latency: None,
                     error_message: None,
                     language_name: buffer.language().map(|language| language.name().to_proto()),
@@ -621,14 +621,14 @@ impl InlineAssistant {
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Above(range.start),
-                height: prompt_editor_height,
+                height: Some(prompt_editor_height),
                 render: build_assist_editor_renderer(prompt_editor),
                 priority: 0,
             },
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Below(range.end),
-                height: 0,
+                height: None,
                 render: Arc::new(|cx| {
                     v_flex()
                         .h_full()
@@ -976,7 +976,7 @@ impl InlineAssistant {
             let active_alternative = assist.codegen.read(cx).active_alternative().clone();
             let message_id = active_alternative.read(cx).message_id.clone();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).inline_assistant_model() {
                 let language_name = assist.editor.upgrade().and_then(|editor| {
                     let multibuffer = editor.read(cx).buffer().read(cx);
                     let snapshot = multibuffer.snapshot(cx);
@@ -996,15 +996,15 @@ impl InlineAssistant {
                         } else {
                             AssistantPhase::Accepted
                         },
-                        model: model.telemetry_id(),
-                        model_provider: model.provider_id().to_string(),
+                        model: model.model.telemetry_id(),
+                        model_provider: model.model.provider_id().to_string(),
                         response_latency: None,
                         error_message: None,
                         language_name: language_name.map(|name| name.to_proto()),
                     },
                     Some(self.telemetry.clone()),
                     cx.http_client(),
-                    model.api_key(cx),
+                    model.model.api_key(cx),
                     cx.background_executor(),
                 );
             }
@@ -1392,7 +1392,7 @@ impl InlineAssistant {
                     deleted_lines_editor.update(cx, |editor, cx| editor.max_point(cx).row().0 + 1);
                 new_blocks.push(BlockProperties {
                     placement: BlockPlacement::Above(new_row),
-                    height,
+                    height: Some(height),
                     style: BlockStyle::Flex,
                     render: Arc::new(move |cx| {
                         div()

crates/agent/src/inline_prompt_editor.rs

@@ -1,4 +1,4 @@
-use crate::assistant_model_selector::AssistantModelSelector;
+use crate::assistant_model_selector::{AssistantModelSelector, ModelType};
 use crate::buffer_codegen::BufferCodegen;
 use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
@@ -582,7 +582,7 @@ impl<T: 'static> PromptEditor<T> {
         let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);
 
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.active_model();
+        let default_model = model_registry.default_model().map(|default| default.model);
         let alternative_models = model_registry.inline_alternative_models();
 
         let get_model_name = |index: usize| -> String {
@@ -890,6 +890,7 @@ impl PromptEditor<BufferCodegen> {
                     fs,
                     model_selector_menu_handle,
                     prompt_editor.focus_handle(cx),
+                    ModelType::InlineAssistant,
                     window,
                     cx,
                 )
@@ -1042,6 +1043,7 @@ impl PromptEditor<TerminalCodegen> {
                     fs,
                     model_selector_menu_handle.clone(),
                     prompt_editor.focus_handle(cx),
+                    ModelType::InlineAssistant,
                     window,
                     cx,
                 )

crates/agent/src/message_editor.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use crate::assistant_model_selector::ModelType;
 use collections::HashSet;
 use editor::actions::MoveUp;
 use editor::{ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorStyle};
@@ -9,8 +10,10 @@ use gpui::{
     Animation, AnimationExt, App, DismissEvent, Entity, Focusable, Subscription, TextStyle,
     WeakEntity, linear_color_stop, linear_gradient, point,
 };
-use language_model::LanguageModelRegistry;
+use language::Buffer;
+use language_model::{ConfiguredModel, LanguageModelRegistry};
 use language_model_selector::ToggleModelSelector;
+use multi_buffer;
 use project::Project;
 use settings::Settings;
 use std::time::Duration;
@@ -28,7 +31,7 @@ use crate::context_picker::{ConfirmBehavior, ContextPicker, ContextPickerComplet
 use crate::context_store::{ContextStore, refresh_context_store_text};
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
 use crate::profile_selector::ProfileSelector;
-use crate::thread::{RequestKind, Thread};
+use crate::thread::{RequestKind, Thread, TokenUsageRatio};
 use crate::thread_store::ThreadStore;
 use crate::{
     AgentDiff, Chat, ChatMode, NewThread, OpenAgentDiff, RemoveAllContext, ThreadEvent,
@@ -137,6 +140,7 @@ impl MessageEditor {
                     fs.clone(),
                     model_selector_menu_handle,
                     editor.focus_handle(cx),
+                    ModelType::Default,
                     window,
                     cx,
                 )
@@ -189,7 +193,7 @@ impl MessageEditor {
 
     fn is_model_selected(&self, cx: &App) -> bool {
         LanguageModelRegistry::read_global(cx)
-            .active_model()
+            .default_model()
             .is_some()
     }
 
@@ -199,20 +203,16 @@ impl MessageEditor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
-        if provider
-            .as_ref()
-            .map_or(false, |provider| provider.must_accept_terms(cx))
-        {
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let Some(ConfiguredModel { model, provider }) = model_registry.default_model() else {
+            return;
+        };
+
+        if provider.must_accept_terms(cx) {
             cx.notify();
             return;
         }
 
-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let Some(model) = model_registry.active_model() else {
-            return;
-        };
-
         let user_message = self.editor.update(cx, |editor, cx| {
             let text = editor.text(cx);
             editor.clear(window, cx);
@@ -240,14 +240,14 @@ impl MessageEditor {
                         cx.emit(ThreadEvent::ShowError(load_error));
                     }
                 })
-                .ok();
+                .log_err();
 
             thread
                 .update(cx, |thread, cx| {
                     let context = context_store.read(cx).context().clone();
                     thread.insert_user_message(user_message, context, checkpoint, cx);
                 })
-                .ok();
+                .log_err();
 
             if let Some(wait_for_summaries) = context_store
                 .update(cx, |context_store, cx| context_store.wait_for_summaries(cx))
@@ -257,7 +257,7 @@ impl MessageEditor {
                     this.waiting_for_summaries_to_send = true;
                     cx.notify();
                 })
-                .ok();
+                .log_err();
 
                 wait_for_summaries.await;
 
@@ -265,7 +265,7 @@ impl MessageEditor {
                     this.waiting_for_summaries_to_send = false;
                     cx.notify();
                 })
-                .ok();
+                .log_err();
             }
 
             // Send to model after summaries are done
@@ -273,7 +273,7 @@ impl MessageEditor {
                 .update(cx, |thread, cx| {
                     thread.send_to_model(model, request_kind, cx);
                 })
-                .ok();
+                .log_err();
         })
         .detach();
     }
@@ -320,6 +320,19 @@ impl MessageEditor {
     fn handle_review_click(&self, window: &mut Window, cx: &mut Context<Self>) {
         AgentDiff::deploy(self.thread.clone(), self.workspace.clone(), window, cx).log_err();
     }
+
+    fn handle_file_click(
+        &self,
+        buffer: Entity<Buffer>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Ok(diff) = AgentDiff::deploy(self.thread.clone(), self.workspace.clone(), window, cx)
+        {
+            let path_key = multi_buffer::PathKey::for_buffer(&buffer, cx);
+            diff.update(cx, |diff, cx| diff.move_to_path(path_key, window, cx));
+        }
+    }
 }
 
 impl Focusable for MessageEditor {
@@ -338,9 +351,12 @@ impl Render for MessageEditor {
 
         let thread = self.thread.read(cx);
         let is_generating = thread.is_generating();
-        let is_too_long = thread.is_getting_too_long(cx);
+        let total_token_usage = thread.total_token_usage(cx);
         let is_model_selected = self.is_model_selected(cx);
         let is_editor_empty = self.is_editor_empty(cx);
+        let needs_confirmation =
+            thread.has_pending_tool_uses() && thread.tools_needing_confirmation().next().is_some();
+
         let submit_label_color = if is_editor_empty {
             Color::Muted
         } else {
@@ -432,11 +448,17 @@ impl Render for MessageEditor {
                                         },
                                     ),
                             )
-                            .child(
-                                Label::new("Generating…")
-                                    .size(LabelSize::XSmall)
-                                    .color(Color::Muted),
-                            )
+                            .child({
+
+
+                                Label::new(if needs_confirmation {
+                                    "Waiting for confirmation…"
+                                } else {
+                                    "Generating…"
+                                })
+                                .size(LabelSize::XSmall)
+                                .color(Color::Muted)
+                            })
                             .child(ui::Divider::vertical())
                             .child(
                                 Button::new("cancel-generation", "Cancel")
@@ -478,11 +500,16 @@ impl Render for MessageEditor {
                         }])
                         .child(
                             h_flex()
+                                .id("edits-container")
                                 .p_1p5()
                                 .justify_between()
                                 .when(self.edits_expanded, |this| {
                                     this.border_b_1().border_color(border_color)
                                 })
+                                .cursor_pointer()
+                                .on_click(cx.listener(|this, _, window, cx| {
+                                    this.handle_review_click(window, cx)
+                                }))
                                 .child(
                                     h_flex()
                                         .gap_1()
@@ -596,11 +623,21 @@ impl Render for MessageEditor {
                                                         .justify_between()
                                                         .child(
                                                             h_flex()
-                                                                .id("file-container")
+                                                                .id(("file-container", index))
                                                                 .pr_8()
                                                                 .gap_1p5()
                                                                 .max_w_full()
                                                                 .overflow_x_scroll()
+                                                                .cursor_pointer()
+                                                                .on_click({
+                                                                    let buffer = buffer.clone();
+                                                                    cx.listener(move |this, _, window, cx| {
+                                                                        this.handle_file_click(buffer.clone(), window, cx);
+                                                                    })
+                                                                })
+                                                                .tooltip(
+                                                                    Tooltip::text(format!("Review {}", path.display()))
+                                                                )
                                                                 .child(file_icon)
                                                                 .child(
                                                                     h_flex()
@@ -779,7 +816,7 @@ impl Render for MessageEditor {
                             ),
                     )
             )
-            .when(is_too_long, |parent| {
+            .when(total_token_usage.ratio != TokenUsageRatio::Normal, |parent| {
                 parent.child(
                     h_flex()
                         .p_2()

crates/agent/src/profile_selector.rs

@@ -130,8 +130,8 @@ impl Render for ProfileSelector {
 
         let model_registry = LanguageModelRegistry::read_global(cx);
         let supports_tools = model_registry
-            .active_model()
-            .map_or(false, |model| model.supports_tools());
+            .default_model()
+            .map_or(false, |default| default.model.supports_tools());
 
         let icon = match profile_id.as_str() {
             "write" => IconName::Pencil,

crates/agent/src/terminal_codegen.rs

@@ -2,7 +2,9 @@ use crate::inline_prompt_editor::CodegenStatus;
 use client::telemetry::Telemetry;
 use futures::{SinkExt, StreamExt, channel::mpsc};
 use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
-use language_model::{LanguageModelRegistry, LanguageModelRequest, report_assistant_event};
+use language_model::{
+    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, report_assistant_event,
+};
 use std::{sync::Arc, time::Instant};
 use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal::Terminal;
@@ -31,7 +33,9 @@ impl TerminalCodegen {
     }
 
     pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        else {
             return;
         };
 

crates/agent/src/terminal_inline_assistant.rs

@@ -13,8 +13,8 @@ use fs::Fs;
 use gpui::{App, Entity, Focusable, Global, Subscription, UpdateGlobal, WeakEntity};
 use language::Buffer;
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
-    report_assistant_event,
+    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
+    Role, report_assistant_event,
 };
 use prompt_store::PromptBuilder;
 use std::sync::Arc;
@@ -286,7 +286,9 @@ impl TerminalInlineAssistant {
                 })
                 .log_err();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).inline_assistant_model()
+            {
                 let codegen = assist.codegen.read(cx);
                 let executor = cx.background_executor().clone();
                 report_assistant_event(

crates/agent/src/thread.rs

@@ -7,17 +7,17 @@ use anyhow::{Context as _, Result, anyhow};
 use assistant_settings::AssistantSettings;
 use assistant_tool::{ActionLog, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
-use collections::{BTreeMap, HashMap, HashSet};
+use collections::{BTreeMap, HashMap};
 use fs::Fs;
 use futures::future::Shared;
 use futures::{FutureExt, StreamExt as _};
 use git::repository::DiffType;
 use gpui::{App, AppContext, Context, Entity, EventEmitter, SharedString, Task, WeakEntity};
 use language_model::{
-    LanguageModel, LanguageModelCompletionEvent, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, LanguageModelRequestTool, LanguageModelToolResult,
-    LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent, PaymentRequiredError,
-    Role, StopReason, TokenUsage,
+    ConfiguredModel, LanguageModel, LanguageModelCompletionEvent, LanguageModelRegistry,
+    LanguageModelRequest, LanguageModelRequestMessage, LanguageModelRequestTool,
+    LanguageModelToolResult, LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent,
+    PaymentRequiredError, Role, StopReason, TokenUsage,
 };
 use project::git_store::{GitStore, GitStoreCheckpoint, RepositoryState};
 use project::{Project, Worktree};
@@ -30,12 +30,12 @@ use settings::Settings;
 use util::{ResultExt as _, TryFutureExt as _, maybe, post_inc};
 use uuid::Uuid;
 
-use crate::context::{AssistantContext, ContextId, attach_context_to_message};
+use crate::context::{AssistantContext, ContextId, format_context_as_string};
 use crate::thread_store::{
     SerializedMessage, SerializedMessageSegment, SerializedThread, SerializedToolResult,
     SerializedToolUse,
 };
-use crate::tool_use::{PendingToolUse, ToolUse, ToolUseState};
+use crate::tool_use::{PendingToolUse, ToolUse, ToolUseState, USING_TOOL_MARKER};
 
 #[derive(Debug, Clone, Copy)]
 pub enum RequestKind {
@@ -82,9 +82,16 @@ pub struct Message {
     pub id: MessageId,
     pub role: Role,
     pub segments: Vec<MessageSegment>,
+    pub context: String,
 }
 
 impl Message {
+    /// Returns whether the message contains any meaningful text that should be displayed
+    /// The model sometimes runs tool without producing any text or just a marker ([`USING_TOOL_MARKER`])
+    pub fn should_display_content(&self) -> bool {
+        self.segments.iter().all(|segment| segment.should_display())
+    }
+
     pub fn push_thinking(&mut self, text: &str) {
         if let Some(MessageSegment::Thinking(segment)) = self.segments.last_mut() {
             segment.push_str(text);
@@ -104,6 +111,11 @@ impl Message {
 
     pub fn to_string(&self) -> String {
         let mut result = String::new();
+
+        if !self.context.is_empty() {
+            result.push_str(&self.context);
+        }
+
         for segment in &self.segments {
             match segment {
                 MessageSegment::Text(text) => result.push_str(text),
@@ -114,11 +126,12 @@ impl Message {
                 }
             }
         }
+
         result
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum MessageSegment {
     Text(String),
     Thinking(String),
@@ -131,6 +144,16 @@ impl MessageSegment {
             Self::Thinking(text) => text,
         }
     }
+
+    pub fn should_display(&self) -> bool {
+        // We add USING_TOOL_MARKER when making a request that includes tool uses
+        // without non-whitespace text around them, and this can cause the model
+        // to mimic the pattern, so we consider those segments not displayable.
+        match self {
+            Self::Text(text) => text.is_empty() || text.trim() == USING_TOOL_MARKER,
+            Self::Thinking(text) => text.is_empty() || text.trim() == USING_TOOL_MARKER,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -198,6 +221,21 @@ pub enum DetailedSummaryState {
     },
 }
 
+#[derive(Default)]
+pub struct TotalTokenUsage {
+    pub total: usize,
+    pub max: usize,
+    pub ratio: TokenUsageRatio,
+}
+
+#[derive(Default, PartialEq, Eq)]
+pub enum TokenUsageRatio {
+    #[default]
+    Normal,
+    Warning,
+    Exceeded,
+}
+
 /// A thread of conversation with the LLM.
 pub struct Thread {
     id: ThreadId,
@@ -252,7 +290,7 @@ impl Thread {
             last_restore_checkpoint: None,
             pending_checkpoint: None,
             tool_use: ToolUseState::new(tools.clone()),
-            action_log: cx.new(|_| ActionLog::new()),
+            action_log: cx.new(|_| ActionLog::new(project.clone())),
             initial_project_snapshot: {
                 let project_snapshot = Self::project_snapshot(project, cx);
                 cx.foreground_executor()
@@ -304,6 +342,7 @@ impl Thread {
                             }
                         })
                         .collect(),
+                    context: message.context,
                 })
                 .collect(),
             next_message_id,
@@ -315,11 +354,11 @@ impl Thread {
             pending_completions: Vec::new(),
             last_restore_checkpoint: None,
             pending_checkpoint: None,
-            project,
+            project: project.clone(),
             prompt_builder,
             tools,
             tool_use,
-            action_log: cx.new(|_| ActionLog::new()),
+            action_log: cx.new(|_| ActionLog::new(project)),
             initial_project_snapshot: Task::ready(serialized.initial_project_snapshot).shared(),
             cumulative_token_usage: serialized.cumulative_token_usage,
             feedback: None,
@@ -346,14 +385,28 @@ impl Thread {
         self.summary.clone()
     }
 
+    pub const DEFAULT_SUMMARY: SharedString = SharedString::new_static("New Thread");
+
     pub fn summary_or_default(&self) -> SharedString {
-        const DEFAULT: SharedString = SharedString::new_static("New Thread");
-        self.summary.clone().unwrap_or(DEFAULT)
+        self.summary.clone().unwrap_or(Self::DEFAULT_SUMMARY)
     }
 
-    pub fn set_summary(&mut self, summary: impl Into<SharedString>, cx: &mut Context<Self>) {
-        self.summary = Some(summary.into());
-        cx.emit(ThreadEvent::SummaryChanged);
+    pub fn set_summary(&mut self, new_summary: impl Into<SharedString>, cx: &mut Context<Self>) {
+        let Some(current_summary) = &self.summary else {
+            // Don't allow setting summary until generated
+            return;
+        };
+
+        let mut new_summary = new_summary.into();
+
+        if new_summary.is_empty() {
+            new_summary = Self::DEFAULT_SUMMARY;
+        }
+
+        if current_summary != &new_summary {
+            self.summary = Some(new_summary);
+            cx.emit(ThreadEvent::SummaryChanged);
+        }
     }
 
     pub fn latest_detailed_summary_or_text(&self) -> SharedString {
@@ -564,15 +617,58 @@ impl Thread {
         git_checkpoint: Option<GitStoreCheckpoint>,
         cx: &mut Context<Self>,
     ) -> MessageId {
-        let message_id =
-            self.insert_message(Role::User, vec![MessageSegment::Text(text.into())], cx);
-        let context_ids = context
+        let text = text.into();
+
+        let message_id = self.insert_message(Role::User, vec![MessageSegment::Text(text)], cx);
+
+        // Filter out contexts that have already been included in previous messages
+        let new_context: Vec<_> = context
+            .into_iter()
+            .filter(|ctx| !self.context.contains_key(&ctx.id()))
+            .collect();
+
+        if !new_context.is_empty() {
+            if let Some(context_string) = format_context_as_string(new_context.iter(), cx) {
+                if let Some(message) = self.messages.iter_mut().find(|m| m.id == message_id) {
+                    message.context = context_string;
+                }
+            }
+
+            self.action_log.update(cx, |log, cx| {
+                // Track all buffers added as context
+                for ctx in &new_context {
+                    match ctx {
+                        AssistantContext::File(file_ctx) => {
+                            log.buffer_added_as_context(file_ctx.context_buffer.buffer.clone(), cx);
+                        }
+                        AssistantContext::Directory(dir_ctx) => {
+                            for context_buffer in &dir_ctx.context_buffers {
+                                log.buffer_added_as_context(context_buffer.buffer.clone(), cx);
+                            }
+                        }
+                        AssistantContext::Symbol(symbol_ctx) => {
+                            log.buffer_added_as_context(
+                                symbol_ctx.context_symbol.buffer.clone(),
+                                cx,
+                            );
+                        }
+                        AssistantContext::FetchedUrl(_) | AssistantContext::Thread(_) => {}
+                    }
+                }
+            });
+        }
+
+        let context_ids = new_context
             .iter()
             .map(|context| context.id())
             .collect::<Vec<_>>();
-        self.context
-            .extend(context.into_iter().map(|context| (context.id(), context)));
+        self.context.extend(
+            new_context
+                .into_iter()
+                .map(|context| (context.id(), context)),
+        );
         self.context_by_message.insert(message_id, context_ids);
+
         if let Some(git_checkpoint) = git_checkpoint {
             self.pending_checkpoint = Some(ThreadCheckpoint {
                 message_id,
@@ -589,7 +685,12 @@ impl Thread {
         cx: &mut Context<Self>,
     ) -> MessageId {
         let id = self.next_message_id.post_inc();
-        self.messages.push(Message { id, role, segments });
+        self.messages.push(Message {
+            id,
+            role,
+            segments,
+            context: String::new(),
+        });
         self.touch_updated_at();
         cx.emit(ThreadEvent::MessageAdded(id));
         id
@@ -695,6 +796,7 @@ impl Thread {
                                 content: tool_result.content.clone(),
                             })
                             .collect(),
+                        context: message.context.clone(),
                     })
                     .collect(),
                 initial_project_snapshot,
@@ -881,8 +983,6 @@ impl Thread {
             log::error!("system_prompt_context not set.")
         }
 
-        let mut added_context_ids = HashSet::<ContextId>::default();
-
         for message in &self.messages {
             let mut request_message = LanguageModelRequestMessage {
                 role: message.role,
@@ -903,23 +1003,6 @@ impl Thread {
                 }
             }
 
-            // Attach context to this message if it's the first to reference it
-            if let Some(context_ids) = self.context_by_message.get(&message.id) {
-                let new_context_ids: Vec<_> = context_ids
-                    .iter()
-                    .filter(|id| !added_context_ids.contains(id))
-                    .collect();
-
-                if !new_context_ids.is_empty() {
-                    let referenced_context = new_context_ids
-                        .iter()
-                        .filter_map(|context_id| self.context.get(*context_id));
-
-                    attach_context_to_message(&mut request_message, referenced_context, cx);
-                    added_context_ids.extend(context_ids.iter());
-                }
-            }
-
             if !message.segments.is_empty() {
                 request_message
                     .content
@@ -939,11 +1022,9 @@ impl Thread {
             request.messages.push(request_message);
         }
 
-        // Set a cache breakpoint at the second-to-last message.
         // https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
-        let breakpoint_index = request.messages.len() - 2;
-        for (index, message) in request.messages.iter_mut().enumerate() {
-            message.cache = index == breakpoint_index;
+        if let Some(last) = request.messages.last_mut() {
+            last.cache = true;
         }
 
         self.attached_tracked_files_state(&mut request.messages, cx);
@@ -968,7 +1049,7 @@ impl Thread {
             };
 
             if stale_message.is_empty() {
-                write!(&mut stale_message, "{}", STALE_FILES_HEADER).ok();
+                write!(&mut stale_message, "{}\n", STALE_FILES_HEADER).ok();
             }
 
             writeln!(&mut stale_message, "- {}", file.path().display()).ok();
@@ -1083,32 +1164,15 @@ impl Thread {
                                 }
                             }
                             LanguageModelCompletionEvent::ToolUse(tool_use) => {
-                                let last_assistant_message = thread
+                                let last_assistant_message_id = thread
                                     .messages
                                     .iter_mut()
-                                    .rfind(|message| message.role == Role::Assistant);
+                                    .rfind(|message| message.role == Role::Assistant)
+                                    .map(|message| message.id)
+                                    .unwrap_or_else(|| {
+                                        thread.insert_message(Role::Assistant, vec![], cx)
+                                    });
 
-                                let last_assistant_message_id =
-                                    if let Some(message) = last_assistant_message {
-                                        if let Some(segment) = message.segments.first_mut() {
-                                            let text = segment.text_mut();
-                                            if text.is_empty() {
-                                                text.push_str("Using tool...");
-                                            }
-                                        } else {
-                                            message.segments.push(MessageSegment::Text(
-                                                "Using tool...".to_string(),
-                                            ));
-                                        }
-
-                                        message.id
-                                    } else {
-                                        thread.insert_message(
-                                            Role::Assistant,
-                                            vec![MessageSegment::Text("Using tool...".to_string())],
-                                            cx,
-                                        )
-                                    };
                                 thread.tool_use.request_tool_use(
                                     last_assistant_message_id,
                                     tool_use,
@@ -1200,14 +1264,11 @@ impl Thread {
     }
 
     pub fn summarize(&mut self, cx: &mut Context<Self>) {
-        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
-            return;
-        };
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).thread_summary_model() else {
             return;
         };
 
-        if !provider.is_authenticated(cx) {
+        if !model.provider.is_authenticated(cx) {
             return;
         }
 
@@ -1226,7 +1287,7 @@ impl Thread {
 
         self.pending_summary = cx.spawn(async move |this, cx| {
             async move {
-                let stream = model.stream_completion_text(request, &cx);
+                let stream = model.model.stream_completion_text(request, &cx);
                 let mut messages = stream.await?;
 
                 let mut new_summary = String::new();
@@ -1246,7 +1307,7 @@ impl Thread {
                         this.summary = Some(new_summary.into());
                     }
 
-                    cx.emit(ThreadEvent::SummaryChanged);
+                    cx.emit(ThreadEvent::SummaryGenerated);
                 })?;
 
                 anyhow::Ok(())
@@ -1270,8 +1331,8 @@ impl Thread {
             _ => {}
         }
 
-        let provider = LanguageModelRegistry::read_global(cx).active_provider()?;
-        let model = LanguageModelRegistry::read_global(cx).active_model()?;
+        let ConfiguredModel { model, provider } =
+            LanguageModelRegistry::read_global(cx).thread_summary_model()?;
 
         if !provider.is_authenticated(cx) {
             return None;
@@ -1439,17 +1500,7 @@ impl Thread {
         })
     }
 
-    pub fn attach_tool_results(
-        &mut self,
-        updated_context: Vec<AssistantContext>,
-        cx: &mut Context<Self>,
-    ) {
-        self.context.extend(
-            updated_context
-                .into_iter()
-                .map(|context| (context.id(), context)),
-        );
-
+    pub fn attach_tool_results(&mut self, cx: &mut Context<Self>) {
         // Insert a user message to contain the tool results.
         self.insert_user_message(
             // TODO: Sending up a user message without any content results in the model sending back
@@ -1658,6 +1709,11 @@ impl Thread {
                     Role::System => "System",
                 }
             )?;
+
+            if !message.context.is_empty() {
+                writeln!(markdown, "{}", message.context)?;
+            }
+
             for segment in &message.segments {
                 match segment {
                     MessageSegment::Text(text) => writeln!(markdown, "{}\n", text)?,
@@ -1712,6 +1768,17 @@ impl Thread {
             .update(cx, |action_log, cx| action_log.keep_all_edits(cx));
     }
 
+    pub fn reject_edits_in_range(
+        &mut self,
+        buffer: Entity<language::Buffer>,
+        buffer_range: Range<language::Anchor>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.action_log.update(cx, |action_log, cx| {
+            action_log.reject_edits_in_range(buffer, buffer_range, cx)
+        })
+    }
+
     pub fn action_log(&self) -> &Entity<ActionLog> {
         &self.action_log
     }
@@ -1724,26 +1791,33 @@ impl Thread {
         self.cumulative_token_usage.clone()
     }
 
-    pub fn is_getting_too_long(&self, cx: &App) -> bool {
+    pub fn total_token_usage(&self, cx: &App) -> TotalTokenUsage {
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let Some(model) = model_registry.active_model() else {
-            return false;
+        let Some(model) = model_registry.default_model() else {
+            return TotalTokenUsage::default();
         };
 
-        let max_tokens = model.max_token_count();
-
-        let current_usage =
-            self.cumulative_token_usage.input_tokens + self.cumulative_token_usage.output_tokens;
+        let max = model.model.max_token_count();
 
         #[cfg(debug_assertions)]
         let warning_threshold: f32 = std::env::var("ZED_THREAD_WARNING_THRESHOLD")
-            .unwrap_or("0.9".to_string())
+            .unwrap_or("0.8".to_string())
             .parse()
             .unwrap();
         #[cfg(not(debug_assertions))]
-        let warning_threshold: f32 = 0.9;
+        let warning_threshold: f32 = 0.8;
 
-        current_usage as f32 >= (max_tokens as f32 * warning_threshold)
+        let total = self.cumulative_token_usage.total_tokens() as usize;
+
+        let ratio = if total >= max {
+            TokenUsageRatio::Exceeded
+        } else if total as f32 / max as f32 >= warning_threshold {
+            TokenUsageRatio::Warning
+        } else {
+            TokenUsageRatio::Normal
+        };
+
+        TotalTokenUsage { total, max, ratio }
     }
 
     pub fn deny_tool_use(
@@ -1787,6 +1861,7 @@ pub enum ThreadEvent {
     MessageAdded(MessageId),
     MessageEdited(MessageId),
     MessageDeleted(MessageId),
+    SummaryGenerated,
     SummaryChanged,
     UsePendingTools,
     ToolFinished {
@@ -1807,3 +1882,415 @@ struct PendingCompletion {
     id: usize,
     _task: Task<()>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{ThreadStore, context_store::ContextStore, thread_store};
+    use assistant_settings::AssistantSettings;
+    use context_server::ContextServerSettings;
+    use editor::EditorSettings;
+    use gpui::TestAppContext;
+    use project::{FakeFs, Project};
+    use prompt_store::PromptBuilder;
+    use serde_json::json;
+    use settings::{Settings, SettingsStore};
+    use std::sync::Arc;
+    use theme::ThemeSettings;
+    use util::path;
+    use workspace::Workspace;
+
+    #[gpui::test]
+    async fn test_message_with_context(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({"code.rs": "fn main() {\n    println!(\"Hello, world!\");\n}"}),
+        )
+        .await;
+
+        let (_workspace, _thread_store, thread, context_store) =
+            setup_test_environment(cx, project.clone()).await;
+
+        add_file_to_context(&project, &context_store, "test/code.rs", cx)
+            .await
+            .unwrap();
+
+        let context =
+            context_store.update(cx, |store, _| store.context().first().cloned().unwrap());
+
+        // Insert user message with context
+        let message_id = thread.update(cx, |thread, cx| {
+            thread.insert_user_message("Please explain this code", vec![context], None, cx)
+        });
+
+        // Check content and context in message object
+        let message = thread.read_with(cx, |thread, _| thread.message(message_id).unwrap().clone());
+
+        // Use different path format strings based on platform for the test
+        #[cfg(windows)]
+        let path_part = r"test\code.rs";
+        #[cfg(not(windows))]
+        let path_part = "test/code.rs";
+
+        let expected_context = format!(
+            r#"
+<context>
+The following items were attached by the user. You don't need to use other tools to read them.
+
+<files>
+```rs {path_part}
+fn main() {{
+    println!("Hello, world!");
+}}
+```
+</files>
+</context>
+"#
+        );
+
+        assert_eq!(message.role, Role::User);
+        assert_eq!(message.segments.len(), 1);
+        assert_eq!(
+            message.segments[0],
+            MessageSegment::Text("Please explain this code".to_string())
+        );
+        assert_eq!(message.context, expected_context);
+
+        // Check message in request
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
+
+        assert_eq!(request.messages.len(), 1);
+        let expected_full_message = format!("{}Please explain this code", expected_context);
+        assert_eq!(request.messages[0].string_contents(), expected_full_message);
+    }
+
+    #[gpui::test]
+    async fn test_only_include_new_contexts(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({
+                "file1.rs": "fn function1() {}\n",
+                "file2.rs": "fn function2() {}\n",
+                "file3.rs": "fn function3() {}\n",
+            }),
+        )
+        .await;
+
+        let (_, _thread_store, thread, context_store) =
+            setup_test_environment(cx, project.clone()).await;
+
+        // Open files individually
+        add_file_to_context(&project, &context_store, "test/file1.rs", cx)
+            .await
+            .unwrap();
+        add_file_to_context(&project, &context_store, "test/file2.rs", cx)
+            .await
+            .unwrap();
+        add_file_to_context(&project, &context_store, "test/file3.rs", cx)
+            .await
+            .unwrap();
+
+        // Get the context objects
+        let contexts = context_store.update(cx, |store, _| store.context().clone());
+        assert_eq!(contexts.len(), 3);
+
+        // First message with context 1
+        let message1_id = thread.update(cx, |thread, cx| {
+            thread.insert_user_message("Message 1", vec![contexts[0].clone()], None, cx)
+        });
+
+        // Second message with contexts 1 and 2 (context 1 should be skipped as it's already included)
+        let message2_id = thread.update(cx, |thread, cx| {
+            thread.insert_user_message(
+                "Message 2",
+                vec![contexts[0].clone(), contexts[1].clone()],
+                None,
+                cx,
+            )
+        });
+
+        // Third message with all three contexts (contexts 1 and 2 should be skipped)
+        let message3_id = thread.update(cx, |thread, cx| {
+            thread.insert_user_message(
+                "Message 3",
+                vec![
+                    contexts[0].clone(),
+                    contexts[1].clone(),
+                    contexts[2].clone(),
+                ],
+                None,
+                cx,
+            )
+        });
+
+        // Check what contexts are included in each message
+        let (message1, message2, message3) = thread.read_with(cx, |thread, _| {
+            (
+                thread.message(message1_id).unwrap().clone(),
+                thread.message(message2_id).unwrap().clone(),
+                thread.message(message3_id).unwrap().clone(),
+            )
+        });
+
+        // First message should include context 1
+        assert!(message1.context.contains("file1.rs"));
+
+        // Second message should include only context 2 (not 1)
+        assert!(!message2.context.contains("file1.rs"));
+        assert!(message2.context.contains("file2.rs"));
+
+        // Third message should include only context 3 (not 1 or 2)
+        assert!(!message3.context.contains("file1.rs"));
+        assert!(!message3.context.contains("file2.rs"));
+        assert!(message3.context.contains("file3.rs"));
+
+        // Check entire request to make sure all contexts are properly included
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
+
+        // The request should contain all 3 messages
+        assert_eq!(request.messages.len(), 3);
+
+        // Check that the contexts are properly formatted in each message
+        assert!(request.messages[0].string_contents().contains("file1.rs"));
+        assert!(!request.messages[0].string_contents().contains("file2.rs"));
+        assert!(!request.messages[0].string_contents().contains("file3.rs"));
+
+        assert!(!request.messages[1].string_contents().contains("file1.rs"));
+        assert!(request.messages[1].string_contents().contains("file2.rs"));
+        assert!(!request.messages[1].string_contents().contains("file3.rs"));
+
+        assert!(!request.messages[2].string_contents().contains("file1.rs"));
+        assert!(!request.messages[2].string_contents().contains("file2.rs"));
+        assert!(request.messages[2].string_contents().contains("file3.rs"));
+    }
+
+    #[gpui::test]
+    async fn test_message_without_files(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({"code.rs": "fn main() {\n    println!(\"Hello, world!\");\n}"}),
+        )
+        .await;
+
+        let (_, _thread_store, thread, _context_store) =
+            setup_test_environment(cx, project.clone()).await;
+
+        // Insert user message without any context (empty context vector)
+        let message_id = thread.update(cx, |thread, cx| {
+            thread.insert_user_message("What is the best way to learn Rust?", vec![], None, cx)
+        });
+
+        // Check content and context in message object
+        let message = thread.read_with(cx, |thread, _| thread.message(message_id).unwrap().clone());
+
+        // Context should be empty when no files are included
+        assert_eq!(message.role, Role::User);
+        assert_eq!(message.segments.len(), 1);
+        assert_eq!(
+            message.segments[0],
+            MessageSegment::Text("What is the best way to learn Rust?".to_string())
+        );
+        assert_eq!(message.context, "");
+
+        // Check message in request
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
+
+        assert_eq!(request.messages.len(), 1);
+        assert_eq!(
+            request.messages[0].string_contents(),
+            "What is the best way to learn Rust?"
+        );
+
+        // Add second message, also without context
+        let message2_id = thread.update(cx, |thread, cx| {
+            thread.insert_user_message("Are there any good books?", vec![], None, cx)
+        });
+
+        let message2 =
+            thread.read_with(cx, |thread, _| thread.message(message2_id).unwrap().clone());
+        assert_eq!(message2.context, "");
+
+        // Check that both messages appear in the request
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
+
+        assert_eq!(request.messages.len(), 2);
+        assert_eq!(
+            request.messages[0].string_contents(),
+            "What is the best way to learn Rust?"
+        );
+        assert_eq!(
+            request.messages[1].string_contents(),
+            "Are there any good books?"
+        );
+    }
+
+    #[gpui::test]
+    async fn test_stale_buffer_notification(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({"code.rs": "fn main() {\n    println!(\"Hello, world!\");\n}"}),
+        )
+        .await;
+
+        let (_workspace, _thread_store, thread, context_store) =
+            setup_test_environment(cx, project.clone()).await;
+
+        // Open buffer and add it to context
+        let buffer = add_file_to_context(&project, &context_store, "test/code.rs", cx)
+            .await
+            .unwrap();
+
+        let context =
+            context_store.update(cx, |store, _| store.context().first().cloned().unwrap());
+
+        // Insert user message with the buffer as context
+        thread.update(cx, |thread, cx| {
+            thread.insert_user_message("Explain this code", vec![context], None, cx)
+        });
+
+        // Create a request and check that it doesn't have a stale buffer warning yet
+        let initial_request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
+
+        // Make sure we don't have a stale file warning yet
+        let has_stale_warning = initial_request.messages.iter().any(|msg| {
+            msg.string_contents()
+                .contains("These files changed since last read:")
+        });
+        assert!(
+            !has_stale_warning,
+            "Should not have stale buffer warning before buffer is modified"
+        );
+
+        // Modify the buffer
+        buffer.update(cx, |buffer, cx| {
+            // Find a position at the end of line 1
+            buffer.edit(
+                [(1..1, "\n    println!(\"Added a new line\");\n")],
+                None,
+                cx,
+            );
+        });
+
+        // Insert another user message without context
+        thread.update(cx, |thread, cx| {
+            thread.insert_user_message("What does the code do now?", vec![], None, cx)
+        });
+
+        // Create a new request and check for the stale buffer warning
+        let new_request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
+
+        // We should have a stale file warning as the last message
+        let last_message = new_request
+            .messages
+            .last()
+            .expect("Request should have messages");
+
+        // The last message should be the stale buffer notification
+        assert_eq!(last_message.role, Role::User);
+
+        // Check the exact content of the message
+        let expected_content = "These files changed since last read:\n- code.rs\n";
+        assert_eq!(
+            last_message.string_contents(),
+            expected_content,
+            "Last message should be exactly the stale buffer notification"
+        );
+    }
+
+    fn init_test_settings(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            language::init(cx);
+            Project::init_settings(cx);
+            AssistantSettings::register(cx);
+            thread_store::init(cx);
+            workspace::init_settings(cx);
+            ThemeSettings::register(cx);
+            ContextServerSettings::register(cx);
+            EditorSettings::register(cx);
+        });
+    }
+
+    // Helper to create a test project with test files
+    async fn create_test_project(
+        cx: &mut TestAppContext,
+        files: serde_json::Value,
+    ) -> Entity<Project> {
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/test"), files).await;
+        Project::test(fs, [path!("/test").as_ref()], cx).await
+    }
+
+    async fn setup_test_environment(
+        cx: &mut TestAppContext,
+        project: Entity<Project>,
+    ) -> (
+        Entity<Workspace>,
+        Entity<ThreadStore>,
+        Entity<Thread>,
+        Entity<ContextStore>,
+    ) {
+        let (workspace, cx) =
+            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
+
+        let thread_store = cx.update(|_, cx| {
+            ThreadStore::new(
+                project.clone(),
+                Arc::default(),
+                Arc::new(PromptBuilder::new(None).unwrap()),
+                cx,
+            )
+            .unwrap()
+        });
+
+        let thread = thread_store.update(cx, |store, cx| store.create_thread(cx));
+        let context_store = cx.new(|_cx| ContextStore::new(workspace.downgrade(), None));
+
+        (workspace, thread_store, thread, context_store)
+    }
+
+    async fn add_file_to_context(
+        project: &Entity<Project>,
+        context_store: &Entity<ContextStore>,
+        path: &str,
+        cx: &mut TestAppContext,
+    ) -> Result<Entity<language::Buffer>> {
+        let buffer_path = project
+            .read_with(cx, |project, cx| project.find_project_path(path, cx))
+            .unwrap();
+
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(buffer_path, cx))
+            .await
+            .unwrap();
+
+        context_store
+            .update(cx, |store, cx| {
+                store.add_file_from_buffer(buffer.clone(), cx)
+            })
+            .await?;
+
+        Ok(buffer)
+    }
+}

crates/agent/src/thread_history.rs

@@ -1,52 +1,179 @@
+use std::sync::Arc;
+
 use assistant_context_editor::SavedContextMetadata;
+use editor::{Editor, EditorEvent};
+use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
-    App, Entity, FocusHandle, Focusable, ScrollStrategy, UniformListScrollHandle, WeakEntity,
-    uniform_list,
+    App, Entity, FocusHandle, Focusable, ScrollStrategy, Task, UniformListScrollHandle, WeakEntity,
+    Window, uniform_list,
 };
 use time::{OffsetDateTime, UtcOffset};
-use ui::{IconButtonShape, ListItem, ListItemSpacing, Tooltip, prelude::*};
+use ui::{HighlightedLabel, IconButtonShape, ListItem, ListItemSpacing, Tooltip, prelude::*};
+use util::ResultExt;
 
 use crate::history_store::{HistoryEntry, HistoryStore};
 use crate::thread_store::SerializedThreadMetadata;
 use crate::{AssistantPanel, RemoveSelectedThread};
 
 pub struct ThreadHistory {
-    focus_handle: FocusHandle,
     assistant_panel: WeakEntity<AssistantPanel>,
     history_store: Entity<HistoryStore>,
     scroll_handle: UniformListScrollHandle,
     selected_index: usize,
+    search_query: SharedString,
+    search_editor: Entity<Editor>,
+    all_entries: Arc<Vec<HistoryEntry>>,
+    matches: Vec<StringMatch>,
+    _subscriptions: Vec<gpui::Subscription>,
+    _search_task: Option<Task<()>>,
 }
 
 impl ThreadHistory {
     pub(crate) fn new(
         assistant_panel: WeakEntity<AssistantPanel>,
         history_store: Entity<HistoryStore>,
+        window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
+        let search_editor = cx.new(|cx| {
+            let mut editor = Editor::single_line(window, cx);
+            editor.set_placeholder_text("Search threads...", cx);
+            editor
+        });
+
+        let search_editor_subscription =
+            cx.subscribe(&search_editor, |this, search_editor, event, cx| {
+                if let EditorEvent::BufferEdited = event {
+                    let query = search_editor.read(cx).text(cx);
+                    this.search_query = query.into();
+                    this.update_search(cx);
+                }
+            });
+
+        let entries: Arc<Vec<_>> = history_store
+            .update(cx, |store, cx| store.entries(cx))
+            .into();
+
+        let history_store_subscription = cx.observe(&history_store, |this, _, cx| {
+            this.update_all_entries(cx);
+        });
+
         Self {
-            focus_handle: cx.focus_handle(),
             assistant_panel,
             history_store,
             scroll_handle: UniformListScrollHandle::default(),
             selected_index: 0,
+            search_query: SharedString::new_static(""),
+            all_entries: entries,
+            matches: Vec::new(),
+            search_editor,
+            _subscriptions: vec![search_editor_subscription, history_store_subscription],
+            _search_task: None,
+        }
+    }
+
+    fn update_all_entries(&mut self, cx: &mut Context<Self>) {
+        self.all_entries = self
+            .history_store
+            .update(cx, |store, cx| store.entries(cx))
+            .into();
+        self.matches.clear();
+        self.update_search(cx);
+    }
+
+    fn update_search(&mut self, cx: &mut Context<Self>) {
+        self._search_task.take();
+
+        if self.has_search_query() {
+            self.perform_search(cx);
+        } else {
+            self.matches.clear();
+            self.set_selected_index(0, cx);
+            cx.notify();
+        }
+    }
+
+    fn perform_search(&mut self, cx: &mut Context<Self>) {
+        let query = self.search_query.clone();
+        let all_entries = self.all_entries.clone();
+
+        let task = cx.spawn(async move |this, cx| {
+            let executor = cx.background_executor().clone();
+
+            let matches = cx
+                .background_spawn(async move {
+                    let mut candidates = Vec::with_capacity(all_entries.len());
+
+                    for (idx, entry) in all_entries.iter().enumerate() {
+                        match entry {
+                            HistoryEntry::Thread(thread) => {
+                                candidates.push(StringMatchCandidate::new(idx, &thread.summary));
+                            }
+                            HistoryEntry::Context(context) => {
+                                candidates.push(StringMatchCandidate::new(idx, &context.title));
+                            }
+                        }
+                    }
+
+                    const MAX_MATCHES: usize = 100;
+
+                    fuzzy::match_strings(
+                        &candidates,
+                        &query,
+                        false,
+                        MAX_MATCHES,
+                        &Default::default(),
+                        executor,
+                    )
+                    .await
+                })
+                .await;
+
+            this.update(cx, |this, cx| {
+                this.matches = matches;
+                this.set_selected_index(0, cx);
+                cx.notify();
+            })
+            .log_err();
+        });
+
+        self._search_task = Some(task);
+    }
+
+    fn has_search_query(&self) -> bool {
+        !self.search_query.is_empty()
+    }
+
+    fn matched_count(&self) -> usize {
+        if self.has_search_query() {
+            self.matches.len()
+        } else {
+            self.all_entries.len()
+        }
+    }
+
+    fn get_match(&self, ix: usize) -> Option<&HistoryEntry> {
+        if self.has_search_query() {
+            self.matches
+                .get(ix)
+                .and_then(|m| self.all_entries.get(m.candidate_id))
+        } else {
+            self.all_entries.get(ix)
         }
     }
 
     pub fn select_previous(
         &mut self,
         _: &menu::SelectPrevious,
-        window: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+        let count = self.matched_count();
         if count > 0 {
             if self.selected_index == 0 {
-                self.set_selected_index(count - 1, window, cx);
+                self.set_selected_index(count - 1, cx);
             } else {
-                self.set_selected_index(self.selected_index - 1, window, cx);
+                self.set_selected_index(self.selected_index - 1, cx);
             }
         }
     }
@@ -54,40 +181,39 @@ impl ThreadHistory {
     pub fn select_next(
         &mut self,
         _: &menu::SelectNext,
-        window: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+        let count = self.matched_count();
         if count > 0 {
             if self.selected_index == count - 1 {
-                self.set_selected_index(0, window, cx);
+                self.set_selected_index(0, cx);
             } else {
-                self.set_selected_index(self.selected_index + 1, window, cx);
+                self.set_selected_index(self.selected_index + 1, cx);
             }
         }
     }
 
-    fn select_first(&mut self, _: &menu::SelectFirst, window: &mut Window, cx: &mut Context<Self>) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+    fn select_first(
+        &mut self,
+        _: &menu::SelectFirst,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self.matched_count();
         if count > 0 {
-            self.set_selected_index(0, window, cx);
+            self.set_selected_index(0, cx);
         }
     }
 
-    fn select_last(&mut self, _: &menu::SelectLast, window: &mut Window, cx: &mut Context<Self>) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+    fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
+        let count = self.matched_count();
         if count > 0 {
-            self.set_selected_index(count - 1, window, cx);
+            self.set_selected_index(count - 1, cx);
         }
     }
 
-    fn set_selected_index(&mut self, index: usize, _window: &mut Window, cx: &mut Context<Self>) {
+    fn set_selected_index(&mut self, index: usize, cx: &mut Context<Self>) {
         self.selected_index = index;
         self.scroll_handle
             .scroll_to_item(index, ScrollStrategy::Top);
@@ -95,23 +221,21 @@ impl ThreadHistory {
     }
 
     fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
-        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
-
-        if let Some(entry) = entries.get(self.selected_index) {
-            match entry {
-                HistoryEntry::Thread(thread) => {
-                    self.assistant_panel
-                        .update(cx, move |this, cx| this.open_thread(&thread.id, window, cx))
-                        .ok();
-                }
+        if let Some(entry) = self.get_match(self.selected_index) {
+            let task_result = match entry {
+                HistoryEntry::Thread(thread) => self
+                    .assistant_panel
+                    .update(cx, move |this, cx| this.open_thread(&thread.id, window, cx)),
                 HistoryEntry::Context(context) => {
-                    self.assistant_panel
-                        .update(cx, move |this, cx| {
-                            this.open_saved_prompt_editor(context.path.clone(), window, cx)
-                        })
-                        .ok();
+                    self.assistant_panel.update(cx, move |this, cx| {
+                        this.open_saved_prompt_editor(context.path.clone(), window, cx)
+                    })
                 }
-            }
+            };
+
+            if let Some(task) = task_result.log_err() {
+                task.detach_and_log_err(cx);
+            };
 
             cx.notify();
         }
@@ -123,25 +247,19 @@ impl ThreadHistory {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+        if let Some(entry) = self.get_match(self.selected_index) {
+            let task_result = match entry {
+                HistoryEntry::Thread(thread) => self
+                    .assistant_panel
+                    .update(cx, |this, cx| this.delete_thread(&thread.id, cx)),
+                HistoryEntry::Context(context) => self
+                    .assistant_panel
+                    .update(cx, |this, cx| this.delete_context(context.path.clone(), cx)),
+            };
 
-        if let Some(entry) = entries.get(self.selected_index) {
-            match entry {
-                HistoryEntry::Thread(thread) => {
-                    self.assistant_panel
-                        .update(cx, |this, cx| {
-                            this.delete_thread(&thread.id, cx);
-                        })
-                        .ok();
-                }
-                HistoryEntry::Context(context) => {
-                    self.assistant_panel
-                        .update(cx, |this, cx| {
-                            this.delete_context(context.path.clone(), cx);
-                        })
-                        .ok();
-                }
-            }
+            if let Some(task) = task_result.log_err() {
+                task.detach_and_log_err(cx);
+            };
 
             cx.notify();
         }
@@ -149,66 +267,109 @@ impl ThreadHistory {
 }
 
 impl Focusable for ThreadHistory {
-    fn focus_handle(&self, _cx: &App) -> FocusHandle {
-        self.focus_handle.clone()
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.search_editor.focus_handle(cx)
     }
 }
 
 impl Render for ThreadHistory {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let history_entries = self.history_store.update(cx, |this, cx| this.entries(cx));
         let selected_index = self.selected_index;
 
         v_flex()
-            .id("thread-history-container")
             .key_context("ThreadHistory")
-            .track_focus(&self.focus_handle)
-            .overflow_y_scroll()
             .size_full()
-            .p_1()
             .on_action(cx.listener(Self::select_previous))
             .on_action(cx.listener(Self::select_next))
             .on_action(cx.listener(Self::select_first))
             .on_action(cx.listener(Self::select_last))
             .on_action(cx.listener(Self::confirm))
             .on_action(cx.listener(Self::remove_selected_thread))
-            .map(|history| {
-                if history_entries.is_empty() {
-                    history
-                        .justify_center()
+            .when(!self.all_entries.is_empty(), |parent| {
+                parent.child(
+                    h_flex()
+                        .h(px(41.)) // Match the toolbar perfectly
+                        .w_full()
+                        .py_1()
+                        .px_2()
+                        .gap_2()
+                        .justify_between()
+                        .border_b_1()
+                        .border_color(cx.theme().colors().border)
+                        .child(
+                            Icon::new(IconName::MagnifyingGlass)
+                                .color(Color::Muted)
+                                .size(IconSize::Small),
+                        )
+                        .child(self.search_editor.clone()),
+                )
+            })
+            .child({
+                let view = v_flex().overflow_hidden().flex_grow();
+
+                if self.all_entries.is_empty() {
+                    view.justify_center()
                         .child(
                             h_flex().w_full().justify_center().child(
                                 Label::new("You don't have any past threads yet.")
                                     .size(LabelSize::Small),
                             ),
                         )
+                } else if self.has_search_query() && self.matches.is_empty() {
+                    view.justify_center().child(
+                        h_flex().w_full().justify_center().child(
+                            Label::new("No threads match your search.").size(LabelSize::Small),
+                        ),
+                    )
                 } else {
-                    history.child(
+                    view.p_1().child(
                         uniform_list(
                             cx.entity().clone(),
                             "thread-history",
-                            history_entries.len(),
+                            self.matched_count(),
                             move |history, range, _window, _cx| {
-                                history_entries[range]
-                                    .iter()
-                                    .enumerate()
-                                    .map(|(index, entry)| {
-                                        h_flex().w_full().pb_1().child(match entry {
-                                            HistoryEntry::Thread(thread) => PastThread::new(
-                                                thread.clone(),
-                                                history.assistant_panel.clone(),
-                                                selected_index == index,
-                                            )
-                                            .into_any_element(),
-                                            HistoryEntry::Context(context) => PastContext::new(
-                                                context.clone(),
-                                                history.assistant_panel.clone(),
-                                                selected_index == index,
-                                            )
-                                            .into_any_element(),
-                                        })
+                                let range_start = range.start;
+                                let assistant_panel = history.assistant_panel.clone();
+
+                                let render_item = |index: usize,
+                                                   entry: &HistoryEntry,
+                                                   highlight_positions: Vec<usize>|
+                                 -> Div {
+                                    h_flex().w_full().pb_1().child(match entry {
+                                        HistoryEntry::Thread(thread) => PastThread::new(
+                                            thread.clone(),
+                                            assistant_panel.clone(),
+                                            selected_index == index + range_start,
+                                            highlight_positions,
+                                        )
+                                        .into_any_element(),
+                                        HistoryEntry::Context(context) => PastContext::new(
+                                            context.clone(),
+                                            assistant_panel.clone(),
+                                            selected_index == index + range_start,
+                                            highlight_positions,
+                                        )
+                                        .into_any_element(),
                                     })
-                                    .collect()
+                                };
+
+                                if history.has_search_query() {
+                                    history.matches[range]
+                                        .iter()
+                                        .enumerate()
+                                        .filter_map(|(index, m)| {
+                                            history.all_entries.get(m.candidate_id).map(|entry| {
+                                                render_item(index, entry, m.positions.clone())
+                                            })
+                                        })
+                                        .collect()
+                                } else {
+                                    history.all_entries[range]
+                                        .iter()
+                                        .enumerate()
+                                        .map(|(index, entry)| render_item(index, entry, vec![]))
+                                        .collect()
+                                }
                             },
                         )
                         .track_scroll(self.scroll_handle.clone())
@@ -224,6 +385,7 @@ pub struct PastThread {
     thread: SerializedThreadMetadata,
     assistant_panel: WeakEntity<AssistantPanel>,
     selected: bool,
+    highlight_positions: Vec<usize>,
 }
 
 impl PastThread {
@@ -231,11 +393,13 @@ impl PastThread {
         thread: SerializedThreadMetadata,
         assistant_panel: WeakEntity<AssistantPanel>,
         selected: bool,
+        highlight_positions: Vec<usize>,
     ) -> Self {
         Self {
             thread,
             assistant_panel,
             selected,
+            highlight_positions,
         }
     }
 }
@@ -258,9 +422,11 @@ impl RenderOnce for PastThread {
             .toggle_state(self.selected)
             .spacing(ListItemSpacing::Sparse)
             .start_slot(
-                div()
-                    .max_w_4_5()
-                    .child(Label::new(summary).size(LabelSize::Small).truncate()),
+                div().max_w_4_5().child(
+                    HighlightedLabel::new(summary, self.highlight_positions)
+                        .size(LabelSize::Small)
+                        .truncate(),
+                ),
             )
             .end_slot(
                 h_flex()
@@ -285,14 +451,21 @@ impl RenderOnce for PastThread {
                         IconButton::new("delete", IconName::TrashAlt)
                             .shape(IconButtonShape::Square)
                             .icon_size(IconSize::XSmall)
-                            .tooltip(Tooltip::text("Delete Thread"))
+                            .tooltip(move |window, cx| {
+                                Tooltip::for_action(
+                                    "Delete Thread",
+                                    &RemoveSelectedThread,
+                                    window,
+                                    cx,
+                                )
+                            })
                             .on_click({
                                 let assistant_panel = self.assistant_panel.clone();
                                 let id = self.thread.id.clone();
                                 move |_event, _window, cx| {
                                     assistant_panel
                                         .update(cx, |this, cx| {
-                                            this.delete_thread(&id, cx);
+                                            this.delete_thread(&id, cx).detach_and_log_err(cx);
                                         })
                                         .ok();
                                 }
@@ -318,6 +491,7 @@ pub struct PastContext {
     context: SavedContextMetadata,
     assistant_panel: WeakEntity<AssistantPanel>,
     selected: bool,
+    highlight_positions: Vec<usize>,
 }
 
 impl PastContext {
@@ -325,11 +499,13 @@ impl PastContext {
         context: SavedContextMetadata,
         assistant_panel: WeakEntity<AssistantPanel>,
         selected: bool,
+        highlight_positions: Vec<usize>,
     ) -> Self {
         Self {
             context,
             assistant_panel,
             selected,
+            highlight_positions,
         }
     }
 }
@@ -337,7 +513,6 @@ impl PastContext {
 impl RenderOnce for PastContext {
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
         let summary = self.context.title;
-
         let context_timestamp = time_format::format_localized_timestamp(
             OffsetDateTime::from_unix_timestamp(self.context.mtime.timestamp()).unwrap(),
             OffsetDateTime::now_utc(),
@@ -354,9 +529,11 @@ impl RenderOnce for PastContext {
         .toggle_state(self.selected)
         .spacing(ListItemSpacing::Sparse)
         .start_slot(
-            div()
-                .max_w_4_5()
-                .child(Label::new(summary).size(LabelSize::Small).truncate()),
+            div().max_w_4_5().child(
+                HighlightedLabel::new(summary, self.highlight_positions)
+                    .size(LabelSize::Small)
+                    .truncate(),
+            ),
         )
         .end_slot(
             h_flex()
@@ -388,7 +565,8 @@ impl RenderOnce for PastContext {
                             move |_event, _window, cx| {
                                 assistant_panel
                                     .update(cx, |this, cx| {
-                                        this.delete_context(path.clone(), cx);
+                                        this.delete_context(path.clone(), cx)
+                                            .detach_and_log_err(cx);
                                     })
                                     .ok();
                             }

crates/agent/src/thread_store.rs

@@ -174,8 +174,9 @@ impl ThreadStore {
             let database = database_future.await.map_err(|err| anyhow!(err))?;
             database.delete_thread(id.clone()).await?;
 
-            this.update(cx, |this, _cx| {
-                this.threads.retain(|thread| thread.id != id)
+            this.update(cx, |this, cx| {
+                this.threads.retain(|thread| thread.id != id);
+                cx.notify();
             })
         })
     }
@@ -374,6 +375,8 @@ pub struct SerializedMessage {
     pub tool_uses: Vec<SerializedToolUse>,
     #[serde(default)]
     pub tool_results: Vec<SerializedToolResult>,
+    #[serde(default)]
+    pub context: String,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -441,6 +444,7 @@ impl LegacySerializedMessage {
             segments: vec![SerializedMessageSegment::Text { text: self.text }],
             tool_uses: self.tool_uses,
             tool_results: self.tool_results,
+            context: String::new(),
         }
     }
 }

crates/agent/src/tool_use.rs

@@ -35,6 +35,18 @@ pub enum ToolUseStatus {
     Error(SharedString),
 }
 
+impl ToolUseStatus {
+    pub fn text(&self) -> SharedString {
+        match self {
+            ToolUseStatus::NeedsConfirmation => "".into(),
+            ToolUseStatus::Pending => "".into(),
+            ToolUseStatus::Running => "".into(),
+            ToolUseStatus::Finished(out) => out.clone(),
+            ToolUseStatus::Error(out) => out.clone(),
+        }
+    }
+}
+
 pub struct ToolUseState {
     tools: Arc<ToolWorkingSet>,
     tool_uses_by_assistant_message: HashMap<MessageId, Vec<LanguageModelToolUse>>,
@@ -43,6 +55,8 @@ pub struct ToolUseState {
     pending_tool_uses_by_id: HashMap<LanguageModelToolUseId, PendingToolUse>,
 }
 
+pub const USING_TOOL_MARKER: &str = "<using_tool>";
+
 impl ToolUseState {
     pub fn new(tools: Arc<ToolWorkingSet>) -> Self {
         Self {
@@ -357,8 +371,28 @@ impl ToolUseState {
         request_message: &mut LanguageModelRequestMessage,
     ) {
         if let Some(tool_uses) = self.tool_uses_by_assistant_message.get(&message_id) {
+            let mut found_tool_use = false;
+
             for tool_use in tool_uses {
                 if self.tool_results.contains_key(&tool_use.id) {
+                    if !found_tool_use {
+                        // The API fails if a message contains a tool use without any (non-whitespace) text around it
+                        match request_message.content.last_mut() {
+                            Some(MessageContent::Text(txt)) => {
+                                if txt.is_empty() {
+                                    txt.push_str(USING_TOOL_MARKER);
+                                }
+                            }
+                            None | Some(_) => {
+                                request_message
+                                    .content
+                                    .push(MessageContent::Text(USING_TOOL_MARKER.into()));
+                            }
+                        };
+                    }
+
+                    found_tool_use = true;
+
                     // Do not send tool uses until they are completed
                     request_message
                         .content

crates/anthropic/Cargo.toml

@@ -26,3 +26,4 @@ serde_json.workspace = true
 strum.workspace = true
 thiserror.workspace = true
 util.workspace = true
+workspace-hack.workspace = true

crates/anthropic/src/anthropic.rs

@@ -1,10 +1,10 @@
 mod supported_countries;
 
-use std::{pin::Pin, str::FromStr};
+use std::str::FromStr;
 
 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
-use futures::{AsyncBufReadExt, AsyncReadExt, Stream, StreamExt, io::BufReader, stream::BoxStream};
+use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};
 use http_client::http::{HeaderMap, HeaderValue};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
@@ -220,16 +220,23 @@ impl Model {
             .map(|header| header.to_string())
             .collect::<Vec<_>>();
 
-        if let Self::Custom {
-            extra_beta_headers, ..
-        } = self
-        {
-            headers.extend(
-                extra_beta_headers
-                    .iter()
-                    .filter(|header| !header.trim().is_empty())
-                    .cloned(),
-            );
+        match self {
+            Self::Claude3_7Sonnet | Self::Claude3_7SonnetThinking => {
+                // Try beta token-efficient tool use (supported in Claude 3.7 Sonnet only)
+                // https://docs.anthropic.com/en/docs/build-with-claude/tool-use/token-efficient-tool-use
+                headers.push("token-efficient-tools-2025-02-19".to_string());
+            }
+            Self::Custom {
+                extra_beta_headers, ..
+            } => {
+                headers.extend(
+                    extra_beta_headers
+                        .iter()
+                        .filter(|header| !header.trim().is_empty())
+                        .cloned(),
+                );
+            }
+            _ => {}
         }
 
         headers.join(",")
@@ -437,50 +444,6 @@ pub async fn stream_completion_with_rate_limit_info(
     }
 }
 
-pub async fn extract_tool_args_from_events(
-    tool_name: String,
-    mut events: Pin<Box<dyn Send + Stream<Item = Result<Event>>>>,
-) -> Result<impl Send + Stream<Item = Result<String>>> {
-    let mut tool_use_index = None;
-    while let Some(event) = events.next().await {
-        if let Event::ContentBlockStart {
-            index,
-            content_block: ResponseContent::ToolUse { name, .. },
-        } = event?
-        {
-            if name == tool_name {
-                tool_use_index = Some(index);
-                break;
-            }
-        }
-    }
-
-    let Some(tool_use_index) = tool_use_index else {
-        return Err(anyhow!("tool not used"));
-    };
-
-    Ok(events.filter_map(move |event| {
-        let result = match event {
-            Err(error) => Some(Err(error)),
-            Ok(Event::ContentBlockDelta { index, delta }) => match delta {
-                ContentDelta::TextDelta { .. } => None,
-                ContentDelta::ThinkingDelta { .. } => None,
-                ContentDelta::SignatureDelta { .. } => None,
-                ContentDelta::InputJsonDelta { partial_json } => {
-                    if index == tool_use_index {
-                        Some(Ok(partial_json))
-                    } else {
-                        None
-                    }
-                }
-            },
-            _ => None,
-        };
-
-        async move { result }
-    }))
-}
-
 #[derive(Debug, Serialize, Deserialize, Copy, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum CacheControlType {

crates/askpass/Cargo.toml

@@ -19,3 +19,4 @@ smol.workspace = true
 tempfile.workspace = true
 util.workspace = true
 which.workspace = true
+workspace-hack.workspace = true

crates/assets/Cargo.toml

@@ -15,3 +15,4 @@ workspace = true
 anyhow.workspace = true
 gpui.workspace = true
 rust-embed.workspace = true
+workspace-hack.workspace = true

crates/assistant/Cargo.toml

@@ -69,6 +69,7 @@ ui.workspace = true
 util.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 ctor.workspace = true

crates/assistant/src/assistant.rs

@@ -161,12 +161,38 @@ fn init_language_model_settings(cx: &mut App) {
 
 fn update_active_language_model_from_settings(cx: &mut App) {
     let settings = AssistantSettings::get_global(cx);
+    // Default model - used as fallback
     let active_model_provider_name =
         LanguageModelProviderId::from(settings.default_model.provider.clone());
     let active_model_id = LanguageModelId::from(settings.default_model.model.clone());
-    let editor_provider_name =
-        LanguageModelProviderId::from(settings.editor_model.provider.clone());
-    let editor_model_id = LanguageModelId::from(settings.editor_model.model.clone());
+
+    // Inline assistant model
+    let inline_assistant_model = settings
+        .inline_assistant_model
+        .as_ref()
+        .unwrap_or(&settings.default_model);
+    let inline_assistant_provider_name =
+        LanguageModelProviderId::from(inline_assistant_model.provider.clone());
+    let inline_assistant_model_id = LanguageModelId::from(inline_assistant_model.model.clone());
+
+    // Commit message model
+    let commit_message_model = settings
+        .commit_message_model
+        .as_ref()
+        .unwrap_or(&settings.default_model);
+    let commit_message_provider_name =
+        LanguageModelProviderId::from(commit_message_model.provider.clone());
+    let commit_message_model_id = LanguageModelId::from(commit_message_model.model.clone());
+
+    // Thread summary model
+    let thread_summary_model = settings
+        .thread_summary_model
+        .as_ref()
+        .unwrap_or(&settings.default_model);
+    let thread_summary_provider_name =
+        LanguageModelProviderId::from(thread_summary_model.provider.clone());
+    let thread_summary_model_id = LanguageModelId::from(thread_summary_model.model.clone());
+
     let inline_alternatives = settings
         .inline_alternatives
         .iter()
@@ -177,9 +203,29 @@ fn update_active_language_model_from_settings(cx: &mut App) {
             )
         })
         .collect::<Vec<_>>();
+
     LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-        registry.select_active_model(&active_model_provider_name, &active_model_id, cx);
-        registry.select_editor_model(&editor_provider_name, &editor_model_id, cx);
+        // Set the default model
+        registry.select_default_model(&active_model_provider_name, &active_model_id, cx);
+
+        // Set the specific models
+        registry.select_inline_assistant_model(
+            &inline_assistant_provider_name,
+            &inline_assistant_model_id,
+            cx,
+        );
+        registry.select_commit_message_model(
+            &commit_message_provider_name,
+            &commit_message_model_id,
+            cx,
+        );
+        registry.select_thread_summary_model(
+            &thread_summary_provider_name,
+            &thread_summary_model_id,
+            cx,
+        );
+
+        // Set the alternatives
         registry.select_inline_alternative_models(inline_alternatives, cx);
     });
 }

crates/assistant/src/assistant_panel.rs

@@ -22,7 +22,8 @@ use gpui::{
 };
 use language::LanguageRegistry;
 use language_model::{
-    AuthenticateError, LanguageModelProviderId, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID,
+    AuthenticateError, ConfiguredModel, LanguageModelProviderId, LanguageModelRegistry,
+    ZED_CLOUD_PROVIDER_ID,
 };
 use project::Project;
 use prompt_library::{PromptLibrary, open_prompt_library};
@@ -36,11 +37,11 @@ use ui::{ContextMenu, PopoverMenu, Tooltip, prelude::*};
 use util::{ResultExt, maybe};
 use workspace::DraggedTab;
 use workspace::{
-    DraggedSelection, Pane, ShowConfiguration, ToggleZoom, Workspace,
+    DraggedSelection, Pane, ToggleZoom, Workspace,
     dock::{DockPosition, Panel, PanelEvent},
     pane,
 };
-use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ToggleFocus};
+use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ShowConfiguration, ToggleFocus};
 
 pub fn init(cx: &mut App) {
     workspace::FollowableViewRegistry::register::<ContextEditor>(cx);
@@ -53,7 +54,15 @@ pub fn init(cx: &mut App) {
                 .register_action(ContextEditor::insert_dragged_files)
                 .register_action(AssistantPanel::show_configuration)
                 .register_action(AssistantPanel::create_new_context)
-                .register_action(AssistantPanel::restart_context_servers);
+                .register_action(AssistantPanel::restart_context_servers)
+                .register_action(|workspace, _: &OpenPromptLibrary, 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(&OpenPromptLibrary, window, cx)
+                        });
+                    }
+                });
         },
     )
     .detach();
@@ -298,8 +307,10 @@ impl AssistantPanel {
                 &LanguageModelRegistry::global(cx),
                 window,
                 |this, _, event: &language_model::Event, window, cx| match event {
-                    language_model::Event::ActiveModelChanged
-                    | language_model::Event::EditorModelChanged => {
+                    language_model::Event::DefaultModelChanged
+                    | language_model::Event::InlineAssistantModelChanged
+                    | language_model::Event::CommitMessageModelChanged
+                    | language_model::Event::ThreadSummaryModelChanged => {
                         this.completion_provider_changed(window, cx);
                     }
                     language_model::Event::ProviderStateChanged => {
@@ -468,12 +479,12 @@ impl AssistantPanel {
     }
 
     fn update_zed_ai_notice_visibility(&mut self, client_status: Status, cx: &mut Context<Self>) {
-        let active_provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let model = LanguageModelRegistry::read_global(cx).default_model();
 
         // If we're signed out and don't have a provider configured, or we're signed-out AND Zed.dev is
         // the provider, we want to show a nudge to sign in.
         let show_zed_ai_notice = client_status.is_signed_out()
-            && active_provider.map_or(true, |provider| provider.id().0 == ZED_CLOUD_PROVIDER_ID);
+            && model.map_or(true, |model| model.provider.id().0 == ZED_CLOUD_PROVIDER_ID);
 
         self.show_zed_ai_notice = show_zed_ai_notice;
         cx.notify();
@@ -541,8 +552,8 @@ impl AssistantPanel {
         }
 
         let Some(new_provider_id) = LanguageModelRegistry::read_global(cx)
-            .active_provider()
-            .map(|p| p.id())
+            .default_model()
+            .map(|default| default.provider.id())
         else {
             return;
         };
@@ -568,7 +579,9 @@ impl AssistantPanel {
             return;
         }
 
-        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
+        let Some(ConfiguredModel { provider, .. }) =
+            LanguageModelRegistry::read_global(cx).default_model()
+        else {
             return;
         };
 
@@ -976,8 +989,8 @@ impl AssistantPanel {
                 |this, _, event: &ConfigurationViewEvent, window, cx| match event {
                     ConfigurationViewEvent::NewProviderContextEditor(provider) => {
                         if LanguageModelRegistry::read_global(cx)
-                            .active_provider()
-                            .map_or(true, |p| p.id() != provider.id())
+                            .default_model()
+                            .map_or(true, |default| default.provider.id() != provider.id())
                         {
                             if let Some(model) = provider.default_model(cx) {
                                 update_settings_file::<AssistantSettings>(
@@ -1155,8 +1168,8 @@ impl AssistantPanel {
 
     fn is_authenticated(&mut self, cx: &mut Context<Self>) -> bool {
         LanguageModelRegistry::read_global(cx)
-            .active_provider()
-            .map_or(false, |provider| provider.is_authenticated(cx))
+            .default_model()
+            .map_or(false, |default| default.provider.is_authenticated(cx))
     }
 
     fn authenticate(
@@ -1164,8 +1177,8 @@ impl AssistantPanel {
         cx: &mut Context<Self>,
     ) -> Option<Task<Result<(), AuthenticateError>>> {
         LanguageModelRegistry::read_global(cx)
-            .active_provider()
-            .map_or(None, |provider| Some(provider.authenticate(cx)))
+            .default_model()
+            .map_or(None, |default| Some(default.provider.authenticate(cx)))
     }
 
     fn restart_context_servers(

crates/assistant/src/inline_assistant.rs

@@ -34,8 +34,8 @@ use gpui::{
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId, line_diff};
 use language_model::{
-    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelTextStream, Role, report_assistant_event,
+    ConfiguredModel, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelTextStream, Role, report_assistant_event,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use multi_buffer::MultiBufferRow;
@@ -312,7 +312,9 @@ impl InlineAssistant {
                 start..end,
             ));
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).default_model()
+            {
                 self.telemetry.report_assistant_event(AssistantEvent {
                     conversation_id: None,
                     kind: AssistantKind::Inline,
@@ -525,14 +527,14 @@ impl InlineAssistant {
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Above(range.start),
-                height: prompt_editor_height,
+                height: Some(prompt_editor_height),
                 render: build_assist_editor_renderer(prompt_editor),
                 priority: 0,
             },
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Below(range.end),
-                height: 0,
+                height: None,
                 render: Arc::new(|cx| {
                     v_flex()
                         .h_full()
@@ -877,7 +879,9 @@ impl InlineAssistant {
             let active_alternative = assist.codegen.read(cx).active_alternative().clone();
             let message_id = active_alternative.read(cx).message_id.clone();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).default_model()
+            {
                 let language_name = assist.editor.upgrade().and_then(|editor| {
                     let multibuffer = editor.read(cx).buffer().read(cx);
                     let multibuffer_snapshot = multibuffer.snapshot(cx);
@@ -1297,7 +1301,7 @@ impl InlineAssistant {
                     deleted_lines_editor.update(cx, |editor, cx| editor.max_point(cx).row().0 + 1);
                 new_blocks.push(BlockProperties {
                     placement: BlockPlacement::Above(new_row),
-                    height,
+                    height: Some(height),
                     style: BlockStyle::Flex,
                     render: Arc::new(move |cx| {
                         div()
@@ -1629,8 +1633,8 @@ impl Render for PromptEditor {
                                 format!(
                                     "Using {}",
                                     LanguageModelRegistry::read_global(cx)
-                                        .active_model()
-                                        .map(|model| model.name().0)
+                                        .default_model()
+                                        .map(|default| default.model.name().0)
                                         .unwrap_or_else(|| "No model selected".into()),
                                 ),
                                 None,
@@ -2077,7 +2081,7 @@ impl PromptEditor {
         let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);
 
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.active_model();
+        let default_model = model_registry.default_model().map(|default| default.model);
         let alternative_models = model_registry.inline_alternative_models();
 
         let get_model_name = |index: usize| -> String {
@@ -2183,7 +2187,9 @@ impl PromptEditor {
     }
 
     fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx).active_model()?;
+        let model = LanguageModelRegistry::read_global(cx)
+            .default_model()?
+            .model;
         let token_counts = self.token_counts?;
         let max_token_count = model.max_token_count();
 
@@ -2638,8 +2644,9 @@ impl Codegen {
         }
 
         let primary_model = LanguageModelRegistry::read_global(cx)
-            .active_model()
-            .context("no active model")?;
+            .default_model()
+            .context("no active model")?
+            .model;
 
         for (model, alternative) in iter::once(primary_model)
             .chain(alternative_models)
@@ -2863,7 +2870,9 @@ impl CodegenAlternative {
         assistant_panel_context: Option<LanguageModelRequest>,
         cx: &App,
     ) -> BoxFuture<'static, Result<TokenCounts>> {
-        if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+        if let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        {
             let request = self.build_request(user_prompt, assistant_panel_context.clone(), cx);
             match request {
                 Ok(request) => {

crates/assistant/src/terminal_inline_assistant.rs

@@ -16,8 +16,8 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
-    report_assistant_event,
+    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
+    Role, report_assistant_event,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use prompt_store::PromptBuilder;
@@ -318,7 +318,9 @@ impl TerminalInlineAssistant {
                 })
                 .log_err();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).inline_assistant_model()
+            {
                 let codegen = assist.codegen.read(cx);
                 let executor = cx.background_executor().clone();
                 report_assistant_event(
@@ -652,8 +654,8 @@ impl Render for PromptEditor {
                                 format!(
                                     "Using {}",
                                     LanguageModelRegistry::read_global(cx)
-                                        .active_model()
-                                        .map(|model| model.name().0)
+                                        .inline_assistant_model()
+                                        .map(|inline_assistant| inline_assistant.model.name().0)
                                         .unwrap_or_else(|| "No model selected".into()),
                                 ),
                                 None,
@@ -822,7 +824,9 @@ impl PromptEditor {
 
     fn count_tokens(&mut self, cx: &mut Context<Self>) {
         let assist_id = self.id;
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        else {
             return;
         };
         self.pending_token_count = cx.spawn(async move |this, cx| {
@@ -980,7 +984,9 @@ impl PromptEditor {
     }
 
     fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx).active_model()?;
+        let model = LanguageModelRegistry::read_global(cx)
+            .inline_assistant_model()?
+            .model;
         let token_count = self.token_count?;
         let max_token_count = model.max_token_count();
 
@@ -1131,7 +1137,9 @@ impl Codegen {
     }
 
     pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        else {
             return;
         };
 

crates/assistant_context_editor/Cargo.toml

@@ -22,6 +22,7 @@ clock.workspace = true
 collections.workspace = true
 context_server.workspace = true
 editor.workspace = true
+feature_flags.workspace = true
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
@@ -53,7 +54,9 @@ theme.workspace = true
 ui.workspace = true
 util.workspace = true
 uuid.workspace = true
+workspace-hack.workspace = true
 workspace.workspace = true
+zed_actions.workspace = true
 
 [dev-dependencies]
 language_model = { workspace = true, features = ["test-support"] }

crates/assistant_context_editor/src/context.rs

@@ -1272,7 +1272,7 @@ impl AssistantContext {
         // Assume it will be a Chat request, even though that takes fewer tokens (and risks going over the limit),
         // because otherwise you see in the UI that your empty message has a bunch of tokens already used.
         let request = self.to_completion_request(RequestType::Chat, cx);
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
             return;
         };
         let debounce = self.token_count.is_some();
@@ -1284,10 +1284,12 @@ impl AssistantContext {
                         .await;
                 }
 
-                let token_count = cx.update(|cx| model.count_tokens(request, cx))?.await?;
+                let token_count = cx
+                    .update(|cx| model.model.count_tokens(request, cx))?
+                    .await?;
                 this.update(cx, |this, cx| {
                     this.token_count = Some(token_count);
-                    this.start_cache_warming(&model, cx);
+                    this.start_cache_warming(&model.model, cx);
                     cx.notify()
                 })
             }
@@ -2304,14 +2306,16 @@ impl AssistantContext {
         cx: &mut Context<Self>,
     ) -> Option<MessageAnchor> {
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let provider = model_registry.active_provider()?;
-        let model = model_registry.active_model()?;
+        let model = model_registry.default_model()?;
         let last_message_id = self.get_last_valid_message_id(cx)?;
 
-        if !provider.is_authenticated(cx) {
+        if !model.provider.is_authenticated(cx) {
             log::info!("completion provider has no credentials");
             return None;
         }
+
+        let model = model.model;
+
         // Compute which messages to cache, including the last one.
         self.mark_cache_anchors(&model.cache_configuration(), false, cx);
 
@@ -2940,15 +2944,12 @@ impl AssistantContext {
     }
 
     pub fn summarize(&mut self, replace_old: bool, cx: &mut Context<Self>) {
-        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
-            return;
-        };
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
             return;
         };
 
         if replace_old || (self.message_anchors.len() >= 2 && self.summary.is_none()) {
-            if !provider.is_authenticated(cx) {
+            if !model.provider.is_authenticated(cx) {
                 return;
             }
 
@@ -2964,7 +2965,7 @@ impl AssistantContext {
 
             self.pending_summary = cx.spawn(async move |this, cx| {
                 async move {
-                    let stream = model.stream_completion_text(request, &cx);
+                    let stream = model.model.stream_completion_text(request, &cx);
                     let mut messages = stream.await?;
 
                     let mut replaced = !replace_old;

crates/assistant_context_editor/src/context_editor.rs

@@ -18,6 +18,7 @@ use editor::{
     scroll::Autoscroll,
 };
 use editor::{FoldPlaceholder, display_map::CreaseId};
+use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt as _};
 use fs::Fs;
 use futures::FutureExt;
 use gpui::{
@@ -56,8 +57,7 @@ use ui::{
 use util::{ResultExt, maybe};
 use workspace::searchable::{Direction, SearchableItemHandle};
 use workspace::{
-    Save, ShowConfiguration, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView,
-    Workspace,
+    Save, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
     item::{self, FollowableItem, Item, ItemHandle},
     notifications::NotificationId,
     pane::{self, SaveIntent},
@@ -384,7 +384,9 @@ impl ContextEditor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let provider = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.provider);
         if provider
             .as_ref()
             .map_or(false, |provider| provider.must_accept_terms(cx))
@@ -1560,7 +1562,7 @@ impl ContextEditor {
                 })
             };
             let create_block_properties = |message: &Message| BlockProperties {
-                height: 2,
+                height: Some(2),
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Above(
                     buffer
@@ -2109,7 +2111,7 @@ impl ContextEditor {
                     let image = render_image.clone();
                     anchor.is_valid(&buffer).then(|| BlockProperties {
                         placement: BlockPlacement::Above(anchor),
-                        height: MAX_HEIGHT_IN_LINES,
+                        height: Some(MAX_HEIGHT_IN_LINES),
                         style: BlockStyle::Sticky,
                         render: Arc::new(move |cx| {
                             let image_size = size_for_image(
@@ -2357,7 +2359,19 @@ impl ContextEditor {
                             .on_click({
                                 let focus_handle = self.focus_handle(cx).clone();
                                 move |_event, window, cx| {
-                                    focus_handle.dispatch_action(&ShowConfiguration, window, cx);
+                                    if cx.has_flag::<Assistant2FeatureFlag>() {
+                                        focus_handle.dispatch_action(
+                                            &zed_actions::agent::OpenConfiguration,
+                                            window,
+                                            cx,
+                                        );
+                                    } else {
+                                        focus_handle.dispatch_action(
+                                            &zed_actions::assistant::ShowConfiguration,
+                                            window,
+                                            cx,
+                                        );
+                                    };
                                 }
                             }),
                     )
@@ -2395,13 +2409,13 @@ impl ContextEditor {
             None => (ButtonStyle::Filled, None),
         };
 
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let model = LanguageModelRegistry::read_global(cx).default_model();
 
         let has_configuration_error = configuration_error(cx).is_some();
         let needs_to_accept_terms = self.show_accept_terms
-            && provider
+            && model
                 .as_ref()
-                .map_or(false, |provider| provider.must_accept_terms(cx));
+                .map_or(false, |model| model.provider.must_accept_terms(cx));
         let disabled = has_configuration_error || needs_to_accept_terms;
 
         ButtonLike::new("send_button")
@@ -2454,7 +2468,9 @@ impl ContextEditor {
             None => (ButtonStyle::Filled, None),
         };
 
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let provider = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.provider);
 
         let has_configuration_error = configuration_error(cx).is_some();
         let needs_to_accept_terms = self.show_accept_terms
@@ -2500,7 +2516,9 @@ impl ContextEditor {
     }
 
     fn render_language_model_selector(&self, cx: &mut Context<Self>) -> impl IntoElement {
-        let active_model = LanguageModelRegistry::read_global(cx).active_model();
+        let active_model = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.model);
         let focus_handle = self.editor().focus_handle(cx).clone();
         let model_name = match active_model {
             Some(model) => model.name().0,
@@ -3020,7 +3038,9 @@ impl EventEmitter<SearchEvent> for ContextEditor {}
 
 impl Render for ContextEditor {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let provider = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.provider);
         let accept_terms = if self.show_accept_terms {
             provider.as_ref().and_then(|provider| {
                 provider.render_accept_terms(LanguageModelProviderTosView::PromptEditorPopup, cx)
@@ -3616,7 +3636,9 @@ enum TokenState {
 fn token_state(context: &Entity<AssistantContext>, cx: &App) -> Option<TokenState> {
     const WARNING_TOKEN_THRESHOLD: f32 = 0.8;
 
-    let model = LanguageModelRegistry::read_global(cx).active_model()?;
+    let model = LanguageModelRegistry::read_global(cx)
+        .default_model()?
+        .model;
     let token_count = context.read(cx).token_count()?;
     let max_token_count = model.max_token_count();
 
@@ -3669,16 +3691,16 @@ pub enum ConfigurationError {
 }
 
 fn configuration_error(cx: &App) -> Option<ConfigurationError> {
-    let provider = LanguageModelRegistry::read_global(cx).active_provider();
-    let is_authenticated = provider
+    let model = LanguageModelRegistry::read_global(cx).default_model();
+    let is_authenticated = model
         .as_ref()
-        .map_or(false, |provider| provider.is_authenticated(cx));
+        .map_or(false, |model| model.provider.is_authenticated(cx));
 
-    if provider.is_some() && is_authenticated {
+    if model.is_some() && is_authenticated {
         return None;
     }
 
-    if provider.is_none() {
+    if model.is_none() {
         return Some(ConfigurationError::NoProvider);
     }
 
@@ -3703,6 +3725,18 @@ pub fn humanize_token_count(count: usize) -> String {
                 format!("{}.{}k", thousands, hundreds)
             }
         }
+        1_000_000..=9_999_999 => {
+            let millions = count / 1_000_000;
+            let hundred_thousands = (count % 1_000_000 + 50_000) / 100_000;
+            if hundred_thousands == 0 {
+                format!("{}M", millions)
+            } else if hundred_thousands == 10 {
+                format!("{}M", millions + 1)
+            } else {
+                format!("{}.{}M", millions, hundred_thousands)
+            }
+        }
+        10_000_000.. => format!("{}M", (count + 500_000) / 1_000_000),
         _ => format!("{}k", (count + 500) / 1000),
     }
 }

crates/assistant_eval/Cargo.toml

@@ -27,14 +27,12 @@ fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 gpui_tokio.workspace = true
-itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_models.workspace = true
 node_runtime.workspace = true
 project.workspace = true
 prompt_store.workspace = true
-regex.workspace = true
 release_channel.workspace = true
 reqwest_client.workspace = true
 serde.workspace = true
@@ -42,4 +40,7 @@ serde_json.workspace = true
 serde_json_lenient.workspace = true
 settings.workspace = true
 smol.workspace = true
+tempfile.workspace = true
 util.workspace = true
+walkdir.workspace = true
+workspace-hack.workspace = true

crates/assistant_eval/README.md

@@ -1,34 +1,25 @@
 # Tool Evals
 
-A framework for evaluating and benchmarking AI assistant performance in the Zed editor.
+A framework for evaluating and benchmarking the agent panel generations.
 
 ## Overview
 
 Tool Evals provides a headless environment for running assistants evaluations on code repositories. It automates the process of:
 
-1. Cloning and setting up test repositories
+1. Setting up test code and repositories
 2. Sending prompts to language models
 3. Allowing the assistant to use tools to modify code
-4. Collecting metrics on performance
+4. Collecting metrics on performance and tool usage
 5. Evaluating results against known good solutions
 
 ## How It Works
 
 The system consists of several key components:
 
-- **Eval**: Loads test cases from the evaluation_data directory, clones repos, and executes evaluations
+- **Eval**: Loads exercises from the zed-ace-framework repository, creates temporary repos, and executes evaluations
 - **HeadlessAssistant**: Provides a headless environment for running the AI assistant
-- **Judge**: Compares AI-generated diffs with reference solutions and scores their functional similarity
-
-The evaluation flow:
-1. An evaluation is loaded from the evaluation_data directory
-2. The target repository is cloned and checked out at a specific commit
-3. A HeadlessAssistant instance is created with the specified language model
-4. The user prompt is sent to the assistant
-5. The assistant responds and uses tools to modify code
-6. Upon completion, a diff is generated from the changes
-7. Results are saved including the diff, assistant's response, and performance metrics
-8. If a reference solution exists, a Judge evaluates the similarity of the solution
+- **Judge**: Evaluates AI-generated solutions against reference implementations and assigns scores
+- **Templates**: Defines evaluation frameworks for different tasks (Project Creation, Code Modification, Conversational Guidance)
 
 ## Setup Requirements
 
@@ -36,6 +27,7 @@ The evaluation flow:
 
 - Rust and Cargo
 - Git
+- Python (for report generation)
 - Network access to clone repositories
 - Appropriate API keys for language models and git services (Anthropic, GitHub, etc.)
 
@@ -43,35 +35,34 @@ The evaluation flow:
 
 Ensure you have the required API keys set, either from a dev run of Zed or via these environment variables:
 - `ZED_ANTHROPIC_API_KEY` for Claude models
-- `ZED_OPENAI_API_KEY` for OpenAI models
 - `ZED_GITHUB_API_KEY` for GitHub API (or similar)
 
 ## Usage
 
-### Running a Single Evaluation
-
-To run a specific evaluation:
-
-```bash
-cargo run -p assistant_eval -- bubbletea-add-set-window-title
-```
-
-The arguments are regex patterns for the evaluation names to run, so to run all evaluations that contain `bubbletea`, run:
-
-```bash
-cargo run -p assistant_eval -- bubbletea
-```
-
-To run all evaluations:
+### Running Evaluations
 
 ```bash
+# Run all tests
 cargo run -p assistant_eval -- --all
+
+# Run only specific languages
+cargo run -p assistant_eval -- --all --languages python,rust
+
+# Limit concurrent evaluations
+cargo run -p assistant_eval -- --all --concurrency 5
+
+# Limit number of exercises per language
+cargo run -p assistant_eval -- --all --max-exercises-per-language 3
 ```
 
-## Evaluation Data Structure
+### Evaluation Template Types
 
-Each evaluation should be placed in the `evaluation_data` directory with the following structure:
+The system supports three types of evaluation templates:
 
-* `prompt.txt`: The user's prompt.
-* `original.diff`: The `git diff` of the change anticipated for this prompt.
-* `setup.json`: Information about the repo used for the evaluation.
+1. **ProjectCreation**: Tests the model's ability to create new implementations from scratch
+2. **CodeModification**: Tests the model's ability to modify existing code to meet new requirements
+3. **ConversationalGuidance**: Tests the model's ability to provide guidance without writing code
+
+### Support Repo
+
+The [zed-industries/zed-ace-framework](https://github.com/zed-industries/zed-ace-framework) contains the analytics and reporting scripts.

crates/assistant_eval/src/eval.rs

@@ -1,6 +1,8 @@
+use crate::git_commands::{run_git, setup_temp_repo};
 use crate::headless_assistant::{HeadlessAppState, HeadlessAssistant};
+use crate::{get_exercise_language, get_exercise_name, templates_eval::Template};
 use agent::RequestKind;
-use anyhow::anyhow;
+use anyhow::{Result, anyhow};
 use collections::HashMap;
 use gpui::{App, Task};
 use language_model::{LanguageModel, TokenUsage};
@@ -10,19 +12,26 @@ use std::{
     io::Write,
     path::{Path, PathBuf},
     sync::Arc,
-    time::Duration,
+    time::{Duration, SystemTime},
 };
-use util::command::new_smol_command;
 
-pub struct Eval {
-    pub name: String,
-    pub path: PathBuf,
-    pub repo_path: PathBuf,
-    pub eval_setup: EvalSetup,
-    pub user_prompt: String,
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct EvalResult {
+    pub exercise_name: String,
+    pub template_name: String,
+    pub score: String,
+    pub diff: String,
+    pub assistant_response: String,
+    pub elapsed_time_ms: u128,
+    pub timestamp: u128,
+    // Token usage fields
+    pub input_tokens: usize,
+    pub output_tokens: usize,
+    pub total_tokens: usize,
+    pub tool_use_counts: usize,
+    pub judge_model_name: String, // Added field for judge model name
 }
 
-#[derive(Debug, Serialize)]
 pub struct EvalOutput {
     pub diff: String,
     pub last_message: String,
@@ -38,19 +47,31 @@ pub struct EvalSetup {
     pub base_sha: String,
 }
 
+pub struct Eval {
+    pub repo_path: PathBuf,
+    pub eval_setup: EvalSetup,
+    pub user_prompt: String,
+}
+
 impl Eval {
-    /// Loads the eval from a path (typically in `evaluation_data`). Clones and checks out the repo
-    /// if necessary.
-    pub async fn load(name: String, path: PathBuf, repos_dir: &Path) -> anyhow::Result<Self> {
+    // Keep this method for potential future use, but mark it as intentionally unused
+    #[allow(dead_code)]
+    pub async fn load(_name: String, path: PathBuf, repos_dir: &Path) -> Result<Self> {
         let prompt_path = path.join("prompt.txt");
         let user_prompt = smol::unblock(|| std::fs::read_to_string(prompt_path)).await?;
         let setup_path = path.join("setup.json");
         let setup_contents = smol::unblock(|| std::fs::read_to_string(setup_path)).await?;
         let eval_setup = serde_json_lenient::from_str_lenient::<EvalSetup>(&setup_contents)?;
+
+        // Move this internal function inside the load method since it's only used here
+        fn repo_dir_name(url: &str) -> String {
+            url.trim_start_matches("https://")
+                .replace(|c: char| !c.is_alphanumeric(), "_")
+        }
+
         let repo_path = repos_dir.join(repo_dir_name(&eval_setup.url));
+
         Ok(Eval {
-            name,
-            path,
             repo_path,
             eval_setup,
             user_prompt,
@@ -62,9 +83,9 @@ impl Eval {
         app_state: Arc<HeadlessAppState>,
         model: Arc<dyn LanguageModel>,
         cx: &mut App,
-    ) -> Task<anyhow::Result<EvalOutput>> {
+    ) -> Task<Result<EvalOutput>> {
         cx.spawn(async move |cx| {
-            checkout_repo(&self.eval_setup, &self.repo_path).await?;
+            run_git(&self.repo_path, &["checkout", &self.eval_setup.base_sha]).await?;
 
             let (assistant, done_rx) =
                 cx.update(|cx| HeadlessAssistant::new(app_state.clone(), cx))??;
@@ -104,9 +125,43 @@ impl Eval {
 
             done_rx.recv().await??;
 
+            // Add this section to check untracked files
+            println!("Checking for untracked files:");
+            let untracked = run_git(
+                &self.repo_path,
+                &["ls-files", "--others", "--exclude-standard"],
+            )
+            .await?;
+            if untracked.is_empty() {
+                println!("No untracked files found");
+            } else {
+                // Add all files to git so they appear in the diff
+                println!("Adding untracked files to git");
+                run_git(&self.repo_path, &["add", "."]).await?;
+            }
+
+            // get git status
+            let _status = run_git(&self.repo_path, &["status", "--short"]).await?;
+
             let elapsed_time = start_time.elapsed()?;
 
-            let diff = query_git(&self.repo_path, vec!["diff"]).await?;
+            // Get diff of staged changes (the files we just added)
+            let staged_diff = run_git(&self.repo_path, &["diff", "--staged"]).await?;
+
+            // Get diff of unstaged changes
+            let unstaged_diff = run_git(&self.repo_path, &["diff"]).await?;
+
+            // Combine both diffs
+            let diff = if unstaged_diff.is_empty() {
+                staged_diff
+            } else if staged_diff.is_empty() {
+                unstaged_diff
+            } else {
+                format!(
+                    "# Staged changes\n{}\n\n# Unstaged changes\n{}",
+                    staged_diff, unstaged_diff
+                )
+            };
 
             assistant.update(cx, |assistant, cx| {
                 let thread = assistant.thread.read(cx);
@@ -132,12 +187,9 @@ impl Eval {
 }
 
 impl EvalOutput {
-    // Method to save the output to a directory
-    pub fn save_to_directory(
-        &self,
-        output_dir: &Path,
-        eval_output_value: String,
-    ) -> anyhow::Result<()> {
+    // Keep this method for potential future use, but mark it as intentionally unused
+    #[allow(dead_code)]
+    pub fn save_to_directory(&self, output_dir: &Path, eval_output_value: String) -> Result<()> {
         // Create the output directory if it doesn't exist
         fs::create_dir_all(&output_dir)?;
 
@@ -192,76 +244,305 @@ impl EvalOutput {
     }
 }
 
-fn repo_dir_name(url: &str) -> String {
-    url.trim_start_matches("https://")
-        .replace(|c: char| !c.is_alphanumeric(), "_")
+pub async fn read_instructions(exercise_path: &Path) -> Result<String> {
+    let instructions_path = exercise_path.join(".docs").join("instructions.md");
+    println!("Reading instructions from: {}", instructions_path.display());
+    let instructions = smol::unblock(move || std::fs::read_to_string(&instructions_path)).await?;
+    Ok(instructions)
 }
 
-async fn checkout_repo(eval_setup: &EvalSetup, repo_path: &Path) -> anyhow::Result<()> {
-    if !repo_path.exists() {
-        smol::unblock({
-            let repo_path = repo_path.to_path_buf();
-            || std::fs::create_dir_all(repo_path)
-        })
-        .await?;
-        run_git(repo_path, vec!["init"]).await?;
-        run_git(repo_path, vec!["remote", "add", "origin", &eval_setup.url]).await?;
-    } else {
-        let actual_origin = query_git(repo_path, vec!["remote", "get-url", "origin"]).await?;
-        if actual_origin != eval_setup.url {
-            return Err(anyhow!(
-                "remote origin {} does not match expected origin {}",
-                actual_origin,
-                eval_setup.url
-            ));
-        }
+pub async fn read_example_solution(exercise_path: &Path, language: &str) -> Result<String> {
+    // Map the language to the file extension
+    let language_extension = match language {
+        "python" => "py",
+        "go" => "go",
+        "rust" => "rs",
+        "typescript" => "ts",
+        "javascript" => "js",
+        "ruby" => "rb",
+        "php" => "php",
+        "bash" => "sh",
+        "multi" => "diff",
+        "internal" => "diff",
+        _ => return Err(anyhow!("Unsupported language: {}", language)),
+    };
+    let example_path = exercise_path
+        .join(".meta")
+        .join(format!("example.{}", language_extension));
+    println!("Reading example solution from: {}", example_path.display());
+    let example = smol::unblock(move || std::fs::read_to_string(&example_path)).await?;
+    Ok(example)
+}
 
-        // TODO: consider including "-x" to remove ignored files. The downside of this is that it will
-        // also remove build artifacts, and so prevent incremental reuse there.
-        run_git(repo_path, vec!["clean", "--force", "-d"]).await?;
-        run_git(repo_path, vec!["reset", "--hard", "HEAD"]).await?;
+pub async fn save_eval_results(exercise_path: &Path, results: Vec<EvalResult>) -> Result<()> {
+    let eval_dir = exercise_path.join("evaluation");
+    fs::create_dir_all(&eval_dir)?;
+
+    let eval_file = eval_dir.join("evals.json");
+
+    println!("Saving evaluation results to: {}", eval_file.display());
+    println!(
+        "Results to save: {} evaluations for exercise path: {}",
+        results.len(),
+        exercise_path.display()
+    );
+
+    // Check file existence before reading/writing
+    if eval_file.exists() {
+        println!("Existing evals.json file found, will update it");
+    } else {
+        println!("No existing evals.json file found, will create new one");
     }
 
-    run_git(
-        repo_path,
-        vec!["fetch", "--depth", "1", "origin", &eval_setup.base_sha],
-    )
-    .await?;
-    run_git(repo_path, vec!["checkout", &eval_setup.base_sha]).await?;
+    // Structure to organize evaluations by test name and timestamp
+    let mut eval_data: serde_json::Value = if eval_file.exists() {
+        let content = fs::read_to_string(&eval_file)?;
+        serde_json::from_str(&content).unwrap_or_else(|_| serde_json::json!({}))
+    } else {
+        serde_json::json!({})
+    };
+
+    // Get current timestamp for this batch of results
+    let timestamp = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)?
+        .as_millis()
+        .to_string();
+
+    // Group the new results by test name (exercise name)
+    for result in results {
+        let exercise_name = &result.exercise_name;
+        let template_name = &result.template_name;
+
+        println!(
+            "Adding result: exercise={}, template={}",
+            exercise_name, template_name
+        );
+
+        // Ensure the exercise entry exists
+        if eval_data.get(exercise_name).is_none() {
+            eval_data[exercise_name] = serde_json::json!({});
+        }
+
+        // Ensure the timestamp entry exists as an object
+        if eval_data[exercise_name].get(&timestamp).is_none() {
+            eval_data[exercise_name][&timestamp] = serde_json::json!({});
+        }
+
+        // Add this result under the timestamp with template name as key
+        eval_data[exercise_name][&timestamp][template_name] = serde_json::to_value(&result)?;
+    }
+
+    // Write back to file with pretty formatting
+    let json_content = serde_json::to_string_pretty(&eval_data)?;
+    match fs::write(&eval_file, json_content) {
+        Ok(_) => println!("✓ Successfully saved results to {}", eval_file.display()),
+        Err(e) => println!("✗ Failed to write results file: {}", e),
+    }
 
     Ok(())
 }
 
-async fn run_git(repo_path: &Path, args: Vec<&str>) -> anyhow::Result<()> {
-    let exit_status = new_smol_command("git")
-        .current_dir(repo_path)
-        .args(args.clone())
-        .status()
-        .await?;
-    if exit_status.success() {
-        Ok(())
-    } else {
-        Err(anyhow!(
-            "`git {}` failed with {}",
-            args.join(" "),
-            exit_status,
-        ))
-    }
-}
+pub async fn run_exercise_eval(
+    exercise_path: PathBuf,
+    template: Template,
+    model: Arc<dyn LanguageModel>,
+    judge_model: Arc<dyn LanguageModel>,
+    app_state: Arc<HeadlessAppState>,
+    base_sha: String,
+    _framework_path: PathBuf,
+    cx: gpui::AsyncApp,
+) -> Result<EvalResult> {
+    let exercise_name = get_exercise_name(&exercise_path);
+    let language = get_exercise_language(&exercise_path)?;
+    let mut instructions = read_instructions(&exercise_path).await?;
+    instructions.push_str(&format!(
+        "\n\nWhen writing the code for this prompt, use {} to achieve the goal.",
+        language
+    ));
+    let example_solution = read_example_solution(&exercise_path, &language).await?;
 
-async fn query_git(repo_path: &Path, args: Vec<&str>) -> anyhow::Result<String> {
-    let output = new_smol_command("git")
-        .current_dir(repo_path)
-        .args(args.clone())
-        .output()
+    println!(
+        "Running evaluation for exercise: {} with template: {}",
+        exercise_name, template.name
+    );
+
+    // Create temporary directory with exercise files
+    let temp_dir = setup_temp_repo(&exercise_path, &base_sha).await?;
+    let temp_path = temp_dir.path().to_path_buf();
+
+    if template.name == "ProjectCreation" {
+        for entry in fs::read_dir(&temp_path)? {
+            let entry = entry?;
+            let path = entry.path();
+
+            // Skip directories that start with dot (like .docs, .meta, .git)
+            if path.is_dir()
+                && path
+                    .file_name()
+                    .and_then(|name| name.to_str())
+                    .map(|name| name.starts_with("."))
+                    .unwrap_or(false)
+            {
+                continue;
+            }
+
+            // Delete regular files
+            if path.is_file() {
+                println!("  Deleting file: {}", path.display());
+                fs::remove_file(path)?;
+            }
+        }
+
+        // Commit the deletion so it shows up in the diff
+        run_git(&temp_path, &["add", "."]).await?;
+        run_git(
+            &temp_path,
+            &["commit", "-m", "Remove root files for clean slate"],
+        )
         .await?;
-    if output.status.success() {
-        Ok(String::from_utf8(output.stdout)?.trim().to_string())
-    } else {
-        Err(anyhow!(
-            "`git {}` failed with {}",
-            args.join(" "),
-            output.status
-        ))
     }
+
+    let local_commit_sha = run_git(&temp_path, &["rev-parse", "HEAD"]).await?;
+
+    // Prepare prompt based on template
+    let prompt = match template.name {
+        "ProjectCreation" => format!(
+            "I need to create a new implementation for this exercise. Please create all the necessary files in the best location.\n\n{}",
+            instructions
+        ),
+        "CodeModification" => format!(
+            "I need help updating my code to meet these requirements. Please modify the appropriate files:\n\n{}",
+            instructions
+        ),
+        "ConversationalGuidance" => format!(
+            "I'm trying to solve this coding exercise but I'm not sure where to start. Can you help me understand the requirements and guide me through the solution process without writing code for me?\n\n{}",
+            instructions
+        ),
+        _ => instructions.clone(),
+    };
+
+    let start_time = SystemTime::now();
+
+    // Create a basic eval struct to work with the existing system
+    let eval = Eval {
+        repo_path: temp_path.clone(),
+        eval_setup: EvalSetup {
+            url: format!("file://{}", temp_path.display()),
+            base_sha: local_commit_sha, // Use the local commit SHA instead of the framework base SHA
+        },
+        user_prompt: prompt,
+    };
+
+    // Run the evaluation
+    let eval_output = cx
+        .update(|cx| eval.run(app_state.clone(), model.clone(), cx))?
+        .await?;
+
+    // Get diff from git
+    let diff = eval_output.diff.clone();
+
+    // For project creation template, we need to compare with reference implementation
+    let judge_output = if template.name == "ProjectCreation" {
+        let project_judge_prompt = template
+            .content
+            .replace(
+                "<!-- ```requirements go here``` -->",
+                &format!("```\n{}\n```", instructions),
+            )
+            .replace(
+                "<!-- ```reference code goes here``` -->",
+                &format!("```{}\n{}\n```", language, example_solution),
+            )
+            .replace(
+                "<!-- ```git diff goes here``` -->",
+                &format!("```\n{}\n```", diff),
+            );
+
+        // Use the run_with_prompt method which we'll add to judge.rs
+        let judge = crate::judge::Judge {
+            original_diff: None,
+            original_message: Some(project_judge_prompt),
+            model: judge_model.clone(),
+        };
+
+        cx.update(|cx| judge.run_with_prompt(cx))?.await?
+    } else if template.name == "CodeModification" {
+        // For CodeModification, we'll compare the example solution with the LLM-generated solution
+        let code_judge_prompt = template
+            .content
+            .replace(
+                "<!-- ```reference code goes here``` -->",
+                &format!("```{}\n{}\n```", language, example_solution),
+            )
+            .replace(
+                "<!-- ```git diff goes here``` -->",
+                &format!("```\n{}\n```", diff),
+            );
+
+        // Use the run_with_prompt method
+        let judge = crate::judge::Judge {
+            original_diff: None,
+            original_message: Some(code_judge_prompt),
+            model: judge_model.clone(),
+        };
+
+        cx.update(|cx| judge.run_with_prompt(cx))?.await?
+    } else {
+        // Conversational template
+        let conv_judge_prompt = template
+            .content
+            .replace(
+                "<!-- ```query goes here``` -->",
+                &format!("```\n{}\n```", instructions),
+            )
+            .replace(
+                "<!-- ```transcript goes here``` -->",
+                &format!("```\n{}\n```", eval_output.last_message),
+            )
+            .replace(
+                "<!-- ```git diff goes here``` -->",
+                &format!("```\n{}\n```", diff),
+            );
+
+        // Use the run_with_prompt method for consistency
+        let judge = crate::judge::Judge {
+            original_diff: None,
+            original_message: Some(conv_judge_prompt),
+            model: judge_model.clone(),
+        };
+
+        cx.update(|cx| judge.run_with_prompt(cx))?.await?
+    };
+
+    let elapsed_time = start_time.elapsed()?;
+
+    // Calculate total tokens as the sum of input and output tokens
+    let input_tokens = eval_output.token_usage.input_tokens;
+    let output_tokens = eval_output.token_usage.output_tokens;
+    let tool_use_counts = eval_output.tool_use_counts.values().sum::<u32>();
+    let total_tokens = input_tokens + output_tokens;
+
+    // Get judge model name
+    let judge_model_name = judge_model.id().0.to_string();
+
+    // Save results to evaluation directory
+    let result = EvalResult {
+        exercise_name: exercise_name.clone(),
+        template_name: template.name.to_string(),
+        score: judge_output.trim().to_string(),
+        diff,
+        assistant_response: eval_output.last_message.clone(),
+        elapsed_time_ms: elapsed_time.as_millis(),
+        timestamp: SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)?
+            .as_millis(),
+        // Convert u32 token counts to usize
+        input_tokens: input_tokens.try_into().unwrap(),
+        output_tokens: output_tokens.try_into().unwrap(),
+        total_tokens: total_tokens.try_into().unwrap(),
+        tool_use_counts: tool_use_counts.try_into().unwrap(),
+        judge_model_name, // Add judge model name to result
+    };
+
+    Ok(result)
 }

crates/assistant_eval/src/get_exercise.rs

@@ -0,0 +1,149 @@
+use anyhow::{Result, anyhow};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+pub fn get_exercise_name(exercise_path: &Path) -> String {
+    exercise_path
+        .file_name()
+        .unwrap_or_default()
+        .to_string_lossy()
+        .to_string()
+}
+
+pub fn get_exercise_language(exercise_path: &Path) -> Result<String> {
+    // Extract the language from path (data/python/exercises/... => python)
+    let parts: Vec<_> = exercise_path.components().collect();
+
+    for (i, part) in parts.iter().enumerate() {
+        if i > 0 && part.as_os_str() == "eval_code" {
+            if i + 1 < parts.len() {
+                let language = parts[i + 1].as_os_str().to_string_lossy().to_string();
+                return Ok(language);
+            }
+        }
+    }
+
+    Err(anyhow!(
+        "Could not determine language from path: {:?}",
+        exercise_path
+    ))
+}
+
+pub fn find_exercises(
+    framework_path: &Path,
+    languages: &[&str],
+    max_per_language: Option<usize>,
+) -> Result<Vec<PathBuf>> {
+    let mut all_exercises = Vec::new();
+
+    println!("Searching for exercises in languages: {:?}", languages);
+
+    for language in languages {
+        let language_dir = framework_path
+            .join("eval_code")
+            .join(language)
+            .join("exercises")
+            .join("practice");
+
+        println!("Checking language directory: {:?}", language_dir);
+        if !language_dir.exists() {
+            println!("Warning: Language directory not found: {:?}", language_dir);
+            continue;
+        }
+
+        let mut exercises = Vec::new();
+        match fs::read_dir(&language_dir) {
+            Ok(entries) => {
+                for entry_result in entries {
+                    match entry_result {
+                        Ok(entry) => {
+                            let path = entry.path();
+
+                            if path.is_dir() {
+                                // Special handling for "internal" directory
+                                if *language == "internal" {
+                                    // Check for repo_info.json to validate it's an internal exercise
+                                    let repo_info_path = path.join(".meta").join("repo_info.json");
+                                    let instructions_path =
+                                        path.join(".docs").join("instructions.md");
+
+                                    if repo_info_path.exists() && instructions_path.exists() {
+                                        exercises.push(path);
+                                    }
+                                } else {
+                                    // Map the language to the file extension - original code
+                                    let language_extension = match *language {
+                                        "python" => "py",
+                                        "go" => "go",
+                                        "rust" => "rs",
+                                        "typescript" => "ts",
+                                        "javascript" => "js",
+                                        "ruby" => "rb",
+                                        "php" => "php",
+                                        "bash" => "sh",
+                                        "multi" => "diff",
+                                        _ => continue, // Skip unsupported languages
+                                    };
+
+                                    // Check if this is a valid exercise with instructions and example
+                                    let instructions_path =
+                                        path.join(".docs").join("instructions.md");
+                                    let has_instructions = instructions_path.exists();
+                                    let example_path = path
+                                        .join(".meta")
+                                        .join(format!("example.{}", language_extension));
+                                    let has_example = example_path.exists();
+
+                                    if has_instructions && has_example {
+                                        exercises.push(path);
+                                    }
+                                }
+                            }
+                        }
+                        Err(err) => println!("Error reading directory entry: {}", err),
+                    }
+                }
+            }
+            Err(err) => println!(
+                "Error reading directory {}: {}",
+                language_dir.display(),
+                err
+            ),
+        }
+
+        // Sort exercises by name for consistent selection
+        exercises.sort_by(|a, b| {
+            let a_name = a.file_name().unwrap_or_default().to_string_lossy();
+            let b_name = b.file_name().unwrap_or_default().to_string_lossy();
+            a_name.cmp(&b_name)
+        });
+
+        // Apply the limit if specified
+        if let Some(limit) = max_per_language {
+            if exercises.len() > limit {
+                println!(
+                    "Limiting {} exercises to {} for language {}",
+                    exercises.len(),
+                    limit,
+                    language
+                );
+                exercises.truncate(limit);
+            }
+        }
+
+        println!(
+            "Found {} exercises for language {}: {:?}",
+            exercises.len(),
+            language,
+            exercises
+                .iter()
+                .map(|p| p.file_name().unwrap_or_default().to_string_lossy())
+                .collect::<Vec<_>>()
+        );
+        all_exercises.extend(exercises);
+    }
+
+    Ok(all_exercises)
+}

crates/assistant_eval/src/git_commands.rs

@@ -0,0 +1,125 @@
+use anyhow::{Result, anyhow};
+use serde::Deserialize;
+use std::{fs, path::Path};
+use tempfile::TempDir;
+use util::command::new_smol_command;
+use walkdir::WalkDir;
+
+#[derive(Debug, Deserialize)]
+pub struct SetupConfig {
+    #[serde(rename = "base.sha")]
+    pub base_sha: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct RepoInfo {
+    pub remote_url: String,
+    pub head_sha: String,
+}
+
+pub async fn run_git(repo_path: &Path, args: &[&str]) -> Result<String> {
+    let output = new_smol_command("git")
+        .current_dir(repo_path)
+        .args(args)
+        .output()
+        .await?;
+
+    if output.status.success() {
+        Ok(String::from_utf8(output.stdout)?.trim().to_string())
+    } else {
+        Err(anyhow!(
+            "Git command failed: {} with status: {}",
+            args.join(" "),
+            output.status
+        ))
+    }
+}
+
+pub async fn read_base_sha(framework_path: &Path) -> Result<String> {
+    let setup_path = framework_path.join("setup.json");
+    let setup_content = smol::unblock(move || std::fs::read_to_string(&setup_path)).await?;
+    let setup_config: SetupConfig = serde_json_lenient::from_str_lenient(&setup_content)?;
+    Ok(setup_config.base_sha)
+}
+
+pub async fn read_repo_info(exercise_path: &Path) -> Result<RepoInfo> {
+    let repo_info_path = exercise_path.join(".meta").join("repo_info.json");
+    println!("Reading repo info from: {}", repo_info_path.display());
+    let repo_info_content = smol::unblock(move || std::fs::read_to_string(&repo_info_path)).await?;
+    let repo_info: RepoInfo = serde_json_lenient::from_str_lenient(&repo_info_content)?;
+
+    // Remove any quotes from the strings
+    let remote_url = repo_info.remote_url.trim_matches('"').to_string();
+    let head_sha = repo_info.head_sha.trim_matches('"').to_string();
+
+    Ok(RepoInfo {
+        remote_url,
+        head_sha,
+    })
+}
+
+pub async fn setup_temp_repo(exercise_path: &Path, _base_sha: &str) -> Result<TempDir> {
+    let temp_dir = TempDir::new()?;
+
+    // Check if this is an internal exercise by looking for repo_info.json
+    let repo_info_path = exercise_path.join(".meta").join("repo_info.json");
+    if repo_info_path.exists() {
+        // This is an internal exercise, handle it differently
+        let repo_info = read_repo_info(exercise_path).await?;
+
+        // Clone the repository to the temp directory
+        let url = repo_info.remote_url;
+        let clone_path = temp_dir.path();
+        println!(
+            "Cloning repository from {} to {}",
+            url,
+            clone_path.display()
+        );
+        run_git(
+            &std::env::current_dir()?,
+            &["clone", &url, &clone_path.to_string_lossy()],
+        )
+        .await?;
+
+        // Checkout the specified commit
+        println!("Checking out commit: {}", repo_info.head_sha);
+        run_git(temp_dir.path(), &["checkout", &repo_info.head_sha]).await?;
+
+        println!("Successfully set up internal repository");
+    } else {
+        // Original code for regular exercises
+        // Copy the exercise files to the temp directory, excluding .docs and .meta
+        for entry in WalkDir::new(exercise_path).min_depth(0).max_depth(10) {
+            let entry = entry?;
+            let source_path = entry.path();
+
+            // Skip .docs and .meta directories completely
+            if source_path.starts_with(exercise_path.join(".docs"))
+                || source_path.starts_with(exercise_path.join(".meta"))
+            {
+                continue;
+            }
+
+            if source_path.is_file() {
+                let relative_path = source_path.strip_prefix(exercise_path)?;
+                let dest_path = temp_dir.path().join(relative_path);
+
+                // Make sure parent directories exist
+                if let Some(parent) = dest_path.parent() {
+                    fs::create_dir_all(parent)?;
+                }
+
+                fs::copy(source_path, dest_path)?;
+            }
+        }
+
+        // Initialize git repo in the temp directory
+        run_git(temp_dir.path(), &["init"]).await?;
+        run_git(temp_dir.path(), &["add", "."]).await?;
+        run_git(temp_dir.path(), &["commit", "-m", "Initial commit"]).await?;
+
+        println!("Created temp repo without .docs and .meta directories");
+    }
+
+    Ok(temp_dir)
+}

crates/assistant_eval/src/headless_assistant.rs

@@ -102,6 +102,40 @@ impl HeadlessAssistant {
                     thread.use_pending_tools(cx);
                 });
             }
+            ThreadEvent::ToolConfirmationNeeded => {
+                // Automatically approve all tools that need confirmation in headless mode
+                println!("Tool confirmation needed - automatically approving in headless mode");
+
+                // Get the tools needing confirmation
+                let tools_needing_confirmation: Vec<_> = thread
+                    .read(cx)
+                    .tools_needing_confirmation()
+                    .cloned()
+                    .collect();
+
+                // Run each tool that needs confirmation
+                for tool_use in tools_needing_confirmation {
+                    if let Some(tool) = thread.read(cx).tools().tool(&tool_use.name, cx) {
+                        thread.update(cx, |thread, cx| {
+                            println!("Auto-approving tool: {}", tool_use.name);
+
+                            // Create a request to send to the tool
+                            let request = thread.to_completion_request(RequestKind::Chat, cx);
+                            let messages = Arc::new(request.messages);
+
+                            // Run the tool
+                            thread.run_tool(
+                                tool_use.id.clone(),
+                                tool_use.ui_text.clone(),
+                                tool_use.input.clone(),
+                                &messages,
+                                tool,
+                                cx,
+                            );
+                        });
+                    }
+                }
+            }
             ThreadEvent::ToolFinished {
                 tool_use_id,
                 pending_tool_use,
@@ -122,11 +156,15 @@ impl HeadlessAssistant {
                 }
                 if thread.read(cx).all_tools_finished() {
                     let model_registry = LanguageModelRegistry::read_global(cx);
-                    if let Some(model) = model_registry.active_model() {
+                    if let Some(model) = model_registry.default_model() {
                         thread.update(cx, |thread, cx| {
-                            thread.attach_tool_results(vec![], cx);
-                            thread.send_to_model(model, RequestKind::Chat, cx);
+                            thread.attach_tool_results(cx);
+                            thread.send_to_model(model.model, RequestKind::Chat, cx);
                         });
+                    } else {
+                        println!(
+                            "Warning: No active language model available to continue conversation"
+                        );
                     }
                 }
             }

crates/assistant_eval/src/judge.rs

@@ -1,58 +1,28 @@
-use crate::eval::EvalOutput;
 use crate::headless_assistant::send_language_model_request;
 use anyhow::anyhow;
 use gpui::{App, Task};
 use language_model::{
     LanguageModel, LanguageModelRequest, LanguageModelRequestMessage, MessageContent, Role,
 };
-use std::{path::Path, sync::Arc};
+use std::sync::Arc;
 
 pub struct Judge {
-    pub original_diff: Option<String>,
     #[allow(dead_code)]
+    pub original_diff: Option<String>,
     pub original_message: Option<String>,
     pub model: Arc<dyn LanguageModel>,
 }
 
 impl Judge {
-    pub async fn load(eval_path: &Path, model: Arc<dyn LanguageModel>) -> anyhow::Result<Judge> {
-        let original_diff_path = eval_path.join("original.diff");
-        let original_diff = smol::unblock(move || {
-            if std::fs::exists(&original_diff_path)? {
-                anyhow::Ok(Some(std::fs::read_to_string(&original_diff_path)?))
-            } else {
-                anyhow::Ok(None)
-            }
-        });
-
-        let original_message_path = eval_path.join("original_message.txt");
-        let original_message = smol::unblock(move || {
-            if std::fs::exists(&original_message_path)? {
-                anyhow::Ok(Some(std::fs::read_to_string(&original_message_path)?))
-            } else {
-                anyhow::Ok(None)
-            }
-        });
-
-        Ok(Self {
-            original_diff: original_diff.await?,
-            original_message: original_message.await?,
-            model,
-        })
-    }
-
-    pub fn run(&self, eval_output: &EvalOutput, cx: &mut App) -> Task<anyhow::Result<String>> {
-        let Some(original_diff) = self.original_diff.as_ref() else {
-            return Task::ready(Err(anyhow!("No original.diff found")));
+    pub fn run_with_prompt(&self, cx: &mut App) -> Task<anyhow::Result<String>> {
+        let Some(prompt) = self.original_message.as_ref() else {
+            return Task::ready(Err(anyhow!("No prompt provided in original_message")));
         };
 
-        // TODO: check for empty diff?
-        let prompt = diff_comparison_prompt(&original_diff, &eval_output.diff);
-
         let request = LanguageModelRequest {
             messages: vec![LanguageModelRequestMessage {
                 role: Role::User,
-                content: vec![MessageContent::Text(prompt)],
+                content: vec![MessageContent::Text(prompt.clone())],
                 cache: false,
             }],
             temperature: Some(0.0),
@@ -61,61 +31,7 @@ impl Judge {
         };
 
         let model = self.model.clone();
+        let request = request.clone();
         cx.spawn(async move |cx| send_language_model_request(model, request, cx).await)
     }
 }
-
-pub fn diff_comparison_prompt(original_diff: &str, new_diff: &str) -> String {
-    format!(
-        r#"# Git Diff Similarity Evaluation Template
-
-## Instructions
-
-Compare the two diffs and score them between 0.0 and 1.0 based on their functional similarity.
-- 1.0 = Perfect functional match (achieves identical results)
-- 0.0 = No functional similarity whatsoever
-
-## Evaluation Criteria
-
-Please consider the following aspects in order of importance:
-
-1. **Functional Equivalence (60%)**
-   - Do both diffs achieve the same end result?
-   - Are the changes functionally equivalent despite possibly using different approaches?
-   - Do the modifications address the same issues or implement the same features?
-
-2. **Logical Structure (20%)**
-   - Are the logical flows similar?
-   - Do the modifications affect the same code paths?
-   - Are control structures (if/else, loops, etc.) modified in similar ways?
-
-3. **Code Content (15%)**
-   - Are similar lines added/removed?
-   - Are the same variables, functions, or methods being modified?
-   - Are the same APIs or libraries being used?
-
-4. **File Layout (5%)**
-   - Are the same files being modified?
-   - Are changes occurring in similar locations within files?
-
-## Input
-
-Original Diff:
-```git
-{}
-```
-
-New Diff:
-```git
-{}
-```
-
-## Output Format
-
-THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
-
-Example output:
-0.85"#,
-        original_diff, new_diff
-    )
-}

crates/assistant_eval/src/main.rs

@@ -1,18 +1,21 @@
 mod eval;
+mod get_exercise;
+mod git_commands;
 mod headless_assistant;
 mod judge;
+mod templates_eval;
 
 use clap::Parser;
-use eval::{Eval, EvalOutput};
-use futures::future;
-use gpui::{Application, AsyncApp};
-use headless_assistant::{HeadlessAppState, authenticate_model_provider, find_model};
-use itertools::Itertools;
-use judge::Judge;
-use language_model::{LanguageModel, LanguageModelRegistry};
-use regex::Regex;
+use eval::{run_exercise_eval, save_eval_results};
+use futures::stream::{self, StreamExt};
+use get_exercise::{find_exercises, get_exercise_language, get_exercise_name};
+use git_commands::read_base_sha;
+use gpui::Application;
+use headless_assistant::{authenticate_model_provider, find_model};
+use language_model::LanguageModelRegistry;
 use reqwest_client::ReqwestClient;
-use std::{cmp, path::PathBuf, sync::Arc};
+use std::{path::PathBuf, sync::Arc};
+use templates_eval::all_templates;
 
 #[derive(Parser, Debug)]
 #[command(
@@ -21,204 +24,231 @@ use std::{cmp, path::PathBuf, sync::Arc};
     before_help = "Tool eval runner"
 )]
 struct Args {
-    /// Regexes to match the names of evals to run.
-    eval_name_regexes: Vec<String>,
-    /// Runs all evals in `evaluation_data`, causes the regex to be ignored.
+    /// Match the names of evals to run.
+    #[arg(long)]
+    exercise_names: Vec<String>,
+    /// Runs all exercises, causes the exercise_names to be ignored.
     #[arg(long)]
     all: bool,
+    /// Supported language types to evaluate (default: internal).
+    /// Internal is data generated from the agent panel
+    #[arg(long, default_value = "internal")]
+    languages: String,
     /// Name of the model (default: "claude-3-7-sonnet-latest")
     #[arg(long, default_value = "claude-3-7-sonnet-latest")]
     model_name: String,
-    /// Name of the editor model (default: value of `--model_name`).
-    #[arg(long)]
-    editor_model_name: Option<String>,
     /// Name of the judge model (default: value of `--model_name`).
     #[arg(long)]
     judge_model_name: Option<String>,
-    /// Number of evaluations to run concurrently (default: 10)
-    #[arg(short, long, default_value = "10")]
+    /// Number of evaluations to run concurrently (default: 3)
+    #[arg(short, long, default_value = "3")]
     concurrency: usize,
+    /// Maximum number of exercises to evaluate per language
+    #[arg(long)]
+    max_exercises_per_language: Option<usize>,
 }
 
+// First, let's define the order in which templates should be executed
+const TEMPLATE_EXECUTION_ORDER: [&str; 3] = [
+    "ProjectCreation",
+    "CodeModification",
+    "ConversationalGuidance",
+];
+
 fn main() {
     env_logger::init();
     let args = Args::parse();
     let http_client = Arc::new(ReqwestClient::new());
     let app = Application::headless().with_http_client(http_client.clone());
 
-    let crate_dir = PathBuf::from("../zed-agent-bench");
-    let evaluation_data_dir = crate_dir.join("evaluation_data").canonicalize().unwrap();
+    // Path to the zed-ace-framework repo
+    let framework_path = PathBuf::from("../zed-ace-framework")
+        .canonicalize()
+        .unwrap();
 
-    let repos_dir = crate_dir.join("repos");
-    if !repos_dir.exists() {
-        std::fs::create_dir_all(&repos_dir).unwrap();
-    }
-    let repos_dir = repos_dir.canonicalize().unwrap();
+    // Fix the 'languages' lifetime issue by creating owned Strings instead of slices
+    let languages: Vec<String> = args.languages.split(',').map(|s| s.to_string()).collect();
 
-    let all_evals = std::fs::read_dir(&evaluation_data_dir)
-        .unwrap()
-        .map(|path| path.unwrap().file_name().to_string_lossy().to_string())
-        .collect::<Vec<_>>();
-
-    let evals_to_run = if args.all {
-        all_evals
-    } else {
-        args.eval_name_regexes
-            .into_iter()
-            .map(|regex_string| Regex::new(&regex_string).unwrap())
-            .flat_map(|regex| {
-                all_evals
-                    .iter()
-                    .filter(|eval_name| regex.is_match(eval_name))
-                    .cloned()
-                    .collect::<Vec<_>>()
-            })
-            .collect::<Vec<_>>()
-    };
-
-    if evals_to_run.is_empty() {
-        panic!("Names of evals to run must be provided or `--all` specified");
-    }
-
-    println!("Will run the following evals: {evals_to_run:?}");
-    println!("Running up to {} evals concurrently", args.concurrency);
-
-    let editor_model_name = if let Some(model_name) = args.editor_model_name {
-        model_name
-    } else {
-        args.model_name.clone()
-    };
-
-    let judge_model_name = if let Some(model_name) = args.judge_model_name {
-        model_name
-    } else {
-        args.model_name.clone()
-    };
+    println!("Using zed-ace-framework at: {:?}", framework_path);
+    println!("Evaluating languages: {:?}", languages);
 
     app.run(move |cx| {
         let app_state = headless_assistant::init(cx);
 
         let model = find_model(&args.model_name, cx).unwrap();
-        let editor_model = find_model(&editor_model_name, cx).unwrap();
-        let judge_model = find_model(&judge_model_name, cx).unwrap();
+        let judge_model = if let Some(model_name) = &args.judge_model_name {
+            find_model(model_name, cx).unwrap()
+        } else {
+            model.clone()
+        };
 
         LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-            registry.set_active_model(Some(model.clone()), cx);
-            registry.set_editor_model(Some(editor_model.clone()), cx);
+            registry.set_default_model(Some(model.clone()), cx);
         });
 
         let model_provider_id = model.provider_id();
-        let editor_model_provider_id = editor_model.provider_id();
         let judge_model_provider_id = judge_model.provider_id();
 
+        let framework_path_clone = framework_path.clone();
+        let languages_clone = languages.clone();
+        let exercise_names = args.exercise_names.clone();
+        let all_flag = args.all;
+
         cx.spawn(async move |cx| {
             // Authenticate all model providers first
             cx.update(|cx| authenticate_model_provider(model_provider_id.clone(), cx))
                 .unwrap()
                 .await
                 .unwrap();
-            cx.update(|cx| authenticate_model_provider(editor_model_provider_id.clone(), cx))
-                .unwrap()
-                .await
-                .unwrap();
             cx.update(|cx| authenticate_model_provider(judge_model_provider_id.clone(), cx))
                 .unwrap()
                 .await
                 .unwrap();
 
-            let eval_load_futures = evals_to_run
+            // Read base SHA from setup.json
+            let base_sha = read_base_sha(&framework_path_clone).await.unwrap();
+
+            // Find all exercises for the specified languages
+            let all_exercises = find_exercises(
+                &framework_path_clone,
+                &languages_clone
+                    .iter()
+                    .map(|s| s.as_str())
+                    .collect::<Vec<_>>(),
+                args.max_exercises_per_language,
+            )
+            .unwrap();
+            println!("Found {} exercises total", all_exercises.len());
+
+            // Filter exercises if specific ones were requested
+            let exercises_to_run = if !exercise_names.is_empty() {
+                // If exercise names are specified, filter by them regardless of --all flag
+                all_exercises
+                    .into_iter()
+                    .filter(|path| {
+                        let name = get_exercise_name(path);
+                        exercise_names.iter().any(|filter| name.contains(filter))
+                    })
+                    .collect()
+            } else if all_flag {
+                // Only use all_flag if no exercise names are specified
+                all_exercises
+            } else {
+                // Default behavior (no filters)
+                all_exercises
+            };
+
+            println!("Will run {} exercises", exercises_to_run.len());
+
+            // Get all templates and sort them according to the execution order
+            let mut templates = all_templates();
+            templates.sort_by_key(|template| {
+                TEMPLATE_EXECUTION_ORDER
+                    .iter()
+                    .position(|&name| name == template.name)
+                    .unwrap_or(usize::MAX)
+            });
+
+            // Create exercise eval tasks - each exercise is a single task that will run templates sequentially
+            let exercise_tasks: Vec<_> = exercises_to_run
                 .into_iter()
-                .map(|eval_name| {
-                    let eval_path = evaluation_data_dir.join(&eval_name);
-                    let load_future = Eval::load(eval_name.clone(), eval_path, &repos_dir);
+                .map(|exercise_path| {
+                    let exercise_name = get_exercise_name(&exercise_path);
+                    let templates_clone = templates.clone();
+                    let model_clone = model.clone();
+                    let judge_model_clone = judge_model.clone();
+                    let app_state_clone = app_state.clone();
+                    let base_sha_clone = base_sha.clone();
+                    let framework_path_clone = framework_path_clone.clone();
+                    let cx_clone = cx.clone();
+
                     async move {
-                        match load_future.await {
-                            Ok(eval) => Some(eval),
+                        println!("Processing exercise: {}", exercise_name);
+                        let mut exercise_results = Vec::new();
+
+                        // Determine the language for this exercise
+                        let language = match get_exercise_language(&exercise_path) {
+                            Ok(lang) => lang,
                             Err(err) => {
-                                // TODO: Persist errors / surface errors at the end.
-                                println!("Error loading {eval_name}: {err}");
-                                None
+                                println!(
+                                    "Error determining language for {}: {}",
+                                    exercise_name, err
+                                );
+                                return exercise_results;
+                            }
+                        };
+
+                        // Run each template sequentially for this exercise
+                        for template in templates_clone {
+                            // For "multi" or "internal" language, only run the CodeModification template
+                            if (language == "multi" || language == "internal")
+                                && template.name != "CodeModification"
+                            {
+                                println!(
+                                    "Skipping {} template for {} language",
+                                    template.name, language
+                                );
+                                continue;
+                            }
+
+                            match run_exercise_eval(
+                                exercise_path.clone(),
+                                template.clone(),
+                                model_clone.clone(),
+                                judge_model_clone.clone(),
+                                app_state_clone.clone(),
+                                base_sha_clone.clone(),
+                                framework_path_clone.clone(),
+                                cx_clone.clone(),
+                            )
+                            .await
+                            {
+                                Ok(result) => {
+                                    println!(
+                                        "Completed {} with template {} - score: {}",
+                                        exercise_name, template.name, result.score
+                                    );
+                                    exercise_results.push(result);
+                                }
+                                Err(err) => {
+                                    println!(
+                                        "Error running {} with template {}: {}",
+                                        exercise_name, template.name, err
+                                    );
+                                }
                             }
                         }
-                    }
-                })
-                .collect::<Vec<_>>();
 
-            let loaded_evals = future::join_all(eval_load_futures)
-                .await
-                .into_iter()
-                .flatten()
-                .collect::<Vec<_>>();
-
-            // The evals need to be loaded and grouped by URL before concurrently running, since
-            // evals that use the same remote URL will use the same working directory.
-            let mut evals_grouped_by_url: Vec<Vec<Eval>> = loaded_evals
-                .into_iter()
-                .map(|eval| (eval.eval_setup.url.clone(), eval))
-                .into_group_map()
-                .into_values()
-                .collect::<Vec<_>>();
-
-            // Sort groups in descending order, so that bigger groups start first.
-            evals_grouped_by_url.sort_by_key(|evals| cmp::Reverse(evals.len()));
-
-            let result_futures = evals_grouped_by_url
-                .into_iter()
-                .map(|evals| {
-                    let model = model.clone();
-                    let judge_model = judge_model.clone();
-                    let app_state = app_state.clone();
-                    let cx = cx.clone();
-
-                    async move {
-                        let mut results = Vec::new();
-                        for eval in evals {
-                            let name = eval.name.clone();
-                            println!("Starting eval named {}", name);
-                            let result = run_eval(
-                                eval,
-                                model.clone(),
-                                judge_model.clone(),
-                                app_state.clone(),
-                                cx.clone(),
-                            )
-                            .await;
-                            results.push((name, result));
+                        // Save results for this exercise
+                        if !exercise_results.is_empty() {
+                            if let Err(err) =
+                                save_eval_results(&exercise_path, exercise_results.clone()).await
+                            {
+                                println!("Error saving results for {}: {}", exercise_name, err);
+                            } else {
+                                println!("Saved results for {}", exercise_name);
+                            }
                         }
-                        results
+
+                        exercise_results
                     }
                 })
-                .collect::<Vec<_>>();
+                .collect();
 
-            let results = future::join_all(result_futures)
-                .await
-                .into_iter()
-                .flatten()
-                .collect::<Vec<_>>();
+            println!(
+                "Running {} exercises with concurrency: {}",
+                exercise_tasks.len(),
+                args.concurrency
+            );
 
-            // Process results in order of completion
-            for (eval_name, result) in results {
-                match result {
-                    Ok((eval_output, judge_output)) => {
-                        println!("Generated diff for {eval_name}:\n");
-                        println!("{}\n", eval_output.diff);
-                        println!("Last message for {eval_name}:\n");
-                        println!("{}\n", eval_output.last_message);
-                        println!("Elapsed time: {:?}", eval_output.elapsed_time);
-                        println!(
-                            "Assistant response count: {}",
-                            eval_output.assistant_response_count
-                        );
-                        println!("Tool use counts: {:?}", eval_output.tool_use_counts);
-                        println!("Judge output for {eval_name}: {judge_output}");
-                    }
-                    Err(err) => {
-                        // TODO: Persist errors / surface errors at the end.
-                        println!("Error running {eval_name}: {err}");
-                    }
-                }
-            }
+            // Run exercises concurrently, with each exercise running its templates sequentially
+            let all_results = stream::iter(exercise_tasks)
+                .buffer_unordered(args.concurrency)
+                .flat_map(stream::iter)
+                .collect::<Vec<_>>()
+                .await;
 
+            println!("Completed {} evaluation runs", all_results.len());
             cx.update(|cx| cx.quit()).unwrap();
         })
         .detach();
@@ -226,18 +256,3 @@ fn main() {
 
     println!("Done running evals");
 }
-
-async fn run_eval(
-    eval: Eval,
-    model: Arc<dyn LanguageModel>,
-    judge_model: Arc<dyn LanguageModel>,
-    app_state: Arc<HeadlessAppState>,
-    cx: AsyncApp,
-) -> anyhow::Result<(EvalOutput, String)> {
-    let path = eval.path.clone();
-    let judge = Judge::load(&path, judge_model).await?;
-    let eval_output = cx.update(|cx| eval.run(app_state, model, cx))?.await?;
-    let judge_output = cx.update(|cx| judge.run(&eval_output, cx))?.await?;
-    eval_output.save_to_directory(&path, judge_output.to_string())?;
-    Ok((eval_output, judge_output))
-}

crates/assistant_eval/src/templates_eval.rs

@@ -0,0 +1,210 @@
+#[derive(Clone, Debug)]
+pub struct Template {
+    pub name: &'static str,
+    pub content: &'static str,
+}
+
+pub fn all_templates() -> Vec<Template> {
+    vec![
+        Template {
+            name: "ProjectCreation",
+            content: r#"
+# Project Creation Evaluation Template
+
+## Instructions
+
+Evaluate how well the AI assistant created a new implementation from scratch. Score it between 0.0 and 1.0 based on quality and fulfillment of requirements.
+- 1.0 = Perfect implementation that creates all necessary files with correct functionality.
+- 0.0 = Completely fails to create working files or meet requirements.
+
+Note: A git diff output is required. If no code changes are provided (i.e., no git diff output), the score must be 0.0.
+
+## Evaluation Criteria
+
+Please consider the following aspects in order of importance:
+
+1. **File Creation (25%)**
+   - Did the assistant create all necessary files?
+   - Are the files appropriately named and organized?
+   - Did the assistant create a complete solution without missing components?
+
+2. **Functional Correctness (40%)**
+   - Does the implementation fulfill all specified requirements?
+   - Does it handle edge cases properly?
+   - Is it free of logical errors and bugs?
+   - Do all components work together as expected?
+
+3. **Code Quality (20%)**
+   - Is the code well-structured, readable and well-documented?
+   - Does it follow language-specific best practices?
+   - Is there proper error handling?
+   - Are naming conventions clear and consistent?
+
+4. **Architecture Design (15%)**
+   - Is the code modular and extensible?
+   - Is there proper separation of concerns?
+   - Are appropriate design patterns used?
+   - Is the overall architecture appropriate for the requirements?
+
+## Input
+
+Requirements:
+<!-- ```requirements go here``` -->
+
+Reference Implementation:
+<!-- ```reference code goes here``` -->
+
+AI-Generated Implementation (git diff output):
+<!-- ```git diff goes here``` -->
+
+## Output Format
+
+THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
+
+EXAMPLE ONE:
+
+0.92
+
+EXAMPLE TWO:
+
+0.85
+
+EXAMPLE THREE:
+
+0.78
+"#,
+        },
+        Template {
+            name: "CodeModification",
+            content: r#"
+# Code Modification Evaluation Template
+
+## Instructions
+
+Evaluate how well the AI assistant modified existing code to meet requirements. Score between 0.0 and 1.0 based on quality and appropriateness of changes.
+- 1.0 = Perfect modifications that correctly implement all requirements.
+- 0.0 = Failed to make appropriate changes or introduced serious errors.
+
+## Evaluation Criteria
+
+Please consider the following aspects in order of importance:
+
+1. **Functional Correctness (50%)**
+   - Do the modifications correctly implement the requirements?
+   - Did the assistant modify the right files and code sections?
+   - Are the changes free of bugs and logical errors?
+   - Do the modifications maintain compatibility with existing code?
+
+2. **Modification Approach (25%)**
+   - Are the changes minimal and focused on what needs to be changed?
+   - Did the assistant avoid unnecessary modifications?
+   - Are the changes integrated seamlessly with the existing codebase?
+   - Did the assistant preserve the original code style and patterns?
+
+3. **Code Quality (15%)**
+   - Are the modifications well-structured and documented?
+   - Do they follow the same conventions as the original code?
+   - Is there proper error handling in the modified code?
+   - Are the changes readable and maintainable?
+
+4. **Solution Completeness (10%)**
+   - Do the modifications completely address all requirements?
+   - Are there any missing changes or overlooked requirements?
+   - Did the assistant consider all necessary edge cases?
+
+## Input
+
+Original:
+<!-- ```reference code goes here``` -->
+
+New (git diff output):
+<!-- ```git diff goes here``` -->
+
+## Output Format
+
+THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
+
+EXAMPLE ONE:
+
+0.92
+
+EXAMPLE TWO:
+
+0.85
+
+EXAMPLE THREE:
+
+0.78
+"#,
+        },
+        Template {
+            name: "ConversationalGuidance",
+            content: r#"
+# Conversational Guidance Evaluation Template
+
+## Instructions
+
+Evaluate the quality of the AI assistant's conversational guidance and score it between 0.0 and 1.0.
+- 1.0 = Perfect guidance with ideal information gathering, clarification, and advice without writing code.
+- 0.0 = Completely unhelpful, inappropriate guidance, or wrote code when it should not have.
+
+## Evaluation Criteria
+
+ABSOLUTE REQUIREMENT:
+   - The assistant should NOT generate complete code solutions in conversation mode.
+   - If the git diff shows the assistant wrote complete code, the score should be significantly reduced.
+
+1. **Information Gathering Effectiveness (30%)**
+   - Did the assistant ask relevant and precise questions?
+   - Did it efficiently narrow down the problem scope?
+   - Did it avoid unnecessary or redundant questions?
+   - Was questioning appropriately paced and contextual?
+
+2. **Conceptual Guidance (30%)**
+   - Did the assistant provide high-level approaches and strategies?
+   - Did it explain relevant concepts and algorithms?
+   - Did it offer planning advice without implementing the solution?
+   - Did it suggest a structured approach to solving the problem?
+
+3. **Educational Value (20%)**
+   - Did the assistant help the user understand the problem better?
+   - Did it provide explanations that would help the user learn?
+   - Did it guide without simply giving away answers?
+   - Did it encourage the user to think through parts of the problem?
+
+4. **Conversation Quality (20%)**
+   - Was the conversation logically structured and easy to follow?
+   - Did the assistant maintain appropriate context throughout?
+   - Was the interaction helpful without being condescending?
+   - Did the conversation reach a satisfactory conclusion with clear next steps?
+
+## Input
+
+Initial Query:
+<!-- ```query goes here``` -->
+
+Conversation Transcript:
+<!-- ```transcript goes here``` -->
+
+Git Diff:
+<!-- ```git diff goes here``` -->
+
+## Output Format
+
+THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
+
+EXAMPLE ONE:
+
+0.92
+
+EXAMPLE TWO:
+
+0.85
+
+EXAMPLE THREE:
+
+0.78
+"#,
+        },
+    ]
+}

crates/assistant_settings/Cargo.toml

@@ -26,6 +26,7 @@ deepseek = { workspace = true, features = ["schemars"] }
 schemars.workspace = true
 serde.workspace = true
 settings.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 fs.workspace = true

crates/assistant_settings/src/assistant_settings.rs

@@ -77,7 +77,9 @@ pub struct AssistantSettings {
     pub default_width: Pixels,
     pub default_height: Pixels,
     pub default_model: LanguageModelSelection,
-    pub editor_model: LanguageModelSelection,
+    pub inline_assistant_model: Option<LanguageModelSelection>,
+    pub commit_message_model: Option<LanguageModelSelection>,
+    pub thread_summary_model: Option<LanguageModelSelection>,
     pub inline_alternatives: Vec<LanguageModelSelection>,
     pub using_outdated_settings_version: bool,
     pub enable_experimental_live_diffs: bool,
@@ -95,13 +97,25 @@ impl AssistantSettings {
 
         cx.is_staff() || self.enable_experimental_live_diffs
     }
+
+    pub fn set_inline_assistant_model(&mut self, provider: String, model: String) {
+        self.inline_assistant_model = Some(LanguageModelSelection { provider, model });
+    }
+
+    pub fn set_commit_message_model(&mut self, provider: String, model: String) {
+        self.commit_message_model = Some(LanguageModelSelection { provider, model });
+    }
+
+    pub fn set_thread_summary_model(&mut self, provider: String, model: String) {
+        self.thread_summary_model = Some(LanguageModelSelection { provider, model });
+    }
 }
 
 /// Assistant panel settings
 #[derive(Clone, Serialize, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum AssistantSettingsContent {
-    Versioned(VersionedAssistantSettingsContent),
+    Versioned(Box<VersionedAssistantSettingsContent>),
     Legacy(LegacyAssistantSettingsContent),
 }
 
@@ -121,14 +135,14 @@ impl JsonSchema for AssistantSettingsContent {
 
 impl Default for AssistantSettingsContent {
     fn default() -> Self {
-        Self::Versioned(VersionedAssistantSettingsContent::default())
+        Self::Versioned(Box::new(VersionedAssistantSettingsContent::default()))
     }
 }
 
 impl AssistantSettingsContent {
     pub fn is_version_outdated(&self) -> bool {
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
                 VersionedAssistantSettingsContent::V1(_) => true,
                 VersionedAssistantSettingsContent::V2(_) => false,
             },
@@ -138,8 +152,8 @@ impl AssistantSettingsContent {
 
     fn upgrade(&self) -> AssistantSettingsContentV2 {
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
-                VersionedAssistantSettingsContent::V1(settings) => AssistantSettingsContentV2 {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
+                VersionedAssistantSettingsContent::V1(ref settings) => AssistantSettingsContentV2 {
                     enabled: settings.enabled,
                     button: settings.button,
                     dock: settings.dock,
@@ -186,7 +200,9 @@ impl AssistantSettingsContent {
                                 })
                             }
                         }),
-                    editor_model: None,
+                    inline_assistant_model: None,
+                    commit_message_model: None,
+                    thread_summary_model: None,
                     inline_alternatives: None,
                     enable_experimental_live_diffs: None,
                     default_profile: None,
@@ -194,7 +210,7 @@ impl AssistantSettingsContent {
                     always_allow_tool_actions: None,
                     notify_when_agent_waiting: None,
                 },
-                VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
+                VersionedAssistantSettingsContent::V2(ref settings) => settings.clone(),
             },
             AssistantSettingsContent::Legacy(settings) => AssistantSettingsContentV2 {
                 enabled: None,
@@ -211,7 +227,9 @@ impl AssistantSettingsContent {
                         .id()
                         .to_string(),
                 }),
-                editor_model: None,
+                inline_assistant_model: None,
+                commit_message_model: None,
+                thread_summary_model: None,
                 inline_alternatives: None,
                 enable_experimental_live_diffs: None,
                 default_profile: None,
@@ -224,11 +242,11 @@ impl AssistantSettingsContent {
 
     pub fn set_dock(&mut self, dock: AssistantDockPosition) {
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
-                VersionedAssistantSettingsContent::V1(settings) => {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
+                VersionedAssistantSettingsContent::V1(ref mut settings) => {
                     settings.dock = Some(dock);
                 }
-                VersionedAssistantSettingsContent::V2(settings) => {
+                VersionedAssistantSettingsContent::V2(ref mut settings) => {
                     settings.dock = Some(dock);
                 }
             },
@@ -243,77 +261,79 @@ impl AssistantSettingsContent {
         let provider = language_model.provider_id().0.to_string();
 
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
-                VersionedAssistantSettingsContent::V1(settings) => match provider.as_ref() {
-                    "zed.dev" => {
-                        log::warn!("attempted to set zed.dev model on outdated settings");
-                    }
-                    "anthropic" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::Anthropic {
-                            default_model: AnthropicModel::from_id(&model).ok(),
-                            api_url,
-                        });
-                    }
-                    "ollama" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::Ollama {
-                            default_model: Some(ollama::Model::new(&model, None, None)),
-                            api_url,
-                        });
-                    }
-                    "lmstudio" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::LmStudio { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::LmStudio {
-                            default_model: Some(lmstudio::Model::new(&model, None, None)),
-                            api_url,
-                        });
-                    }
-                    "openai" => {
-                        let (api_url, available_models) = match &settings.provider {
-                            Some(AssistantProviderContentV1::OpenAi {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
+                VersionedAssistantSettingsContent::V1(ref mut settings) => {
+                    match provider.as_ref() {
+                        "zed.dev" => {
+                            log::warn!("attempted to set zed.dev model on outdated settings");
+                        }
+                        "anthropic" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::Anthropic {
+                                default_model: AnthropicModel::from_id(&model).ok(),
+                                api_url,
+                            });
+                        }
+                        "ollama" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::Ollama {
+                                default_model: Some(ollama::Model::new(&model, None, None)),
+                                api_url,
+                            });
+                        }
+                        "lmstudio" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::LmStudio { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::LmStudio {
+                                default_model: Some(lmstudio::Model::new(&model, None, None)),
+                                api_url,
+                            });
+                        }
+                        "openai" => {
+                            let (api_url, available_models) = match &settings.provider {
+                                Some(AssistantProviderContentV1::OpenAi {
+                                    api_url,
+                                    available_models,
+                                    ..
+                                }) => (api_url.clone(), available_models.clone()),
+                                _ => (None, None),
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::OpenAi {
+                                default_model: OpenAiModel::from_id(&model).ok(),
                                 api_url,
                                 available_models,
-                                ..
-                            }) => (api_url.clone(), available_models.clone()),
-                            _ => (None, None),
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::OpenAi {
-                            default_model: OpenAiModel::from_id(&model).ok(),
-                            api_url,
-                            available_models,
-                        });
+                            });
+                        }
+                        "deepseek" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::DeepSeek { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::DeepSeek {
+                                default_model: DeepseekModel::from_id(&model).ok(),
+                                api_url,
+                            });
+                        }
+                        _ => {}
                     }
-                    "deepseek" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::DeepSeek { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::DeepSeek {
-                            default_model: DeepseekModel::from_id(&model).ok(),
-                            api_url,
-                        });
-                    }
-                    _ => {}
-                },
-                VersionedAssistantSettingsContent::V2(settings) => {
+                }
+                VersionedAssistantSettingsContent::V2(ref mut settings) => {
                     settings.default_model = Some(LanguageModelSelection { provider, model });
                 }
             },
@@ -325,23 +345,48 @@ impl AssistantSettingsContent {
         }
     }
 
+    pub fn set_inline_assistant_model(&mut self, provider: String, model: String) {
+        if let AssistantSettingsContent::Versioned(boxed) = self {
+            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                settings.inline_assistant_model = Some(LanguageModelSelection { provider, model });
+            }
+        }
+    }
+
+    pub fn set_commit_message_model(&mut self, provider: String, model: String) {
+        if let AssistantSettingsContent::Versioned(boxed) = self {
+            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                settings.commit_message_model = Some(LanguageModelSelection { provider, model });
+            }
+        }
+    }
+
+    pub fn set_thread_summary_model(&mut self, provider: String, model: String) {
+        if let AssistantSettingsContent::Versioned(boxed) = self {
+            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                settings.thread_summary_model = Some(LanguageModelSelection { provider, model });
+            }
+        }
+    }
+
     pub fn set_always_allow_tool_actions(&mut self, allow: bool) {
-        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
-            self
-        else {
+        let AssistantSettingsContent::Versioned(boxed) = self else {
             return;
         };
-        settings.always_allow_tool_actions = Some(allow);
+
+        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+            settings.always_allow_tool_actions = Some(allow);
+        }
     }
 
     pub fn set_profile(&mut self, profile_id: AgentProfileId) {
-        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
-            self
-        else {
+        let AssistantSettingsContent::Versioned(boxed) = self else {
             return;
         };
 
-        settings.default_profile = Some(profile_id);
+        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+            settings.default_profile = Some(profile_id);
+        }
     }
 
     pub fn create_profile(
@@ -349,37 +394,37 @@ impl AssistantSettingsContent {
         profile_id: AgentProfileId,
         profile: AgentProfile,
     ) -> Result<()> {
-        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
-            self
-        else {
+        let AssistantSettingsContent::Versioned(boxed) = self else {
             return Ok(());
         };
 
-        let profiles = settings.profiles.get_or_insert_default();
-        if profiles.contains_key(&profile_id) {
-            bail!("profile with ID '{profile_id}' already exists");
-        }
+        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+            let profiles = settings.profiles.get_or_insert_default();
+            if profiles.contains_key(&profile_id) {
+                bail!("profile with ID '{profile_id}' already exists");
+            }
 
-        profiles.insert(
-            profile_id,
-            AgentProfileContent {
-                name: profile.name.into(),
-                tools: profile.tools,
-                enable_all_context_servers: Some(profile.enable_all_context_servers),
-                context_servers: profile
-                    .context_servers
-                    .into_iter()
-                    .map(|(server_id, preset)| {
-                        (
-                            server_id,
-                            ContextServerPresetContent {
-                                tools: preset.tools,
-                            },
-                        )
-                    })
-                    .collect(),
-            },
-        );
+            profiles.insert(
+                profile_id,
+                AgentProfileContent {
+                    name: profile.name.into(),
+                    tools: profile.tools,
+                    enable_all_context_servers: Some(profile.enable_all_context_servers),
+                    context_servers: profile
+                        .context_servers
+                        .into_iter()
+                        .map(|(server_id, preset)| {
+                            (
+                                server_id,
+                                ContextServerPresetContent {
+                                    tools: preset.tools,
+                                },
+                            )
+                        })
+                        .collect(),
+                },
+            );
+        }
 
         Ok(())
     }
@@ -403,7 +448,9 @@ impl Default for VersionedAssistantSettingsContent {
             default_width: None,
             default_height: None,
             default_model: None,
-            editor_model: None,
+            inline_assistant_model: None,
+            commit_message_model: None,
+            thread_summary_model: None,
             inline_alternatives: None,
             enable_experimental_live_diffs: None,
             default_profile: None,
@@ -436,10 +483,14 @@ pub struct AssistantSettingsContentV2 {
     ///
     /// Default: 320
     default_height: Option<f32>,
-    /// The default model to use when creating new chats.
+    /// The default model to use when creating new chats and for other features when a specific model is not specified.
     default_model: Option<LanguageModelSelection>,
-    /// The model to use when applying edits from the assistant.
-    editor_model: Option<LanguageModelSelection>,
+    /// Model to use for the inline assistant. Defaults to default_model when not specified.
+    inline_assistant_model: Option<LanguageModelSelection>,
+    /// Model to use for generating git commit messages. Defaults to default_model when not specified.
+    commit_message_model: Option<LanguageModelSelection>,
+    /// Model to use for generating thread summaries. Defaults to default_model when not specified.
+    thread_summary_model: Option<LanguageModelSelection>,
     /// Additional models with which to generate alternatives when performing inline assists.
     inline_alternatives: Option<Vec<LanguageModelSelection>>,
     /// Enable experimental live diffs in the assistant panel.
@@ -601,7 +652,15 @@ impl Settings for AssistantSettings {
                 value.default_height.map(Into::into),
             );
             merge(&mut settings.default_model, value.default_model);
-            merge(&mut settings.editor_model, value.editor_model);
+            settings.inline_assistant_model = value
+                .inline_assistant_model
+                .or(settings.inline_assistant_model.take());
+            settings.commit_message_model = value
+                .commit_message_model
+                .or(settings.commit_message_model.take());
+            settings.thread_summary_model = value
+                .thread_summary_model
+                .or(settings.thread_summary_model.take());
             merge(&mut settings.inline_alternatives, value.inline_alternatives);
             merge(
                 &mut settings.enable_experimental_live_diffs,
@@ -692,16 +751,15 @@ mod tests {
             settings::SettingsStore::global(cx).update_settings_file::<AssistantSettings>(
                 fs.clone(),
                 |settings, _| {
-                    *settings = AssistantSettingsContent::Versioned(
+                    *settings = AssistantSettingsContent::Versioned(Box::new(
                         VersionedAssistantSettingsContent::V2(AssistantSettingsContentV2 {
                             default_model: Some(LanguageModelSelection {
                                 provider: "test-provider".into(),
                                 model: "gpt-99".into(),
                             }),
-                            editor_model: Some(LanguageModelSelection {
-                                provider: "test-provider".into(),
-                                model: "gpt-99".into(),
-                            }),
+                            inline_assistant_model: None,
+                            commit_message_model: None,
+                            thread_summary_model: None,
                             inline_alternatives: None,
                             enabled: None,
                             button: None,
@@ -714,7 +772,7 @@ mod tests {
                             always_allow_tool_actions: None,
                             notify_when_agent_waiting: None,
                         }),
-                    )
+                    ))
                 },
             );
         });

crates/assistant_slash_command/Cargo.toml

@@ -26,6 +26,7 @@ serde.workspace = true
 serde_json.workspace = true
 ui.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }

crates/assistant_slash_commands/Cargo.toml

@@ -42,6 +42,7 @@ ui.workspace = true
 util.workspace = true
 workspace.workspace = true
 worktree.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 env_logger.workspace = true

crates/assistant_tool/Cargo.toml

@@ -28,6 +28,7 @@ serde.workspace = true
 serde_json.workspace = true
 text.workspace = true
 util.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 buffer_diff = { workspace = true, features = ["test-support"] }

crates/assistant_tool/src/action_log.rs

@@ -1,31 +1,31 @@
 use anyhow::{Context as _, Result};
 use buffer_diff::BufferDiff;
-use collections::{BTreeMap, HashSet};
+use collections::BTreeMap;
 use futures::{StreamExt, channel::mpsc};
 use gpui::{App, AppContext, AsyncApp, Context, Entity, Subscription, Task, WeakEntity};
 use language::{Anchor, Buffer, BufferEvent, DiskState, Point};
+use project::{Project, ProjectItem};
 use std::{cmp, ops::Range, sync::Arc};
 use text::{Edit, Patch, Rope};
 use util::RangeExt;
 
 /// Tracks actions performed by tools in a thread
 pub struct ActionLog {
-    /// Buffers that user manually added to the context, and whose content has
-    /// changed since the model last saw them.
-    stale_buffers_in_context: HashSet<Entity<Buffer>>,
     /// Buffers that we want to notify the model about when they change.
     tracked_buffers: BTreeMap<Entity<Buffer>, TrackedBuffer>,
     /// Has the model edited a file since it last checked diagnostics?
     edited_since_project_diagnostics_check: bool,
+    /// The project this action log is associated with
+    project: Entity<Project>,
 }
 
 impl ActionLog {
-    /// Creates a new, empty action log.
-    pub fn new() -> Self {
+    /// Creates a new, empty action log associated with the given project.
+    pub fn new(project: Entity<Project>) -> Self {
         Self {
-            stale_buffers_in_context: HashSet::default(),
             tracked_buffers: BTreeMap::default(),
             edited_since_project_diagnostics_check: false,
+            project,
         }
     }
 
@@ -259,6 +259,11 @@ impl ActionLog {
         self.track_buffer(buffer, false, cx);
     }
 
+    /// Track a buffer that was added as context, so we can notify the model about user edits.
+    pub fn buffer_added_as_context(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
+        self.track_buffer(buffer, false, cx);
+    }
+
     /// Track a buffer as read, so we can notify the model about user edits.
     pub fn will_create_buffer(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
         self.track_buffer(buffer.clone(), true, cx);
@@ -268,7 +273,6 @@ impl ActionLog {
     /// Mark a buffer as edited, so we can refresh it in the context
     pub fn buffer_edited(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
         self.edited_since_project_diagnostics_check = true;
-        self.stale_buffers_in_context.insert(buffer.clone());
 
         let tracked_buffer = self.track_buffer(buffer.clone(), false, cx);
         if let TrackedBufferStatus::Deleted = tracked_buffer.status {
@@ -324,14 +328,14 @@ impl ActionLog {
                     {
                         true
                     } else {
-                        let old_bytes = tracked_buffer
+                        let old_range = tracked_buffer
                             .base_text
                             .point_to_offset(Point::new(edit.old.start, 0))
                             ..tracked_buffer.base_text.point_to_offset(cmp::min(
                                 Point::new(edit.old.end, 0),
                                 tracked_buffer.base_text.max_point(),
                             ));
-                        let new_bytes = tracked_buffer
+                        let new_range = tracked_buffer
                             .snapshot
                             .point_to_offset(Point::new(edit.new.start, 0))
                             ..tracked_buffer.snapshot.point_to_offset(cmp::min(
@@ -339,10 +343,10 @@ impl ActionLog {
                                 tracked_buffer.snapshot.max_point(),
                             ));
                         tracked_buffer.base_text.replace(
-                            old_bytes,
+                            old_range,
                             &tracked_buffer
                                 .snapshot
-                                .text_for_range(new_bytes)
+                                .text_for_range(new_range)
                                 .collect::<String>(),
                         );
                         delta += edit.new_len() as i32 - edit.old_len() as i32;
@@ -354,6 +358,87 @@ impl ActionLog {
         }
     }
 
+    pub fn reject_edits_in_range(
+        &mut self,
+        buffer: Entity<Buffer>,
+        buffer_range: Range<impl language::ToPoint>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {
+            return Task::ready(Ok(()));
+        };
+
+        match tracked_buffer.status {
+            TrackedBufferStatus::Created => {
+                let delete = buffer
+                    .read(cx)
+                    .entry_id(cx)
+                    .and_then(|entry_id| {
+                        self.project
+                            .update(cx, |project, cx| project.delete_entry(entry_id, false, cx))
+                    })
+                    .unwrap_or(Task::ready(Ok(())));
+                self.tracked_buffers.remove(&buffer);
+                cx.notify();
+                delete
+            }
+            TrackedBufferStatus::Deleted => {
+                buffer.update(cx, |buffer, cx| {
+                    buffer.set_text(tracked_buffer.base_text.to_string(), cx)
+                });
+                let save = self
+                    .project
+                    .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx));
+
+                // Clear all tracked changes for this buffer and start over as if we just read it.
+                self.tracked_buffers.remove(&buffer);
+                self.track_buffer(buffer.clone(), false, cx);
+                cx.notify();
+                save
+            }
+            TrackedBufferStatus::Modified => {
+                buffer.update(cx, |buffer, cx| {
+                    let buffer_range =
+                        buffer_range.start.to_point(buffer)..buffer_range.end.to_point(buffer);
+
+                    let mut edits_to_revert = Vec::new();
+                    for edit in tracked_buffer.unreviewed_changes.edits() {
+                        if buffer_range.end.row < edit.new.start {
+                            break;
+                        } else if buffer_range.start.row > edit.new.end {
+                            continue;
+                        }
+
+                        let old_range = tracked_buffer
+                            .base_text
+                            .point_to_offset(Point::new(edit.old.start, 0))
+                            ..tracked_buffer.base_text.point_to_offset(cmp::min(
+                                Point::new(edit.old.end, 0),
+                                tracked_buffer.base_text.max_point(),
+                            ));
+                        let old_text = tracked_buffer
+                            .base_text
+                            .chunks_in_range(old_range)
+                            .collect::<String>();
+
+                        let new_range = tracked_buffer
+                            .snapshot
+                            .anchor_before(Point::new(edit.new.start, 0))
+                            ..tracked_buffer.snapshot.anchor_after(cmp::min(
+                                Point::new(edit.new.end, 0),
+                                tracked_buffer.snapshot.max_point(),
+                            ));
+                        edits_to_revert.push((new_range, old_text));
+                    }
+
+                    buffer.edit(edits_to_revert, None, cx);
+                });
+                self.project
+                    .update(cx, |project, cx| project.save_buffer(buffer, cx))
+            }
+        }
+    }
+
     pub fn keep_all_edits(&mut self, cx: &mut Context<Self>) {
         self.tracked_buffers
             .retain(|_buffer, tracked_buffer| match tracked_buffer.status {
@@ -391,11 +476,6 @@ impl ActionLog {
             })
             .map(|(buffer, _)| buffer)
     }
-
-    /// Takes and returns the set of buffers pending refresh, clearing internal state.
-    pub fn take_stale_buffers_in_context(&mut self) -> HashSet<Entity<Buffer>> {
-        std::mem::take(&mut self.stale_buffers_in_context)
-    }
 }
 
 fn apply_non_conflicting_edits(
@@ -580,9 +660,22 @@ mod tests {
         }
     }
 
+    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);
+        });
+    }
+
     #[gpui::test(iterations = 10)]
     async fn test_keep_edits(cx: &mut TestAppContext) {
-        let action_log = cx.new(|_| ActionLog::new());
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno", cx));
 
         cx.update(|cx| {
@@ -648,7 +741,11 @@ mod tests {
 
     #[gpui::test(iterations = 10)]
     async fn test_deletions(cx: &mut TestAppContext) {
-        let action_log = cx.new(|_| ActionLog::new());
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno\npqr", cx));
 
         cx.update(|cx| {
@@ -718,7 +815,11 @@ mod tests {
 
     #[gpui::test(iterations = 10)]
     async fn test_overlapping_user_edits(cx: &mut TestAppContext) {
-        let action_log = cx.new(|_| ActionLog::new());
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno", cx));
 
         cx.update(|cx| {
@@ -802,15 +903,12 @@ mod tests {
     }
 
     #[gpui::test(iterations = 10)]
-    async fn test_creation(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            language::init(cx);
-            Project::init_settings(cx);
-        });
+    async fn test_creating_files(cx: &mut TestAppContext) {
+        init_test(cx);
 
-        let action_log = cx.new(|_| ActionLog::new());
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
 
         let fs = FakeFs::new(cx.executor());
         fs.insert_tree(path!("/dir"), json!({})).await;
@@ -869,12 +967,7 @@ mod tests {
 
     #[gpui::test(iterations = 10)]
     async fn test_deleting_files(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            language::init(cx);
-            Project::init_settings(cx);
-        });
+        init_test(cx);
 
         let fs = FakeFs::new(cx.executor());
         fs.insert_tree(
@@ -891,7 +984,7 @@ mod tests {
             .read_with(cx, |project, cx| project.find_project_path("dir/file2", cx))
             .unwrap();
 
-        let action_log = cx.new(|_| ActionLog::new());
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer1 = project
             .update(cx, |project, cx| {
                 project.open_buffer(file1_path.clone(), cx)
@@ -981,15 +1074,222 @@ mod tests {
         assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
     }
 
+    #[gpui::test(iterations = 10)]
+    async fn test_reject_edits(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/dir"), json!({"file": "abc\ndef\nghi\njkl\nmno"}))
+            .await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+
+        cx.update(|cx| {
+            action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(1, 1)..Point::new(1, 2), "E\nXYZ")], None, cx)
+                    .unwrap()
+            });
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(5, 2)..Point::new(5, 3), "O")], None, cx)
+                    .unwrap()
+            });
+            action_log.update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndE\nXYZf\nghi\njkl\nmnO"
+        );
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![
+                    HunkStatus {
+                        range: Point::new(1, 0)..Point::new(3, 0),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "def\n".into(),
+                    },
+                    HunkStatus {
+                        range: Point::new(5, 0)..Point::new(5, 3),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "mno".into(),
+                    }
+                ],
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(1, 0), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndef\nghi\njkl\nmnO"
+        );
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![HunkStatus {
+                    range: Point::new(4, 0)..Point::new(4, 3),
+                    diff_status: DiffHunkStatusKind::Modified,
+                    old_text: "mno".into(),
+                }],
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(4, 0)..Point::new(4, 0), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndef\nghi\njkl\nmno"
+        );
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
+    #[gpui::test(iterations = 10)]
+    async fn test_reject_deleted_file(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/dir"), json!({"file": "content"}))
+            .await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path.clone(), cx))
+            .await
+            .unwrap();
+
+        cx.update(|cx| {
+            action_log.update(cx, |log, cx| log.will_delete_buffer(buffer.clone(), cx));
+        });
+        project
+            .update(cx, |project, cx| {
+                project.delete_file(file_path.clone(), false, cx)
+            })
+            .unwrap()
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert!(!fs.is_file(path!("/dir/file").as_ref()).await);
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![HunkStatus {
+                    range: Point::new(0, 0)..Point::new(0, 0),
+                    diff_status: DiffHunkStatusKind::Deleted,
+                    old_text: "content".into(),
+                }]
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(0, 0), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert_eq!(buffer.read_with(cx, |buffer, _| buffer.text()), "content");
+        assert!(fs.is_file(path!("/dir/file").as_ref()).await);
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
+    #[gpui::test(iterations = 10)]
+    async fn test_reject_created_file(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| {
+                project.find_project_path("dir/new_file", cx)
+            })
+            .unwrap();
+
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+        cx.update(|cx| {
+            buffer.update(cx, |buffer, cx| buffer.set_text("content", cx));
+            action_log.update(cx, |log, cx| log.will_create_buffer(buffer.clone(), cx));
+        });
+        project
+            .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))
+            .await
+            .unwrap();
+        assert!(fs.is_file(path!("/dir/new_file").as_ref()).await);
+        cx.run_until_parked();
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![HunkStatus {
+                    range: Point::new(0, 0)..Point::new(0, 7),
+                    diff_status: DiffHunkStatusKind::Added,
+                    old_text: "".into(),
+                }],
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(0, 11), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert!(!fs.is_file(path!("/dir/new_file").as_ref()).await);
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
     #[gpui::test(iterations = 100)]
     async fn test_random_diffs(mut rng: StdRng, cx: &mut TestAppContext) {
+        init_test(cx);
+
         let operations = env::var("OPERATIONS")
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(20);
 
-        let action_log = cx.new(|_| ActionLog::new());
         let text = RandomCharIter::new(&mut rng).take(50).collect::<String>();
-        let buffer = cx.new(|cx| Buffer::local(text, cx));
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/dir"), json!({"file": text})).await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+
         action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
 
         for _ in 0..operations {
@@ -997,10 +1297,20 @@ mod tests {
                 0..25 => {
                     action_log.update(cx, |log, cx| {
                         let range = buffer.read(cx).random_byte_range(0, &mut rng);
-                        log::info!("keeping all edits in range {:?}", range);
+                        log::info!("keeping edits in range {:?}", range);
                         log.keep_edits_in_range(buffer.clone(), range, cx)
                     });
                 }
+                25..50 => {
+                    action_log
+                        .update(cx, |log, cx| {
+                            let range = buffer.read(cx).random_byte_range(0, &mut rng);
+                            log::info!("rejecting edits in range {:?}", range);
+                            log.reject_edits_in_range(buffer.clone(), range, cx)
+                        })
+                        .await
+                        .unwrap();
+                }
                 _ => {
                     let is_agent_change = rng.gen_bool(0.5);
                     if is_agent_change {

crates/assistant_tools/Cargo.toml

@@ -16,7 +16,6 @@ anyhow.workspace = true
 assistant_tool.workspace = true
 chrono.workspace = true
 collections.workspace = true
-feature_flags.workspace = true
 futures.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
@@ -24,21 +23,17 @@ http_client.workspace = true
 itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
-log.workspace = true
 lsp.workspace = true
 project.workspace = true
 regex.workspace = true
-release_channel.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-settings.workspace = true
-theme.workspace = true
 ui.workspace = true
 util.workspace = true
-workspace.workspace = true
 worktree.workspace = true
 open = { workspace = true }
+workspace-hack.workspace = true
 
 [dev-dependencies]
 collections = { workspace = true, features = ["test-support"] }

crates/assistant_tools/src/assistant_tools.rs

@@ -7,7 +7,6 @@ mod create_directory_tool;
 mod create_file_tool;
 mod delete_path_tool;
 mod diagnostics_tool;
-mod edit_files_tool;
 mod fetch_tool;
 mod find_replace_file_tool;
 mod list_directory_tool;
@@ -37,7 +36,6 @@ use crate::create_directory_tool::CreateDirectoryTool;
 use crate::create_file_tool::CreateFileTool;
 use crate::delete_path_tool::DeletePathTool;
 use crate::diagnostics_tool::DiagnosticsTool;
-use crate::edit_files_tool::EditFilesTool;
 use crate::fetch_tool::FetchTool;
 use crate::find_replace_file_tool::FindReplaceFileTool;
 use crate::list_directory_tool::ListDirectoryTool;
@@ -51,7 +49,6 @@ use crate::thinking_tool::ThinkingTool;
 
 pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     assistant_tool::init(cx);
-    crate::edit_files_tool::log::init(cx);
 
     let registry = ToolRegistry::global(cx);
     registry.register_tool(BashTool);
@@ -64,7 +61,6 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     registry.register_tool(SymbolInfoTool);
     registry.register_tool(MovePathTool);
     registry.register_tool(DiagnosticsTool);
-    registry.register_tool(EditFilesTool);
     registry.register_tool(ListDirectoryTool);
     registry.register_tool(NowTool);
     registry.register_tool(OpenTool);

crates/assistant_tools/src/batch_tool.rs

@@ -31,19 +31,19 @@ pub struct BatchToolInput {
     /// {
     ///   "invocations": [
     ///     {
-    ///       "name": "read-file",
+    ///       "name": "read_file",
     ///       "input": {
     ///         "path": "src/main.rs"
     ///       }
     ///     },
     ///     {
-    ///       "name": "list-directory",
+    ///       "name": "list_directory",
     ///       "input": {
     ///         "path": "src/lib"
     ///       }
     ///     },
     ///     {
-    ///       "name": "regex-search",
+    ///       "name": "regex_search",
     ///       "input": {
     ///         "regex": "fn run\\("
     ///       }
@@ -61,7 +61,7 @@ pub struct BatchToolInput {
     /// {
     ///   "invocations": [
     ///     {
-    ///       "name": "find-replace-file",
+    ///       "name": "find_replace_file",
     ///       "input": {
     ///         "path": "src/config.rs",
     ///         "display_description": "Update default timeout value",
@@ -70,7 +70,7 @@ pub struct BatchToolInput {
     ///       }
     ///     },
     ///     {
-    ///       "name": "find-replace-file",
+    ///       "name": "find_replace_file",
     ///       "input": {
     ///         "path": "src/config.rs",
     ///         "display_description": "Update API endpoint URL",
@@ -91,13 +91,13 @@ pub struct BatchToolInput {
     /// {
     ///   "invocations": [
     ///     {
-    ///       "name": "regex-search",
+    ///       "name": "regex_search",
     ///       "input": {
     ///         "regex": "impl Database"
     ///       }
     ///     },
     ///     {
-    ///       "name": "path-search",
+    ///       "name": "path_search",
     ///       "input": {
     ///         "glob": "**/*test*.rs"
     ///       }
@@ -115,7 +115,7 @@ pub struct BatchToolInput {
     /// {
     ///   "invocations": [
     ///     {
-    ///       "name": "find-replace-file",
+    ///       "name": "find_replace_file",
     ///       "input": {
     ///         "path": "src/models/user.rs",
     ///         "display_description": "Add email field to User struct",
@@ -124,7 +124,7 @@ pub struct BatchToolInput {
     ///       }
     ///     },
     ///     {
-    ///       "name": "find-replace-file",
+    ///       "name": "find_replace_file",
     ///       "input": {
     ///         "path": "src/db/queries.rs",
     ///         "display_description": "Update user insertion query",

crates/assistant_tools/src/code_symbols_tool.rs

@@ -156,7 +156,7 @@ impl Tool for CodeSymbolsTool {
     }
 }
 
-async fn file_outline(
+pub async fn file_outline(
     project: Entity<Project>,
     path: String,
     action_log: Entity<ActionLog>,

crates/assistant_tools/src/edit_files_tool.rs

@@ -1,559 +0,0 @@
-mod edit_action;
-pub mod log;
-
-use crate::replace::{replace_exact, replace_with_flexible_indent};
-use crate::schema::json_schema_for;
-use anyhow::{Context, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
-use collections::HashSet;
-use edit_action::{EditAction, EditActionParser, edit_model_prompt};
-use futures::{SinkExt, StreamExt, channel::mpsc};
-use gpui::{App, AppContext, AsyncApp, Entity, Task};
-use language_model::LanguageModelToolSchemaFormat;
-use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, MessageContent, Role,
-};
-use log::{EditToolLog, EditToolRequestId};
-use project::Project;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::fmt::Write;
-use std::sync::Arc;
-use ui::IconName;
-use util::ResultExt;
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct EditFilesToolInput {
-    /// High-level edit instructions. These will be interpreted by a smaller
-    /// model, so explain the changes you want that model to make and which
-    /// file paths need changing. The description should be concise and clear.
-    ///
-    /// WARNING: When specifying which file paths need changing, you MUST
-    /// start each path with one of the project's root directories.
-    ///
-    /// WARNING: NEVER include code blocks or snippets in edit instructions.
-    /// Only provide natural language descriptions of the changes needed! The tool will
-    /// reject any instructions that contain code blocks or snippets.
-    ///
-    /// The following examples assume we have two root directories in the project:
-    /// - root-1
-    /// - root-2
-    ///
-    /// <example>
-    /// If you want to introduce a new quit function to kill the process, your
-    /// instructions should be: "Add a new `quit` function to
-    /// `root-1/src/main.rs` to kill the process".
-    ///
-    /// Notice how the file path starts with root-1. Without that, the path
-    /// would be ambiguous and the call would fail!
-    /// </example>
-    ///
-    /// <example>
-    /// If you want to change documentation to always start with a capital
-    /// letter, your instructions should be: "In `root-2/db.js`,
-    /// `root-2/inMemory.js` and `root-2/sql.js`, change all the documentation
-    /// to start with a capital letter".
-    ///
-    /// Notice how we never specify code snippets in the instructions!
-    /// </example>
-    pub edit_instructions: String,
-
-    /// A user-friendly description of what changes are being made.
-    /// This will be shown to the user in the UI to describe the edit operation. The screen real estate for this UI will be extremely
-    /// constrained, so make the description extremely terse.
-    ///
-    /// <example>
-    /// For fixing a broken authentication system:
-    /// "Fix auth bug in login flow"
-    /// </example>
-    ///
-    /// <example>
-    /// For adding unit tests to a module:
-    /// "Add tests for user profile logic"
-    /// </example>
-    pub display_description: String,
-}
-
-pub struct EditFilesTool;
-
-impl Tool for EditFilesTool {
-    fn name(&self) -> String {
-        "edit_files".into()
-    }
-
-    fn needs_confirmation(&self) -> bool {
-        false
-    }
-
-    fn description(&self) -> String {
-        include_str!("./edit_files_tool/description.md").into()
-    }
-
-    fn icon(&self) -> IconName {
-        IconName::Pencil
-    }
-
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> serde_json::Value {
-        json_schema_for::<EditFilesToolInput>(format)
-    }
-
-    fn ui_text(&self, input: &serde_json::Value) -> String {
-        match serde_json::from_value::<EditFilesToolInput>(input.clone()) {
-            Ok(input) => input.display_description,
-            Err(_) => "Edit files".to_string(),
-        }
-    }
-
-    fn run(
-        self: Arc<Self>,
-        input: serde_json::Value,
-        messages: &[LanguageModelRequestMessage],
-        project: Entity<Project>,
-        action_log: Entity<ActionLog>,
-        cx: &mut App,
-    ) -> Task<Result<String>> {
-        let input = match serde_json::from_value::<EditFilesToolInput>(input) {
-            Ok(input) => input,
-            Err(err) => return Task::ready(Err(anyhow!(err))),
-        };
-
-        match EditToolLog::try_global(cx) {
-            Some(log) => {
-                let req_id = log.update(cx, |log, cx| {
-                    log.new_request(input.edit_instructions.clone(), cx)
-                });
-
-                let task = EditToolRequest::new(
-                    input,
-                    messages,
-                    project,
-                    action_log,
-                    Some((log.clone(), req_id)),
-                    cx,
-                );
-
-                cx.spawn(async move |cx| {
-                    let result = task.await;
-
-                    let str_result = match &result {
-                        Ok(out) => Ok(out.clone()),
-                        Err(err) => Err(err.to_string()),
-                    };
-
-                    log.update(cx, |log, cx| log.set_tool_output(req_id, str_result, cx))
-                        .log_err();
-
-                    result
-                })
-            }
-
-            None => EditToolRequest::new(input, messages, project, action_log, None, cx),
-        }
-    }
-}
-
-struct EditToolRequest {
-    parser: EditActionParser,
-    editor_response: EditorResponse,
-    project: Entity<Project>,
-    action_log: Entity<ActionLog>,
-    tool_log: Option<(Entity<EditToolLog>, EditToolRequestId)>,
-}
-
-enum EditorResponse {
-    /// The editor model hasn't produced any actions yet.
-    /// If we don't have any by the end, we'll return its message to the architect model.
-    Message(String),
-    /// The editor model produced at least one action.
-    Actions {
-        applied: Vec<AppliedAction>,
-        search_errors: Vec<SearchError>,
-    },
-}
-
-struct AppliedAction {
-    source: String,
-    buffer: Entity<language::Buffer>,
-}
-
-#[derive(Debug)]
-enum DiffResult {
-    Diff(language::Diff),
-    SearchError(SearchError),
-}
-
-#[derive(Debug)]
-enum SearchError {
-    NoMatch {
-        file_path: String,
-        search: String,
-    },
-    EmptyBuffer {
-        file_path: String,
-        search: String,
-        exists: bool,
-    },
-}
-
-impl EditToolRequest {
-    fn new(
-        input: EditFilesToolInput,
-        messages: &[LanguageModelRequestMessage],
-        project: Entity<Project>,
-        action_log: Entity<ActionLog>,
-        tool_log: Option<(Entity<EditToolLog>, EditToolRequestId)>,
-        cx: &mut App,
-    ) -> Task<Result<String>> {
-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let Some(model) = model_registry.editor_model() else {
-            return Task::ready(Err(anyhow!("No editor model configured")));
-        };
-
-        let mut messages = messages.to_vec();
-        // Remove the last tool use (this run) to prevent an invalid request
-        'outer: for message in messages.iter_mut().rev() {
-            for (index, content) in message.content.iter().enumerate().rev() {
-                match content {
-                    MessageContent::ToolUse(_) => {
-                        message.content.remove(index);
-                        break 'outer;
-                    }
-                    MessageContent::ToolResult(_) => {
-                        // If we find any tool results before a tool use, the request is already valid
-                        break 'outer;
-                    }
-                    MessageContent::Text(_) | MessageContent::Image(_) => {}
-                }
-            }
-        }
-
-        messages.push(LanguageModelRequestMessage {
-            role: Role::User,
-            content: vec![edit_model_prompt().into(), input.edit_instructions.into()],
-            cache: false,
-        });
-
-        cx.spawn(async move |cx| {
-            let llm_request = LanguageModelRequest {
-                messages,
-                tools: vec![],
-                stop: vec![],
-                temperature: Some(0.0),
-            };
-
-            let (mut tx, mut rx) = mpsc::channel::<String>(32);
-            let stream = model.stream_completion_text(llm_request, &cx);
-            let reader_task = cx.background_spawn(async move {
-                let mut chunks = stream.await?;
-
-                while let Some(chunk) = chunks.stream.next().await {
-                    if let Some(chunk) = chunk.log_err() {
-                        // we don't process here because the API fails
-                        // if we take too long between reads
-                        tx.send(chunk).await?
-                    }
-                }
-                tx.close().await?;
-                anyhow::Ok(())
-            });
-
-            let mut request = Self {
-                parser: EditActionParser::new(),
-                editor_response: EditorResponse::Message(String::with_capacity(256)),
-                action_log,
-                project,
-                tool_log,
-            };
-
-            while let Some(chunk) = rx.next().await {
-                request.process_response_chunk(&chunk, cx).await?;
-            }
-
-            reader_task.await?;
-
-            request.finalize(cx).await
-        })
-    }
-
-    async fn process_response_chunk(&mut self, chunk: &str, cx: &mut AsyncApp) -> Result<()> {
-        let new_actions = self.parser.parse_chunk(chunk);
-
-        if let EditorResponse::Message(ref mut message) = self.editor_response {
-            if new_actions.is_empty() {
-                message.push_str(chunk);
-            }
-        }
-
-        if let Some((ref log, req_id)) = self.tool_log {
-            log.update(cx, |log, cx| {
-                log.push_editor_response_chunk(req_id, chunk, &new_actions, cx)
-            })
-            .log_err();
-        }
-
-        for action in new_actions {
-            self.apply_action(action, cx).await?;
-        }
-
-        Ok(())
-    }
-
-    async fn apply_action(
-        &mut self,
-        (action, source): (EditAction, String),
-        cx: &mut AsyncApp,
-    ) -> Result<()> {
-        let project_path = self.project.read_with(cx, |project, cx| {
-            project
-                .find_project_path(action.file_path(), cx)
-                .context("Path not found in project")
-        })??;
-
-        let buffer = self
-            .project
-            .update(cx, |project, cx| project.open_buffer(project_path, cx))?
-            .await?;
-
-        let result = match action {
-            EditAction::Replace {
-                old,
-                new,
-                file_path,
-            } => {
-                let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
-
-                cx.background_executor()
-                    .spawn(Self::replace_diff(old, new, file_path, snapshot))
-                    .await
-            }
-            EditAction::Write { content, .. } => Ok(DiffResult::Diff(
-                buffer
-                    .read_with(cx, |buffer, cx| buffer.diff(content, cx))?
-                    .await,
-            )),
-        }?;
-
-        match result {
-            DiffResult::SearchError(error) => {
-                self.push_search_error(error);
-            }
-            DiffResult::Diff(diff) => {
-                cx.update(|cx| {
-                    self.action_log
-                        .update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
-                    buffer.update(cx, |buffer, cx| {
-                        buffer.finalize_last_transaction();
-                        buffer.apply_diff(diff, cx);
-                        buffer.finalize_last_transaction();
-                    });
-                    self.action_log
-                        .update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
-                })?;
-
-                self.push_applied_action(AppliedAction { source, buffer });
-            }
-        }
-
-        anyhow::Ok(())
-    }
-
-    fn push_search_error(&mut self, error: SearchError) {
-        match &mut self.editor_response {
-            EditorResponse::Message(_) => {
-                self.editor_response = EditorResponse::Actions {
-                    applied: Vec::new(),
-                    search_errors: vec![error],
-                };
-            }
-            EditorResponse::Actions { search_errors, .. } => {
-                search_errors.push(error);
-            }
-        }
-    }
-
-    fn push_applied_action(&mut self, action: AppliedAction) {
-        match &mut self.editor_response {
-            EditorResponse::Message(_) => {
-                self.editor_response = EditorResponse::Actions {
-                    applied: vec![action],
-                    search_errors: Vec::new(),
-                };
-            }
-            EditorResponse::Actions { applied, .. } => {
-                applied.push(action);
-            }
-        }
-    }
-
-    async fn replace_diff(
-        old: String,
-        new: String,
-        file_path: std::path::PathBuf,
-        snapshot: language::BufferSnapshot,
-    ) -> Result<DiffResult> {
-        if snapshot.is_empty() {
-            let exists = snapshot
-                .file()
-                .map_or(false, |file| file.disk_state().exists());
-
-            let error = SearchError::EmptyBuffer {
-                file_path: file_path.display().to_string(),
-                exists,
-                search: old,
-            };
-
-            return Ok(DiffResult::SearchError(error));
-        }
-
-        let replace_result =
-            // Try to match exactly
-            replace_exact(&old, &new, &snapshot)
-            .await
-            // If that fails, try being flexible about indentation
-            .or_else(|| replace_with_flexible_indent(&old, &new, &snapshot));
-
-        let Some(diff) = replace_result else {
-            let error = SearchError::NoMatch {
-                search: old,
-                file_path: file_path.display().to_string(),
-            };
-
-            return Ok(DiffResult::SearchError(error));
-        };
-
-        Ok(DiffResult::Diff(diff))
-    }
-
-    async fn finalize(self, cx: &mut AsyncApp) -> Result<String> {
-        match self.editor_response {
-            EditorResponse::Message(message) => Err(anyhow!(
-                "No edits were applied! You might need to provide more context.\n\n{}",
-                message
-            )),
-            EditorResponse::Actions {
-                applied,
-                search_errors,
-            } => {
-                let mut output = String::with_capacity(1024);
-
-                let parse_errors = self.parser.errors();
-                let has_errors = !search_errors.is_empty() || !parse_errors.is_empty();
-
-                if has_errors {
-                    let error_count = search_errors.len() + parse_errors.len();
-
-                    if applied.is_empty() {
-                        writeln!(
-                            &mut output,
-                            "{} errors occurred! No edits were applied.",
-                            error_count,
-                        )?;
-                    } else {
-                        writeln!(
-                            &mut output,
-                            "{} errors occurred, but {} edits were correctly applied.",
-                            error_count,
-                            applied.len(),
-                        )?;
-
-                        writeln!(
-                            &mut output,
-                            "# {} SEARCH/REPLACE block(s) applied:\n\nDo not re-send these since they are already applied!\n",
-                            applied.len()
-                        )?;
-                    }
-                } else {
-                    write!(
-                        &mut output,
-                        "Successfully applied! Here's a list of applied edits:"
-                    )?;
-                }
-
-                let mut changed_buffers = HashSet::default();
-
-                for action in applied {
-                    changed_buffers.insert(action.buffer.clone());
-                    write!(&mut output, "\n\n{}", action.source)?;
-                }
-
-                for buffer in &changed_buffers {
-                    self.project
-                        .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))?
-                        .await?;
-                }
-
-                if !search_errors.is_empty() {
-                    writeln!(
-                        &mut output,
-                        "\n\n## {} SEARCH/REPLACE block(s) failed to match:\n",
-                        search_errors.len()
-                    )?;
-
-                    for error in search_errors {
-                        match error {
-                            SearchError::NoMatch { file_path, search } => {
-                                writeln!(
-                                    &mut output,
-                                    "### No exact match in: `{}`\n```\n{}\n```\n",
-                                    file_path, search,
-                                )?;
-                            }
-                            SearchError::EmptyBuffer {
-                                file_path,
-                                exists: true,
-                                search,
-                            } => {
-                                writeln!(
-                                    &mut output,
-                                    "### No match because `{}` is empty:\n```\n{}\n```\n",
-                                    file_path, search,
-                                )?;
-                            }
-                            SearchError::EmptyBuffer {
-                                file_path,
-                                exists: false,
-                                search,
-                            } => {
-                                writeln!(
-                                    &mut output,
-                                    "### No match because `{}` does not exist:\n```\n{}\n```\n",
-                                    file_path, search,
-                                )?;
-                            }
-                        }
-                    }
-
-                    write!(
-                        &mut output,
-                        "The SEARCH section must exactly match an existing block of lines including all white \
-                        space, comments, indentation, docstrings, etc."
-                    )?;
-                }
-
-                if !parse_errors.is_empty() {
-                    writeln!(
-                        &mut output,
-                        "\n\n## {} SEARCH/REPLACE blocks failed to parse:",
-                        parse_errors.len()
-                    )?;
-
-                    for error in parse_errors {
-                        writeln!(&mut output, "- {}", error)?;
-                    }
-                }
-
-                if has_errors {
-                    writeln!(
-                        &mut output,
-                        "\n\nYou can fix errors by running the tool again. You can include instructions, \
-                        but errors are part of the conversation so you don't need to repeat them.",
-                    )?;
-
-                    Err(anyhow!(output))
-                } else {
-                    Ok(output)
-                }
-            }
-        }
-    }
-}

crates/assistant_tools/src/edit_files_tool/description.md

@@ -1,11 +0,0 @@
-Edit files in the current project by specifying instructions in natural language.
-
-IMPORTANT NOTE: If there is a find-replace tool, use that instead of this tool! This tool is only to be used as a fallback in case that tool is unavailable. Always prefer that tool if it is available.
-
-When using this tool, you should suggest one coherent edit that can be made to the codebase.
-
-When the set of edits you want to make is large or complex, feel free to invoke this tool multiple times, each time focusing on a specific change you wanna make.
-
-You should use this tool when you want to edit a subset of a file's contents, but not the entire file. You should not use this tool when you want to replace the entire contents of a file with completely different contents, and you absolutely must never use this tool to create new files from scratch. If you ever consider using this tool to create a new file from scratch, for any reason, instead you must reconsider and choose a different approach.
-
-DO NOT call this tool until the code to be edited appears in the conversation! You must use the `read-files` tool or ask the user to add it to context first.

crates/assistant_tools/src/edit_files_tool/edit_action.rs

@@ -1,967 +0,0 @@
-use std::{
-    mem::take,
-    ops::Range,
-    path::{Path, PathBuf},
-};
-use util::ResultExt;
-
-/// Represents an edit action to be performed on a file.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum EditAction {
-    /// Replace specific content in a file with new content
-    Replace {
-        file_path: PathBuf,
-        old: String,
-        new: String,
-    },
-    /// Write content to a file (create or overwrite)
-    Write { file_path: PathBuf, content: String },
-}
-
-impl EditAction {
-    pub fn file_path(&self) -> &Path {
-        match self {
-            EditAction::Replace { file_path, .. } => file_path,
-            EditAction::Write { file_path, .. } => file_path,
-        }
-    }
-}
-
-/// Parses edit actions from an LLM response.
-/// See system.md for more details on the format.
-#[derive(Debug)]
-pub struct EditActionParser {
-    state: State,
-    line: usize,
-    column: usize,
-    marker_ix: usize,
-    action_source: Vec<u8>,
-    fence_start_offset: usize,
-    block_range: Range<usize>,
-    old_range: Range<usize>,
-    new_range: Range<usize>,
-    errors: Vec<ParseError>,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-enum State {
-    /// Anywhere outside an action
-    Default,
-    /// After opening ```, in optional language tag
-    OpenFence,
-    /// In SEARCH marker
-    SearchMarker,
-    /// In search block or divider
-    SearchBlock,
-    /// In replace block or REPLACE marker
-    ReplaceBlock,
-    /// In closing ```
-    CloseFence,
-}
-
-/// used to avoid having source code that looks like git-conflict markers
-macro_rules! marker_sym {
-    ($char:expr) => {
-        concat!($char, $char, $char, $char, $char, $char, $char)
-    };
-}
-
-const SEARCH_MARKER: &str = concat!(marker_sym!('<'), " SEARCH");
-const DIVIDER: &str = marker_sym!('=');
-const NL_DIVIDER: &str = concat!("\n", marker_sym!('='));
-const REPLACE_MARKER: &str = concat!(marker_sym!('>'), " REPLACE");
-const NL_REPLACE_MARKER: &str = concat!("\n", marker_sym!('>'), " REPLACE");
-const FENCE: &str = "```";
-
-impl EditActionParser {
-    /// Creates a new `EditActionParser`
-    pub fn new() -> Self {
-        Self {
-            state: State::Default,
-            line: 1,
-            column: 0,
-            action_source: Vec::new(),
-            fence_start_offset: 0,
-            marker_ix: 0,
-            block_range: Range::default(),
-            old_range: Range::default(),
-            new_range: Range::default(),
-            errors: Vec::new(),
-        }
-    }
-
-    /// Processes a chunk of input text and returns any completed edit actions.
-    ///
-    /// This method can be called repeatedly with fragments of input. The parser
-    /// maintains its state between calls, allowing you to process streaming input
-    /// as it becomes available. Actions are only inserted once they are fully parsed.
-    ///
-    /// If a block fails to parse, it will simply be skipped and an error will be recorded.
-    /// All errors can be accessed through the `EditActionsParser::errors` method.
-    pub fn parse_chunk(&mut self, input: &str) -> Vec<(EditAction, String)> {
-        use State::*;
-
-        let mut actions = Vec::new();
-
-        for byte in input.bytes() {
-            // Update line and column tracking
-            if byte == b'\n' {
-                self.line += 1;
-                self.column = 0;
-            } else {
-                self.column += 1;
-            }
-
-            let action_offset = self.action_source.len();
-
-            match &self.state {
-                Default => match self.match_marker(byte, FENCE, false) {
-                    MarkerMatch::Complete => {
-                        self.fence_start_offset = action_offset + 1 - FENCE.len();
-                        self.to_state(OpenFence);
-                    }
-                    MarkerMatch::Partial => {}
-                    MarkerMatch::None => {
-                        if self.marker_ix > 0 {
-                            self.marker_ix = 0;
-                        } else if self.action_source.ends_with(b"\n") {
-                            self.action_source.clear();
-                        }
-                    }
-                },
-                OpenFence => {
-                    // skip language tag
-                    if byte == b'\n' {
-                        self.to_state(SearchMarker);
-                    }
-                }
-                SearchMarker => {
-                    if self.expect_marker(byte, SEARCH_MARKER, true) {
-                        self.to_state(SearchBlock);
-                    }
-                }
-                SearchBlock => {
-                    if self.extend_block_range(byte, DIVIDER, NL_DIVIDER) {
-                        self.old_range = take(&mut self.block_range);
-                        self.to_state(ReplaceBlock);
-                    }
-                }
-                ReplaceBlock => {
-                    if self.extend_block_range(byte, REPLACE_MARKER, NL_REPLACE_MARKER) {
-                        self.new_range = take(&mut self.block_range);
-                        self.to_state(CloseFence);
-                    }
-                }
-                CloseFence => {
-                    if self.expect_marker(byte, FENCE, false) {
-                        self.action_source.push(byte);
-
-                        if let Some(action) = self.action() {
-                            actions.push(action);
-                        }
-
-                        self.errors();
-                        self.reset();
-
-                        continue;
-                    }
-                }
-            };
-
-            self.action_source.push(byte);
-        }
-
-        actions
-    }
-
-    /// Returns a reference to the errors encountered during parsing.
-    pub fn errors(&self) -> &[ParseError] {
-        &self.errors
-    }
-
-    fn action(&mut self) -> Option<(EditAction, String)> {
-        let old_range = take(&mut self.old_range);
-        let new_range = take(&mut self.new_range);
-
-        let action_source = take(&mut self.action_source);
-        let action_source = String::from_utf8(action_source).log_err()?;
-
-        let mut file_path_bytes = action_source[..self.fence_start_offset].to_owned();
-
-        if file_path_bytes.ends_with("\n") {
-            file_path_bytes.pop();
-            if file_path_bytes.ends_with("\r") {
-                file_path_bytes.pop();
-            }
-        }
-
-        let file_path = PathBuf::from(file_path_bytes);
-
-        if old_range.is_empty() {
-            return Some((
-                EditAction::Write {
-                    file_path,
-                    content: action_source[new_range].to_owned(),
-                },
-                action_source,
-            ));
-        }
-
-        let old = action_source[old_range].to_owned();
-        let new = action_source[new_range].to_owned();
-
-        let action = EditAction::Replace {
-            file_path,
-            old,
-            new,
-        };
-
-        Some((action, action_source))
-    }
-
-    fn to_state(&mut self, state: State) {
-        self.state = state;
-        self.marker_ix = 0;
-    }
-
-    fn reset(&mut self) {
-        self.action_source.clear();
-        self.block_range = Range::default();
-        self.old_range = Range::default();
-        self.new_range = Range::default();
-        self.fence_start_offset = 0;
-        self.marker_ix = 0;
-        self.to_state(State::Default);
-    }
-
-    fn expect_marker(&mut self, byte: u8, marker: &'static str, trailing_newline: bool) -> bool {
-        match self.match_marker(byte, marker, trailing_newline) {
-            MarkerMatch::Complete => true,
-            MarkerMatch::Partial => false,
-            MarkerMatch::None => {
-                self.errors.push(ParseError {
-                    line: self.line,
-                    column: self.column,
-                    expected: marker,
-                    found: byte,
-                });
-
-                self.reset();
-                false
-            }
-        }
-    }
-
-    fn extend_block_range(&mut self, byte: u8, marker: &str, nl_marker: &str) -> bool {
-        let marker = if self.block_range.is_empty() {
-            // do not require another newline if block is empty
-            marker
-        } else {
-            nl_marker
-        };
-
-        let offset = self.action_source.len();
-
-        match self.match_marker(byte, marker, true) {
-            MarkerMatch::Complete => {
-                if self.action_source[self.block_range.clone()].ends_with(b"\r") {
-                    self.block_range.end -= 1;
-                }
-
-                true
-            }
-            MarkerMatch::Partial => false,
-            MarkerMatch::None => {
-                if self.marker_ix > 0 {
-                    self.marker_ix = 0;
-                    self.block_range.end = offset;
-
-                    // The beginning of marker might match current byte
-                    match self.match_marker(byte, marker, true) {
-                        MarkerMatch::Complete => return true,
-                        MarkerMatch::Partial => return false,
-                        MarkerMatch::None => { /* no match, keep collecting */ }
-                    }
-                }
-
-                if self.block_range.is_empty() {
-                    self.block_range.start = offset;
-                }
-                self.block_range.end = offset + 1;
-
-                false
-            }
-        }
-    }
-
-    fn match_marker(&mut self, byte: u8, marker: &str, trailing_newline: bool) -> MarkerMatch {
-        if trailing_newline && self.marker_ix >= marker.len() {
-            if byte == b'\n' {
-                MarkerMatch::Complete
-            } else if byte == b'\r' {
-                MarkerMatch::Partial
-            } else {
-                MarkerMatch::None
-            }
-        } else if byte == marker.as_bytes()[self.marker_ix] {
-            self.marker_ix += 1;
-
-            if self.marker_ix < marker.len() || trailing_newline {
-                MarkerMatch::Partial
-            } else {
-                MarkerMatch::Complete
-            }
-        } else {
-            MarkerMatch::None
-        }
-    }
-}
-
-#[derive(Debug)]
-enum MarkerMatch {
-    None,
-    Partial,
-    Complete,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct ParseError {
-    line: usize,
-    column: usize,
-    expected: &'static str,
-    found: u8,
-}
-
-impl std::fmt::Display for ParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "input:{}:{}: Expected marker {:?}, found {:?}",
-            self.line, self.column, self.expected, self.found as char
-        )
-    }
-}
-
-pub fn edit_model_prompt() -> String {
-    include_str!("edit_prompt.md")
-        .to_string()
-        .replace("{{SEARCH_MARKER}}", SEARCH_MARKER)
-        .replace("{{DIVIDER}}", DIVIDER)
-        .replace("{{REPLACE_MARKER}}", REPLACE_MARKER)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rand::prelude::*;
-    use util::line_endings;
-
-    const WRONG_MARKER: &str = concat!(marker_sym!('<'), " WRONG_MARKER");
-
-    #[test]
-    fn test_simple_edit_action() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"src/main.rs
-```
-{}
-fn original() {{}}
-{}
-fn replacement() {{}}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 1);
-        assert_eq!(
-            actions[0].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old: "fn original() {}".to_string(),
-                new: "fn replacement() {}".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_with_language_tag() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"src/main.rs
-```rust
-{}
-fn original() {{}}
-{}
-fn replacement() {{}}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 1);
-        assert_eq!(
-            actions[0].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old: "fn original() {}".to_string(),
-                new: "fn replacement() {}".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_with_surrounding_text() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"Here's a modification I'd like to make to the file:
-
-src/main.rs
-```rust
-{}
-fn original() {{}}
-{}
-fn replacement() {{}}
-{}
-```
-
-This change makes the function better.
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 1);
-        assert_eq!(
-            actions[0].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old: "fn original() {}".to_string(),
-                new: "fn replacement() {}".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_multiple_edit_actions() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"First change:
-src/main.rs
-```
-{}
-fn original() {{}}
-{}
-fn replacement() {{}}
-{}
-```
-
-Second change:
-src/utils.rs
-```rust
-{}
-fn old_util() -> bool {{ false }}
-{}
-fn new_util() -> bool {{ true }}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER, SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 2);
-
-        let (action, _) = &actions[0];
-        assert_eq!(
-            action,
-            &EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old: "fn original() {}".to_string(),
-                new: "fn replacement() {}".to_string(),
-            }
-        );
-        let (action2, _) = &actions[1];
-        assert_eq!(
-            action2,
-            &EditAction::Replace {
-                file_path: PathBuf::from("src/utils.rs"),
-                old: "fn old_util() -> bool { false }".to_string(),
-                new: "fn new_util() -> bool { true }".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_multiline() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"src/main.rs
-```rust
-{}
-fn original() {{
-    println!("This is the original function");
-    let x = 42;
-    if x > 0 {{
-        println!("Positive number");
-    }}
-}}
-{}
-fn replacement() {{
-    println!("This is the replacement function");
-    let x = 100;
-    if x > 50 {{
-        println!("Large number");
-    }} else {{
-        println!("Small number");
-    }}
-}}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 1);
-
-        let (action, _) = &actions[0];
-        assert_eq!(
-            action,
-            &EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old: "fn original() {\n    println!(\"This is the original function\");\n    let x = 42;\n    if x > 0 {\n        println!(\"Positive number\");\n    }\n}".to_string(),
-                new: "fn replacement() {\n    println!(\"This is the replacement function\");\n    let x = 100;\n    if x > 50 {\n        println!(\"Large number\");\n    } else {\n        println!(\"Small number\");\n    }\n}".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_write_action() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"Create a new main.rs file:
-
-src/main.rs
-```rust
-{}
-{}
-fn new_function() {{
-    println!("This function is being added");
-}}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 1);
-        assert_eq!(
-            actions[0].0,
-            EditAction::Write {
-                file_path: PathBuf::from("src/main.rs"),
-                content: "fn new_function() {\n    println!(\"This function is being added\");\n}"
-                    .to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_empty_replace() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"src/main.rs
-```rust
-{}
-fn this_will_be_deleted() {{
-    println!("Deleting this function");
-}}
-{}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 1);
-        assert_eq!(
-            actions[0].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old: "fn this_will_be_deleted() {\n    println!(\"Deleting this function\");\n}"
-                    .to_string(),
-                new: "".to_string(),
-            }
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input.replace("\n", "\r\n"));
-        assert_no_errors(&parser);
-        assert_eq!(actions.len(), 1);
-        assert_eq!(
-            actions[0].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old:
-                    "fn this_will_be_deleted() {\r\n    println!(\"Deleting this function\");\r\n}"
-                        .to_string(),
-                new: "".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_empty_both() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"src/main.rs
-```rust
-{}
-{}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        assert_eq!(actions.len(), 1);
-        assert_eq!(
-            actions[0].0,
-            EditAction::Write {
-                file_path: PathBuf::from("src/main.rs"),
-                content: String::new(),
-            }
-        );
-        assert_no_errors(&parser);
-    }
-
-    #[test]
-    fn test_resumability() {
-        // Construct test input using format with multiline string literals
-        let input_part1 = format!("src/main.rs\n```rust\n{}\nfn ori", SEARCH_MARKER);
-
-        let input_part2 = format!("ginal() {{}}\n{}\nfn replacement() {{}}", DIVIDER);
-
-        let input_part3 = format!("\n{}\n```\n", REPLACE_MARKER);
-
-        let mut parser = EditActionParser::new();
-        let actions1 = parser.parse_chunk(&input_part1);
-        assert_no_errors(&parser);
-        assert_eq!(actions1.len(), 0);
-
-        let actions2 = parser.parse_chunk(&input_part2);
-        // No actions should be complete yet
-        assert_no_errors(&parser);
-        assert_eq!(actions2.len(), 0);
-
-        let actions3 = parser.parse_chunk(&input_part3);
-        // The third chunk should complete the action
-        assert_no_errors(&parser);
-        assert_eq!(actions3.len(), 1);
-        let (action, _) = &actions3[0];
-        assert_eq!(
-            action,
-            &EditAction::Replace {
-                file_path: PathBuf::from("src/main.rs"),
-                old: "fn original() {}".to_string(),
-                new: "fn replacement() {}".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn test_parser_state_preservation() {
-        let mut parser = EditActionParser::new();
-        let first_chunk = format!("src/main.rs\n```rust\n{}\n", SEARCH_MARKER);
-        let actions1 = parser.parse_chunk(&first_chunk);
-
-        // Check parser is in the correct state
-        assert_no_errors(&parser);
-        assert_eq!(parser.state, State::SearchBlock);
-        assert_eq!(parser.action_source, first_chunk.as_bytes());
-
-        // Continue parsing
-        let second_chunk = format!("original code\n{}\n", DIVIDER);
-        let actions2 = parser.parse_chunk(&second_chunk);
-
-        assert_no_errors(&parser);
-        assert_eq!(parser.state, State::ReplaceBlock);
-        assert_eq!(
-            &parser.action_source[parser.old_range.clone()],
-            b"original code"
-        );
-
-        let third_chunk = format!("replacement code\n{}\n```\n", REPLACE_MARKER);
-        let actions3 = parser.parse_chunk(&third_chunk);
-
-        // After complete parsing, state should reset
-        assert_no_errors(&parser);
-        assert_eq!(parser.state, State::Default);
-        assert_eq!(parser.action_source, b"\n");
-        assert!(parser.old_range.is_empty());
-        assert!(parser.new_range.is_empty());
-
-        assert_eq!(actions1.len(), 0);
-        assert_eq!(actions2.len(), 0);
-        assert_eq!(actions3.len(), 1);
-    }
-
-    #[test]
-    fn test_invalid_search_marker() {
-        let input = format!(
-            r#"src/main.rs
-```rust
-{}
-fn original() {{}}
-{}
-fn replacement() {{}}
-{}
-```
-"#,
-            WRONG_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-        assert_eq!(actions.len(), 0);
-
-        assert_eq!(parser.errors().len(), 1);
-        let error = &parser.errors()[0];
-
-        assert_eq!(
-            error.to_string(),
-            format!(
-                "input:3:9: Expected marker \"{}\", found 'W'",
-                SEARCH_MARKER
-            )
-        );
-    }
-
-    #[test]
-    fn test_missing_closing_fence() {
-        // Construct test input using format with multiline string literals
-        let input = format!(
-            r#"src/main.rs
-```rust
-{}
-fn original() {{}}
-{}
-fn replacement() {{}}
-{}
-<!-- Missing closing fence -->
-
-src/utils.rs
-```rust
-{}
-fn utils_func() {{}}
-{}
-fn new_utils_func() {{}}
-{}
-```
-"#,
-            SEARCH_MARKER, DIVIDER, REPLACE_MARKER, SEARCH_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&input);
-
-        // Only the second block should be parsed
-        assert_eq!(actions.len(), 1);
-        let (action, _) = &actions[0];
-        assert_eq!(
-            action,
-            &EditAction::Replace {
-                file_path: PathBuf::from("src/utils.rs"),
-                old: "fn utils_func() {}".to_string(),
-                new: "fn new_utils_func() {}".to_string(),
-            }
-        );
-        assert_eq!(parser.errors().len(), 1);
-        assert_eq!(
-            parser.errors()[0].to_string(),
-            "input:8:1: Expected marker \"```\", found '<'"
-        );
-
-        // The parser should continue after an error
-        assert_eq!(parser.state, State::Default);
-    }
-
-    #[test]
-    fn test_parse_examples_in_edit_prompt() {
-        let mut parser = EditActionParser::new();
-        let actions = parser.parse_chunk(&edit_model_prompt());
-        assert_examples_in_edit_prompt(&actions, parser.errors());
-    }
-
-    #[gpui::test(iterations = 10)]
-    fn test_random_chunking_of_edit_prompt(mut rng: StdRng) {
-        let mut parser = EditActionParser::new();
-        let mut remaining: &str = &edit_model_prompt();
-        let mut actions = Vec::with_capacity(5);
-
-        while !remaining.is_empty() {
-            let chunk_size = rng.gen_range(1..=std::cmp::min(remaining.len(), 100));
-
-            let (chunk, rest) = remaining.split_at(chunk_size);
-
-            let chunk_actions = parser.parse_chunk(chunk);
-            actions.extend(chunk_actions);
-            remaining = rest;
-        }
-
-        assert_examples_in_edit_prompt(&actions, parser.errors());
-    }
-
-    fn assert_examples_in_edit_prompt(actions: &[(EditAction, String)], errors: &[ParseError]) {
-        assert_eq!(actions.len(), 5);
-
-        assert_eq!(
-            actions[0].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("mathweb/flask/app.py"),
-                old: "from flask import Flask".to_string(),
-                new: line_endings!("import math\nfrom flask import Flask").to_string(),
-            },
-        );
-
-        assert_eq!(
-            actions[1].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("mathweb/flask/app.py"),
-                old: line_endings!("def factorial(n):\n    \"compute factorial\"\n\n    if n == 0:\n        return 1\n    else:\n        return n * factorial(n-1)\n").to_string(),
-                new: "".to_string(),
-            }
-        );
-
-        assert_eq!(
-            actions[2].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("mathweb/flask/app.py"),
-                old: "    return str(factorial(n))".to_string(),
-                new: "    return str(math.factorial(n))".to_string(),
-            },
-        );
-
-        assert_eq!(
-            actions[3].0,
-            EditAction::Write {
-                file_path: PathBuf::from("hello.py"),
-                content: line_endings!(
-                    "def hello():\n    \"print a greeting\"\n\n    print(\"hello\")"
-                )
-                .to_string(),
-            },
-        );
-
-        assert_eq!(
-            actions[4].0,
-            EditAction::Replace {
-                file_path: PathBuf::from("main.py"),
-                old: line_endings!(
-                    "def hello():\n    \"print a greeting\"\n\n    print(\"hello\")"
-                )
-                .to_string(),
-                new: "from hello import hello".to_string(),
-            },
-        );
-
-        // The system prompt includes some text that would produce errors
-        assert_eq!(
-            errors[0].to_string(),
-            format!(
-                "input:102:1: Expected marker \"{}\", found '3'",
-                SEARCH_MARKER
-            )
-        );
-        #[cfg(not(windows))]
-        assert_eq!(
-            errors[1].to_string(),
-            format!(
-                "input:109:0: Expected marker \"{}\", found '\\n'",
-                SEARCH_MARKER
-            )
-        );
-        #[cfg(windows)]
-        assert_eq!(
-            errors[1].to_string(),
-            format!(
-                "input:108:1: Expected marker \"{}\", found '\\r'",
-                SEARCH_MARKER
-            )
-        );
-    }
-
-    #[test]
-    fn test_print_error() {
-        let input = format!(
-            r#"src/main.rs
-```rust
-{}
-fn original() {{}}
-{}
-fn replacement() {{}}
-{}
-```
-"#,
-            WRONG_MARKER, DIVIDER, REPLACE_MARKER
-        );
-
-        let mut parser = EditActionParser::new();
-        parser.parse_chunk(&input);
-
-        assert_eq!(parser.errors().len(), 1);
-        let error = &parser.errors()[0];
-        let expected_error = format!(
-            r#"input:3:9: Expected marker "{}", found 'W'"#,
-            SEARCH_MARKER
-        );
-
-        assert_eq!(format!("{}", error), expected_error);
-    }
-
-    // helpers
-
-    fn assert_no_errors(parser: &EditActionParser) {
-        let errors = parser.errors();
-
-        assert!(
-            errors.is_empty(),
-            "Expected no errors, but found:\n\n{}",
-            errors
-                .iter()
-                .map(|e| e.to_string())
-                .collect::<Vec<String>>()
-                .join("\n")
-        );
-    }
-}

crates/assistant_tools/src/edit_files_tool/edit_prompt.md

@@ -1,134 +0,0 @@
-Act as an expert software developer.
-Always use best practices when coding.
-Respect and use existing conventions, libraries, etc that are already present in the code base.
-
-Take requests for changes to the supplied code.
-Always reply to the user in the same language they are using.
-
-Once you understand the request, you MUST:
-
-1. Decide if you need to propose *SEARCH/REPLACE* edits to any files that haven't been added to the chat. You can create new files without asking!
-
-2. Think step-by-step and explain the needed changes in a few short sentences.
-
-3. Describe each change with a *SEARCH/REPLACE block* per the examples below.
-
-All changes to files must use this *SEARCH/REPLACE block* format.
-ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
-
-# Example conversations:
-
-## USER: Change get_factorial() to use math.factorial
-
-## ASSISTANT: To make this change we need to modify `mathweb/flask/app.py` to:
-
-1. Import the math package.
-2. Remove the existing factorial() function.
-3. Update get_factorial() to call math.factorial instead.
-
-Here are the *SEARCH/REPLACE* blocks:
-
-mathweb/flask/app.py
-```python
-{{SEARCH_MARKER}}
-from flask import Flask
-{{DIVIDER}}
-import math
-from flask import Flask
-{{REPLACE_MARKER}}
-```
-
-mathweb/flask/app.py
-```python
-{{SEARCH_MARKER}}
-def factorial(n):
-    "compute factorial"
-
-    if n == 0:
-        return 1
-    else:
-        return n * factorial(n-1)
-
-{{DIVIDER}}
-{{REPLACE_MARKER}}
-```
-
-mathweb/flask/app.py
-```python
-{{SEARCH_MARKER}}
-    return str(factorial(n))
-{{DIVIDER}}
-    return str(math.factorial(n))
-{{REPLACE_MARKER}}
-```
-
-
-## USER: Refactor hello() into its own file.
-
-## ASSISTANT: To make this change we need to modify `main.py` and make a new file `hello.py`:
-
-1. Make a new hello.py file with hello() in it.
-2. Remove hello() from main.py and replace it with an import.
-
-Here are the *SEARCH/REPLACE* blocks:
-
-hello.py
-```python
-{{SEARCH_MARKER}}
-{{DIVIDER}}
-def hello():
-    "print a greeting"
-
-    print("hello")
-{{REPLACE_MARKER}}
-```
-
-main.py
-```python
-{{SEARCH_MARKER}}
-def hello():
-    "print a greeting"
-
-    print("hello")
-{{DIVIDER}}
-from hello import hello
-{{REPLACE_MARKER}}
-```
-# *SEARCH/REPLACE block* Rules:
-
-Every *SEARCH/REPLACE block* must use this format:
-1. The *FULL* file path alone on a line, verbatim. No bold asterisks, no quotes around it, no escaping of characters, etc.
-2. The opening fence and code language, eg: ```python
-3. The start of search block: {{SEARCH_MARKER}}
-4. A contiguous chunk of lines to search for in the existing source code
-5. The dividing line: {{DIVIDER}}
-6. The lines to replace into the source code
-7. The end of the replace block: {{REPLACE_MARKER}}
-8. The closing fence: ```
-
-Use the *FULL* file path, as shown to you by the user. Make sure to include the project's root directory name at the start of the path. *NEVER* specify the absolute path of the file!
-
-Every *SEARCH* section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, etc.
-If the file contains code or other data wrapped/escaped in json/xml/quotes or other containers, you need to propose edits to the literal contents of the file, including the container markup.
-
-*SEARCH/REPLACE* blocks will *only* replace the first match occurrence.
-Including multiple unique *SEARCH/REPLACE* blocks if needed.
-Include enough lines in each SEARCH section to uniquely match each set of lines that need to change.
-
-Keep *SEARCH/REPLACE* blocks concise.
-Break large *SEARCH/REPLACE* blocks into a series of smaller blocks that each change a small portion of the file.
-Include just the changing lines, and a few surrounding lines if needed for uniqueness.
-Do not include long runs of unchanging lines in *SEARCH/REPLACE* blocks.
-
-Only create *SEARCH/REPLACE* blocks for files that have been read! Even though the conversation includes `read-file` tool results, you *CANNOT* issue your own reads. If the conversation doesn't include the code you need to edit, ask for it to be read explicitly.
-
-To move code within a file, use 2 *SEARCH/REPLACE* blocks: 1 to delete it from its current location, 1 to insert it in the new location.
-
-Pay attention to which filenames the user wants you to edit, especially if they are asking you to create a new file.
-
-If you want to put code in a new file, use a *SEARCH/REPLACE block* with:
-- A new file path, including dir name if needed
-- An empty `SEARCH` section
-- The new file's contents in the `REPLACE` section
-
-ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!

crates/assistant_tools/src/edit_files_tool/log.rs

@@ -1,417 +0,0 @@
-use std::path::Path;
-
-use collections::HashSet;
-use feature_flags::FeatureFlagAppExt;
-use gpui::{
-    App, Empty, Entity, EventEmitter, FocusHandle, Focusable, Global, ListAlignment, ListState,
-    SharedString, Subscription, Window, actions, list, prelude::*,
-};
-use release_channel::ReleaseChannel;
-use settings::Settings;
-use ui::prelude::*;
-use workspace::{Item, Workspace, WorkspaceId, item::ItemEvent};
-
-use super::edit_action::EditAction;
-
-actions!(debug, [EditTool]);
-
-pub fn init(cx: &mut App) {
-    if cx.is_staff() || ReleaseChannel::global(cx) == ReleaseChannel::Dev {
-        // Track events even before opening the log
-        EditToolLog::global(cx);
-    }
-
-    cx.observe_new(|workspace: &mut Workspace, _, _| {
-        workspace.register_action(|workspace, _: &EditTool, window, cx| {
-            let viewer = cx.new(EditToolLogViewer::new);
-            workspace.add_item_to_active_pane(Box::new(viewer), None, true, window, cx)
-        });
-    })
-    .detach();
-}
-
-pub struct GlobalEditToolLog(Entity<EditToolLog>);
-
-impl Global for GlobalEditToolLog {}
-
-#[derive(Default)]
-pub struct EditToolLog {
-    requests: Vec<EditToolRequest>,
-}
-
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
-pub struct EditToolRequestId(u32);
-
-impl EditToolLog {
-    pub fn global(cx: &mut App) -> Entity<Self> {
-        match Self::try_global(cx) {
-            Some(entity) => entity,
-            None => {
-                let entity = cx.new(|_cx| Self::default());
-                cx.set_global(GlobalEditToolLog(entity.clone()));
-                entity
-            }
-        }
-    }
-
-    pub fn try_global(cx: &App) -> Option<Entity<Self>> {
-        cx.try_global::<GlobalEditToolLog>()
-            .map(|log| log.0.clone())
-    }
-
-    pub fn new_request(
-        &mut self,
-        instructions: String,
-        cx: &mut Context<Self>,
-    ) -> EditToolRequestId {
-        let id = EditToolRequestId(self.requests.len() as u32);
-        self.requests.push(EditToolRequest {
-            id,
-            instructions,
-            editor_response: None,
-            tool_output: None,
-            parsed_edits: Vec::new(),
-        });
-        cx.emit(EditToolLogEvent::Inserted);
-        id
-    }
-
-    pub fn push_editor_response_chunk(
-        &mut self,
-        id: EditToolRequestId,
-        chunk: &str,
-        new_actions: &[(EditAction, String)],
-        cx: &mut Context<Self>,
-    ) {
-        if let Some(request) = self.requests.get_mut(id.0 as usize) {
-            match &mut request.editor_response {
-                None => {
-                    request.editor_response = Some(chunk.to_string());
-                }
-                Some(response) => {
-                    response.push_str(chunk);
-                }
-            }
-            request
-                .parsed_edits
-                .extend(new_actions.iter().cloned().map(|(action, _)| action));
-
-            cx.emit(EditToolLogEvent::Updated);
-        }
-    }
-
-    pub fn set_tool_output(
-        &mut self,
-        id: EditToolRequestId,
-        tool_output: Result<String, String>,
-        cx: &mut Context<Self>,
-    ) {
-        if let Some(request) = self.requests.get_mut(id.0 as usize) {
-            request.tool_output = Some(tool_output);
-            cx.emit(EditToolLogEvent::Updated);
-        }
-    }
-}
-
-enum EditToolLogEvent {
-    Inserted,
-    Updated,
-}
-
-impl EventEmitter<EditToolLogEvent> for EditToolLog {}
-
-pub struct EditToolRequest {
-    id: EditToolRequestId,
-    instructions: String,
-    // we don't use a result here because the error might have occurred after we got a response
-    editor_response: Option<String>,
-    parsed_edits: Vec<EditAction>,
-    tool_output: Option<Result<String, String>>,
-}
-
-pub struct EditToolLogViewer {
-    focus_handle: FocusHandle,
-    log: Entity<EditToolLog>,
-    list_state: ListState,
-    expanded_edits: HashSet<(EditToolRequestId, usize)>,
-    _subscription: Subscription,
-}
-
-impl EditToolLogViewer {
-    pub fn new(cx: &mut Context<Self>) -> Self {
-        let log = EditToolLog::global(cx);
-
-        let subscription = cx.subscribe(&log, Self::handle_log_event);
-
-        Self {
-            focus_handle: cx.focus_handle(),
-            log: log.clone(),
-            list_state: ListState::new(
-                log.read(cx).requests.len(),
-                ListAlignment::Bottom,
-                px(1024.),
-                {
-                    let this = cx.entity().downgrade();
-                    move |ix, window: &mut Window, cx: &mut App| {
-                        this.update(cx, |this, cx| this.render_request(ix, window, cx))
-                            .unwrap()
-                    }
-                },
-            ),
-            expanded_edits: HashSet::default(),
-            _subscription: subscription,
-        }
-    }
-
-    fn handle_log_event(
-        &mut self,
-        _: Entity<EditToolLog>,
-        event: &EditToolLogEvent,
-        cx: &mut Context<Self>,
-    ) {
-        match event {
-            EditToolLogEvent::Inserted => {
-                let count = self.list_state.item_count();
-                self.list_state.splice(count..count, 1);
-            }
-            EditToolLogEvent::Updated => {}
-        }
-
-        cx.notify();
-    }
-
-    fn render_request(
-        &self,
-        index: usize,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> AnyElement {
-        let requests = &self.log.read(cx).requests;
-        let request = &requests[index];
-
-        v_flex()
-            .gap_3()
-            .child(Self::render_section(IconName::ArrowRight, "Tool Input"))
-            .child(request.instructions.clone())
-            .py_5()
-            .when(index + 1 < requests.len(), |element| {
-                element
-                    .border_b_1()
-                    .border_color(cx.theme().colors().border)
-            })
-            .map(|parent| match &request.editor_response {
-                None => {
-                    if request.tool_output.is_none() {
-                        parent.child("...")
-                    } else {
-                        parent
-                    }
-                }
-                Some(response) => parent
-                    .child(Self::render_section(
-                        IconName::ZedAssistant,
-                        "Editor Response",
-                    ))
-                    .child(Label::new(response.clone()).buffer_font(cx)),
-            })
-            .when(!request.parsed_edits.is_empty(), |parent| {
-                parent
-                    .child(Self::render_section(IconName::Microscope, "Parsed Edits"))
-                    .child(
-                        v_flex()
-                            .gap_2()
-                            .children(request.parsed_edits.iter().enumerate().map(
-                                |(index, edit)| {
-                                    self.render_edit_action(edit, request.id, index, cx)
-                                },
-                            )),
-                    )
-            })
-            .when_some(request.tool_output.as_ref(), |parent, output| {
-                parent
-                    .child(Self::render_section(IconName::ArrowLeft, "Tool Output"))
-                    .child(match output {
-                        Ok(output) => Label::new(output.clone()).color(Color::Success),
-                        Err(error) => Label::new(error.clone()).color(Color::Error),
-                    })
-            })
-            .into_any()
-    }
-
-    fn render_section(icon: IconName, title: &'static str) -> AnyElement {
-        h_flex()
-            .gap_1()
-            .child(Icon::new(icon).color(Color::Muted))
-            .child(Label::new(title).size(LabelSize::Small).color(Color::Muted))
-            .into_any()
-    }
-
-    fn render_edit_action(
-        &self,
-        edit_action: &EditAction,
-        request_id: EditToolRequestId,
-        index: usize,
-        cx: &Context<Self>,
-    ) -> AnyElement {
-        let expanded_id = (request_id, index);
-
-        match edit_action {
-            EditAction::Replace {
-                file_path,
-                old,
-                new,
-            } => self
-                .render_edit_action_container(
-                    expanded_id,
-                    &file_path,
-                    [
-                        Self::render_block(IconName::MagnifyingGlass, "Search", old.clone(), cx)
-                            .border_r_1()
-                            .border_color(cx.theme().colors().border)
-                            .into_any(),
-                        Self::render_block(IconName::Replace, "Replace", new.clone(), cx)
-                            .into_any(),
-                    ],
-                    cx,
-                )
-                .into_any(),
-            EditAction::Write { file_path, content } => self
-                .render_edit_action_container(
-                    expanded_id,
-                    &file_path,
-                    [
-                        Self::render_block(IconName::Pencil, "Write", content.clone(), cx)
-                            .into_any(),
-                    ],
-                    cx,
-                )
-                .into_any(),
-        }
-    }
-
-    fn render_edit_action_container(
-        &self,
-        expanded_id: (EditToolRequestId, usize),
-        file_path: &Path,
-        content: impl IntoIterator<Item = AnyElement>,
-        cx: &Context<Self>,
-    ) -> AnyElement {
-        let is_expanded = self.expanded_edits.contains(&expanded_id);
-
-        v_flex()
-            .child(
-                h_flex()
-                    .bg(cx.theme().colors().element_background)
-                    .border_1()
-                    .border_color(cx.theme().colors().border)
-                    .rounded_t_md()
-                    .when(!is_expanded, |el| el.rounded_b_md())
-                    .py_1()
-                    .px_2()
-                    .gap_1()
-                    .child(
-                        ui::Disclosure::new(ElementId::Integer(expanded_id.1), is_expanded)
-                            .on_click(cx.listener(move |this, _ev, _window, cx| {
-                                if is_expanded {
-                                    this.expanded_edits.remove(&expanded_id);
-                                } else {
-                                    this.expanded_edits.insert(expanded_id);
-                                }
-
-                                cx.notify();
-                            })),
-                    )
-                    .child(Label::new(file_path.display().to_string()).size(LabelSize::Small)),
-            )
-            .child(if is_expanded {
-                h_flex()
-                    .border_1()
-                    .border_t_0()
-                    .border_color(cx.theme().colors().border)
-                    .rounded_b_md()
-                    .children(content)
-                    .into_any()
-            } else {
-                Empty.into_any()
-            })
-            .into_any()
-    }
-
-    fn render_block(icon: IconName, title: &'static str, content: String, cx: &App) -> Div {
-        v_flex()
-            .p_1()
-            .gap_1()
-            .flex_1()
-            .h_full()
-            .child(
-                h_flex()
-                    .gap_1()
-                    .child(Icon::new(icon).color(Color::Muted))
-                    .child(Label::new(title).size(LabelSize::Small).color(Color::Muted)),
-            )
-            .font(theme::ThemeSettings::get_global(cx).buffer_font.clone())
-            .text_sm()
-            .child(content)
-            .child(div().flex_1())
-    }
-}
-
-impl EventEmitter<()> for EditToolLogViewer {}
-
-impl Focusable for EditToolLogViewer {
-    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-
-impl Item for EditToolLogViewer {
-    type Event = ();
-
-    fn to_item_events(_: &Self::Event, _: impl FnMut(ItemEvent)) {}
-
-    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
-        Some("Edit Tool Log".into())
-    }
-
-    fn telemetry_event_text(&self) -> Option<&'static str> {
-        None
-    }
-
-    fn clone_on_split(
-        &self,
-        _workspace_id: Option<WorkspaceId>,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<Entity<Self>>
-    where
-        Self: Sized,
-    {
-        Some(cx.new(Self::new))
-    }
-}
-
-impl Render for EditToolLogViewer {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        if self.list_state.item_count() == 0 {
-            return v_flex()
-                .justify_center()
-                .size_full()
-                .gap_1()
-                .bg(cx.theme().colors().editor_background)
-                .text_center()
-                .text_lg()
-                .child("No requests yet")
-                .child(
-                    div()
-                        .text_ui(cx)
-                        .child("Go ask the assistant to perform some edits"),
-                );
-        }
-
-        v_flex()
-            .p_4()
-            .bg(cx.theme().colors().editor_background)
-            .size_full()
-            .child(list(self.list_state.clone()).flex_grow())
-    }
-}

crates/assistant_tools/src/read_file_tool.rs

@@ -1,6 +1,6 @@
-use std::path::Path;
 use std::sync::Arc;
 
+use crate::code_symbols_tool::file_outline;
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool};
@@ -13,6 +13,11 @@ use serde::{Deserialize, Serialize};
 use ui::IconName;
 use util::markdown::MarkdownString;
 
+/// 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,
+/// and suggest trying again using line ranges from the outline.
+const MAX_FILE_SIZE_TO_READ: usize = 4096;
+
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ReadFileToolInput {
     /// The relative path of the file to read.
@@ -26,10 +31,10 @@ pub struct ReadFileToolInput {
     /// - directory1
     /// - directory2
     ///
-    /// If you wanna access `file.txt` in `directory1`, you should use the path `directory1/file.txt`.
-    /// If you wanna access `file.txt` in `directory2`, you should use the path `directory2/file.txt`.
+    /// If you want to access `file.txt` in `directory1`, you should use the path `directory1/file.txt`.
+    /// If you want to access `file.txt` in `directory2`, you should use the path `directory2/file.txt`.
     /// </example>
-    pub path: Arc<Path>,
+    pub path: String,
 
     /// Optional line number to start reading on (1-based index)
     #[serde(default)]
@@ -66,8 +71,12 @@ 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.display().to_string());
-                format!("Read file {path}")
+                let path = MarkdownString::inline_code(&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})"),
+                    _ => format!("Read file {path}"),
+                }
             }
             Err(_) => "Read file".to_string(),
         }
@@ -87,12 +96,10 @@ impl Tool for ReadFileTool {
         };
 
         let Some(project_path) = project.read(cx).find_project_path(&input.path, cx) else {
-            return Task::ready(Err(anyhow!(
-                "Path {} not found in project",
-                &input.path.display()
-            )));
+            return Task::ready(Err(anyhow!("Path {} not found in project", &input.path,)));
         };
 
+        let file_path = input.path.clone();
         cx.spawn(async move |cx| {
             let buffer = cx
                 .update(|cx| {
@@ -100,27 +107,46 @@ impl Tool for ReadFileTool {
                 })?
                 .await?;
 
-            let result = buffer.read_with(cx, |buffer, _cx| {
-                let text = buffer.text();
-                if input.start_line.is_some() || input.end_line.is_some() {
+            // Check if specific line ranges are provided
+            if input.start_line.is_some() || input.end_line.is_some() {
+                let result = buffer.read_with(cx, |buffer, _cx| {
+                    let text = buffer.text();
                     let start = input.start_line.unwrap_or(1);
                     let lines = text.split('\n').skip(start - 1);
                     if let Some(end) = input.end_line {
-                        let count = end.saturating_sub(start);
+                        let count = end.saturating_sub(start).max(1); // Ensure at least 1 line
                         Itertools::intersperse(lines.take(count), "\n").collect()
                     } else {
                         Itertools::intersperse(lines, "\n").collect()
                     }
+                })?;
+
+                action_log.update(cx, |log, cx| {
+                    log.buffer_read(buffer, cx);
+                })?;
+
+                Ok(result)
+            } else {
+                // No line ranges specified, so check file size to see if it's too big.
+                let file_size = buffer.read_with(cx, |buffer, _cx| buffer.text().len())?;
+
+                if file_size <= MAX_FILE_SIZE_TO_READ {
+                    // File is small enough, so return its contents.
+                    let result = buffer.read_with(cx, |buffer, _cx| buffer.text())?;
+
+                    action_log.update(cx, |log, cx| {
+                        log.buffer_read(buffer, cx);
+                    })?;
+
+                    Ok(result)
                 } else {
-                    text
+                    // File is too big, so return an error with the outline
+                    // and a suggestion to read again with line numbers.
+                    let outline = file_outline(project, file_path, action_log, None, 0, cx).await?;
+
+                    Ok(format!("This file was too big to read all at once. Here is an outline of its symbols:\n\n{outline}\n\nUsing the line numbers in this outline, you can call this tool again while specifying the start_line and end_line fields to see the implementations of symbols in the outline."))
                 }
-            })?;
-
-            action_log.update(cx, |log, cx| {
-                log.buffer_read(buffer, cx);
-            })?;
-
-            anyhow::Ok(result)
+            }
         })
     }
 }

crates/assistant_tools/src/read_file_tool/description.md

@@ -1 +1,6 @@
 Reads the content of the given file in the project.
+
+If the file is too big to read all at once, and neither a start line
+nor an end line was specified, then this returns an outline of the
+file's symbols (with line numbers) instead of the file's contents,
+so that it can be called again with line ranges.

crates/audio/Cargo.toml

@@ -20,3 +20,4 @@ gpui.workspace = true
 parking_lot.workspace = true
 rodio = { version = "0.20.0", default-features = false, features = ["wav"] }
 util.workspace = true
+workspace-hack.workspace = true

crates/auto_update/Cargo.toml

@@ -29,3 +29,4 @@ smol.workspace = true
 tempfile.workspace = true
 which.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true

crates/auto_update_ui/Cargo.toml

@@ -25,3 +25,4 @@ serde_json.workspace = true
 smol.workspace = true
 util.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true

crates/aws_http_client/Cargo.toml

@@ -20,3 +20,4 @@ aws-smithy-types.workspace = true
 futures.workspace = true
 http_client.workspace = true
 tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
+workspace-hack.workspace = true

crates/aws_http_client/src/aws_http_client.rs

@@ -9,7 +9,7 @@ use aws_smithy_runtime_api::client::http::{
 use aws_smithy_runtime_api::client::orchestrator::{HttpRequest as AwsHttpRequest, HttpResponse};
 use aws_smithy_runtime_api::client::result::ConnectorError;
 use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
-use aws_smithy_runtime_api::http::StatusCode;
+use aws_smithy_runtime_api::http::{Headers, StatusCode};
 use aws_smithy_types::body::SdkBody;
 use futures::AsyncReadExt;
 use http_client::{AsyncBody, Inner};
@@ -52,10 +52,17 @@ impl AwsConnector for AwsHttpConnector {
             let (parts, body) = response.into_parts();
             let body = convert_to_sdk_body(body, handle).await;
 
-            Ok(HttpResponse::new(
-                StatusCode::try_from(parts.status.as_u16()).unwrap(),
-                body,
-            ))
+            let mut response =
+                HttpResponse::new(StatusCode::try_from(parts.status.as_u16()).unwrap(), body);
+
+            let headers = match Headers::try_from(parts.headers) {
+                Ok(headers) => headers,
+                Err(err) => return Err(ConnectorError::other(err.into(), None)),
+            };
+
+            *response.headers_mut() = headers;
+
+            Ok(response)
         })
     }
 }

crates/bedrock/Cargo.toml

@@ -26,3 +26,4 @@ serde_json.workspace = true
 strum.workspace = true
 thiserror.workspace = true
 tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
+workspace-hack.workspace = true

crates/bedrock/src/bedrock.rs

@@ -1,21 +1,25 @@
 mod models;
 
+use std::collections::HashMap;
 use std::pin::Pin;
 
-use anyhow::{Context, Error, Result, anyhow};
+use anyhow::{Error, Result, anyhow};
 use aws_sdk_bedrockruntime as bedrock;
 pub use aws_sdk_bedrockruntime as bedrock_client;
 pub use aws_sdk_bedrockruntime::types::{
-    ContentBlock as BedrockInnerContent, SpecificToolChoice as BedrockSpecificTool,
-    ToolChoice as BedrockToolChoice, ToolInputSchema as BedrockToolInputSchema,
-    ToolSpecification as BedrockTool,
+    AutoToolChoice as BedrockAutoToolChoice, ContentBlock as BedrockInnerContent,
+    Tool as BedrockTool, ToolChoice as BedrockToolChoice, ToolConfiguration as BedrockToolConfig,
+    ToolInputSchema as BedrockToolInputSchema, ToolSpecification as BedrockToolSpec,
 };
 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,
-    Message as BedrockMessage, ResponseStream as BedrockResponseStream,
+    ImageBlock as BedrockImageBlock, Message as BedrockMessage,
+    ResponseStream as BedrockResponseStream, ToolResultBlock as BedrockToolResultBlock,
+    ToolResultContentBlock as BedrockToolResultContentBlock,
+    ToolResultStatus as BedrockToolResultStatus, ToolUseBlock as BedrockToolUseBlock,
 };
 use futures::stream::{self, BoxStream, Stream};
 use serde::{Deserialize, Serialize};
@@ -24,25 +28,6 @@ use thiserror::Error;
 
 pub use crate::models::*;
 
-pub async fn complete(
-    client: &bedrock::Client,
-    request: Request,
-) -> Result<BedrockResponse, BedrockError> {
-    let response = bedrock::Client::converse(client)
-        .model_id(request.model.clone())
-        .set_messages(request.messages.into())
-        .send()
-        .await
-        .context("failed to send request to Bedrock");
-
-    match response {
-        Ok(output) => output
-            .output
-            .ok_or_else(|| BedrockError::Other(anyhow!("no output"))),
-        Err(err) => Err(BedrockError::Other(err)),
-    }
-}
-
 pub async fn stream_completion(
     client: bedrock::Client,
     request: Request,
@@ -50,11 +35,32 @@ pub async fn stream_completion(
 ) -> Result<BoxStream<'static, Result<BedrockStreamingResponse, BedrockError>>, Error> {
     handle
         .spawn(async move {
-            let response = bedrock::Client::converse_stream(&client)
+            let mut response = bedrock::Client::converse_stream(&client)
                 .model_id(request.model.clone())
-                .set_messages(request.messages.into())
-                .send()
-                .await;
+                .set_messages(request.messages.into());
+
+            if let Some(Thinking::Enabled {
+                budget_tokens: Some(budget_tokens),
+            }) = request.thinking
+            {
+                response =
+                    response.additional_model_request_fields(Document::Object(HashMap::from([(
+                        "thinking".to_string(),
+                        Document::from(HashMap::from([
+                            ("type".to_string(), Document::String("enabled".to_string())),
+                            (
+                                "budget_tokens".to_string(),
+                                Document::Number(AwsNumber::PosInt(budget_tokens)),
+                            ),
+                        ])),
+                    )])));
+            }
+
+            if request.tools.is_some() && !request.tools.as_ref().unwrap().tools.is_empty() {
+                response = response.set_tool_config(request.tools);
+            }
+
+            let response = response.send().await;
 
             match response {
                 Ok(output) => {
@@ -65,7 +71,7 @@ pub async fn stream_completion(
                         >,
                     > = Box::pin(stream::unfold(output.stream, |mut stream| async move {
                         match stream.recv().await {
-                            Ok(Some(output)) => Some((Ok(output), stream)),
+                            Ok(Some(output)) => Some(({ Ok(output) }, stream)),
                             Ok(None) => None,
                             Err(err) => {
                                 Some((
@@ -135,13 +141,18 @@ pub fn value_to_aws_document(value: &Value) -> Document {
     }
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Thinking {
+    Enabled { budget_tokens: Option<u64> },
+}
+
 #[derive(Debug)]
 pub struct Request {
     pub model: String,
     pub max_tokens: u32,
     pub messages: Vec<BedrockMessage>,
-    pub tools: Vec<BedrockTool>,
-    pub tool_choice: Option<BedrockToolChoice>,
+    pub tools: Option<BedrockToolConfig>,
+    pub thinking: Option<Thinking>,
     pub system: Option<String>,
     pub metadata: Option<Metadata>,
     pub stop_sequences: Vec<String>,

crates/bedrock/src/models.rs

@@ -2,21 +2,38 @@ use anyhow::anyhow;
 use serde::{Deserialize, Serialize};
 use strum::EnumIter;
 
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub enum BedrockModelMode {
+    #[default]
+    Default,
+    Thinking {
+        budget_tokens: Option<u64>,
+    },
+}
+
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
     // Anthropic models (already included)
     #[default]
     #[serde(rename = "claude-3-5-sonnet-v2", alias = "claude-3-5-sonnet-latest")]
-    Claude3_5Sonnet,
+    Claude3_5SonnetV2,
     #[serde(rename = "claude-3-7-sonnet", alias = "claude-3-7-sonnet-latest")]
     Claude3_7Sonnet,
+    #[serde(
+        rename = "claude-3-7-sonnet-thinking",
+        alias = "claude-3-7-sonnet-thinking-latest"
+    )]
+    Claude3_7SonnetThinking,
     #[serde(rename = "claude-3-opus", alias = "claude-3-opus-latest")]
     Claude3Opus,
     #[serde(rename = "claude-3-sonnet", alias = "claude-3-sonnet-latest")]
     Claude3Sonnet,
     #[serde(rename = "claude-3-5-haiku", alias = "claude-3-5-haiku-latest")]
     Claude3_5Haiku,
+    Claude3_5Sonnet,
+    Claude3Haiku,
     // Amazon Nova Models
     AmazonNovaLite,
     AmazonNovaMicro,
@@ -69,7 +86,7 @@ pub enum Model {
 impl Model {
     pub fn from_id(id: &str) -> anyhow::Result<Self> {
         if id.starts_with("claude-3-5-sonnet-v2") {
-            Ok(Self::Claude3_5Sonnet)
+            Ok(Self::Claude3_5SonnetV2)
         } else if id.starts_with("claude-3-opus") {
             Ok(Self::Claude3Opus)
         } else if id.starts_with("claude-3-sonnet") {
@@ -78,6 +95,8 @@ impl Model {
             Ok(Self::Claude3_5Haiku)
         } else if id.starts_with("claude-3-7-sonnet") {
             Ok(Self::Claude3_7Sonnet)
+        } else if id.starts_with("claude-3-7-sonnet-thinking") {
+            Ok(Self::Claude3_7SonnetThinking)
         } else {
             Err(anyhow!("invalid model id"))
         }
@@ -85,14 +104,18 @@ impl Model {
 
     pub fn id(&self) -> &str {
         match self {
-            Model::Claude3_5Sonnet => "us.anthropic.claude-3-5-sonnet-20241022-v2:0",
-            Model::Claude3Opus => "us.anthropic.claude-3-opus-20240229-v1:0",
-            Model::Claude3Sonnet => "us.anthropic.claude-3-sonnet-20240229-v1:0",
-            Model::Claude3_5Haiku => "us.anthropic.claude-3-5-haiku-20241022-v1:0",
-            Model::Claude3_7Sonnet => "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
-            Model::AmazonNovaLite => "us.amazon.nova-lite-v1:0",
-            Model::AmazonNovaMicro => "us.amazon.nova-micro-v1:0",
-            Model::AmazonNovaPro => "us.amazon.nova-pro-v1:0",
+            Model::Claude3_5SonnetV2 => "anthropic.claude-3-5-sonnet-20241022-v2:0",
+            Model::Claude3_5Sonnet => "anthropic.claude-3-5-sonnet-20240620-v1:0",
+            Model::Claude3Opus => "anthropic.claude-3-opus-20240229-v1:0",
+            Model::Claude3Sonnet => "anthropic.claude-3-sonnet-20240229-v1:0",
+            Model::Claude3Haiku => "anthropic.claude-3-haiku-20240307-v1:0",
+            Model::Claude3_5Haiku => "anthropic.claude-3-5-haiku-20241022-v1:0",
+            Model::Claude3_7Sonnet | Model::Claude3_7SonnetThinking => {
+                "anthropic.claude-3-7-sonnet-20250219-v1:0"
+            }
+            Model::AmazonNovaLite => "amazon.nova-lite-v1:0",
+            Model::AmazonNovaMicro => "amazon.nova-micro-v1:0",
+            Model::AmazonNovaPro => "amazon.nova-pro-v1:0",
             Model::DeepSeekR1 => "us.deepseek.r1-v1:0",
             Model::AI21J2GrandeInstruct => "ai21.j2-grande-instruct",
             Model::AI21J2JumboInstruct => "ai21.j2-jumbo-instruct",
@@ -128,11 +151,14 @@ impl Model {
 
     pub fn display_name(&self) -> &str {
         match self {
-            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet v2",
+            Self::Claude3_5SonnetV2 => "Claude 3.5 Sonnet v2",
+            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
             Self::Claude3Opus => "Claude 3 Opus",
             Self::Claude3Sonnet => "Claude 3 Sonnet",
+            Self::Claude3Haiku => "Claude 3 Haiku",
             Self::Claude3_5Haiku => "Claude 3.5 Haiku",
             Self::Claude3_7Sonnet => "Claude 3.7 Sonnet",
+            Self::Claude3_7SonnetThinking => "Claude 3.7 Sonnet Thinking",
             Self::AmazonNovaLite => "Amazon Nova Lite",
             Self::AmazonNovaMicro => "Amazon Nova Micro",
             Self::AmazonNovaPro => "Amazon Nova Pro",
@@ -173,7 +199,7 @@ impl Model {
 
     pub fn max_token_count(&self) -> usize {
         match self {
-            Self::Claude3_5Sonnet
+            Self::Claude3_5SonnetV2
             | Self::Claude3Opus
             | Self::Claude3Sonnet
             | Self::Claude3_5Haiku
@@ -186,7 +212,8 @@ impl Model {
     pub fn max_output_tokens(&self) -> u32 {
         match self {
             Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3_5Haiku => 4_096,
-            Self::Claude3_5Sonnet => 8_192,
+            Self::Claude3_7Sonnet | Self::Claude3_7SonnetThinking => 128_000,
+            Self::Claude3_5SonnetV2 => 8_192,
             Self::Custom {
                 max_output_tokens, ..
             } => max_output_tokens.unwrap_or(4_096),
@@ -196,7 +223,7 @@ impl Model {
 
     pub fn default_temperature(&self) -> f32 {
         match self {
-            Self::Claude3_5Sonnet
+            Self::Claude3_5SonnetV2
             | Self::Claude3Opus
             | Self::Claude3Sonnet
             | Self::Claude3_5Haiku
@@ -208,4 +235,253 @@ impl Model {
             _ => 1.0,
         }
     }
+
+    pub fn supports_tool_use(&self) -> bool {
+        match self {
+            // Anthropic Claude 3 models (all support tool use)
+            Self::Claude3Opus
+            | Self::Claude3Sonnet
+            | Self::Claude3_5Sonnet
+            | Self::Claude3_5SonnetV2
+            | Self::Claude3_7Sonnet
+            | Self::Claude3_7SonnetThinking
+            | Self::Claude3_5Haiku => true,
+
+            // Amazon Nova models (all support tool use)
+            Self::AmazonNovaPro | Self::AmazonNovaLite | Self::AmazonNovaMicro => true,
+
+            // AI21 Jamba 1.5 models support tool use
+            Self::AI21Jamba15LargeV1 | Self::AI21Jamba15MiniV1 => true,
+
+            // Cohere Command R models support tool use
+            Self::CohereCommandRV1 | Self::CohereCommandRPlusV1 => true,
+
+            // All other models don't support tool use
+            // Including Meta Llama 3.2, AI21 Jurassic, and others
+            _ => false,
+        }
+    }
+
+    pub fn mode(&self) -> BedrockModelMode {
+        match self {
+            Model::Claude3_7SonnetThinking => BedrockModelMode::Thinking {
+                budget_tokens: Some(4096),
+            },
+            _ => BedrockModelMode::Default,
+        }
+    }
+
+    pub fn cross_region_inference_id(&self, region: &str) -> Result<String, anyhow::Error> {
+        let region_group = if region.starts_with("us-gov-") {
+            "us-gov"
+        } else if region.starts_with("us-") {
+            "us"
+        } else if region.starts_with("eu-") {
+            "eu"
+        } else if region.starts_with("ap-") || region == "me-central-1" || region == "me-south-1" {
+            "apac"
+        } else if region.starts_with("ca-") || region.starts_with("sa-") {
+            // Canada and South America regions - default to US profiles
+            "us"
+        } else {
+            // Unknown region
+            return Err(anyhow!("Unsupported Region"));
+        };
+
+        let model_id = self.id();
+
+        match (self, region_group) {
+            // Custom models can't have CRI IDs
+            (Model::Custom { .. }, _) => Ok(self.id().into()),
+
+            // Models with US Gov only
+            (Model::Claude3_5Sonnet, "us-gov") | (Model::Claude3Haiku, "us-gov") => {
+                Ok(format!("{}.{}", region_group, model_id))
+            }
+
+            // Models available only in US
+            (Model::Claude3Opus, "us")
+            | (Model::Claude3_7Sonnet, "us")
+            | (Model::Claude3_7SonnetThinking, "us") => {
+                Ok(format!("{}.{}", region_group, model_id))
+            }
+
+            // Models available in US, EU, and APAC
+            (Model::Claude3_5SonnetV2, "us")
+            | (Model::Claude3_5SonnetV2, "apac")
+            | (Model::Claude3_5Sonnet, _)
+            | (Model::Claude3Haiku, _)
+            | (Model::Claude3Sonnet, _)
+            | (Model::AmazonNovaLite, _)
+            | (Model::AmazonNovaMicro, _)
+            | (Model::AmazonNovaPro, _) => Ok(format!("{}.{}", region_group, model_id)),
+
+            // Models with limited EU availability
+            (Model::MetaLlama321BInstructV1, "us")
+            | (Model::MetaLlama321BInstructV1, "eu")
+            | (Model::MetaLlama323BInstructV1, "us")
+            | (Model::MetaLlama323BInstructV1, "eu") => {
+                Ok(format!("{}.{}", region_group, model_id))
+            }
+
+            // US-only models (all remaining Meta models)
+            (Model::MetaLlama38BInstructV1, "us")
+            | (Model::MetaLlama370BInstructV1, "us")
+            | (Model::MetaLlama318BInstructV1, "us")
+            | (Model::MetaLlama318BInstructV1_128k, "us")
+            | (Model::MetaLlama3170BInstructV1, "us")
+            | (Model::MetaLlama3170BInstructV1_128k, "us")
+            | (Model::MetaLlama3211BInstructV1, "us")
+            | (Model::MetaLlama3290BInstructV1, "us") => {
+                Ok(format!("{}.{}", region_group, model_id))
+            }
+
+            // Any other combination is not supported
+            _ => Ok(self.id().into()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_us_region_inference_ids() -> anyhow::Result<()> {
+        // Test US regions
+        assert_eq!(
+            Model::Claude3_5SonnetV2.cross_region_inference_id("us-east-1")?,
+            "us.anthropic.claude-3-5-sonnet-20241022-v2:0"
+        );
+        assert_eq!(
+            Model::Claude3_5SonnetV2.cross_region_inference_id("us-west-2")?,
+            "us.anthropic.claude-3-5-sonnet-20241022-v2:0"
+        );
+        assert_eq!(
+            Model::AmazonNovaPro.cross_region_inference_id("us-east-2")?,
+            "us.amazon.nova-pro-v1:0"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_eu_region_inference_ids() -> anyhow::Result<()> {
+        // Test European regions
+        assert_eq!(
+            Model::Claude3Sonnet.cross_region_inference_id("eu-west-1")?,
+            "eu.anthropic.claude-3-sonnet-20240229-v1:0"
+        );
+        assert_eq!(
+            Model::AmazonNovaMicro.cross_region_inference_id("eu-north-1")?,
+            "eu.amazon.nova-micro-v1:0"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_apac_region_inference_ids() -> anyhow::Result<()> {
+        // Test Asia-Pacific regions
+        assert_eq!(
+            Model::Claude3_5SonnetV2.cross_region_inference_id("ap-northeast-1")?,
+            "apac.anthropic.claude-3-5-sonnet-20241022-v2:0"
+        );
+        assert_eq!(
+            Model::AmazonNovaLite.cross_region_inference_id("ap-south-1")?,
+            "apac.amazon.nova-lite-v1:0"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_gov_region_inference_ids() -> anyhow::Result<()> {
+        // Test Government regions
+        assert_eq!(
+            Model::Claude3_5Sonnet.cross_region_inference_id("us-gov-east-1")?,
+            "us-gov.anthropic.claude-3-5-sonnet-20240620-v1:0"
+        );
+        assert_eq!(
+            Model::Claude3Haiku.cross_region_inference_id("us-gov-west-1")?,
+            "us-gov.anthropic.claude-3-haiku-20240307-v1:0"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_meta_models_inference_ids() -> anyhow::Result<()> {
+        // Test Meta models
+        assert_eq!(
+            Model::MetaLlama370BInstructV1.cross_region_inference_id("us-east-1")?,
+            "us.meta.llama3-70b-instruct-v1:0"
+        );
+        assert_eq!(
+            Model::MetaLlama321BInstructV1.cross_region_inference_id("eu-west-1")?,
+            "eu.meta.llama3-2-1b-instruct-v1:0"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_mistral_models_inference_ids() -> anyhow::Result<()> {
+        // Mistral models don't follow the regional prefix pattern,
+        // so they should return their original IDs
+        assert_eq!(
+            Model::MistralMistralLarge2402V1.cross_region_inference_id("us-east-1")?,
+            "mistral.mistral-large-2402-v1:0"
+        );
+        assert_eq!(
+            Model::MistralMixtral8x7BInstructV0.cross_region_inference_id("eu-west-1")?,
+            "mistral.mixtral-8x7b-instruct-v0:1"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_ai21_models_inference_ids() -> anyhow::Result<()> {
+        // AI21 models don't follow the regional prefix pattern,
+        // so they should return their original IDs
+        assert_eq!(
+            Model::AI21J2UltraV1.cross_region_inference_id("us-east-1")?,
+            "ai21.j2-ultra-v1"
+        );
+        assert_eq!(
+            Model::AI21JambaInstructV1.cross_region_inference_id("eu-west-1")?,
+            "ai21.jamba-instruct-v1:0"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_cohere_models_inference_ids() -> anyhow::Result<()> {
+        // Cohere models don't follow the regional prefix pattern,
+        // so they should return their original IDs
+        assert_eq!(
+            Model::CohereCommandRV1.cross_region_inference_id("us-east-1")?,
+            "cohere.command-r-v1:0"
+        );
+        assert_eq!(
+            Model::CohereCommandTextV14_4k.cross_region_inference_id("ap-southeast-1")?,
+            "cohere.command-text-v14:7:4k"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_custom_model_inference_ids() -> anyhow::Result<()> {
+        // Test custom models
+        let custom_model = Model::Custom {
+            name: "custom.my-model-v1:0".to_string(),
+            max_tokens: 100000,
+            display_name: Some("My Custom Model".to_string()),
+            max_output_tokens: Some(8192),
+            default_temperature: Some(0.7),
+        };
+
+        // Custom model should return its name unchanged
+        assert_eq!(
+            custom_model.cross_region_inference_id("us-east-1")?,
+            "custom.my-model-v1:0"
+        );
+
+        Ok(())
+    }
 }

crates/breadcrumbs/Cargo.toml

@@ -20,6 +20,7 @@ theme.workspace = true
 ui.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }

crates/buffer_diff/Cargo.toml

@@ -27,6 +27,7 @@ rope.workspace = true
 sum_tree.workspace = true
 text.workspace = true
 util.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 ctor.workspace = true

crates/call/Cargo.toml

@@ -42,6 +42,7 @@ telemetry.workspace = true
 util.workspace = true
 gpui_tokio.workspace = true
 livekit_client.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 client = { workspace = true, features = ["test-support"] }

crates/channel/Cargo.toml

@@ -32,6 +32,7 @@ sum_tree.workspace = true
 text.workspace = true
 time.workspace = true
 util.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 collections = { workspace = true, features = ["test-support"] }

crates/cli/Cargo.toml

@@ -31,6 +31,7 @@ release_channel.workspace = true
 serde.workspace = true
 util.workspace = true
 tempfile.workspace = true
+workspace-hack.workspace = true
 
 [target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies]
 exec.workspace = true

crates/client/Cargo.toml

@@ -51,6 +51,7 @@ url.workspace = true
 util.workspace = true
 worktree.workspace = true
 telemetry.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 clock = { workspace = true, features = ["test-support"] }

crates/clock/Cargo.toml

@@ -19,3 +19,4 @@ test-support = ["dep:parking_lot"]
 parking_lot = { workspace = true, optional = true }
 serde.workspace = true
 smallvec.workspace = true
+workspace-hack.workspace = true

crates/collab/Cargo.toml

@@ -76,6 +76,7 @@ tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json", "registry", "tracing-log"] } # workaround for https://github.com/tokio-rs/tracing/issues/2927
 util.workspace = true
 uuid.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 assistant = { workspace = true, features = ["test-support"] }

crates/collab_ui/Cargo.toml

@@ -64,6 +64,7 @@ title_bar.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 call = { workspace = true, features = ["test-support"] }

crates/collections/Cargo.toml

@@ -18,3 +18,4 @@ test-support = []
 [dependencies]
 indexmap.workspace = true
 rustc-hash.workspace = true
+workspace-hack.workspace = true

crates/command_palette/Cargo.toml

@@ -31,6 +31,7 @@ util.workspace = true
 telemetry.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 ctor.workspace = true

crates/command_palette_hooks/Cargo.toml

@@ -16,3 +16,4 @@ doctest = false
 collections.workspace = true
 derive_more.workspace = true
 gpui.workspace = true
+workspace-hack.workspace = true

crates/component/Cargo.toml

@@ -17,6 +17,7 @@ gpui.workspace = true
 linkme.workspace = true
 parking_lot.workspace = true
 theme.workspace = true
+workspace-hack.workspace = true
 
 [features]
 default = []

crates/component_preview/Cargo.toml

@@ -24,3 +24,4 @@ ui.workspace = true
 workspace.workspace = true
 notifications.workspace = true
 collections.workspace = true
+workspace-hack.workspace = true

crates/context_server/Cargo.toml

@@ -33,3 +33,4 @@ settings.workspace = true
 smol.workspace = true
 url = { workspace = true, features = ["serde"] }
 util.workspace = true
+workspace-hack.workspace = true

crates/context_server_settings/Cargo.toml

@@ -19,3 +19,4 @@ schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
+workspace-hack.workspace = true

crates/copilot/Cargo.toml

@@ -52,6 +52,7 @@ task.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true
 
 [target.'cfg(windows)'.dependencies]
 async-std = { version = "1.12.0", features = ["unstable"] }

crates/copilot/src/copilot.rs

@@ -57,11 +57,11 @@ pub fn init(
     node_runtime: NodeRuntime,
     cx: &mut App,
 ) {
-    copilot_chat::init(fs, http.clone(), cx);
+    copilot_chat::init(fs.clone(), http.clone(), cx);
 
     let copilot = cx.new({
         let node_runtime = node_runtime.clone();
-        move |cx| Copilot::start(new_server_id, node_runtime, cx)
+        move |cx| Copilot::start(new_server_id, fs, node_runtime, cx)
     });
     Copilot::set_global(copilot.clone(), cx);
     cx.observe(&copilot, |handle, cx| {
@@ -301,6 +301,7 @@ pub struct Completion {
 }
 
 pub struct Copilot {
+    fs: Arc<dyn Fs>,
     node_runtime: NodeRuntime,
     server: CopilotServer,
     buffers: HashSet<WeakEntity<Buffer>>,
@@ -332,11 +333,13 @@ impl Copilot {
 
     fn start(
         new_server_id: LanguageServerId,
+        fs: Arc<dyn Fs>,
         node_runtime: NodeRuntime,
         cx: &mut Context<Self>,
     ) -> Self {
         let mut this = Self {
             server_id: new_server_id,
+            fs,
             node_runtime,
             server: CopilotServer::Disabled,
             buffers: Default::default(),
@@ -380,12 +383,14 @@ impl Copilot {
             return;
         }
         let server_id = self.server_id;
+        let fs = self.fs.clone();
         let node_runtime = self.node_runtime.clone();
         let env = self.build_env(&language_settings.edit_predictions.copilot);
         let start_task = cx
             .spawn(async move |this, cx| {
                 Self::start_language_server(
                     server_id,
+                    fs,
                     node_runtime,
                     env,
                     this,
@@ -425,6 +430,7 @@ impl Copilot {
 
     #[cfg(any(test, feature = "test-support"))]
     pub fn fake(cx: &mut gpui::TestAppContext) -> (Entity<Self>, lsp::FakeLanguageServer) {
+        use fs::FakeFs;
         use lsp::FakeLanguageServer;
         use node_runtime::NodeRuntime;
 
@@ -442,6 +448,7 @@ impl Copilot {
         let node_runtime = NodeRuntime::unavailable();
         let this = cx.new(|cx| Self {
             server_id: LanguageServerId(0),
+            fs: FakeFs::new(cx.background_executor().clone()),
             node_runtime,
             server: CopilotServer::Running(RunningCopilotServer {
                 lsp: Arc::new(server),
@@ -456,6 +463,7 @@ impl Copilot {
 
     async fn start_language_server(
         new_server_id: LanguageServerId,
+        fs: Arc<dyn Fs>,
         node_runtime: NodeRuntime,
         env: Option<HashMap<String, String>>,
         this: WeakEntity<Self>,
@@ -463,7 +471,7 @@ impl Copilot {
         cx: &mut AsyncApp,
     ) {
         let start_language_server = async {
-            let server_path = get_copilot_lsp(node_runtime.clone()).await?;
+            let server_path = get_copilot_lsp(fs, node_runtime.clone()).await?;
             let node_path = node_runtime.binary_path().await?;
             let arguments: Vec<OsString> = vec![server_path.into(), "--stdio".into()];
             let binary = LanguageServerBinary {
@@ -664,11 +672,13 @@ impl Copilot {
         let env = self.build_env(&language_settings.edit_predictions.copilot);
         let start_task = cx
             .spawn({
+                let fs = self.fs.clone();
                 let node_runtime = self.node_runtime.clone();
                 let server_id = self.server_id;
                 async move |this, cx| {
                     clear_copilot_dir().await;
-                    Self::start_language_server(server_id, node_runtime, env, this, false, cx).await
+                    Self::start_language_server(server_id, fs, node_runtime, env, this, false, cx)
+                        .await
                 }
             })
             .shared();
@@ -1050,7 +1060,7 @@ async fn clear_copilot_config_dir() {
     remove_matching(copilot_chat::copilot_chat_config_dir(), |_| true).await
 }
 
-async fn get_copilot_lsp(node_runtime: NodeRuntime) -> anyhow::Result<PathBuf> {
+async fn get_copilot_lsp(fs: Arc<dyn Fs>, node_runtime: NodeRuntime) -> anyhow::Result<PathBuf> {
     const PACKAGE_NAME: &str = "@github/copilot-language-server";
     const SERVER_PATH: &str =
         "node_modules/@github/copilot-language-server/dist/language-server.js";
@@ -1060,6 +1070,8 @@ async fn get_copilot_lsp(node_runtime: NodeRuntime) -> anyhow::Result<PathBuf> {
         .await?;
     let server_path = paths::copilot_dir().join(SERVER_PATH);
 
+    fs.create_dir(paths::copilot_dir()).await?;
+
     let should_install = node_runtime
         .should_install_npm_package(
             PACKAGE_NAME,