acp thread view: Always use editors for user messages (#36256)

This means the cursor will be at the position you clicked:


https://github.com/user-attachments/assets/0693950d-7513-4d90-88e2-55817df7213a


Release Notes:

- N/A

crates/agent_ui/src/acp/entry_view_state.rs

@@ -1,45 +1,141 @@
-use std::{collections::HashMap, ops::Range};
+use std::ops::Range;
 
-use acp_thread::AcpThread;
-use editor::{Editor, EditorMode, MinimapVisibility, MultiBuffer};
+use acp_thread::{AcpThread, AgentThreadEntry};
+use agent::{TextThreadStore, ThreadStore};
+use collections::HashMap;
+use editor::{Editor, EditorMode, MinimapVisibility};
 use gpui::{
-    AnyEntity, App, AppContext as _, Entity, EntityId, TextStyleRefinement, WeakEntity, Window,
+    AnyEntity, App, AppContext as _, Entity, EntityId, EventEmitter, TextStyleRefinement,
+    WeakEntity, Window,
 };
 use language::language_settings::SoftWrap;
+use project::Project;
 use settings::Settings as _;
 use terminal_view::TerminalView;
 use theme::ThemeSettings;
-use ui::TextSize;
+use ui::{Context, TextSize};
 use workspace::Workspace;
 
-#[derive(Default)]
+use crate::acp::message_editor::{MessageEditor, MessageEditorEvent};
+
 pub struct EntryViewState {
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    thread_store: Entity<ThreadStore>,
+    text_thread_store: Entity<TextThreadStore>,
     entries: Vec<Entry>,
 }
 
 impl EntryViewState {
+    pub fn new(
+        workspace: WeakEntity<Workspace>,
+        project: Entity<Project>,
+        thread_store: Entity<ThreadStore>,
+        text_thread_store: Entity<TextThreadStore>,
+    ) -> Self {
+        Self {
+            workspace,
+            project,
+            thread_store,
+            text_thread_store,
+            entries: Vec::new(),
+        }
+    }
+
     pub fn entry(&self, index: usize) -> Option<&Entry> {
         self.entries.get(index)
     }
 
     pub fn sync_entry(
         &mut self,
-        workspace: WeakEntity<Workspace>,
-        thread: Entity<AcpThread>,
         index: usize,
+        thread: &Entity<AcpThread>,
         window: &mut Window,
-        cx: &mut App,
+        cx: &mut Context<Self>,
     ) {
-        debug_assert!(index <= self.entries.len());
-        let entry = if let Some(entry) = self.entries.get_mut(index) {
-            entry
-        } else {
-            self.entries.push(Entry::default());
-            self.entries.last_mut().unwrap()
+        let Some(thread_entry) = thread.read(cx).entries().get(index) else {
+            return;
         };
 
-        entry.sync_diff_multibuffers(&thread, index, window, cx);
-        entry.sync_terminals(&workspace, &thread, index, window, cx);
+        match thread_entry {
+            AgentThreadEntry::UserMessage(message) => {
+                let has_id = message.id.is_some();
+                let chunks = message.chunks.clone();
+                let message_editor = cx.new(|cx| {
+                    let mut editor = MessageEditor::new(
+                        self.workspace.clone(),
+                        self.project.clone(),
+                        self.thread_store.clone(),
+                        self.text_thread_store.clone(),
+                        editor::EditorMode::AutoHeight {
+                            min_lines: 1,
+                            max_lines: None,
+                        },
+                        window,
+                        cx,
+                    );
+                    if !has_id {
+                        editor.set_read_only(true, cx);
+                    }
+                    editor.set_message(chunks, window, cx);
+                    editor
+                });
+                cx.subscribe(&message_editor, move |_, editor, event, cx| {
+                    cx.emit(EntryViewEvent {
+                        entry_index: index,
+                        view_event: ViewEvent::MessageEditorEvent(editor, *event),
+                    })
+                })
+                .detach();
+                self.set_entry(index, Entry::UserMessage(message_editor));
+            }
+            AgentThreadEntry::ToolCall(tool_call) => {
+                let terminals = tool_call.terminals().cloned().collect::<Vec<_>>();
+                let diffs = tool_call.diffs().cloned().collect::<Vec<_>>();
+
+                let views = if let Some(Entry::Content(views)) = self.entries.get_mut(index) {
+                    views
+                } else {
+                    self.set_entry(index, Entry::empty());
+                    let Some(Entry::Content(views)) = self.entries.get_mut(index) else {
+                        unreachable!()
+                    };
+                    views
+                };
+
+                for terminal in terminals {
+                    views.entry(terminal.entity_id()).or_insert_with(|| {
+                        create_terminal(
+                            self.workspace.clone(),
+                            self.project.clone(),
+                            terminal.clone(),
+                            window,
+                            cx,
+                        )
+                        .into_any()
+                    });
+                }
+
+                for diff in diffs {
+                    views
+                        .entry(diff.entity_id())
+                        .or_insert_with(|| create_editor_diff(diff.clone(), window, cx).into_any());
+                }
+            }
+            AgentThreadEntry::AssistantMessage(_) => {
+                if index == self.entries.len() {
+                    self.entries.push(Entry::empty())
+                }
+            }
+        };
+    }
+
+    fn set_entry(&mut self, index: usize, entry: Entry) {
+        if index == self.entries.len() {
+            self.entries.push(entry);
+        } else {
+            self.entries[index] = entry;
+        }
     }
 
     pub fn remove(&mut self, range: Range<usize>) {
@@ -48,26 +144,51 @@ impl EntryViewState {
 
     pub fn settings_changed(&mut self, cx: &mut App) {
         for entry in self.entries.iter() {
-            for view in entry.views.values() {
-                if let Ok(diff_editor) = view.clone().downcast::<Editor>() {
-                    diff_editor.update(cx, |diff_editor, cx| {
-                        diff_editor
-                            .set_text_style_refinement(diff_editor_text_style_refinement(cx));
-                        cx.notify();
-                    })
+            match entry {
+                Entry::UserMessage { .. } => {}
+                Entry::Content(response_views) => {
+                    for view in response_views.values() {
+                        if let Ok(diff_editor) = view.clone().downcast::<Editor>() {
+                            diff_editor.update(cx, |diff_editor, cx| {
+                                diff_editor.set_text_style_refinement(
+                                    diff_editor_text_style_refinement(cx),
+                                );
+                                cx.notify();
+                            })
+                        }
+                    }
                 }
             }
         }
     }
 }
 
-pub struct Entry {
-    views: HashMap<EntityId, AnyEntity>,
+impl EventEmitter<EntryViewEvent> for EntryViewState {}
+
+pub struct EntryViewEvent {
+    pub entry_index: usize,
+    pub view_event: ViewEvent,
+}
+
+pub enum ViewEvent {
+    MessageEditorEvent(Entity<MessageEditor>, MessageEditorEvent),
+}
+
+pub enum Entry {
+    UserMessage(Entity<MessageEditor>),
+    Content(HashMap<EntityId, AnyEntity>),
 }
 
 impl Entry {
-    pub fn editor_for_diff(&self, diff: &Entity<MultiBuffer>) -> Option<Entity<Editor>> {
-        self.views
+    pub fn message_editor(&self) -> Option<&Entity<MessageEditor>> {
+        match self {
+            Self::UserMessage(editor) => Some(editor),
+            Entry::Content(_) => None,
+        }
+    }
+
+    pub fn editor_for_diff(&self, diff: &Entity<acp_thread::Diff>) -> Option<Entity<Editor>> {
+        self.content_map()?
             .get(&diff.entity_id())
             .cloned()
             .map(|entity| entity.downcast::<Editor>().unwrap())
@@ -77,118 +198,88 @@ impl Entry {
         &self,
         terminal: &Entity<acp_thread::Terminal>,
     ) -> Option<Entity<TerminalView>> {
-        self.views
+        self.content_map()?
             .get(&terminal.entity_id())
             .cloned()
             .map(|entity| entity.downcast::<TerminalView>().unwrap())
     }
 
-    fn sync_diff_multibuffers(
-        &mut self,
-        thread: &Entity<AcpThread>,
-        index: usize,
-        window: &mut Window,
-        cx: &mut App,
-    ) {
-        let Some(entry) = thread.read(cx).entries().get(index) else {
-            return;
-        };
-
-        let multibuffers = entry
-            .diffs()
-            .map(|diff| diff.read(cx).multibuffer().clone());
-
-        let multibuffers = multibuffers.collect::<Vec<_>>();
-
-        for multibuffer in multibuffers {
-            if self.views.contains_key(&multibuffer.entity_id()) {
-                return;
-            }
-
-            let editor = cx.new(|cx| {
-                let mut editor = Editor::new(
-                    EditorMode::Full {
-                        scale_ui_elements_with_buffer_font_size: false,
-                        show_active_line_background: false,
-                        sized_by_content: true,
-                    },
-                    multibuffer.clone(),
-                    None,
-                    window,
-                    cx,
-                );
-                editor.set_show_gutter(false, cx);
-                editor.disable_inline_diagnostics();
-                editor.disable_expand_excerpt_buttons(cx);
-                editor.set_show_vertical_scrollbar(false, cx);
-                editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx);
-                editor.set_soft_wrap_mode(SoftWrap::None, cx);
-                editor.scroll_manager.set_forbid_vertical_scroll(true);
-                editor.set_show_indent_guides(false, cx);
-                editor.set_read_only(true);
-                editor.set_show_breakpoints(false, cx);
-                editor.set_show_code_actions(false, cx);
-                editor.set_show_git_diff_gutter(false, cx);
-                editor.set_expand_all_diff_hunks(cx);
-                editor.set_text_style_refinement(diff_editor_text_style_refinement(cx));
-                editor
-            });
-
-            let entity_id = multibuffer.entity_id();
-            self.views.insert(entity_id, editor.into_any());
+    fn content_map(&self) -> Option<&HashMap<EntityId, AnyEntity>> {
+        match self {
+            Self::Content(map) => Some(map),
+            _ => None,
         }
     }
 
-    fn sync_terminals(
-        &mut self,
-        workspace: &WeakEntity<Workspace>,
-        thread: &Entity<AcpThread>,
-        index: usize,
-        window: &mut Window,
-        cx: &mut App,
-    ) {
-        let Some(entry) = thread.read(cx).entries().get(index) else {
-            return;
-        };
-
-        let terminals = entry
-            .terminals()
-            .map(|terminal| terminal.clone())
-            .collect::<Vec<_>>();
-
-        for terminal in terminals {
-            if self.views.contains_key(&terminal.entity_id()) {
-                return;
-            }
-
-            let Some(strong_workspace) = workspace.upgrade() else {
-                return;
-            };
-
-            let terminal_view = cx.new(|cx| {
-                let mut view = TerminalView::new(
-                    terminal.read(cx).inner().clone(),
-                    workspace.clone(),
-                    None,
-                    strong_workspace.read(cx).project().downgrade(),
-                    window,
-                    cx,
-                );
-                view.set_embedded_mode(Some(1000), cx);
-                view
-            });
-
-            let entity_id = terminal.entity_id();
-            self.views.insert(entity_id, terminal_view.into_any());
-        }
+    fn empty() -> Self {
+        Self::Content(HashMap::default())
     }
 
     #[cfg(test)]
-    pub fn len(&self) -> usize {
-        self.views.len()
+    pub fn has_content(&self) -> bool {
+        match self {
+            Self::Content(map) => !map.is_empty(),
+            Self::UserMessage(_) => false,
+        }
     }
 }
 
+fn create_terminal(
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    terminal: Entity<acp_thread::Terminal>,
+    window: &mut Window,
+    cx: &mut App,
+) -> Entity<TerminalView> {
+    cx.new(|cx| {
+        let mut view = TerminalView::new(
+            terminal.read(cx).inner().clone(),
+            workspace.clone(),
+            None,
+            project.downgrade(),
+            window,
+            cx,
+        );
+        view.set_embedded_mode(Some(1000), cx);
+        view
+    })
+}
+
+fn create_editor_diff(
+    diff: Entity<acp_thread::Diff>,
+    window: &mut Window,
+    cx: &mut App,
+) -> Entity<Editor> {
+    cx.new(|cx| {
+        let mut editor = Editor::new(
+            EditorMode::Full {
+                scale_ui_elements_with_buffer_font_size: false,
+                show_active_line_background: false,
+                sized_by_content: true,
+            },
+            diff.read(cx).multibuffer().clone(),
+            None,
+            window,
+            cx,
+        );
+        editor.set_show_gutter(false, cx);
+        editor.disable_inline_diagnostics();
+        editor.disable_expand_excerpt_buttons(cx);
+        editor.set_show_vertical_scrollbar(false, cx);
+        editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx);
+        editor.set_soft_wrap_mode(SoftWrap::None, cx);
+        editor.scroll_manager.set_forbid_vertical_scroll(true);
+        editor.set_show_indent_guides(false, cx);
+        editor.set_read_only(true);
+        editor.set_show_breakpoints(false, cx);
+        editor.set_show_code_actions(false, cx);
+        editor.set_show_git_diff_gutter(false, cx);
+        editor.set_expand_all_diff_hunks(cx);
+        editor.set_text_style_refinement(diff_editor_text_style_refinement(cx));
+        editor
+    })
+}
+
 fn diff_editor_text_style_refinement(cx: &mut App) -> TextStyleRefinement {
     TextStyleRefinement {
         font_size: Some(
@@ -201,26 +292,20 @@ fn diff_editor_text_style_refinement(cx: &mut App) -> TextStyleRefinement {
     }
 }
 
-impl Default for Entry {
-    fn default() -> Self {
-        Self {
-            // Avoid allocating in the heap by default
-            views: HashMap::with_capacity(0),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::{path::Path, rc::Rc};
 
     use acp_thread::{AgentConnection, StubAgentConnection};
+    use agent::{TextThreadStore, ThreadStore};
     use agent_client_protocol as acp;
     use agent_settings::AgentSettings;
     use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind};
     use editor::{EditorSettings, RowInfo};
     use fs::FakeFs;
-    use gpui::{SemanticVersion, TestAppContext};
+    use gpui::{AppContext as _, SemanticVersion, TestAppContext};
+
+    use crate::acp::entry_view_state::EntryViewState;
     use multi_buffer::MultiBufferRow;
     use pretty_assertions::assert_matches;
     use project::Project;
@@ -230,8 +315,6 @@ mod tests {
     use util::path;
     use workspace::Workspace;
 
-    use crate::acp::entry_view_state::EntryViewState;
-
     #[gpui::test]
     async fn test_diff_sync(cx: &mut TestAppContext) {
         init_test(cx);
@@ -269,7 +352,7 @@ mod tests {
             .update(|_, cx| {
                 connection
                     .clone()
-                    .new_thread(project, Path::new(path!("/project")), cx)
+                    .new_thread(project.clone(), Path::new(path!("/project")), cx)
             })
             .await
             .unwrap();
@@ -279,12 +362,23 @@ mod tests {
             connection.send_update(session_id, acp::SessionUpdate::ToolCall(tool_call), cx)
         });
 
-        let mut view_state = EntryViewState::default();
-        cx.update(|window, cx| {
-            view_state.sync_entry(workspace.downgrade(), thread.clone(), 0, window, cx);
+        let thread_store = cx.new(|cx| ThreadStore::fake(project.clone(), cx));
+        let text_thread_store = cx.new(|cx| TextThreadStore::fake(project.clone(), cx));
+
+        let view_state = cx.new(|_cx| {
+            EntryViewState::new(
+                workspace.downgrade(),
+                project.clone(),
+                thread_store,
+                text_thread_store,
+            )
         });
 
-        let multibuffer = thread.read_with(cx, |thread, cx| {
+        view_state.update_in(cx, |view_state, window, cx| {
+            view_state.sync_entry(0, &thread, window, cx)
+        });
+
+        let diff = thread.read_with(cx, |thread, _cx| {
             thread
                 .entries()
                 .get(0)
@@ -292,15 +386,14 @@ mod tests {
                 .diffs()
                 .next()
                 .unwrap()
-                .read(cx)
-                .multibuffer()
                 .clone()
         });
 
         cx.run_until_parked();
 
-        let entry = view_state.entry(0).unwrap();
-        let diff_editor = entry.editor_for_diff(&multibuffer).unwrap();
+        let diff_editor = view_state.read_with(cx, |view_state, _cx| {
+            view_state.entry(0).unwrap().editor_for_diff(&diff).unwrap()
+        });
         assert_eq!(
             diff_editor.read_with(cx, |editor, cx| editor.text(cx)),
             "hi world\nhello world"