Merge branch 'main' into message-editor

Cargo.lock

@@ -14,6 +14,7 @@ dependencies = [
  "collections",
  "editor",
  "env_logger 0.11.8",
+ "file_icons",
  "futures 0.3.31",
  "gpui",
  "indoc",
@@ -394,7 +395,6 @@ dependencies = [
  "ui",
  "ui_input",
  "unindent",
- "url",
  "urlencoding",
  "util",
  "uuid",

assets/keymaps/default-linux.json

@@ -331,8 +331,6 @@
     "use_key_equivalents": true,
     "bindings": {
       "enter": "agent::Chat",
-      "up": "agent::PreviousHistoryMessage",
-      "down": "agent::NextHistoryMessage",
       "shift-ctrl-r": "agent::OpenAgentDiff",
       "ctrl-shift-y": "agent::KeepAll",
       "ctrl-shift-n": "agent::RejectAll"

assets/keymaps/default-macos.json

@@ -383,8 +383,6 @@
     "use_key_equivalents": true,
     "bindings": {
       "enter": "agent::Chat",
-      "up": "agent::PreviousHistoryMessage",
-      "down": "agent::NextHistoryMessage",
       "shift-ctrl-r": "agent::OpenAgentDiff",
       "cmd-shift-y": "agent::KeepAll",
       "cmd-shift-n": "agent::RejectAll"

crates/acp_thread/Cargo.toml

@@ -23,6 +23,7 @@ anyhow.workspace = true
 buffer_diff.workspace = true
 collections.workspace = true
 editor.workspace = true
+file_icons.workspace = true
 futures.workspace = true
 gpui.workspace = true
 itertools.workspace = true

crates/acp_thread/src/acp_thread.rs

@@ -32,6 +32,7 @@ use util::ResultExt;
 pub struct UserMessage {
     pub id: Option<UserMessageId>,
     pub content: ContentBlock,
+    pub chunks: Vec<acp::ContentBlock>,
     pub checkpoint: Option<GitStoreCheckpoint>,
 }
 
@@ -399,7 +400,7 @@ impl ContentBlock {
             }
         }
 
-        let new_content = self.block_string_contents(block);
+        let new_content = self.extract_content_from_block(block);
 
         match self {
             ContentBlock::Empty => {
@@ -409,7 +410,7 @@ impl ContentBlock {
                 markdown.update(cx, |markdown, cx| markdown.append(&new_content, cx));
             }
             ContentBlock::ResourceLink { resource_link } => {
-                let existing_content = Self::resource_link_md(&resource_link.uri);
+                let existing_content = Self::resource_link_to_content(&resource_link.uri);
                 let combined = format!("{}\n{}", existing_content, new_content);
 
                 *self = Self::create_markdown_block(combined, language_registry, cx);
@@ -417,6 +418,14 @@ impl ContentBlock {
         }
     }
 
+    fn resource_link_to_content(uri: &str) -> String {
+        if let Some(uri) = MentionUri::parse(&uri).log_err() {
+            uri.as_link().to_string()
+        } else {
+            uri.to_string()
+        }
+    }
+
     fn create_markdown_block(
         content: String,
         language_registry: &Arc<LanguageRegistry>,
@@ -428,11 +437,11 @@ impl ContentBlock {
         }
     }
 
-    fn block_string_contents(&self, block: acp::ContentBlock) -> String {
+    fn extract_content_from_block(&self, block: acp::ContentBlock) -> String {
         match block {
             acp::ContentBlock::Text(text_content) => text_content.text.clone(),
             acp::ContentBlock::ResourceLink(resource_link) => {
-                Self::resource_link_md(&resource_link.uri)
+                Self::resource_link_to_content(&resource_link.uri)
             }
             acp::ContentBlock::Resource(acp::EmbeddedResource {
                 resource:
@@ -441,21 +450,13 @@ impl ContentBlock {
                         ..
                     }),
                 ..
-            }) => Self::resource_link_md(&uri),
+            }) => Self::resource_link_to_content(&uri),
             acp::ContentBlock::Image(_)
             | acp::ContentBlock::Audio(_)
             | acp::ContentBlock::Resource(_) => String::new(),
         }
     }
 
-    fn resource_link_md(uri: &str) -> String {
-        if let Some(uri) = MentionUri::parse(&uri).log_err() {
-            uri.as_link().to_string()
-        } else {
-            uri.to_string()
-        }
-    }
-
     fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str {
         match self {
             ContentBlock::Empty => "",
@@ -804,18 +805,25 @@ impl AcpThread {
         let entries_len = self.entries.len();
 
         if let Some(last_entry) = self.entries.last_mut()
-            && let AgentThreadEntry::UserMessage(UserMessage { id, content, .. }) = last_entry
+            && let AgentThreadEntry::UserMessage(UserMessage {
+                id,
+                content,
+                chunks,
+                ..
+            }) = last_entry
         {
             *id = message_id.or(id.take());
-            content.append(chunk, &language_registry, cx);
+            content.append(chunk.clone(), &language_registry, cx);
+            chunks.push(chunk);
             let idx = entries_len - 1;
             cx.emit(AcpThreadEvent::EntryUpdated(idx));
         } else {
-            let content = ContentBlock::new(chunk, &language_registry, cx);
+            let content = ContentBlock::new(chunk.clone(), &language_registry, cx);
             self.push_entry(
                 AgentThreadEntry::UserMessage(UserMessage {
                     id: message_id,
                     content,
+                    chunks: vec![chunk],
                     checkpoint: None,
                 }),
                 cx,
@@ -1150,6 +1158,7 @@ impl AcpThread {
             AgentThreadEntry::UserMessage(UserMessage {
                 id: message_id.clone(),
                 content: block,
+                chunks: message.clone(),
                 checkpoint: None,
             }),
             cx,

crates/acp_thread/src/mention.rs

@@ -1,16 +1,21 @@
 use agent::ThreadId;
 use anyhow::{Context as _, Result, bail};
+use file_icons::FileIcons;
 use prompt_store::{PromptId, UserPromptId};
 use std::{
     fmt,
     ops::Range,
     path::{Path, PathBuf},
 };
+use ui::{App, IconName, SharedString};
 use url::Url;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum MentionUri {
-    File(PathBuf),
+    File {
+        abs_path: PathBuf,
+        is_directory: bool,
+    },
     Symbol {
         path: PathBuf,
         name: String,
@@ -75,8 +80,12 @@ impl MentionUri {
                 } else {
                     let file_path =
                         PathBuf::from(format!("{}{}", url.host_str().unwrap_or(""), path));
+                    let is_directory = input.ends_with("/");
 
-                    Ok(Self::File(file_path))
+                    Ok(Self::File {
+                        abs_path: file_path,
+                        is_directory,
+                    })
                 }
             }
             "zed" => {
@@ -108,9 +117,9 @@ impl MentionUri {
         }
     }
 
-    fn name(&self) -> String {
+    pub fn name(&self) -> String {
         match self {
-            MentionUri::File(path) => path
+            MentionUri::File { abs_path, .. } => abs_path
                 .file_name()
                 .unwrap_or_default()
                 .to_string_lossy()
@@ -126,15 +135,45 @@ impl MentionUri {
         }
     }
 
+    pub fn icon_path(&self, cx: &mut App) -> SharedString {
+        match self {
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
+                if *is_directory {
+                    FileIcons::get_folder_icon(false, cx)
+                        .unwrap_or_else(|| IconName::Folder.path().into())
+                } else {
+                    FileIcons::get_icon(&abs_path, cx)
+                        .unwrap_or_else(|| IconName::File.path().into())
+                }
+            }
+            MentionUri::Symbol { .. } => IconName::Code.path().into(),
+            MentionUri::Thread { .. } => IconName::Thread.path().into(),
+            MentionUri::TextThread { .. } => IconName::Thread.path().into(),
+            MentionUri::Rule { .. } => IconName::Reader.path().into(),
+            MentionUri::Selection { .. } => IconName::Reader.path().into(),
+            MentionUri::Fetch { .. } => IconName::ToolWeb.path().into(),
+        }
+    }
+
     pub fn as_link<'a>(&'a self) -> MentionLink<'a> {
         MentionLink(self)
     }
 
     pub fn to_uri(&self) -> Url {
         match self {
-            MentionUri::File(path) => {
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
                 let mut url = Url::parse("file:///").unwrap();
-                url.set_path(&path.to_string_lossy());
+                let mut path = abs_path.to_string_lossy().to_string();
+                if *is_directory && !path.ends_with("/") {
+                    path.push_str("/");
+                }
+                url.set_path(&path);
                 url
             }
             MentionUri::Symbol {
@@ -226,12 +265,53 @@ mod tests {
         let file_uri = "file:///path/to/file.rs";
         let parsed = MentionUri::parse(file_uri).unwrap();
         match &parsed {
-            MentionUri::File(path) => assert_eq!(path.to_str().unwrap(), "/path/to/file.rs"),
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
+                assert_eq!(abs_path.to_str().unwrap(), "/path/to/file.rs");
+                assert!(!is_directory);
+            }
             _ => panic!("Expected File variant"),
         }
         assert_eq!(parsed.to_uri().to_string(), file_uri);
     }
 
+    #[test]
+    fn test_parse_directory_uri() {
+        let file_uri = "file:///path/to/dir/";
+        let parsed = MentionUri::parse(file_uri).unwrap();
+        match &parsed {
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
+                assert_eq!(abs_path.to_str().unwrap(), "/path/to/dir");
+                assert!(is_directory);
+            }
+            _ => panic!("Expected File variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), file_uri);
+    }
+
+    #[test]
+    fn test_to_directory_uri_with_slash() {
+        let uri = MentionUri::File {
+            abs_path: PathBuf::from("/path/to/dir/"),
+            is_directory: true,
+        };
+        assert_eq!(uri.to_uri().to_string(), "file:///path/to/dir/");
+    }
+
+    #[test]
+    fn test_to_directory_uri_without_slash() {
+        let uri = MentionUri::File {
+            abs_path: PathBuf::from("/path/to/dir"),
+            is_directory: true,
+        };
+        assert_eq!(uri.to_uri().to_string(), "file:///path/to/dir/");
+    }
+
     #[test]
     fn test_parse_symbol_uri() {
         let symbol_uri = "file:///path/to/file.rs?symbol=MySymbol#L10:20";

crates/agent/src/thread_store.rs

@@ -205,22 +205,6 @@ impl ThreadStore {
         (this, ready_rx)
     }
 
-    #[cfg(any(test, feature = "test-support"))]
-    pub fn fake(project: Entity<Project>, cx: &mut App) -> Self {
-        Self {
-            project,
-            tools: cx.new(|_| ToolWorkingSet::default()),
-            prompt_builder: Arc::new(PromptBuilder::new(None).unwrap()),
-            prompt_store: None,
-            context_server_tool_ids: HashMap::default(),
-            threads: Vec::new(),
-            project_context: SharedProjectContext::default(),
-            reload_system_prompt_tx: mpsc::channel(0).0,
-            _reload_system_prompt_task: Task::ready(()),
-            _subscriptions: vec![],
-        }
-    }
-
     fn handle_project_event(
         &mut self,
         _project: Entity<Project>,

crates/agent2/src/thread.rs

@@ -25,8 +25,8 @@ use schemars::{JsonSchema, Schema};
 use serde::{Deserialize, Serialize};
 use settings::{Settings, update_settings_file};
 use smol::stream::StreamExt;
+use std::fmt::Write;
 use std::{cell::RefCell, collections::BTreeMap, path::Path, rc::Rc, sync::Arc};
-use std::{fmt::Write, ops::Range};
 use util::{ResultExt, markdown::MarkdownCodeBlock};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -79,9 +79,9 @@ impl UserMessage {
                 }
                 UserMessageContent::Mention { uri, content } => {
                     if !content.is_empty() {
-                        let _ = write!(&mut markdown, "{}\n\n{}\n", uri.as_link(), content);
+                        markdown.push_str(&format!("{}\n\n{}\n", uri.to_link(), content));
                     } else {
-                        let _ = write!(&mut markdown, "{}\n", uri.as_link());
+                        markdown.push_str(&format!("{}\n", uri.to_link()));
                     }
                 }
             }
@@ -104,14 +104,12 @@ impl UserMessage {
         const OPEN_FILES_TAG: &str = "<files>";
         const OPEN_SYMBOLS_TAG: &str = "<symbols>";
         const OPEN_THREADS_TAG: &str = "<threads>";
-        const OPEN_FETCH_TAG: &str = "<fetched_urls>";
         const OPEN_RULES_TAG: &str =
             "<rules>\nThe user has specified the following rules that should be applied:\n";
 
         let mut file_context = OPEN_FILES_TAG.to_string();
         let mut symbol_context = OPEN_SYMBOLS_TAG.to_string();
         let mut thread_context = OPEN_THREADS_TAG.to_string();
-        let mut fetch_context = OPEN_FETCH_TAG.to_string();
         let mut rules_context = OPEN_RULES_TAG.to_string();
 
         for chunk in &self.content {
@@ -124,40 +122,21 @@ impl UserMessage {
                 }
                 UserMessageContent::Mention { uri, content } => {
                     match uri {
-                        MentionUri::File(path) => {
+                        MentionUri::File(path) | MentionUri::Symbol(path, _) => {
                             write!(
                                 &mut symbol_context,
                                 "\n{}",
                                 MarkdownCodeBlock {
-                                    tag: &codeblock_tag(&path, None),
+                                    tag: &codeblock_tag(&path),
                                     text: &content.to_string(),
                                 }
                             )
                             .ok();
                         }
-                        MentionUri::Symbol {
-                            path, line_range, ..
-                        }
-                        | MentionUri::Selection {
-                            path, line_range, ..
-                        } => {
-                            write!(
-                                &mut rules_context,
-                                "\n{}",
-                                MarkdownCodeBlock {
-                                    tag: &codeblock_tag(&path, Some(line_range)),
-                                    text: &content
-                                }
-                            )
-                            .ok();
-                        }
-                        MentionUri::Thread { .. } => {
+                        MentionUri::Thread(_session_id) => {
                             write!(&mut thread_context, "\n{}\n", content).ok();
                         }
-                        MentionUri::TextThread { .. } => {
-                            write!(&mut thread_context, "\n{}\n", content).ok();
-                        }
-                        MentionUri::Rule { .. } => {
+                        MentionUri::Rule(_user_prompt_id) => {
                             write!(
                                 &mut rules_context,
                                 "\n{}",
@@ -168,12 +147,9 @@ impl UserMessage {
                             )
                             .ok();
                         }
-                        MentionUri::Fetch { url } => {
-                            write!(&mut fetch_context, "\nFetch: {}\n\n{}", url, content).ok();
-                        }
                     }
 
-                    language_model::MessageContent::Text(uri.as_link().to_string())
+                    language_model::MessageContent::Text(uri.to_link())
                 }
             };
 
@@ -203,13 +179,6 @@ impl UserMessage {
                 .push(language_model::MessageContent::Text(thread_context));
         }
 
-        if fetch_context.len() > OPEN_FETCH_TAG.len() {
-            fetch_context.push_str("</fetched_urls>\n");
-            message
-                .content
-                .push(language_model::MessageContent::Text(fetch_context));
-        }
-
         if rules_context.len() > OPEN_RULES_TAG.len() {
             rules_context.push_str("</user_rules>\n");
             message
@@ -231,26 +200,6 @@ impl UserMessage {
     }
 }
 
-fn codeblock_tag(full_path: &Path, line_range: Option<&Range<u32>>) -> String {
-    let mut result = String::new();
-
-    if let Some(extension) = full_path.extension().and_then(|ext| ext.to_str()) {
-        let _ = write!(result, "{} ", extension);
-    }
-
-    let _ = write!(result, "{}", full_path.display());
-
-    if let Some(range) = line_range {
-        if range.start == range.end {
-            let _ = write!(result, ":{}", range.start + 1);
-        } else {
-            let _ = write!(result, ":{}-{}", range.start + 1, range.end + 1);
-        }
-    }
-
-    result
-}
-
 impl AgentMessage {
     pub fn to_markdown(&self) -> String {
         let mut markdown = String::from("## Assistant\n\n");
@@ -1418,6 +1367,18 @@ impl std::ops::DerefMut for ToolCallEventStreamReceiver {
     }
 }
 
+fn codeblock_tag(full_path: &Path) -> String {
+    let mut result = String::new();
+
+    if let Some(extension) = full_path.extension().and_then(|ext| ext.to_str()) {
+        let _ = write!(result, "{} ", extension);
+    }
+
+    let _ = write!(result, "{}", full_path.display());
+
+    result
+}
+
 impl From<&str> for UserMessageContent {
     fn from(text: &str) -> Self {
         Self::Text(text.into())

crates/agent_ui/Cargo.toml

@@ -93,7 +93,6 @@ time.workspace = true
 time_format.workspace = true
 ui.workspace = true
 ui_input.workspace = true
-url.workspace = true
 urlencoding.workspace = true
 util.workspace = true
 uuid.workspace = true
@@ -103,8 +102,6 @@ workspace.workspace = true
 zed_actions.workspace = true
 
 [dev-dependencies]
-agent = { workspace = true, features = ["test-support"] }
-assistant_context = { workspace = true, features = ["test-support"] }
 assistant_tools.workspace = true
 buffer_diff = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }

crates/agent_ui/src/acp.rs

@@ -1,10 +1,9 @@
 mod completion_provider;
-mod message_history;
+mod message_editor;
 mod model_selector;
 mod model_selector_popover;
 mod thread_view;
 
-pub use message_history::MessageHistory;
 pub use model_selector::AcpModelSelector;
 pub use model_selector_popover::AcpModelSelectorPopover;
 pub use thread_view::AcpThreadView;

crates/agent_ui/src/acp/message_editor.rs

@@ -0,0 +1,456 @@
+use crate::acp::completion_provider::ContextPickerCompletionProvider;
+use crate::acp::completion_provider::MentionSet;
+use acp_thread::MentionUri;
+use agent_client_protocol as acp;
+use anyhow::Result;
+use collections::HashSet;
+use editor::{
+    AnchorRangeExt, ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorMode,
+    EditorStyle, MultiBuffer,
+};
+use file_icons::FileIcons;
+use gpui::{
+    AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable, Task, TextStyle, WeakEntity,
+};
+use language::Buffer;
+use language::Language;
+use parking_lot::Mutex;
+use project::{CompletionIntent, Project};
+use settings::Settings;
+use std::path::Path;
+use std::rc::Rc;
+use std::sync::Arc;
+use theme::ThemeSettings;
+use ui::{
+    ActiveTheme, App, IconName, InteractiveElement, IntoElement, ParentElement, Render,
+    SharedString, Styled, TextSize, Window, div,
+};
+use util::ResultExt;
+use workspace::Workspace;
+use zed_actions::agent::Chat;
+
+pub struct MessageEditor {
+    editor: Entity<Editor>,
+    project: Entity<Project>,
+    mention_set: Arc<Mutex<MentionSet>>,
+}
+
+pub enum MessageEditorEvent {
+    Send,
+    Cancel,
+}
+
+impl EventEmitter<MessageEditorEvent> for MessageEditor {}
+
+impl MessageEditor {
+    pub fn new(
+        workspace: WeakEntity<Workspace>,
+        project: Entity<Project>,
+        mode: EditorMode,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let language = Language::new(
+            language::LanguageConfig {
+                completion_query_characters: HashSet::from_iter(['.', '-', '_', '@']),
+                ..Default::default()
+            },
+            None,
+        );
+
+        let mention_set = Arc::new(Mutex::new(MentionSet::default()));
+        let editor = cx.new(|cx| {
+            let buffer = cx.new(|cx| Buffer::local("", cx).with_language(Arc::new(language), cx));
+            let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
+
+            let mut editor = Editor::new(mode, buffer, None, window, cx);
+            editor.set_placeholder_text("Message the agent － @ to include files", cx);
+            editor.set_show_indent_guides(false, cx);
+            editor.set_soft_wrap();
+            editor.set_use_modal_editing(true);
+            editor.set_completion_provider(Some(Rc::new(ContextPickerCompletionProvider::new(
+                mention_set.clone(),
+                workspace,
+                cx.weak_entity(),
+            ))));
+            editor.set_context_menu_options(ContextMenuOptions {
+                min_entries_visible: 12,
+                max_entries_visible: 12,
+                placement: Some(ContextMenuPlacement::Above),
+            });
+            editor
+        });
+
+        Self {
+            editor,
+            project,
+            mention_set,
+        }
+    }
+
+    pub fn is_empty(&self, cx: &App) -> bool {
+        self.editor.read(cx).is_empty(cx)
+    }
+
+    pub fn contents(&self, cx: &mut Context<Self>) -> Task<Result<Vec<acp::ContentBlock>>> {
+        let contents = self.mention_set.lock().contents(self.project.clone(), cx);
+        let editor = self.editor.clone();
+
+        cx.spawn(async move |_, cx| {
+            let contents = contents.await?;
+
+            editor.update(cx, |editor, cx| {
+                let mut ix = 0;
+                let mut chunks: Vec<acp::ContentBlock> = Vec::new();
+                let text = editor.text(cx);
+                editor.display_map.update(cx, |map, cx| {
+                    let snapshot = map.snapshot(cx);
+                    for (crease_id, crease) in snapshot.crease_snapshot.creases() {
+                        // Skip creases that have been edited out of the message buffer.
+                        if !crease.range().start.is_valid(&snapshot.buffer_snapshot) {
+                            continue;
+                        }
+
+                        if let Some(mention) = contents.get(&crease_id) {
+                            let crease_range = crease.range().to_offset(&snapshot.buffer_snapshot);
+                            if crease_range.start > ix {
+                                chunks.push(text[ix..crease_range.start].into());
+                            }
+                            chunks.push(acp::ContentBlock::Resource(acp::EmbeddedResource {
+                                annotations: None,
+                                resource: acp::EmbeddedResourceResource::TextResourceContents(
+                                    acp::TextResourceContents {
+                                        mime_type: None,
+                                        text: mention.content.clone(),
+                                        uri: mention.uri.to_uri(),
+                                    },
+                                ),
+                            }));
+                            ix = crease_range.end;
+                        }
+                    }
+
+                    if ix < text.len() {
+                        let last_chunk = text[ix..].trim_end();
+                        if !last_chunk.is_empty() {
+                            chunks.push(last_chunk.into());
+                        }
+                    }
+                });
+
+                chunks
+            })
+        })
+    }
+
+    pub fn clear(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.editor.update(cx, |editor, cx| {
+            editor.clear(window, cx);
+            editor.remove_creases(self.mention_set.lock().drain(), cx)
+        });
+    }
+
+    fn chat(&mut self, _: &Chat, _: &mut Window, cx: &mut Context<Self>) {
+        cx.emit(MessageEditorEvent::Send)
+    }
+
+    fn cancel(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context<Self>) {
+        cx.emit(MessageEditorEvent::Cancel)
+    }
+
+    pub fn insert_dragged_files(
+        &self,
+        paths: Vec<project::ProjectPath>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let buffer = self.editor.read(cx).buffer().clone();
+        let Some((&excerpt_id, _, _)) = buffer.read(cx).snapshot(cx).as_singleton() else {
+            return;
+        };
+        let Some(buffer) = buffer.read(cx).as_singleton() else {
+            return;
+        };
+        for path in paths {
+            let Some(entry) = self.project.read(cx).entry_for_path(&path, cx) else {
+                continue;
+            };
+            let Some(abs_path) = self.project.read(cx).absolute_path(&path, cx) else {
+                continue;
+            };
+
+            let anchor = buffer.update(cx, |buffer, _cx| buffer.anchor_before(buffer.len()));
+            let path_prefix = abs_path
+                .file_name()
+                .unwrap_or(path.path.as_os_str())
+                .display()
+                .to_string();
+            let completion = ContextPickerCompletionProvider::completion_for_path(
+                path,
+                &path_prefix,
+                false,
+                entry.is_dir(),
+                excerpt_id,
+                anchor..anchor,
+                self.editor.clone(),
+                self.mention_set.clone(),
+                self.project.clone(),
+                cx,
+            );
+
+            self.editor.update(cx, |message_editor, cx| {
+                message_editor.edit(
+                    [(
+                        multi_buffer::Anchor::max()..multi_buffer::Anchor::max(),
+                        completion.new_text,
+                    )],
+                    cx,
+                );
+            });
+            if let Some(confirm) = completion.confirm.clone() {
+                confirm(CompletionIntent::Complete, window, cx);
+            }
+        }
+    }
+
+    pub fn set_mode(&mut self, mode: EditorMode, cx: &mut Context<Self>) {
+        self.editor.update(cx, |editor, cx| {
+            editor.set_mode(mode);
+            cx.notify()
+        });
+    }
+
+    pub fn set_message(
+        &mut self,
+        message: &[acp::ContentBlock],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let mut text = String::new();
+        let mut mentions = Vec::new();
+
+        for chunk in message {
+            match chunk {
+                acp::ContentBlock::Text(text_content) => {
+                    text.push_str(&text_content.text);
+                }
+                acp::ContentBlock::Resource(acp::EmbeddedResource {
+                    resource: acp::EmbeddedResourceResource::TextResourceContents(resource),
+                    ..
+                }) => {
+                    if let Some(mention) = MentionUri::parse(&resource.uri).log_err() {
+                        let project_path = self
+                            .project
+                            .read(cx)
+                            .project_path_for_absolute_path(&abs_path, cx);
+                        let start = text.len();
+                        write!(text, "{}", mention.as_link());
+                        let end = text.len();
+                        mentions.push((start..end, project_path, filename));
+                    }
+                }
+                acp::ContentBlock::Image(_)
+                | acp::ContentBlock::Audio(_)
+                | acp::ContentBlock::Resource(_)
+                | acp::ContentBlock::ResourceLink(_) => {}
+            }
+        }
+
+        let snapshot = self.editor.update(cx, |editor, cx| {
+            editor.set_text(text, window, cx);
+            editor.buffer().read(cx).snapshot(cx)
+        });
+
+        self.mention_set.lock().clear();
+        for (range, project_path, filename) in mentions {
+            let crease_icon_path = if project_path.path.is_dir() {
+                FileIcons::get_folder_icon(false, cx)
+                    .unwrap_or_else(|| IconName::Folder.path().into())
+            } else {
+                FileIcons::get_icon(Path::new(project_path.path.as_ref()), cx)
+                    .unwrap_or_else(|| IconName::File.path().into())
+            };
+
+            let anchor = snapshot.anchor_before(range.start);
+            if let Some(project_path) = self.project.read(cx).absolute_path(&project_path, cx) {
+                let crease_id = crate::context_picker::insert_crease_for_mention(
+                    anchor.excerpt_id,
+                    anchor.text_anchor,
+                    range.end - range.start,
+                    filename,
+                    crease_icon_path,
+                    self.editor.clone(),
+                    window,
+                    cx,
+                );
+
+                if let Some(crease_id) = crease_id {
+                    self.mention_set.lock().insert(crease_id, project_path);
+                }
+            }
+        }
+        cx.notify();
+    }
+
+    #[cfg(test)]
+    pub fn set_text(&mut self, text: &str, window: &mut Window, cx: &mut Context<Self>) {
+        self.editor.update(cx, |editor, cx| {
+            editor.set_text(text, window, cx);
+        });
+    }
+}
+
+impl Focusable for MessageEditor {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.editor.focus_handle(cx)
+    }
+}
+
+impl Render for MessageEditor {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .key_context("MessageEditor")
+            .on_action(cx.listener(Self::chat))
+            .on_action(cx.listener(Self::cancel))
+            .flex_1()
+            .child({
+                let settings = ThemeSettings::get_global(cx);
+                let font_size = TextSize::Small
+                    .rems(cx)
+                    .to_pixels(settings.agent_font_size(cx));
+                let line_height = settings.buffer_line_height.value() * font_size;
+
+                let text_style = TextStyle {
+                    color: cx.theme().colors().text,
+                    font_family: settings.buffer_font.family.clone(),
+                    font_fallbacks: settings.buffer_font.fallbacks.clone(),
+                    font_features: settings.buffer_font.features.clone(),
+                    font_size: font_size.into(),
+                    line_height: line_height.into(),
+                    ..Default::default()
+                };
+
+                EditorElement::new(
+                    &self.editor,
+                    EditorStyle {
+                        background: cx.theme().colors().editor_background,
+                        local_player: cx.theme().players().local(),
+                        text: text_style,
+                        syntax: cx.theme().syntax().clone(),
+                        ..Default::default()
+                    },
+                )
+            })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use agent_client_protocol as acp;
+    use editor::EditorMode;
+    use fs::FakeFs;
+    use gpui::{AppContext, TestAppContext};
+    use lsp::{CompletionContext, CompletionTriggerKind};
+    use project::{CompletionIntent, Project};
+    use serde_json::json;
+    use util::path;
+    use workspace::Workspace;
+
+    use crate::acp::{message_editor::MessageEditor, thread_view::tests::init_test};
+
+    #[gpui::test]
+    async fn test_at_mention_removal(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/project", json!({"file": ""})).await;
+        let project = Project::test(fs, [Path::new(path!("/project"))], cx).await;
+
+        let (workspace, cx) =
+            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
+
+        let message_editor = cx.update(|window, cx| {
+            cx.new(|cx| {
+                MessageEditor::new(
+                    workspace.downgrade(),
+                    project.clone(),
+                    EditorMode::AutoHeight {
+                        min_lines: 1,
+                        max_lines: None,
+                    },
+                    window,
+                    cx,
+                )
+            })
+        });
+        let editor = message_editor.update(cx, |message_editor, _| message_editor.editor.clone());
+
+        cx.run_until_parked();
+
+        let excerpt_id = editor.update(cx, |editor, cx| {
+            editor
+                .buffer()
+                .read(cx)
+                .excerpt_ids()
+                .into_iter()
+                .next()
+                .unwrap()
+        });
+        let completions = editor.update_in(cx, |editor, window, cx| {
+            editor.set_text("Hello @", window, cx);
+            let buffer = editor.buffer().read(cx).as_singleton().unwrap();
+            let completion_provider = editor.completion_provider().unwrap();
+            completion_provider.completions(
+                excerpt_id,
+                &buffer,
+                text::Anchor::MAX,
+                CompletionContext {
+                    trigger_kind: CompletionTriggerKind::TRIGGER_CHARACTER,
+                    trigger_character: Some("@".into()),
+                },
+                window,
+                cx,
+            )
+        });
+        let [_, completion]: [_; 2] = completions
+            .await
+            .unwrap()
+            .into_iter()
+            .flat_map(|response| response.completions)
+            .collect::<Vec<_>>()
+            .try_into()
+            .unwrap();
+
+        editor.update_in(cx, |editor, window, cx| {
+            let snapshot = editor.buffer().read(cx).snapshot(cx);
+            let start = snapshot
+                .anchor_in_excerpt(excerpt_id, completion.replace_range.start)
+                .unwrap();
+            let end = snapshot
+                .anchor_in_excerpt(excerpt_id, completion.replace_range.end)
+                .unwrap();
+            editor.edit([(start..end, completion.new_text)], cx);
+            (completion.confirm.unwrap())(CompletionIntent::Complete, window, cx);
+        });
+
+        cx.run_until_parked();
+
+        // Backspace over the inserted crease (and the following space).
+        editor.update_in(cx, |editor, window, cx| {
+            editor.backspace(&Default::default(), window, cx);
+            editor.backspace(&Default::default(), window, cx);
+        });
+
+        let content = message_editor
+            .update_in(cx, |message_editor, _window, cx| {
+                message_editor.contents(cx)
+            })
+            .await
+            .unwrap();
+
+        // We don't send a resource link for the deleted crease.
+        pretty_assertions::assert_matches!(content.as_slice(), [acp::ContentBlock::Text { .. }]);
+    }
+}

crates/agent_ui/src/acp/message_history.rs

@@ -1,88 +0,0 @@
-pub struct MessageHistory<T> {
-    items: Vec<T>,
-    current: Option<usize>,
-}
-
-impl<T> Default for MessageHistory<T> {
-    fn default() -> Self {
-        MessageHistory {
-            items: Vec::new(),
-            current: None,
-        }
-    }
-}
-
-impl<T> MessageHistory<T> {
-    pub fn push(&mut self, message: T) {
-        self.current.take();
-        self.items.push(message);
-    }
-
-    pub fn reset_position(&mut self) {
-        self.current.take();
-    }
-
-    pub fn prev(&mut self) -> Option<&T> {
-        if self.items.is_empty() {
-            return None;
-        }
-
-        let new_ix = self
-            .current
-            .get_or_insert(self.items.len())
-            .saturating_sub(1);
-
-        self.current = Some(new_ix);
-        self.items.get(new_ix)
-    }
-
-    pub fn next(&mut self) -> Option<&T> {
-        let current = self.current.as_mut()?;
-        *current += 1;
-
-        self.items.get(*current).or_else(|| {
-            self.current.take();
-            None
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_prev_next() {
-        let mut history = MessageHistory::default();
-
-        // Test empty history
-        assert_eq!(history.prev(), None);
-        assert_eq!(history.next(), None);
-
-        // Add some messages
-        history.push("first");
-        history.push("second");
-        history.push("third");
-
-        // Test prev navigation
-        assert_eq!(history.prev(), Some(&"third"));
-        assert_eq!(history.prev(), Some(&"second"));
-        assert_eq!(history.prev(), Some(&"first"));
-        assert_eq!(history.prev(), Some(&"first"));
-
-        assert_eq!(history.next(), Some(&"second"));
-
-        // Test mixed navigation
-        history.push("fourth");
-        assert_eq!(history.prev(), Some(&"fourth"));
-        assert_eq!(history.prev(), Some(&"third"));
-        assert_eq!(history.next(), Some(&"fourth"));
-        assert_eq!(history.next(), None);
-
-        // Test that push resets navigation
-        history.prev();
-        history.prev();
-        history.push("fifth");
-        assert_eq!(history.prev(), Some(&"fifth"));
-    }
-}

crates/agent_ui/src/agent_panel.rs

@@ -1,4 +1,3 @@
-use std::cell::RefCell;
 use std::ops::{Not, Range};
 use std::path::Path;
 use std::rc::Rc;
@@ -11,7 +10,6 @@ use serde::{Deserialize, Serialize};
 
 use crate::NewExternalAgentThread;
 use crate::agent_diff::AgentDiffThread;
-use crate::message_editor::{MAX_EDITOR_LINES, MIN_EDITOR_LINES};
 use crate::{
     AddContextServer, AgentDiffPane, ContinueThread, ContinueWithBurnMode,
     DeleteRecentlyOpenThread, ExpandMessageEditor, Follow, InlineAssistant, NewTextThread,
@@ -477,8 +475,6 @@ pub struct AgentPanel {
     configuration_subscription: Option<Subscription>,
     local_timezone: UtcOffset,
     active_view: ActiveView,
-    acp_message_history:
-        Rc<RefCell<crate::acp::MessageHistory<Vec<agent_client_protocol::ContentBlock>>>>,
     previous_view: Option<ActiveView>,
     history_store: Entity<HistoryStore>,
     history: Entity<ThreadHistory>,
@@ -766,7 +762,6 @@ impl AgentPanel {
             .unwrap(),
             inline_assist_context_store,
             previous_view: None,
-            acp_message_history: Default::default(),
             history_store: history_store.clone(),
             history: cx.new(|cx| ThreadHistory::new(weak_self, history_store, window, cx)),
             hovered_recent_history_item: None,
@@ -824,7 +819,9 @@ impl AgentPanel {
                 thread.update(cx, |thread, cx| thread.cancel_last_completion(window, cx));
             }
             ActiveView::ExternalAgentThread { thread_view, .. } => {
-                thread_view.update(cx, |thread_element, cx| thread_element.cancel(cx));
+                thread_view.update(cx, |thread_element, cx| {
+                    thread_element.cancel_generation(cx)
+                });
             }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {}
         }
@@ -963,7 +960,6 @@ impl AgentPanel {
     ) {
         let workspace = self.workspace.clone();
         let project = self.project.clone();
-        let message_history = self.acp_message_history.clone();
         let fs = self.fs.clone();
 
         const LAST_USED_EXTERNAL_AGENT_KEY: &str = "agent_panel__last_used_external_agent";
@@ -973,9 +969,6 @@ impl AgentPanel {
             agent: crate::ExternalAgent,
         }
 
-        let thread_store = self.thread_store.clone();
-        let text_thread_store = self.context_store.clone();
-
         cx.spawn_in(window, async move |this, cx| {
             let server: Rc<dyn AgentServer> = match agent_choice {
                 Some(agent) => {
@@ -1010,18 +1003,7 @@ impl AgentPanel {
 
             this.update_in(cx, |this, window, cx| {
                 let thread_view = cx.new(|cx| {
-                    crate::acp::AcpThreadView::new(
-                        server,
-                        workspace.clone(),
-                        project,
-                        thread_store.clone(),
-                        text_thread_store.clone(),
-                        message_history,
-                        MIN_EDITOR_LINES,
-                        Some(MAX_EDITOR_LINES),
-                        window,
-                        cx,
-                    )
+                    crate::acp::AcpThreadView::new(server, workspace.clone(), project, window, cx)
                 });
 
                 this.set_active_view(ActiveView::ExternalAgentThread { thread_view }, window, cx);
@@ -1575,8 +1557,6 @@ impl AgentPanel {
             self.active_view = new_view;
         }
 
-        self.acp_message_history.borrow_mut().reset_position();
-
         self.focus_handle(cx).focus(window);
     }
 

crates/agent_ui/src/context_picker.rs

@@ -1,16 +1,15 @@
 mod completion_provider;
-pub(crate) mod fetch_context_picker;
+mod fetch_context_picker;
 pub(crate) mod file_context_picker;
-pub(crate) mod rules_context_picker;
-pub(crate) mod symbol_context_picker;
-pub(crate) mod thread_context_picker;
+mod rules_context_picker;
+mod symbol_context_picker;
+mod thread_context_picker;
 
 use std::ops::Range;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use anyhow::{Result, anyhow};
-use collections::HashSet;
 pub use completion_provider::ContextPickerCompletionProvider;
 use editor::display_map::{Crease, CreaseId, CreaseMetadata, FoldId};
 use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
@@ -46,7 +45,7 @@ use agent::{
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum ContextPickerEntry {
+enum ContextPickerEntry {
     Mode(ContextPickerMode),
     Action(ContextPickerAction),
 }
@@ -75,7 +74,7 @@ impl ContextPickerEntry {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum ContextPickerMode {
+enum ContextPickerMode {
     File,
     Symbol,
     Fetch,
@@ -84,7 +83,7 @@ pub(crate) enum ContextPickerMode {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum ContextPickerAction {
+enum ContextPickerAction {
     AddSelections,
 }
 
@@ -532,7 +531,7 @@ impl ContextPicker {
             return vec![];
         };
 
-        recent_context_picker_entries_with_store(
+        recent_context_picker_entries(
             context_store,
             self.thread_store.clone(),
             self.text_thread_store.clone(),
@@ -586,8 +585,7 @@ impl Render for ContextPicker {
             })
     }
 }
-
-pub(crate) enum RecentEntry {
+enum RecentEntry {
     File {
         project_path: ProjectPath,
         path_prefix: Arc<str>,
@@ -595,7 +593,7 @@ pub(crate) enum RecentEntry {
     Thread(ThreadContextEntry),
 }
 
-pub(crate) fn available_context_picker_entries(
+fn available_context_picker_entries(
     prompt_store: &Option<Entity<PromptStore>>,
     thread_store: &Option<WeakEntity<ThreadStore>>,
     workspace: &Entity<Workspace>,
@@ -632,56 +630,24 @@ pub(crate) fn available_context_picker_entries(
     entries
 }
 
-fn recent_context_picker_entries_with_store(
+fn recent_context_picker_entries(
     context_store: Entity<ContextStore>,
     thread_store: Option<WeakEntity<ThreadStore>>,
     text_thread_store: Option<WeakEntity<TextThreadStore>>,
     workspace: Entity<Workspace>,
     exclude_path: Option<ProjectPath>,
     cx: &App,
-) -> Vec<RecentEntry> {
-    let project = workspace.read(cx).project();
-
-    let mut exclude_paths = context_store.read(cx).file_paths(cx);
-    exclude_paths.extend(exclude_path);
-
-    let exclude_paths = exclude_paths
-        .into_iter()
-        .filter_map(|project_path| project.read(cx).absolute_path(&project_path, cx))
-        .collect();
-
-    let exclude_threads = context_store.read(cx).thread_ids();
-
-    recent_context_picker_entries(
-        thread_store,
-        text_thread_store,
-        workspace,
-        &exclude_paths,
-        exclude_threads,
-        cx,
-    )
-}
-
-pub(crate) fn recent_context_picker_entries(
-    thread_store: Option<WeakEntity<ThreadStore>>,
-    text_thread_store: Option<WeakEntity<TextThreadStore>>,
-    workspace: Entity<Workspace>,
-    exclude_paths: &HashSet<PathBuf>,
-    exclude_threads: &HashSet<ThreadId>,
-    cx: &App,
 ) -> Vec<RecentEntry> {
     let mut recent = Vec::with_capacity(6);
+    let mut current_files = context_store.read(cx).file_paths(cx);
+    current_files.extend(exclude_path);
     let workspace = workspace.read(cx);
     let project = workspace.project().read(cx);
 
     recent.extend(
         workspace
             .recent_navigation_history_iter(cx)
-            .filter(|(_, abs_path)| {
-                abs_path
-                    .as_ref()
-                    .map_or(true, |path| !exclude_paths.contains(path.as_path()))
-            })
+            .filter(|(path, _)| !current_files.contains(path))
             .take(4)
             .filter_map(|(project_path, _)| {
                 project
@@ -693,6 +659,8 @@ pub(crate) fn recent_context_picker_entries(
             }),
     );
 
+    let current_threads = context_store.read(cx).thread_ids();
+
     let active_thread_id = workspace
         .panel::<AgentPanel>(cx)
         .and_then(|panel| Some(panel.read(cx).active_thread(cx)?.read(cx).id()));
@@ -704,7 +672,7 @@ pub(crate) fn recent_context_picker_entries(
         let mut threads = unordered_thread_entries(thread_store, text_thread_store, cx)
             .filter(|(_, thread)| match thread {
                 ThreadContextEntry::Thread { id, .. } => {
-                    Some(id) != active_thread_id && !exclude_threads.contains(id)
+                    Some(id) != active_thread_id && !current_threads.contains(id)
                 }
                 ThreadContextEntry::Context { .. } => true,
             })
@@ -742,7 +710,7 @@ fn add_selections_as_context(
     })
 }
 
-pub(crate) fn selection_ranges(
+fn selection_ranges(
     workspace: &Entity<Workspace>,
     cx: &mut App,
 ) -> Vec<(Entity<Buffer>, Range<text::Anchor>)> {

crates/agent_ui/src/context_picker/completion_provider.rs

@@ -35,7 +35,7 @@ use super::symbol_context_picker::search_symbols;
 use super::thread_context_picker::{ThreadContextEntry, ThreadMatch, search_threads};
 use super::{
     ContextPickerAction, ContextPickerEntry, ContextPickerMode, MentionLink, RecentEntry,
-    available_context_picker_entries, recent_context_picker_entries_with_store, selection_ranges,
+    available_context_picker_entries, recent_context_picker_entries, selection_ranges,
 };
 use crate::message_editor::ContextCreasesAddon;
 
@@ -787,7 +787,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
             .and_then(|b| b.read(cx).file())
             .map(|file| ProjectPath::from_file(file.as_ref(), cx));
 
-        let recent_entries = recent_context_picker_entries_with_store(
+        let recent_entries = recent_context_picker_entries(
             context_store.clone(),
             thread_store.clone(),
             text_thread_store.clone(),

crates/assistant_context/Cargo.toml

@@ -11,9 +11,6 @@ workspace = true
 [lib]
 path = "src/assistant_context.rs"
 
-[features]
-test-support = []
-
 [dependencies]
 agent_settings.workspace = true
 anyhow.workspace = true

crates/assistant_context/src/context_store.rs

@@ -138,27 +138,6 @@ impl ContextStore {
         })
     }
 
-    #[cfg(any(test, feature = "test-support"))]
-    pub fn fake(project: Entity<Project>, cx: &mut Context<Self>) -> Self {
-        Self {
-            contexts: Default::default(),
-            contexts_metadata: Default::default(),
-            context_server_slash_command_ids: Default::default(),
-            host_contexts: Default::default(),
-            fs: project.read(cx).fs().clone(),
-            languages: project.read(cx).languages().clone(),
-            slash_commands: Arc::default(),
-            telemetry: project.read(cx).client().telemetry().clone(),
-            _watch_updates: Task::ready(None),
-            client: project.read(cx).client(),
-            project,
-            project_is_shared: false,
-            client_subscription: None,
-            _project_subscriptions: Default::default(),
-            prompt_builder: Arc::new(PromptBuilder::new(None).unwrap()),
-        }
-    }
-
     async fn handle_advertise_contexts(
         this: Entity<Self>,
         envelope: TypedEnvelope<proto::AdvertiseContexts>,

crates/editor/src/editor.rs

@@ -12176,8 +12176,6 @@ impl Editor {
         let clipboard_text = Cow::Borrowed(text);
 
         self.transact(window, cx, |this, window, cx| {
-            let had_active_edit_prediction = this.has_active_edit_prediction();
-
             if let Some(mut clipboard_selections) = clipboard_selections {
                 let old_selections = this.selections.all::<usize>(cx);
                 let all_selections_were_entire_line =
@@ -12250,11 +12248,6 @@ impl Editor {
             } else {
                 this.insert(&clipboard_text, window, cx);
             }
-
-            let trigger_in_words =
-                this.show_edit_predictions_in_menu() || !had_active_edit_prediction;
-
-            this.trigger_completion_on_input(&text, trigger_in_words, window, cx);
         });
     }
 

crates/onboarding/src/editing_page.rs

@@ -721,7 +721,7 @@ fn render_popular_settings_section(
                 .items_start()
                 .justify_between()
                 .child(
-                    v_flex().child(Label::new("Minimap")).child(
+                    v_flex().child(Label::new("Mini Map")).child(
                         Label::new("See a high-level overview of your source code.")
                             .color(Color::Muted),
                     ),

crates/prompt_store/src/prompt_store.rs

@@ -58,6 +58,15 @@ pub enum PromptId {
     EditWorkflow,
 }
 
+impl std::fmt::Display for PromptId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PromptId::User { uuid } => write!(f, "{}", uuid.0),
+            PromptId::EditWorkflow => write!(f, "Edit workflow"),
+        }
+    }
+}
+
 impl PromptId {
     pub fn new() -> PromptId {
         UserPromptId::new().into()
@@ -90,15 +99,6 @@ impl From<Uuid> for UserPromptId {
     }
 }
 
-impl std::fmt::Display for PromptId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            PromptId::User { uuid } => write!(f, "{}", uuid.0),
-            PromptId::EditWorkflow => write!(f, "Edit workflow"),
-        }
-    }
-}
-
 pub struct PromptStore {
     env: heed::Env,
     metadata_cache: RwLock<MetadataCache>,

crates/zed/src/zed/app_menus.rs

@@ -35,7 +35,6 @@ pub fn app_menus() -> Vec<Menu> {
                     ],
                 }),
                 MenuItem::separator(),
-                #[cfg(target_os = "macos")]
                 MenuItem::os_submenu("Services", gpui::SystemMenuType::Services),
                 MenuItem::separator(),
                 MenuItem::action("Extensions", zed_actions::Extensions::default()),

crates/zed_actions/src/lib.rs

@@ -285,10 +285,6 @@ pub mod agent {
             ResetOnboarding,
             /// Starts a chat conversation with the agent.
             Chat,
-            /// Displays the previous message in the history.
-            PreviousHistoryMessage,
-            /// Displays the next message in the history.
-            NextHistoryMessage,
             /// Toggles the language model selector dropdown.
             #[action(deprecated_aliases = ["assistant::ToggleModelSelector", "assistant2::ToggleModelSelector"])]
             ToggleModelSelector