Merge branch 'main' into sumtree-v10000

crates/acp_thread/Cargo.toml

@@ -13,27 +13,35 @@ path = "src/acp_thread.rs"
 doctest = false
 
 [features]
-test-support = ["gpui/test-support", "project/test-support"]
+test-support = ["gpui/test-support", "project/test-support", "dep:parking_lot"]
 
 [dependencies]
+action_log.workspace = true
 agent-client-protocol.workspace = true
 anyhow.workspace = true
-assistant_tool.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
 language.workspace = true
 language_model.workspace = true
 markdown.workspace = true
+parking_lot = { workspace = true, optional = true }
 project.workspace = true
+prompt_store.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
+terminal.workspace = true
 ui.workspace = true
+url.workspace = true
 util.workspace = true
+uuid.workspace = true
+watch.workspace = true
 workspace-hack.workspace = true
 
 [dev-dependencies]

crates/acp_thread/src/connection.rs

@@ -1,18 +1,141 @@
-use std::{error::Error, fmt, path::Path, rc::Rc, sync::Arc};
-
+use crate::AcpThread;
 use agent_client_protocol::{self as acp};
 use anyhow::Result;
-use gpui::{AsyncApp, Entity, Task};
-use language_model::LanguageModel;
+use collections::IndexMap;
+use gpui::{Entity, SharedString, Task};
+use language_model::LanguageModelProviderId;
 use project::Project;
-use ui::App;
+use serde::{Deserialize, Serialize};
+use std::{any::Any, error::Error, fmt, path::Path, rc::Rc, sync::Arc};
+use ui::{App, IconName};
+use uuid::Uuid;
 
-use crate::AcpThread;
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
+pub struct UserMessageId(Arc<str>);
+
+impl UserMessageId {
+    pub fn new() -> Self {
+        Self(Uuid::new_v4().to_string().into())
+    }
+}
+
+pub trait AgentConnection {
+    fn new_thread(
+        self: Rc<Self>,
+        project: Entity<Project>,
+        cwd: &Path,
+        cx: &mut App,
+    ) -> Task<Result<Entity<AcpThread>>>;
+
+    fn auth_methods(&self) -> &[acp::AuthMethod];
+
+    fn authenticate(&self, method: acp::AuthMethodId, cx: &mut App) -> Task<Result<()>>;
+
+    fn prompt(
+        &self,
+        user_message_id: Option<UserMessageId>,
+        params: acp::PromptRequest,
+        cx: &mut App,
+    ) -> Task<Result<acp::PromptResponse>>;
+
+    fn prompt_capabilities(&self) -> acp::PromptCapabilities;
+
+    fn resume(
+        &self,
+        _session_id: &acp::SessionId,
+        _cx: &mut App,
+    ) -> Option<Rc<dyn AgentSessionResume>> {
+        None
+    }
+
+    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App);
+
+    fn session_editor(
+        &self,
+        _session_id: &acp::SessionId,
+        _cx: &mut App,
+    ) -> Option<Rc<dyn AgentSessionEditor>> {
+        None
+    }
+
+    /// Returns this agent as an [Rc<dyn ModelSelector>] if the model selection capability is supported.
+    ///
+    /// If the agent does not support model selection, returns [None].
+    /// This allows sharing the selector in UI components.
+    fn model_selector(&self) -> Option<Rc<dyn AgentModelSelector>> {
+        None
+    }
+
+    fn telemetry(&self) -> Option<Rc<dyn AgentTelemetry>> {
+        None
+    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
+}
+
+impl dyn AgentConnection {
+    pub fn downcast<T: 'static + AgentConnection + Sized>(self: Rc<Self>) -> Option<Rc<T>> {
+        self.into_any().downcast().ok()
+    }
+}
+
+pub trait AgentSessionEditor {
+    fn truncate(&self, message_id: UserMessageId, cx: &mut App) -> Task<Result<()>>;
+}
+
+pub trait AgentSessionResume {
+    fn run(&self, cx: &mut App) -> Task<Result<acp::PromptResponse>>;
+}
+
+pub trait AgentTelemetry {
+    /// The name of the agent used for telemetry.
+    fn agent_name(&self) -> String;
+
+    /// A representation of the current thread state that can be serialized for
+    /// storage with telemetry events.
+    fn thread_data(
+        &self,
+        session_id: &acp::SessionId,
+        cx: &mut App,
+    ) -> Task<Result<serde_json::Value>>;
+}
+
+#[derive(Debug)]
+pub struct AuthRequired {
+    pub description: Option<String>,
+    pub provider_id: Option<LanguageModelProviderId>,
+}
+
+impl AuthRequired {
+    pub fn new() -> Self {
+        Self {
+            description: None,
+            provider_id: None,
+        }
+    }
+
+    pub fn with_description(mut self, description: String) -> Self {
+        self.description = Some(description);
+        self
+    }
+
+    pub fn with_language_model_provider(mut self, provider_id: LanguageModelProviderId) -> Self {
+        self.provider_id = Some(provider_id);
+        self
+    }
+}
+
+impl Error for AuthRequired {}
+impl fmt::Display for AuthRequired {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Authentication required")
+    }
+}
 
 /// Trait for agents that support listing, selecting, and querying language models.
 ///
 /// This is an optional capability; agents indicate support via [AgentConnection::model_selector].
-pub trait ModelSelector: 'static {
+pub trait AgentModelSelector: 'static {
     /// Lists all available language models for this agent.
     ///
     /// # Parameters
@@ -20,7 +143,7 @@ pub trait ModelSelector: 'static {
     ///
     /// # Returns
     /// A task resolving to the list of models or an error (e.g., if no models are configured).
-    fn list_models(&self, cx: &mut AsyncApp) -> Task<Result<Vec<Arc<dyn LanguageModel>>>>;
+    fn list_models(&self, cx: &mut App) -> Task<Result<AgentModelList>>;
 
     /// Selects a model for a specific session (thread).
     ///
@@ -37,8 +160,8 @@ pub trait ModelSelector: 'static {
     fn select_model(
         &self,
         session_id: acp::SessionId,
-        model: Arc<dyn LanguageModel>,
-        cx: &mut AsyncApp,
+        model_id: AgentModelId,
+        cx: &mut App,
     ) -> Task<Result<()>>;
 
     /// Retrieves the currently selected model for a specific session (thread).
@@ -52,42 +175,276 @@ pub trait ModelSelector: 'static {
     fn selected_model(
         &self,
         session_id: &acp::SessionId,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<Arc<dyn LanguageModel>>>;
+        cx: &mut App,
+    ) -> Task<Result<AgentModelInfo>>;
+
+    /// Whenever the model list is updated the receiver will be notified.
+    fn watch(&self, cx: &mut App) -> watch::Receiver<()>;
 }
 
-pub trait AgentConnection {
-    fn new_thread(
-        self: Rc<Self>,
-        project: Entity<Project>,
-        cwd: &Path,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<Entity<AcpThread>>>;
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AgentModelId(pub SharedString);
 
-    fn auth_methods(&self) -> &[acp::AuthMethod];
+impl std::ops::Deref for AgentModelId {
+    type Target = SharedString;
 
-    fn authenticate(&self, method: acp::AuthMethodId, cx: &mut App) -> Task<Result<()>>;
-
-    fn prompt(&self, params: acp::PromptRequest, cx: &mut App)
-    -> Task<Result<acp::PromptResponse>>;
-
-    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App);
-
-    /// Returns this agent as an [Rc<dyn ModelSelector>] if the model selection capability is supported.
-    ///
-    /// If the agent does not support model selection, returns [None].
-    /// This allows sharing the selector in UI components.
-    fn model_selector(&self) -> Option<Rc<dyn ModelSelector>> {
-        None // Default impl for agents that don't support it
+    fn deref(&self) -> &Self::Target {
+        &self.0
     }
 }
 
-#[derive(Debug)]
-pub struct AuthRequired;
-
-impl Error for AuthRequired {}
-impl fmt::Display for AuthRequired {
+impl fmt::Display for AgentModelId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "AuthRequired")
+        self.0.fmt(f)
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AgentModelInfo {
+    pub id: AgentModelId,
+    pub name: SharedString,
+    pub icon: Option<IconName>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AgentModelGroupName(pub SharedString);
+
+#[derive(Debug, Clone)]
+pub enum AgentModelList {
+    Flat(Vec<AgentModelInfo>),
+    Grouped(IndexMap<AgentModelGroupName, Vec<AgentModelInfo>>),
+}
+
+impl AgentModelList {
+    pub fn is_empty(&self) -> bool {
+        match self {
+            AgentModelList::Flat(models) => models.is_empty(),
+            AgentModelList::Grouped(groups) => groups.is_empty(),
+        }
+    }
+}
+
+#[cfg(feature = "test-support")]
+mod test_support {
+    use std::sync::Arc;
+
+    use action_log::ActionLog;
+    use collections::HashMap;
+    use futures::{channel::oneshot, future::try_join_all};
+    use gpui::{AppContext as _, WeakEntity};
+    use parking_lot::Mutex;
+
+    use super::*;
+
+    #[derive(Clone, Default)]
+    pub struct StubAgentConnection {
+        sessions: Arc<Mutex<HashMap<acp::SessionId, Session>>>,
+        permission_requests: HashMap<acp::ToolCallId, Vec<acp::PermissionOption>>,
+        next_prompt_updates: Arc<Mutex<Vec<acp::SessionUpdate>>>,
+    }
+
+    struct Session {
+        thread: WeakEntity<AcpThread>,
+        response_tx: Option<oneshot::Sender<acp::StopReason>>,
+    }
+
+    impl StubAgentConnection {
+        pub fn new() -> Self {
+            Self {
+                next_prompt_updates: Default::default(),
+                permission_requests: HashMap::default(),
+                sessions: Arc::default(),
+            }
+        }
+
+        pub fn set_next_prompt_updates(&self, updates: Vec<acp::SessionUpdate>) {
+            *self.next_prompt_updates.lock() = updates;
+        }
+
+        pub fn with_permission_requests(
+            mut self,
+            permission_requests: HashMap<acp::ToolCallId, Vec<acp::PermissionOption>>,
+        ) -> Self {
+            self.permission_requests = permission_requests;
+            self
+        }
+
+        pub fn send_update(
+            &self,
+            session_id: acp::SessionId,
+            update: acp::SessionUpdate,
+            cx: &mut App,
+        ) {
+            assert!(
+                self.next_prompt_updates.lock().is_empty(),
+                "Use either send_update or set_next_prompt_updates"
+            );
+
+            self.sessions
+                .lock()
+                .get(&session_id)
+                .unwrap()
+                .thread
+                .update(cx, |thread, cx| {
+                    thread.handle_session_update(update, cx).unwrap();
+                })
+                .unwrap();
+        }
+
+        pub fn end_turn(&self, session_id: acp::SessionId, stop_reason: acp::StopReason) {
+            self.sessions
+                .lock()
+                .get_mut(&session_id)
+                .unwrap()
+                .response_tx
+                .take()
+                .expect("No pending turn")
+                .send(stop_reason)
+                .unwrap();
+        }
+    }
+
+    impl AgentConnection for StubAgentConnection {
+        fn auth_methods(&self) -> &[acp::AuthMethod] {
+            &[]
+        }
+
+        fn new_thread(
+            self: Rc<Self>,
+            project: Entity<Project>,
+            _cwd: &Path,
+            cx: &mut gpui::App,
+        ) -> Task<gpui::Result<Entity<AcpThread>>> {
+            let session_id = acp::SessionId(self.sessions.lock().len().to_string().into());
+            let action_log = cx.new(|_| ActionLog::new(project.clone()));
+            let thread = cx.new(|_cx| {
+                AcpThread::new(
+                    "Test",
+                    self.clone(),
+                    project,
+                    action_log,
+                    session_id.clone(),
+                )
+            });
+            self.sessions.lock().insert(
+                session_id,
+                Session {
+                    thread: thread.downgrade(),
+                    response_tx: None,
+                },
+            );
+            Task::ready(Ok(thread))
+        }
+
+        fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+            acp::PromptCapabilities {
+                image: true,
+                audio: true,
+                embedded_context: true,
+            }
+        }
+
+        fn authenticate(
+            &self,
+            _method_id: acp::AuthMethodId,
+            _cx: &mut App,
+        ) -> Task<gpui::Result<()>> {
+            unimplemented!()
+        }
+
+        fn prompt(
+            &self,
+            _id: Option<UserMessageId>,
+            params: acp::PromptRequest,
+            cx: &mut App,
+        ) -> Task<gpui::Result<acp::PromptResponse>> {
+            let mut sessions = self.sessions.lock();
+            let Session {
+                thread,
+                response_tx,
+            } = sessions.get_mut(&params.session_id).unwrap();
+            let mut tasks = vec![];
+            if self.next_prompt_updates.lock().is_empty() {
+                let (tx, rx) = oneshot::channel();
+                response_tx.replace(tx);
+                cx.spawn(async move |_| {
+                    let stop_reason = rx.await?;
+                    Ok(acp::PromptResponse { stop_reason })
+                })
+            } else {
+                for update in self.next_prompt_updates.lock().drain(..) {
+                    let thread = thread.clone();
+                    let update = update.clone();
+                    let permission_request = if let acp::SessionUpdate::ToolCall(tool_call) =
+                        &update
+                        && let Some(options) = self.permission_requests.get(&tool_call.id)
+                    {
+                        Some((tool_call.clone(), options.clone()))
+                    } else {
+                        None
+                    };
+                    let task = cx.spawn(async move |cx| {
+                        if let Some((tool_call, options)) = permission_request {
+                            let permission = thread.update(cx, |thread, cx| {
+                                thread.request_tool_call_authorization(
+                                    tool_call.clone().into(),
+                                    options.clone(),
+                                    cx,
+                                )
+                            })?;
+                            permission?.await?;
+                        }
+                        thread.update(cx, |thread, cx| {
+                            thread.handle_session_update(update.clone(), cx).unwrap();
+                        })?;
+                        anyhow::Ok(())
+                    });
+                    tasks.push(task);
+                }
+
+                cx.spawn(async move |_| {
+                    try_join_all(tasks).await?;
+                    Ok(acp::PromptResponse {
+                        stop_reason: acp::StopReason::EndTurn,
+                    })
+                })
+            }
+        }
+
+        fn cancel(&self, session_id: &acp::SessionId, _cx: &mut App) {
+            if let Some(end_turn_tx) = self
+                .sessions
+                .lock()
+                .get_mut(session_id)
+                .unwrap()
+                .response_tx
+                .take()
+            {
+                end_turn_tx.send(acp::StopReason::Cancelled).unwrap();
+            }
+        }
+
+        fn session_editor(
+            &self,
+            _session_id: &agent_client_protocol::SessionId,
+            _cx: &mut App,
+        ) -> Option<Rc<dyn AgentSessionEditor>> {
+            Some(Rc::new(StubAgentSessionEditor))
+        }
+
+        fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+            self
+        }
+    }
+
+    struct StubAgentSessionEditor;
+
+    impl AgentSessionEditor for StubAgentSessionEditor {
+        fn truncate(&self, _: UserMessageId, _: &mut App) -> Task<Result<()>> {
+            Task::ready(Ok(()))
+        }
+    }
+}
+
+#[cfg(feature = "test-support")]
+pub use test_support::*;

crates/acp_thread/src/diff.rs

@@ -0,0 +1,385 @@
+use anyhow::Result;
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
+use editor::{MultiBuffer, PathKey};
+use gpui::{App, AppContext, AsyncApp, Context, Entity, Subscription, Task};
+use itertools::Itertools;
+use language::{
+    Anchor, Buffer, Capability, LanguageRegistry, OffsetRangeExt as _, Point, Rope, TextBuffer,
+};
+use std::{
+    cmp::Reverse,
+    ops::Range,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use util::ResultExt;
+
+pub enum Diff {
+    Pending(PendingDiff),
+    Finalized(FinalizedDiff),
+}
+
+impl Diff {
+    pub fn finalized(
+        path: PathBuf,
+        old_text: Option<String>,
+        new_text: String,
+        language_registry: Arc<LanguageRegistry>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let multibuffer = cx.new(|_cx| MultiBuffer::without_headers(Capability::ReadOnly));
+        let buffer = cx.new(|cx| Buffer::local(new_text, cx));
+        let task = cx.spawn({
+            let multibuffer = multibuffer.clone();
+            let path = path.clone();
+            async move |_, cx| {
+                let language = language_registry
+                    .language_for_file_path(&path)
+                    .await
+                    .log_err();
+
+                buffer.update(cx, |buffer, cx| buffer.set_language(language.clone(), cx))?;
+
+                let diff = build_buffer_diff(
+                    old_text.unwrap_or("".into()).into(),
+                    &buffer,
+                    Some(language_registry.clone()),
+                    cx,
+                )
+                .await?;
+
+                multibuffer
+                    .update(cx, |multibuffer, cx| {
+                        let hunk_ranges = {
+                            let buffer = buffer.read(cx);
+                            let diff = diff.read(cx);
+                            diff.hunks_intersecting_range(Anchor::MIN..Anchor::MAX, buffer, cx)
+                                .map(|diff_hunk| diff_hunk.buffer_range.to_point(buffer))
+                                .collect::<Vec<_>>()
+                        };
+
+                        multibuffer.set_excerpts_for_path(
+                            PathKey::for_buffer(&buffer, cx),
+                            buffer.clone(),
+                            hunk_ranges,
+                            editor::DEFAULT_MULTIBUFFER_CONTEXT,
+                            cx,
+                        );
+                        multibuffer.add_diff(diff, cx);
+                    })
+                    .log_err();
+
+                anyhow::Ok(())
+            }
+        });
+
+        Self::Finalized(FinalizedDiff {
+            multibuffer,
+            path,
+            _update_diff: task,
+        })
+    }
+
+    pub fn new(buffer: Entity<Buffer>, cx: &mut Context<Self>) -> Self {
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let base_text = buffer_snapshot.text();
+        let language_registry = buffer.read(cx).language_registry();
+        let text_snapshot = buffer.read(cx).text_snapshot();
+        let buffer_diff = cx.new(|cx| {
+            let mut diff = BufferDiff::new(&text_snapshot, cx);
+            let _ = diff.set_base_text(
+                buffer_snapshot.clone(),
+                language_registry,
+                text_snapshot,
+                cx,
+            );
+            let snapshot = diff.snapshot(cx);
+
+            let secondary_diff = cx.new(|cx| {
+                let mut diff = BufferDiff::new(&buffer_snapshot, cx);
+                diff.set_snapshot(snapshot, &buffer_snapshot, cx);
+                diff
+            });
+            diff.set_secondary_diff(secondary_diff);
+
+            diff
+        });
+
+        let multibuffer = cx.new(|cx| {
+            let mut multibuffer = MultiBuffer::without_headers(Capability::ReadOnly);
+            multibuffer.add_diff(buffer_diff.clone(), cx);
+            multibuffer
+        });
+
+        Self::Pending(PendingDiff {
+            multibuffer,
+            base_text: Arc::new(base_text),
+            _subscription: cx.observe(&buffer, |this, _, cx| {
+                if let Diff::Pending(diff) = this {
+                    diff.update(cx);
+                }
+            }),
+            buffer,
+            diff: buffer_diff,
+            revealed_ranges: Vec::new(),
+            update_diff: Task::ready(Ok(())),
+        })
+    }
+
+    pub fn reveal_range(&mut self, range: Range<Anchor>, cx: &mut Context<Self>) {
+        if let Self::Pending(diff) = self {
+            diff.reveal_range(range, cx);
+        }
+    }
+
+    pub fn finalize(&mut self, cx: &mut Context<Self>) {
+        if let Self::Pending(diff) = self {
+            *self = Self::Finalized(diff.finalize(cx));
+        }
+    }
+
+    pub fn multibuffer(&self) -> &Entity<MultiBuffer> {
+        match self {
+            Self::Pending(PendingDiff { multibuffer, .. }) => multibuffer,
+            Self::Finalized(FinalizedDiff { multibuffer, .. }) => multibuffer,
+        }
+    }
+
+    pub fn to_markdown(&self, cx: &App) -> String {
+        let buffer_text = self
+            .multibuffer()
+            .read(cx)
+            .all_buffers()
+            .iter()
+            .map(|buffer| buffer.read(cx).text())
+            .join("\n");
+        let path = match self {
+            Diff::Pending(PendingDiff { buffer, .. }) => {
+                buffer.read(cx).file().map(|file| file.path().as_ref())
+            }
+            Diff::Finalized(FinalizedDiff { path, .. }) => Some(path.as_path()),
+        };
+        format!(
+            "Diff: {}\n```\n{}\n```\n",
+            path.unwrap_or(Path::new("untitled")).display(),
+            buffer_text
+        )
+    }
+
+    pub fn has_revealed_range(&self, cx: &App) -> bool {
+        self.multibuffer().read(cx).excerpt_paths().next().is_some()
+    }
+}
+
+pub struct PendingDiff {
+    multibuffer: Entity<MultiBuffer>,
+    base_text: Arc<String>,
+    buffer: Entity<Buffer>,
+    diff: Entity<BufferDiff>,
+    revealed_ranges: Vec<Range<Anchor>>,
+    _subscription: Subscription,
+    update_diff: Task<Result<()>>,
+}
+
+impl PendingDiff {
+    pub fn update(&mut self, cx: &mut Context<Diff>) {
+        let buffer = self.buffer.clone();
+        let buffer_diff = self.diff.clone();
+        let base_text = self.base_text.clone();
+        self.update_diff = cx.spawn(async move |diff, cx| {
+            let text_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot())?;
+            let diff_snapshot = BufferDiff::update_diff(
+                buffer_diff.clone(),
+                text_snapshot.clone(),
+                Some(base_text),
+                false,
+                false,
+                None,
+                None,
+                cx,
+            )
+            .await?;
+            buffer_diff.update(cx, |diff, cx| {
+                diff.set_snapshot(diff_snapshot.clone(), &text_snapshot, cx);
+                diff.secondary_diff().unwrap().update(cx, |diff, cx| {
+                    diff.set_snapshot(diff_snapshot.clone(), &text_snapshot, cx);
+                });
+            })?;
+            diff.update(cx, |diff, cx| {
+                if let Diff::Pending(diff) = diff {
+                    diff.update_visible_ranges(cx);
+                }
+            })
+        });
+    }
+
+    pub fn reveal_range(&mut self, range: Range<Anchor>, cx: &mut Context<Diff>) {
+        self.revealed_ranges.push(range);
+        self.update_visible_ranges(cx);
+    }
+
+    fn finalize(&self, cx: &mut Context<Diff>) -> FinalizedDiff {
+        let ranges = self.excerpt_ranges(cx);
+        let base_text = self.base_text.clone();
+        let language_registry = self.buffer.read(cx).language_registry();
+
+        let path = self
+            .buffer
+            .read(cx)
+            .file()
+            .map(|file| file.path().as_ref())
+            .unwrap_or(Path::new("untitled"))
+            .into();
+
+        // Replace the buffer in the multibuffer with the snapshot
+        let buffer = cx.new(|cx| {
+            let language = self.buffer.read(cx).language().cloned();
+            let buffer = TextBuffer::new_normalized(
+                0,
+                cx.entity_id().as_non_zero_u64().into(),
+                self.buffer.read(cx).line_ending(),
+                self.buffer.read(cx).as_rope().clone(),
+            );
+            let mut buffer = Buffer::build(buffer, None, Capability::ReadWrite);
+            buffer.set_language(language, cx);
+            buffer
+        });
+
+        let buffer_diff = cx.spawn({
+            let buffer = buffer.clone();
+            async move |_this, cx| {
+                build_buffer_diff(base_text, &buffer, language_registry, cx).await
+            }
+        });
+
+        let update_diff = cx.spawn(async move |this, cx| {
+            let buffer_diff = buffer_diff.await?;
+            this.update(cx, |this, cx| {
+                this.multibuffer().update(cx, |multibuffer, cx| {
+                    let path_key = PathKey::for_buffer(&buffer, cx);
+                    multibuffer.clear(cx);
+                    multibuffer.set_excerpts_for_path(
+                        path_key,
+                        buffer,
+                        ranges,
+                        editor::DEFAULT_MULTIBUFFER_CONTEXT,
+                        cx,
+                    );
+                    multibuffer.add_diff(buffer_diff.clone(), cx);
+                });
+
+                cx.notify();
+            })
+        });
+
+        FinalizedDiff {
+            path,
+            multibuffer: self.multibuffer.clone(),
+            _update_diff: update_diff,
+        }
+    }
+
+    fn update_visible_ranges(&mut self, cx: &mut Context<Diff>) {
+        let ranges = self.excerpt_ranges(cx);
+        self.multibuffer.update(cx, |multibuffer, cx| {
+            multibuffer.set_excerpts_for_path(
+                PathKey::for_buffer(&self.buffer, cx),
+                self.buffer.clone(),
+                ranges,
+                editor::DEFAULT_MULTIBUFFER_CONTEXT,
+                cx,
+            );
+            let end = multibuffer.len(cx);
+            Some(multibuffer.snapshot(cx).offset_to_point(end).row + 1)
+        });
+        cx.notify();
+    }
+
+    fn excerpt_ranges(&self, cx: &App) -> Vec<Range<Point>> {
+        let buffer = self.buffer.read(cx);
+        let diff = self.diff.read(cx);
+        let mut ranges = diff
+            .hunks_intersecting_range(Anchor::MIN..Anchor::MAX, buffer, cx)
+            .map(|diff_hunk| diff_hunk.buffer_range.to_point(buffer))
+            .collect::<Vec<_>>();
+        ranges.extend(
+            self.revealed_ranges
+                .iter()
+                .map(|range| range.to_point(buffer)),
+        );
+        ranges.sort_unstable_by_key(|range| (range.start, Reverse(range.end)));
+
+        // Merge adjacent ranges
+        let mut ranges = ranges.into_iter().peekable();
+        let mut merged_ranges = Vec::new();
+        while let Some(mut range) = ranges.next() {
+            while let Some(next_range) = ranges.peek() {
+                if range.end >= next_range.start {
+                    range.end = range.end.max(next_range.end);
+                    ranges.next();
+                } else {
+                    break;
+                }
+            }
+
+            merged_ranges.push(range);
+        }
+        merged_ranges
+    }
+}
+
+pub struct FinalizedDiff {
+    path: PathBuf,
+    multibuffer: Entity<MultiBuffer>,
+    _update_diff: Task<Result<()>>,
+}
+
+async fn build_buffer_diff(
+    old_text: Arc<String>,
+    buffer: &Entity<Buffer>,
+    language_registry: Option<Arc<LanguageRegistry>>,
+    cx: &mut AsyncApp,
+) -> Result<Entity<BufferDiff>> {
+    let buffer = cx.update(|cx| buffer.read(cx).snapshot())?;
+
+    let old_text_rope = cx
+        .background_spawn({
+            let old_text = old_text.clone();
+            async move { Rope::from(old_text.as_str()) }
+        })
+        .await;
+    let base_buffer = cx
+        .update(|cx| {
+            Buffer::build_snapshot(
+                old_text_rope,
+                buffer.language().cloned(),
+                language_registry,
+                cx,
+            )
+        })?
+        .await;
+
+    let diff_snapshot = cx
+        .update(|cx| {
+            BufferDiffSnapshot::new_with_base_buffer(
+                buffer.text.clone(),
+                Some(old_text),
+                base_buffer,
+                cx,
+            )
+        })?
+        .await;
+
+    let secondary_diff = cx.new(|cx| {
+        let mut diff = BufferDiff::new(&buffer, cx);
+        diff.set_snapshot(diff_snapshot.clone(), &buffer, cx);
+        diff
+    })?;
+
+    cx.new(|cx| {
+        let mut diff = BufferDiff::new(&buffer.text, cx);
+        diff.set_snapshot(diff_snapshot, &buffer, cx);
+        diff.set_secondary_diff(secondary_diff);
+        diff
+    })
+}

crates/acp_thread/src/mention.rs

@@ -0,0 +1,438 @@
+use agent_client_protocol as acp;
+use anyhow::{Context as _, Result, bail};
+use file_icons::FileIcons;
+use prompt_store::{PromptId, UserPromptId};
+use serde::{Deserialize, Serialize};
+use std::{
+    fmt,
+    ops::Range,
+    path::{Path, PathBuf},
+    str::FromStr,
+};
+use ui::{App, IconName, SharedString};
+use url::Url;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
+pub enum MentionUri {
+    File {
+        abs_path: PathBuf,
+    },
+    Directory {
+        abs_path: PathBuf,
+    },
+    Symbol {
+        path: PathBuf,
+        name: String,
+        line_range: Range<u32>,
+    },
+    Thread {
+        id: acp::SessionId,
+        name: String,
+    },
+    TextThread {
+        path: PathBuf,
+        name: String,
+    },
+    Rule {
+        id: PromptId,
+        name: String,
+    },
+    Selection {
+        path: PathBuf,
+        line_range: Range<u32>,
+    },
+    Fetch {
+        url: Url,
+    },
+}
+
+impl MentionUri {
+    pub fn parse(input: &str) -> Result<Self> {
+        let url = url::Url::parse(input)?;
+        let path = url.path();
+        match url.scheme() {
+            "file" => {
+                let path = url.to_file_path().ok().context("Extracting file path")?;
+                if let Some(fragment) = url.fragment() {
+                    let range = fragment
+                        .strip_prefix("L")
+                        .context("Line range must start with \"L\"")?;
+                    let (start, end) = range
+                        .split_once(":")
+                        .context("Line range must use colon as separator")?;
+                    let line_range = start
+                        .parse::<u32>()
+                        .context("Parsing line range start")?
+                        .checked_sub(1)
+                        .context("Line numbers should be 1-based")?
+                        ..end
+                            .parse::<u32>()
+                            .context("Parsing line range end")?
+                            .checked_sub(1)
+                            .context("Line numbers should be 1-based")?;
+                    if let Some(name) = single_query_param(&url, "symbol")? {
+                        Ok(Self::Symbol {
+                            name,
+                            path,
+                            line_range,
+                        })
+                    } else {
+                        Ok(Self::Selection { path, line_range })
+                    }
+                } else if input.ends_with("/") {
+                    Ok(Self::Directory { abs_path: path })
+                } else {
+                    Ok(Self::File { abs_path: path })
+                }
+            }
+            "zed" => {
+                if let Some(thread_id) = path.strip_prefix("/agent/thread/") {
+                    let name = single_query_param(&url, "name")?.context("Missing thread name")?;
+                    Ok(Self::Thread {
+                        id: acp::SessionId(thread_id.into()),
+                        name,
+                    })
+                } else if let Some(path) = path.strip_prefix("/agent/text-thread/") {
+                    let name = single_query_param(&url, "name")?.context("Missing thread name")?;
+                    Ok(Self::TextThread {
+                        path: path.into(),
+                        name,
+                    })
+                } else if let Some(rule_id) = path.strip_prefix("/agent/rule/") {
+                    let name = single_query_param(&url, "name")?.context("Missing rule name")?;
+                    let rule_id = UserPromptId(rule_id.parse()?);
+                    Ok(Self::Rule {
+                        id: rule_id.into(),
+                        name,
+                    })
+                } else {
+                    bail!("invalid zed url: {:?}", input);
+                }
+            }
+            "http" | "https" => Ok(MentionUri::Fetch { url }),
+            other => bail!("unrecognized scheme {:?}", other),
+        }
+    }
+
+    pub fn name(&self) -> String {
+        match self {
+            MentionUri::File { abs_path, .. } | MentionUri::Directory { abs_path, .. } => abs_path
+                .file_name()
+                .unwrap_or_default()
+                .to_string_lossy()
+                .into_owned(),
+            MentionUri::Symbol { name, .. } => name.clone(),
+            MentionUri::Thread { name, .. } => name.clone(),
+            MentionUri::TextThread { name, .. } => name.clone(),
+            MentionUri::Rule { name, .. } => name.clone(),
+            MentionUri::Selection {
+                path, line_range, ..
+            } => selection_name(path, line_range),
+            MentionUri::Fetch { url } => url.to_string(),
+        }
+    }
+
+    pub fn icon_path(&self, cx: &mut App) -> SharedString {
+        match self {
+            MentionUri::File { abs_path } => {
+                FileIcons::get_icon(abs_path, cx).unwrap_or_else(|| IconName::File.path().into())
+            }
+            MentionUri::Directory { .. } => FileIcons::get_folder_icon(false, cx)
+                .unwrap_or_else(|| IconName::Folder.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 { abs_path } => {
+                Url::from_file_path(abs_path).expect("mention path should be absolute")
+            }
+            MentionUri::Directory { abs_path } => {
+                Url::from_directory_path(abs_path).expect("mention path should be absolute")
+            }
+            MentionUri::Symbol {
+                path,
+                name,
+                line_range,
+            } => {
+                let mut url = Url::from_file_path(path).expect("mention path should be absolute");
+                url.query_pairs_mut().append_pair("symbol", name);
+                url.set_fragment(Some(&format!(
+                    "L{}:{}",
+                    line_range.start + 1,
+                    line_range.end + 1
+                )));
+                url
+            }
+            MentionUri::Selection { path, line_range } => {
+                let mut url = Url::from_file_path(path).expect("mention path should be absolute");
+                url.set_fragment(Some(&format!(
+                    "L{}:{}",
+                    line_range.start + 1,
+                    line_range.end + 1
+                )));
+                url
+            }
+            MentionUri::Thread { name, id } => {
+                let mut url = Url::parse("zed:///").unwrap();
+                url.set_path(&format!("/agent/thread/{id}"));
+                url.query_pairs_mut().append_pair("name", name);
+                url
+            }
+            MentionUri::TextThread { path, name } => {
+                let mut url = Url::parse("zed:///").unwrap();
+                url.set_path(&format!("/agent/text-thread/{}", path.to_string_lossy()));
+                url.query_pairs_mut().append_pair("name", name);
+                url
+            }
+            MentionUri::Rule { name, id } => {
+                let mut url = Url::parse("zed:///").unwrap();
+                url.set_path(&format!("/agent/rule/{id}"));
+                url.query_pairs_mut().append_pair("name", name);
+                url
+            }
+            MentionUri::Fetch { url } => url.clone(),
+        }
+    }
+}
+
+impl FromStr for MentionUri {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<Self> {
+        Self::parse(s)
+    }
+}
+
+pub struct MentionLink<'a>(&'a MentionUri);
+
+impl fmt::Display for MentionLink<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "[@{}]({})", self.0.name(), self.0.to_uri())
+    }
+}
+
+fn single_query_param(url: &Url, name: &'static str) -> Result<Option<String>> {
+    let pairs = url.query_pairs().collect::<Vec<_>>();
+    match pairs.as_slice() {
+        [] => Ok(None),
+        [(k, v)] => {
+            if k != name {
+                bail!("invalid query parameter")
+            }
+
+            Ok(Some(v.to_string()))
+        }
+        _ => bail!("too many query pairs"),
+    }
+}
+
+pub fn selection_name(path: &Path, line_range: &Range<u32>) -> String {
+    format!(
+        "{} ({}:{})",
+        path.file_name().unwrap_or_default().display(),
+        line_range.start + 1,
+        line_range.end + 1
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use util::{path, uri};
+
+    use super::*;
+
+    #[test]
+    fn test_parse_file_uri() {
+        let file_uri = uri!("file:///path/to/file.rs");
+        let parsed = MentionUri::parse(file_uri).unwrap();
+        match &parsed {
+            MentionUri::File { abs_path } => {
+                assert_eq!(abs_path.to_str().unwrap(), path!("/path/to/file.rs"));
+            }
+            _ => panic!("Expected File variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), file_uri);
+    }
+
+    #[test]
+    fn test_parse_directory_uri() {
+        let file_uri = uri!("file:///path/to/dir/");
+        let parsed = MentionUri::parse(file_uri).unwrap();
+        match &parsed {
+            MentionUri::Directory { abs_path } => {
+                assert_eq!(abs_path.to_str().unwrap(), path!("/path/to/dir/"));
+            }
+            _ => panic!("Expected Directory variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), file_uri);
+    }
+
+    #[test]
+    fn test_to_directory_uri_with_slash() {
+        let uri = MentionUri::Directory {
+            abs_path: PathBuf::from(path!("/path/to/dir/")),
+        };
+        let expected = uri!("file:///path/to/dir/");
+        assert_eq!(uri.to_uri().to_string(), expected);
+    }
+
+    #[test]
+    fn test_to_directory_uri_without_slash() {
+        let uri = MentionUri::Directory {
+            abs_path: PathBuf::from(path!("/path/to/dir")),
+        };
+        let expected = uri!("file:///path/to/dir/");
+        assert_eq!(uri.to_uri().to_string(), expected);
+    }
+
+    #[test]
+    fn test_parse_symbol_uri() {
+        let symbol_uri = uri!("file:///path/to/file.rs?symbol=MySymbol#L10:20");
+        let parsed = MentionUri::parse(symbol_uri).unwrap();
+        match &parsed {
+            MentionUri::Symbol {
+                path,
+                name,
+                line_range,
+            } => {
+                assert_eq!(path.to_str().unwrap(), path!("/path/to/file.rs"));
+                assert_eq!(name, "MySymbol");
+                assert_eq!(line_range.start, 9);
+                assert_eq!(line_range.end, 19);
+            }
+            _ => panic!("Expected Symbol variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), symbol_uri);
+    }
+
+    #[test]
+    fn test_parse_selection_uri() {
+        let selection_uri = uri!("file:///path/to/file.rs#L5:15");
+        let parsed = MentionUri::parse(selection_uri).unwrap();
+        match &parsed {
+            MentionUri::Selection { path, line_range } => {
+                assert_eq!(path.to_str().unwrap(), path!("/path/to/file.rs"));
+                assert_eq!(line_range.start, 4);
+                assert_eq!(line_range.end, 14);
+            }
+            _ => panic!("Expected Selection variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), selection_uri);
+    }
+
+    #[test]
+    fn test_parse_thread_uri() {
+        let thread_uri = "zed:///agent/thread/session123?name=Thread+name";
+        let parsed = MentionUri::parse(thread_uri).unwrap();
+        match &parsed {
+            MentionUri::Thread {
+                id: thread_id,
+                name,
+            } => {
+                assert_eq!(thread_id.to_string(), "session123");
+                assert_eq!(name, "Thread name");
+            }
+            _ => panic!("Expected Thread variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), thread_uri);
+    }
+
+    #[test]
+    fn test_parse_rule_uri() {
+        let rule_uri = "zed:///agent/rule/d8694ff2-90d5-4b6f-be33-33c1763acd52?name=Some+rule";
+        let parsed = MentionUri::parse(rule_uri).unwrap();
+        match &parsed {
+            MentionUri::Rule { id, name } => {
+                assert_eq!(id.to_string(), "d8694ff2-90d5-4b6f-be33-33c1763acd52");
+                assert_eq!(name, "Some rule");
+            }
+            _ => panic!("Expected Rule variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), rule_uri);
+    }
+
+    #[test]
+    fn test_parse_fetch_http_uri() {
+        let http_uri = "http://example.com/path?query=value#fragment";
+        let parsed = MentionUri::parse(http_uri).unwrap();
+        match &parsed {
+            MentionUri::Fetch { url } => {
+                assert_eq!(url.to_string(), http_uri);
+            }
+            _ => panic!("Expected Fetch variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), http_uri);
+    }
+
+    #[test]
+    fn test_parse_fetch_https_uri() {
+        let https_uri = "https://example.com/api/endpoint";
+        let parsed = MentionUri::parse(https_uri).unwrap();
+        match &parsed {
+            MentionUri::Fetch { url } => {
+                assert_eq!(url.to_string(), https_uri);
+            }
+            _ => panic!("Expected Fetch variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), https_uri);
+    }
+
+    #[test]
+    fn test_invalid_scheme() {
+        assert!(MentionUri::parse("ftp://example.com").is_err());
+        assert!(MentionUri::parse("ssh://example.com").is_err());
+        assert!(MentionUri::parse("unknown://example.com").is_err());
+    }
+
+    #[test]
+    fn test_invalid_zed_path() {
+        assert!(MentionUri::parse("zed:///invalid/path").is_err());
+        assert!(MentionUri::parse("zed:///agent/unknown/test").is_err());
+    }
+
+    #[test]
+    fn test_invalid_line_range_format() {
+        // Missing L prefix
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#10:20")).is_err());
+
+        // Missing colon separator
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#L1020")).is_err());
+
+        // Invalid numbers
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#L10:abc")).is_err());
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#Labc:20")).is_err());
+    }
+
+    #[test]
+    fn test_invalid_query_parameters() {
+        // Invalid query parameter name
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#L10:20?invalid=test")).is_err());
+
+        // Too many query parameters
+        assert!(
+            MentionUri::parse(uri!(
+                "file:///path/to/file.rs#L10:20?symbol=test&another=param"
+            ))
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn test_zero_based_line_numbers() {
+        // Test that 0-based line numbers are rejected (should be 1-based)
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#L0:10")).is_err());
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#L1:0")).is_err());
+        assert!(MentionUri::parse(uri!("file:///path/to/file.rs#L0:0")).is_err());
+    }
+}

crates/acp_thread/src/terminal.rs

@@ -0,0 +1,93 @@
+use gpui::{App, AppContext, Context, Entity};
+use language::LanguageRegistry;
+use markdown::Markdown;
+use std::{path::PathBuf, process::ExitStatus, sync::Arc, time::Instant};
+
+pub struct Terminal {
+    command: Entity<Markdown>,
+    working_dir: Option<PathBuf>,
+    terminal: Entity<terminal::Terminal>,
+    started_at: Instant,
+    output: Option<TerminalOutput>,
+}
+
+pub struct TerminalOutput {
+    pub ended_at: Instant,
+    pub exit_status: Option<ExitStatus>,
+    pub was_content_truncated: bool,
+    pub original_content_len: usize,
+    pub content_line_count: usize,
+    pub finished_with_empty_output: bool,
+}
+
+impl Terminal {
+    pub fn new(
+        command: String,
+        working_dir: Option<PathBuf>,
+        terminal: Entity<terminal::Terminal>,
+        language_registry: Arc<LanguageRegistry>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        Self {
+            command: cx.new(|cx| {
+                Markdown::new(
+                    format!("```\n{}\n```", command).into(),
+                    Some(language_registry.clone()),
+                    None,
+                    cx,
+                )
+            }),
+            working_dir,
+            terminal,
+            started_at: Instant::now(),
+            output: None,
+        }
+    }
+
+    pub fn finish(
+        &mut self,
+        exit_status: Option<ExitStatus>,
+        original_content_len: usize,
+        truncated_content_len: usize,
+        content_line_count: usize,
+        finished_with_empty_output: bool,
+        cx: &mut Context<Self>,
+    ) {
+        self.output = Some(TerminalOutput {
+            ended_at: Instant::now(),
+            exit_status,
+            was_content_truncated: truncated_content_len < original_content_len,
+            original_content_len,
+            content_line_count,
+            finished_with_empty_output,
+        });
+        cx.notify();
+    }
+
+    pub fn command(&self) -> &Entity<Markdown> {
+        &self.command
+    }
+
+    pub fn working_dir(&self) -> &Option<PathBuf> {
+        &self.working_dir
+    }
+
+    pub fn started_at(&self) -> Instant {
+        self.started_at
+    }
+
+    pub fn output(&self) -> Option<&TerminalOutput> {
+        self.output.as_ref()
+    }
+
+    pub fn inner(&self) -> &Entity<terminal::Terminal> {
+        &self.terminal
+    }
+
+    pub fn to_markdown(&self, cx: &App) -> String {
+        format!(
+            "Terminal:\n```\n{}\n```\n",
+            self.terminal.read(cx).get_content()
+        )
+    }
+}

crates/action_log/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "action_log"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lib]
+path = "src/action_log.rs"
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow.workspace = true
+buffer_diff.workspace = true
+clock.workspace = true
+collections.workspace = true
+futures.workspace = true
+gpui.workspace = true
+language.workspace = true
+project.workspace = true
+text.workspace = true
+util.workspace = true
+watch.workspace = true
+workspace-hack.workspace = true
+
+
+[dev-dependencies]
+buffer_diff = { workspace = true, features = ["test-support"] }
+collections = { workspace = true, features = ["test-support"] }
+clock = { workspace = true, features = ["test-support"] }
+ctor.workspace = true
+gpui = { workspace = true, features = ["test-support"] }
+indoc.workspace = true
+language = { workspace = true, features = ["test-support"] }
+log.workspace = true
+pretty_assertions.workspace = true
+project = { workspace = true, features = ["test-support"] }
+rand.workspace = true
+serde_json.workspace = true
+settings = { workspace = true, features = ["test-support"] }
+text = { workspace = true, features = ["test-support"] }
+util = { workspace = true, features = ["test-support"] }
+zlog.workspace = true

crates/action_log/src/action_log.rs

@@ -17,8 +17,6 @@ use util::{
 pub struct ActionLog {
     /// 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>,
 }
@@ -28,7 +26,6 @@ impl ActionLog {
     pub fn new(project: Entity<Project>) -> Self {
         Self {
             tracked_buffers: BTreeMap::default(),
-            edited_since_project_diagnostics_check: false,
             project,
         }
     }
@@ -37,16 +34,6 @@ impl ActionLog {
         &self.project
     }
 
-    /// Notifies a diagnostics check
-    pub fn checked_project_diagnostics(&mut self) {
-        self.edited_since_project_diagnostics_check = false;
-    }
-
-    /// Returns true if any files have been edited since the last project diagnostics check
-    pub fn has_edited_files_since_project_diagnostics_check(&self) -> bool {
-        self.edited_since_project_diagnostics_check
-    }
-
     pub fn latest_snapshot(&self, buffer: &Entity<Buffer>) -> Option<text::BufferSnapshot> {
         Some(self.tracked_buffers.get(buffer)?.snapshot.clone())
     }
@@ -129,7 +116,7 @@ impl ActionLog {
             } else if buffer
                 .read(cx)
                 .file()
-                .map_or(false, |file| file.disk_state().exists())
+                .is_some_and(|file| file.disk_state().exists())
             {
                 TrackedBufferStatus::Created {
                     existing_file_content: Some(buffer.read(cx).as_rope().clone()),
@@ -174,7 +161,7 @@ impl ActionLog {
                     diff_base,
                     last_seen_base,
                     unreviewed_edits,
-                    snapshot: text_snapshot.clone(),
+                    snapshot: text_snapshot,
                     status,
                     version: buffer.read(cx).version(),
                     diff,
@@ -203,7 +190,7 @@ impl ActionLog {
         cx: &mut Context<Self>,
     ) {
         match event {
-            BufferEvent::Edited { .. } => self.handle_buffer_edited(buffer, cx),
+            BufferEvent::Edited => self.handle_buffer_edited(buffer, cx),
             BufferEvent::FileHandleChanged => {
                 self.handle_buffer_file_changed(buffer, cx);
             }
@@ -228,7 +215,7 @@ impl ActionLog {
                 if buffer
                     .read(cx)
                     .file()
-                    .map_or(false, |file| file.disk_state() == DiskState::Deleted)
+                    .is_some_and(|file| file.disk_state() == DiskState::Deleted)
                 {
                     // If the buffer had been edited by a tool, but it got
                     // deleted externally, we want to stop tracking it.
@@ -240,7 +227,7 @@ impl ActionLog {
                 if buffer
                     .read(cx)
                     .file()
-                    .map_or(false, |file| file.disk_state() != DiskState::Deleted)
+                    .is_some_and(|file| file.disk_state() != DiskState::Deleted)
                 {
                     // If the buffer had been deleted by a tool, but it got
                     // resurrected externally, we want to clear the edits we
@@ -277,15 +264,14 @@ impl ActionLog {
             if let Some((git_diff, (buffer_repo, _))) = git_diff.as_ref().zip(buffer_repo) {
                 cx.update(|cx| {
                     let mut old_head = buffer_repo.read(cx).head_commit.clone();
-                    Some(cx.subscribe(git_diff, move |_, event, cx| match event {
-                        buffer_diff::BufferDiffEvent::DiffChanged { .. } => {
+                    Some(cx.subscribe(git_diff, move |_, event, cx| {
+                        if let buffer_diff::BufferDiffEvent::DiffChanged { .. } = event {
                             let new_head = buffer_repo.read(cx).head_commit.clone();
                             if new_head != old_head {
                                 old_head = new_head;
                                 git_diff_updates_tx.send(()).ok();
                             }
                         }
-                        _ => {}
                     }))
                 })?
             } else {
@@ -303,7 +289,7 @@ impl ActionLog {
                 }
                 _ = git_diff_updates_rx.changed().fuse() => {
                     if let Some(git_diff) = git_diff.as_ref() {
-                        Self::keep_committed_edits(&this, &buffer, &git_diff, cx).await?;
+                        Self::keep_committed_edits(&this, &buffer, git_diff, cx).await?;
                     }
                 }
             }
@@ -475,7 +461,7 @@ impl ActionLog {
             anyhow::Ok((
                 tracked_buffer.diff.clone(),
                 buffer.read(cx).language().cloned(),
-                buffer.read(cx).language_registry().clone(),
+                buffer.read(cx).language_registry(),
             ))
         })??;
         let diff_snapshot = BufferDiff::update_diff(
@@ -511,7 +497,7 @@ impl ActionLog {
                                     new: new_range,
                                 },
                                 &new_diff_base,
-                                &buffer_snapshot.as_rope(),
+                                buffer_snapshot.as_rope(),
                             ));
                         }
                         unreviewed_edits
@@ -543,15 +529,12 @@ impl ActionLog {
 
     /// Mark a buffer as created by agent, so we can refresh it in the context
     pub fn buffer_created(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
-        self.edited_since_project_diagnostics_check = true;
-        self.track_buffer_internal(buffer.clone(), true, cx);
+        self.track_buffer_internal(buffer, true, cx);
     }
 
     /// Mark a buffer as edited by agent, 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;
-
-        let tracked_buffer = self.track_buffer_internal(buffer.clone(), false, cx);
+        let tracked_buffer = self.track_buffer_internal(buffer, false, cx);
         if let TrackedBufferStatus::Deleted = tracked_buffer.status {
             tracked_buffer.status = TrackedBufferStatus::Modified;
         }
@@ -630,10 +613,10 @@ impl ActionLog {
                         false
                     }
                 });
-                if tracked_buffer.unreviewed_edits.is_empty() {
-                    if let TrackedBufferStatus::Created { .. } = &mut tracked_buffer.status {
-                        tracked_buffer.status = TrackedBufferStatus::Modified;
-                    }
+                if tracked_buffer.unreviewed_edits.is_empty()
+                    && let TrackedBufferStatus::Created { .. } = &mut tracked_buffer.status
+                {
+                    tracked_buffer.status = TrackedBufferStatus::Modified;
                 }
                 tracked_buffer.schedule_diff_update(ChangeAuthor::User, cx);
             }
@@ -827,7 +810,7 @@ impl ActionLog {
                 tracked.version != buffer.version
                     && buffer
                         .file()
-                        .map_or(false, |file| file.disk_state() != DiskState::Deleted)
+                        .is_some_and(|file| file.disk_state() != DiskState::Deleted)
             })
             .map(|(buffer, _)| buffer)
     }
@@ -863,7 +846,7 @@ fn apply_non_conflicting_edits(
                 conflict = true;
                 if new_edits
                     .peek()
-                    .map_or(false, |next_edit| next_edit.old.overlaps(&old_edit.new))
+                    .is_some_and(|next_edit| next_edit.old.overlaps(&old_edit.new))
                 {
                     new_edit = new_edits.next().unwrap();
                 } else {
@@ -980,7 +963,7 @@ impl TrackedBuffer {
     fn has_edits(&self, cx: &App) -> bool {
         self.diff
             .read(cx)
-            .hunks(&self.buffer.read(cx), cx)
+            .hunks(self.buffer.read(cx), cx)
             .next()
             .is_some()
     }
@@ -2284,7 +2267,7 @@ mod tests {
             log::info!("quiescing...");
             cx.run_until_parked();
             action_log.update(cx, |log, cx| {
-                let tracked_buffer = log.tracked_buffers.get(&buffer).unwrap();
+                let tracked_buffer = log.tracked_buffers.get(buffer).unwrap();
                 let mut old_text = tracked_buffer.diff_base.clone();
                 let new_text = buffer.read(cx).as_rope();
                 for edit in tracked_buffer.unreviewed_edits.edits() {
@@ -2442,7 +2425,7 @@ mod tests {
         assert_eq!(
             unreviewed_hunks(&action_log, cx),
             vec![(
-                buffer.clone(),
+                buffer,
                 vec![
                     HunkStatus {
                         range: Point::new(6, 0)..Point::new(7, 0),

crates/activity_indicator/src/activity_indicator.rs

@@ -103,26 +103,21 @@ impl ActivityIndicator {
             cx.subscribe_in(
                 &workspace_handle,
                 window,
-                |activity_indicator, _, event, window, cx| match event {
-                    workspace::Event::ClearActivityIndicator { .. } => {
-                        if activity_indicator.statuses.pop().is_some() {
-                            activity_indicator.dismiss_error_message(
-                                &DismissErrorMessage,
-                                window,
-                                cx,
-                            );
-                            cx.notify();
-                        }
+                |activity_indicator, _, event, window, cx| {
+                    if let workspace::Event::ClearActivityIndicator = event
+                        && activity_indicator.statuses.pop().is_some()
+                    {
+                        activity_indicator.dismiss_error_message(&DismissErrorMessage, window, cx);
+                        cx.notify();
                     }
-                    _ => {}
                 },
             )
             .detach();
 
             cx.subscribe(
                 &project.read(cx).lsp_store(),
-                |activity_indicator, _, event, cx| match event {
-                    LspStoreEvent::LanguageServerUpdate { name, message, .. } => {
+                |activity_indicator, _, event, cx| {
+                    if let LspStoreEvent::LanguageServerUpdate { name, message, .. } = event {
                         if let proto::update_language_server::Variant::StatusUpdate(status_update) =
                             message
                         {
@@ -191,7 +186,6 @@ impl ActivityIndicator {
                         }
                         cx.notify()
                     }
-                    _ => {}
                 },
             )
             .detach();
@@ -206,9 +200,10 @@ impl ActivityIndicator {
 
             cx.subscribe(
                 &project.read(cx).git_store().clone(),
-                |_, _, event: &GitStoreEvent, cx| match event {
-                    project::git_store::GitStoreEvent::JobsUpdated => cx.notify(),
-                    _ => {}
+                |_, _, event: &GitStoreEvent, cx| {
+                    if let project::git_store::GitStoreEvent::JobsUpdated = event {
+                        cx.notify()
+                    }
                 },
             )
             .detach();
@@ -458,26 +453,24 @@ impl ActivityIndicator {
             .map(|r| r.read(cx))
             .and_then(Repository::current_job);
         // Show any long-running git command
-        if let Some(job_info) = current_job {
-            if Instant::now() - job_info.start >= GIT_OPERATION_DELAY {
-                return Some(Content {
-                    icon: Some(
-                        Icon::new(IconName::ArrowCircle)
-                            .size(IconSize::Small)
-                            .with_animation(
-                                "arrow-circle",
-                                Animation::new(Duration::from_secs(2)).repeat(),
-                                |icon, delta| {
-                                    icon.transform(Transformation::rotate(percentage(delta)))
-                                },
-                            )
-                            .into_any_element(),
-                    ),
-                    message: job_info.message.into(),
-                    on_click: None,
-                    tooltip_message: None,
-                });
-            }
+        if let Some(job_info) = current_job
+            && Instant::now() - job_info.start >= GIT_OPERATION_DELAY
+        {
+            return Some(Content {
+                icon: Some(
+                    Icon::new(IconName::ArrowCircle)
+                        .size(IconSize::Small)
+                        .with_animation(
+                            "arrow-circle",
+                            Animation::new(Duration::from_secs(2)).repeat(),
+                            |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
+                        )
+                        .into_any_element(),
+                ),
+                message: job_info.message.into(),
+                on_click: None,
+                tooltip_message: None,
+            });
         }
 
         // Show any language server installation info.
@@ -702,7 +695,7 @@ impl ActivityIndicator {
                     on_click: Some(Arc::new(|this, window, cx| {
                         this.dismiss_error_message(&DismissErrorMessage, window, cx)
                     })),
-                    tooltip_message: Some(Self::version_tooltip_message(&version)),
+                    tooltip_message: Some(Self::version_tooltip_message(version)),
                 }),
                 AutoUpdateStatus::Installing { version } => Some(Content {
                     icon: Some(
@@ -714,21 +707,13 @@ impl ActivityIndicator {
                     on_click: Some(Arc::new(|this, window, cx| {
                         this.dismiss_error_message(&DismissErrorMessage, window, cx)
                     })),
-                    tooltip_message: Some(Self::version_tooltip_message(&version)),
+                    tooltip_message: Some(Self::version_tooltip_message(version)),
                 }),
-                AutoUpdateStatus::Updated {
-                    binary_path,
-                    version,
-                } => Some(Content {
+                AutoUpdateStatus::Updated { version } => Some(Content {
                     icon: None,
                     message: "Click to restart and update Zed".to_string(),
-                    on_click: Some(Arc::new({
-                        let reload = workspace::Reload {
-                            binary_path: Some(binary_path.clone()),
-                        };
-                        move |_, _, cx| workspace::reload(&reload, cx)
-                    })),
-                    tooltip_message: Some(Self::version_tooltip_message(&version)),
+                    on_click: Some(Arc::new(move |_, _, cx| workspace::reload(cx))),
+                    tooltip_message: Some(Self::version_tooltip_message(version)),
                 }),
                 AutoUpdateStatus::Errored => Some(Content {
                     icon: Some(
@@ -748,21 +733,20 @@ impl ActivityIndicator {
 
         if let Some(extension_store) =
             ExtensionStore::try_global(cx).map(|extension_store| extension_store.read(cx))
+            && let Some(extension_id) = extension_store.outstanding_operations().keys().next()
         {
-            if let Some(extension_id) = extension_store.outstanding_operations().keys().next() {
-                return Some(Content {
-                    icon: Some(
-                        Icon::new(IconName::Download)
-                            .size(IconSize::Small)
-                            .into_any_element(),
-                    ),
-                    message: format!("Updating {extension_id} extension…"),
-                    on_click: Some(Arc::new(|this, window, cx| {
-                        this.dismiss_error_message(&DismissErrorMessage, window, cx)
-                    })),
-                    tooltip_message: None,
-                });
-            }
+            return Some(Content {
+                icon: Some(
+                    Icon::new(IconName::Download)
+                        .size(IconSize::Small)
+                        .into_any_element(),
+                ),
+                message: format!("Updating {extension_id} extension…"),
+                on_click: Some(Arc::new(|this, window, cx| {
+                    this.dismiss_error_message(&DismissErrorMessage, window, cx)
+                })),
+                tooltip_message: None,
+            });
         }
 
         None

crates/agent/Cargo.toml

@@ -19,6 +19,7 @@ test-support = [
 ]
 
 [dependencies]
+action_log.workspace = true
 agent_settings.workspace = true
 anyhow.workspace = true
 assistant_context.workspace = true
@@ -30,7 +31,6 @@ collections.workspace = true
 component.workspace = true
 context_server.workspace = true
 convert_case.workspace = true
-feature_flags.workspace = true
 fs.workspace = true
 futures.workspace = true
 git.workspace = true

crates/agent/src/agent_profile.rs

@@ -90,7 +90,7 @@ impl AgentProfile {
             return false;
         };
 
-        return Self::is_enabled(settings, source, tool_name);
+        Self::is_enabled(settings, source, tool_name)
     }
 
     fn is_enabled(settings: &AgentProfileSettings, source: ToolSource, name: String) -> bool {
@@ -132,7 +132,7 @@ mod tests {
         });
         let tool_set = default_tool_set(cx);
 
-        let profile = AgentProfile::new(id.clone(), tool_set);
+        let profile = AgentProfile::new(id, tool_set);
 
         let mut enabled_tools = cx
             .read(|cx| profile.enabled_tools(cx))
@@ -169,7 +169,7 @@ mod tests {
         });
         let tool_set = default_tool_set(cx);
 
-        let profile = AgentProfile::new(id.clone(), tool_set);
+        let profile = AgentProfile::new(id, tool_set);
 
         let mut enabled_tools = cx
             .read(|cx| profile.enabled_tools(cx))
@@ -202,7 +202,7 @@ mod tests {
         });
         let tool_set = default_tool_set(cx);
 
-        let profile = AgentProfile::new(id.clone(), tool_set);
+        let profile = AgentProfile::new(id, tool_set);
 
         let mut enabled_tools = cx
             .read(|cx| profile.enabled_tools(cx))
@@ -326,7 +326,7 @@ mod tests {
             _input: serde_json::Value,
             _request: Arc<language_model::LanguageModelRequest>,
             _project: Entity<Project>,
-            _action_log: Entity<assistant_tool::ActionLog>,
+            _action_log: Entity<action_log::ActionLog>,
             _model: Arc<dyn language_model::LanguageModel>,
             _window: Option<gpui::AnyWindowHandle>,
             _cx: &mut App,

crates/agent/src/context.rs

@@ -20,7 +20,7 @@ use text::{Anchor, OffsetRangeExt as _};
 use util::markdown::MarkdownCodeBlock;
 use util::{ResultExt as _, post_inc};
 
-pub const RULES_ICON: IconName = IconName::Context;
+pub const RULES_ICON: IconName = IconName::Reader;
 
 pub enum ContextKind {
     File,
@@ -40,8 +40,8 @@ impl ContextKind {
             ContextKind::File => IconName::File,
             ContextKind::Directory => IconName::Folder,
             ContextKind::Symbol => IconName::Code,
-            ContextKind::Selection => IconName::Context,
-            ContextKind::FetchedUrl => IconName::Globe,
+            ContextKind::Selection => IconName::Reader,
+            ContextKind::FetchedUrl => IconName::ToolWeb,
             ContextKind::Thread => IconName::Thread,
             ContextKind::TextThread => IconName::TextThread,
             ContextKind::Rules => RULES_ICON,
@@ -201,24 +201,24 @@ impl FileContextHandle {
                         parse_status.changed().await.log_err();
                     }
 
-                    if let Ok(snapshot) = buffer.read_with(cx, |buffer, _| buffer.snapshot()) {
-                        if let Some(outline) = snapshot.outline(None) {
-                            let items = outline
-                                .items
-                                .into_iter()
-                                .map(|item| item.to_point(&snapshot));
+                    if let Ok(snapshot) = buffer.read_with(cx, |buffer, _| buffer.snapshot())
+                        && let Some(outline) = snapshot.outline(None)
+                    {
+                        let items = outline
+                            .items
+                            .into_iter()
+                            .map(|item| item.to_point(&snapshot));
 
-                            if let Ok(outline_text) =
-                                outline::render_outline(items, None, 0, usize::MAX).await
-                            {
-                                let context = AgentContext::File(FileContext {
-                                    handle: self,
-                                    full_path,
-                                    text: outline_text.into(),
-                                    is_outline: true,
-                                });
-                                return Some((context, vec![buffer]));
-                            }
+                        if let Ok(outline_text) =
+                            outline::render_outline(items, None, 0, usize::MAX).await
+                        {
+                            let context = AgentContext::File(FileContext {
+                                handle: self,
+                                full_path,
+                                text: outline_text.into(),
+                                is_outline: true,
+                            });
+                            return Some((context, vec![buffer]));
                         }
                     }
                 }
@@ -362,7 +362,7 @@ impl Display for DirectoryContext {
         let mut is_first = true;
         for descendant in &self.descendants {
             if !is_first {
-                write!(f, "\n")?;
+                writeln!(f)?;
             } else {
                 is_first = false;
             }
@@ -650,7 +650,7 @@ impl TextThreadContextHandle {
 impl Display for TextThreadContext {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // TODO: escape title?
-        write!(f, "<text_thread title=\"{}\">\n", self.title)?;
+        writeln!(f, "<text_thread title=\"{}\">", self.title)?;
         write!(f, "{}", self.text.trim())?;
         write!(f, "\n</text_thread>")
     }
@@ -716,7 +716,7 @@ impl RulesContextHandle {
 impl Display for RulesContext {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(title) = &self.title {
-            write!(f, "Rules title: {}\n", title)?;
+            writeln!(f, "Rules title: {}", title)?;
         }
         let code_block = MarkdownCodeBlock {
             tag: "",

crates/agent/src/context_server_tool.rs

@@ -1,7 +1,8 @@
 use std::sync::Arc;
 
+use action_log::ActionLog;
 use anyhow::{Result, anyhow, bail};
-use assistant_tool::{ActionLog, Tool, ToolResult, ToolSource};
+use assistant_tool::{Tool, ToolResult, ToolSource};
 use context_server::{ContextServerId, types};
 use gpui::{AnyWindowHandle, App, Entity, Task};
 use icons::IconName;
@@ -85,15 +86,13 @@ impl Tool for ContextServerTool {
     ) -> ToolResult {
         if let Some(server) = self.store.read(cx).get_running_server(&self.server_id) {
             let tool_name = self.tool.name.clone();
-            let server_clone = server.clone();
-            let input_clone = input.clone();
 
             cx.spawn(async move |_cx| {
-                let Some(protocol) = server_clone.client() else {
+                let Some(protocol) = server.client() else {
                     bail!("Context server not initialized");
                 };
 
-                let arguments = if let serde_json::Value::Object(map) = input_clone {
+                let arguments = if let serde_json::Value::Object(map) = input {
                     Some(map.into_iter().collect())
                 } else {
                     None

crates/agent/src/context_store.rs

@@ -338,11 +338,9 @@ impl ContextStore {
             image_task,
             context_id: self.next_context_id.post_inc(),
         });
-        if self.has_context(&context) {
-            if remove_if_exists {
-                self.remove_context(&context, cx);
-                return None;
-            }
+        if self.has_context(&context) && remove_if_exists {
+            self.remove_context(&context, cx);
+            return None;
         }
 
         self.insert_context(context.clone(), cx);

crates/agent/src/history_store.rs

@@ -212,7 +212,16 @@ impl HistoryStore {
     fn load_recently_opened_entries(cx: &AsyncApp) -> Task<Result<Vec<HistoryEntryId>>> {
         cx.background_spawn(async move {
             let path = paths::data_dir().join(NAVIGATION_HISTORY_PATH);
-            let contents = smol::fs::read_to_string(path).await?;
+            let contents = match smol::fs::read_to_string(path).await {
+                Ok(it) => it,
+                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                    return Ok(Vec::new());
+                }
+                Err(e) => {
+                    return Err(e)
+                        .context("deserializing persisted agent panel navigation history");
+                }
+            };
             let entries = serde_json::from_str::<Vec<SerializedRecentOpen>>(&contents)
                 .context("deserializing persisted agent panel navigation history")?
                 .into_iter()
@@ -245,10 +254,9 @@ impl HistoryStore {
     }
 
     pub fn remove_recently_opened_thread(&mut self, id: ThreadId, cx: &mut Context<Self>) {
-        self.recently_opened_entries.retain(|entry| match entry {
-            HistoryEntryId::Thread(thread_id) if thread_id == &id => false,
-            _ => true,
-        });
+        self.recently_opened_entries.retain(
+            |entry| !matches!(entry, HistoryEntryId::Thread(thread_id) if thread_id == &id),
+        );
         self.save_recently_opened_entries(cx);
     }
 

crates/agent/src/thread.rs

@@ -8,14 +8,17 @@ use crate::{
     },
     tool_use::{PendingToolUse, ToolUse, ToolUseMetadata, ToolUseState},
 };
-use agent_settings::{AgentProfileId, AgentSettings, CompletionMode, SUMMARIZE_THREAD_PROMPT};
+use action_log::ActionLog;
+use agent_settings::{
+    AgentProfileId, AgentSettings, CompletionMode, SUMMARIZE_THREAD_DETAILED_PROMPT,
+    SUMMARIZE_THREAD_PROMPT,
+};
 use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, AnyToolCard, Tool, ToolWorkingSet};
+use assistant_tool::{AnyToolCard, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use client::{ModelRequestUsage, RequestUsage};
 use cloud_llm_client::{CompletionIntent, CompletionRequestStatus, Plan, UsageLimit};
 use collections::HashMap;
-use feature_flags::{self, FeatureFlagAppExt};
 use futures::{FutureExt, StreamExt as _, future::Shared};
 use git::repository::DiffType;
 use gpui::{
@@ -107,7 +110,7 @@ impl std::fmt::Display for PromptId {
 }
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
-pub struct MessageId(pub(crate) usize);
+pub struct MessageId(pub usize);
 
 impl MessageId {
     fn post_inc(&mut self) -> Self {
@@ -178,7 +181,7 @@ impl Message {
         }
     }
 
-    pub fn to_string(&self) -> String {
+    pub fn to_message_content(&self) -> String {
         let mut result = String::new();
 
         if !self.loaded_context.text.is_empty() {
@@ -384,10 +387,8 @@ pub struct Thread {
     cumulative_token_usage: TokenUsage,
     exceeded_window_error: Option<ExceededWindowError>,
     tool_use_limit_reached: bool,
-    feedback: Option<ThreadFeedback>,
     retry_state: Option<RetryState>,
     message_feedback: HashMap<MessageId, ThreadFeedback>,
-    last_auto_capture_at: Option<Instant>,
     last_received_chunk_at: Option<Instant>,
     request_callback: Option<
         Box<dyn FnMut(&LanguageModelRequest, &[Result<LanguageModelCompletionEvent, String>])>,
@@ -485,15 +486,13 @@ impl Thread {
             cumulative_token_usage: TokenUsage::default(),
             exceeded_window_error: None,
             tool_use_limit_reached: false,
-            feedback: None,
             retry_state: None,
             message_feedback: HashMap::default(),
-            last_auto_capture_at: None,
             last_error_context: None,
             last_received_chunk_at: None,
             request_callback: None,
             remaining_turns: u32::MAX,
-            configured_model: configured_model.clone(),
+            configured_model,
             profile: AgentProfile::new(profile_id, tools),
         }
     }
@@ -531,7 +530,7 @@ impl Thread {
                 .and_then(|model| {
                     let model = SelectedModel {
                         provider: model.provider.clone().into(),
-                        model: model.model.clone().into(),
+                        model: model.model.into(),
                     };
                     registry.select_model(&model, cx)
                 })
@@ -611,9 +610,7 @@ impl Thread {
             cumulative_token_usage: serialized.cumulative_token_usage,
             exceeded_window_error: None,
             tool_use_limit_reached: serialized.tool_use_limit_reached,
-            feedback: None,
             message_feedback: HashMap::default(),
-            last_auto_capture_at: None,
             last_error_context: None,
             last_received_chunk_at: None,
             request_callback: None,
@@ -843,11 +840,17 @@ impl Thread {
                     .await
                     .unwrap_or(false);
 
-                if !equal {
-                    this.update(cx, |this, cx| {
-                        this.insert_checkpoint(pending_checkpoint, cx)
-                    })?;
-                }
+                this.update(cx, |this, cx| {
+                    this.pending_checkpoint = if equal {
+                        Some(pending_checkpoint)
+                    } else {
+                        this.insert_checkpoint(pending_checkpoint, cx);
+                        Some(ThreadCheckpoint {
+                            message_id: this.next_message_id,
+                            git_checkpoint: final_checkpoint,
+                        })
+                    }
+                })?;
 
                 Ok(())
             }
@@ -1026,8 +1029,6 @@ impl Thread {
             });
         }
 
-        self.auto_capture_telemetry(cx);
-
         message_id
     }
 
@@ -1642,17 +1643,15 @@ impl Thread {
         };
 
         self.tool_use
-            .request_tool_use(tool_message_id, tool_use, tool_use_metadata.clone(), cx);
+            .request_tool_use(tool_message_id, tool_use, tool_use_metadata, cx);
 
-        let pending_tool_use = self.tool_use.insert_tool_output(
-            tool_use_id.clone(),
+        self.tool_use.insert_tool_output(
+            tool_use_id,
             tool_name,
             tool_output,
             self.configured_model.as_ref(),
             self.completion_mode,
-        );
-
-        pending_tool_use
+        )
     }
 
     pub fn stream_completion(
@@ -1685,7 +1684,7 @@ impl Thread {
         self.last_received_chunk_at = Some(Instant::now());
 
         let task = cx.spawn(async move |thread, cx| {
-            let stream_completion_future = model.stream_completion(request, &cx);
+            let stream_completion_future = model.stream_completion(request, cx);
             let initial_token_usage =
                 thread.read_with(cx, |thread, _cx| thread.cumulative_token_usage);
             let stream_completion = async {
@@ -1817,7 +1816,7 @@ impl Thread {
                                 let streamed_input = if tool_use.is_input_complete {
                                     None
                                 } else {
-                                    Some((&tool_use.input).clone())
+                                    Some(tool_use.input.clone())
                                 };
 
                                 let ui_text = thread.tool_use.request_tool_use(
@@ -1899,7 +1898,6 @@ impl Thread {
                         cx.emit(ThreadEvent::StreamedCompletion);
                         cx.notify();
 
-                        thread.auto_capture_telemetry(cx);
                         Ok(())
                     })??;
 
@@ -1967,11 +1965,9 @@ impl Thread {
 
                                                 if let Some(prev_message) =
                                                     thread.messages.get(ix - 1)
-                                                {
-                                                    if prev_message.role == Role::Assistant {
+                                                    && prev_message.role == Role::Assistant {
                                                         break;
                                                     }
-                                                }
                                             }
                                         }
 
@@ -2044,7 +2040,7 @@ impl Thread {
 
                                             retry_scheduled = thread
                                                 .handle_retryable_error_with_delay(
-                                                    &completion_error,
+                                                    completion_error,
                                                     Some(retry_strategy),
                                                     model.clone(),
                                                     intent,
@@ -2074,8 +2070,6 @@ impl Thread {
                         request_callback(request, response_events);
                     }
 
-                    thread.auto_capture_telemetry(cx);
-
                     if let Ok(initial_usage) = initial_token_usage {
                         let usage = thread.cumulative_token_usage - initial_usage;
 
@@ -2123,7 +2117,7 @@ impl Thread {
 
         self.pending_summary = cx.spawn(async move |this, cx| {
             let result = async {
-                let mut messages = model.model.stream_completion(request, &cx).await?;
+                let mut messages = model.model.stream_completion(request, cx).await?;
 
                 let mut new_summary = String::new();
                 while let Some(event) = messages.next().await {
@@ -2267,6 +2261,15 @@ impl Thread {
                     max_attempts: 3,
                 })
             }
+            Other(err)
+                if err.is::<PaymentRequiredError>()
+                    || err.is::<ModelRequestLimitReachedError>() =>
+            {
+                // Retrying won't help for Payment Required or Model Request Limit errors (where
+                // the user must upgrade to usage-based billing to get more requests, or else wait
+                // for a significant amount of time for the request limit to reset).
+                None
+            }
             // Conservatively assume that any other errors are non-retryable
             HttpResponseError { .. } | Other(..) => Some(RetryStrategy::Fixed {
                 delay: BASE_RETRY_DELAY,
@@ -2422,12 +2425,10 @@ impl Thread {
             return;
         }
 
-        let added_user_message = include_str!("./prompts/summarize_thread_detailed_prompt.txt");
-
         let request = self.to_summarize_request(
             &model,
             CompletionIntent::ThreadContextSummarization,
-            added_user_message.into(),
+            SUMMARIZE_THREAD_DETAILED_PROMPT.into(),
             cx,
         );
 
@@ -2440,7 +2441,7 @@ impl Thread {
         // which result to prefer (the old task could complete after the new one, resulting in a
         // stale summary).
         self.detailed_summary_task = cx.spawn(async move |thread, cx| {
-            let stream = model.stream_completion_text(request, &cx);
+            let stream = model.stream_completion_text(request, cx);
             let Some(mut messages) = stream.await.log_err() else {
                 thread
                     .update(cx, |thread, _cx| {
@@ -2469,13 +2470,13 @@ impl Thread {
                 .ok()?;
 
             // Save thread so its summary can be reused later
-            if let Some(thread) = thread.upgrade() {
-                if let Ok(Ok(save_task)) = cx.update(|cx| {
+            if let Some(thread) = thread.upgrade()
+                && let Ok(Ok(save_task)) = cx.update(|cx| {
                     thread_store
                         .update(cx, |thread_store, cx| thread_store.save_thread(&thread, cx))
-                }) {
-                    save_task.await.log_err();
-                }
+                })
+            {
+                save_task.await.log_err();
             }
 
             Some(())
@@ -2520,7 +2521,6 @@ impl Thread {
         model: Arc<dyn LanguageModel>,
         cx: &mut Context<Self>,
     ) -> Vec<PendingToolUse> {
-        self.auto_capture_telemetry(cx);
         let request =
             Arc::new(self.to_completion_request(model.clone(), CompletionIntent::ToolResults, cx));
         let pending_tool_uses = self
@@ -2724,13 +2724,11 @@ impl Thread {
         window: Option<AnyWindowHandle>,
         cx: &mut Context<Self>,
     ) {
-        if self.all_tools_finished() {
-            if let Some(ConfiguredModel { model, .. }) = self.configured_model.as_ref() {
-                if !canceled {
-                    self.send_to_model(model.clone(), CompletionIntent::ToolResults, window, cx);
-                }
-                self.auto_capture_telemetry(cx);
-            }
+        if self.all_tools_finished()
+            && let Some(ConfiguredModel { model, .. }) = self.configured_model.as_ref()
+            && !canceled
+        {
+            self.send_to_model(model.clone(), CompletionIntent::ToolResults, window, cx);
         }
 
         cx.emit(ThreadEvent::ToolFinished {
@@ -2786,10 +2784,6 @@ impl Thread {
         cx.emit(ThreadEvent::CancelEditing);
     }
 
-    pub fn feedback(&self) -> Option<ThreadFeedback> {
-        self.feedback
-    }
-
     pub fn message_feedback(&self, message_id: MessageId) -> Option<ThreadFeedback> {
         self.message_feedback.get(&message_id).copied()
     }
@@ -2822,7 +2816,7 @@ impl Thread {
 
         let message_content = self
             .message(message_id)
-            .map(|msg| msg.to_string())
+            .map(|msg| msg.to_message_content())
             .unwrap_or_default();
 
         cx.background_spawn(async move {
@@ -2851,52 +2845,6 @@ impl Thread {
         })
     }
 
-    pub fn report_feedback(
-        &mut self,
-        feedback: ThreadFeedback,
-        cx: &mut Context<Self>,
-    ) -> Task<Result<()>> {
-        let last_assistant_message_id = self
-            .messages
-            .iter()
-            .rev()
-            .find(|msg| msg.role == Role::Assistant)
-            .map(|msg| msg.id);
-
-        if let Some(message_id) = last_assistant_message_id {
-            self.report_message_feedback(message_id, feedback, cx)
-        } else {
-            let final_project_snapshot = Self::project_snapshot(self.project.clone(), cx);
-            let serialized_thread = self.serialize(cx);
-            let thread_id = self.id().clone();
-            let client = self.project.read(cx).client();
-            self.feedback = Some(feedback);
-            cx.notify();
-
-            cx.background_spawn(async move {
-                let final_project_snapshot = final_project_snapshot.await;
-                let serialized_thread = serialized_thread.await?;
-                let thread_data = serde_json::to_value(serialized_thread)
-                    .unwrap_or_else(|_| serde_json::Value::Null);
-
-                let rating = match feedback {
-                    ThreadFeedback::Positive => "positive",
-                    ThreadFeedback::Negative => "negative",
-                };
-                telemetry::event!(
-                    "Assistant Thread Rated",
-                    rating,
-                    thread_id,
-                    thread_data,
-                    final_project_snapshot
-                );
-                client.telemetry().flush_events().await;
-
-                Ok(())
-            })
-        }
-    }
-
     /// Create a snapshot of the current project state including git information and unsaved buffers.
     fn project_snapshot(
         project: Entity<Project>,
@@ -2917,11 +2865,11 @@ impl Thread {
                 let buffer_store = project.read(app_cx).buffer_store();
                 for buffer_handle in buffer_store.read(app_cx).buffers() {
                     let buffer = buffer_handle.read(app_cx);
-                    if buffer.is_dirty() {
-                        if let Some(file) = buffer.file() {
-                            let path = file.path().to_string_lossy().to_string();
-                            unsaved_buffers.push(path);
-                        }
+                    if buffer.is_dirty()
+                        && let Some(file) = buffer.file()
+                    {
+                        let path = file.path().to_string_lossy().to_string();
+                        unsaved_buffers.push(path);
                     }
                 }
             })
@@ -3131,50 +3079,6 @@ impl Thread {
         &self.project
     }
 
-    pub fn auto_capture_telemetry(&mut self, cx: &mut Context<Self>) {
-        if !cx.has_flag::<feature_flags::ThreadAutoCaptureFeatureFlag>() {
-            return;
-        }
-
-        let now = Instant::now();
-        if let Some(last) = self.last_auto_capture_at {
-            if now.duration_since(last).as_secs() < 10 {
-                return;
-            }
-        }
-
-        self.last_auto_capture_at = Some(now);
-
-        let thread_id = self.id().clone();
-        let github_login = self
-            .project
-            .read(cx)
-            .user_store()
-            .read(cx)
-            .current_user()
-            .map(|user| user.github_login.clone());
-        let client = self.project.read(cx).client();
-        let serialize_task = self.serialize(cx);
-
-        cx.background_executor()
-            .spawn(async move {
-                if let Ok(serialized_thread) = serialize_task.await {
-                    if let Ok(thread_data) = serde_json::to_value(serialized_thread) {
-                        telemetry::event!(
-                            "Agent Thread Auto-Captured",
-                            thread_id = thread_id.to_string(),
-                            thread_data = thread_data,
-                            auto_capture_reason = "tracked_user",
-                            github_login = github_login
-                        );
-
-                        client.telemetry().flush_events().await;
-                    }
-                }
-            })
-            .detach();
-    }
-
     pub fn cumulative_token_usage(&self) -> TokenUsage {
         self.cumulative_token_usage
     }
@@ -3217,13 +3121,13 @@ impl Thread {
             .model
             .max_token_count_for_mode(self.completion_mode().into());
 
-        if let Some(exceeded_error) = &self.exceeded_window_error {
-            if model.model.id() == exceeded_error.model_id {
-                return Some(TotalTokenUsage {
-                    total: exceeded_error.token_count,
-                    max,
-                });
-            }
+        if let Some(exceeded_error) = &self.exceeded_window_error
+            && model.model.id() == exceeded_error.model_id
+        {
+            return Some(TotalTokenUsage {
+                total: exceeded_error.token_count,
+                max,
+            });
         }
 
         let total = self
@@ -3284,7 +3188,7 @@ impl Thread {
             self.configured_model.as_ref(),
             self.completion_mode,
         );
-        self.tool_finished(tool_use_id.clone(), None, true, window, cx);
+        self.tool_finished(tool_use_id, None, true, window, cx);
     }
 }
 
@@ -3916,7 +3820,7 @@ fn main() {{
                 AgentSettings {
                     model_parameters: vec![LanguageModelParameters {
                         provider: Some(model.provider_id().0.to_string().into()),
-                        model: Some(model.id().0.clone()),
+                        model: Some(model.id().0),
                         temperature: Some(0.66),
                     }],
                     ..AgentSettings::get_global(cx).clone()
@@ -3936,7 +3840,7 @@ fn main() {{
                 AgentSettings {
                     model_parameters: vec![LanguageModelParameters {
                         provider: None,
-                        model: Some(model.id().0.clone()),
+                        model: Some(model.id().0),
                         temperature: Some(0.66),
                     }],
                     ..AgentSettings::get_global(cx).clone()
@@ -3976,7 +3880,7 @@ fn main() {{
                 AgentSettings {
                     model_parameters: vec![LanguageModelParameters {
                         provider: Some("anthropic".into()),
-                        model: Some(model.id().0.clone()),
+                        model: Some(model.id().0),
                         temperature: Some(0.66),
                     }],
                     ..AgentSettings::get_global(cx).clone()
@@ -4027,7 +3931,7 @@ fn main() {{
         });
 
         let fake_model = model.as_fake();
-        simulate_successful_response(&fake_model, cx);
+        simulate_successful_response(fake_model, cx);
 
         // Should start generating summary when there are >= 2 messages
         thread.read_with(cx, |thread, _| {
@@ -4122,7 +4026,7 @@ fn main() {{
         });
 
         let fake_model = model.as_fake();
-        simulate_successful_response(&fake_model, cx);
+        simulate_successful_response(fake_model, cx);
 
         thread.read_with(cx, |thread, _| {
             // State is still Error, not Generating
@@ -5321,7 +5225,7 @@ fn main() {{
     }
 
     #[gpui::test]
-    async fn test_retry_cancelled_on_stop(cx: &mut TestAppContext) {
+    async fn test_retry_canceled_on_stop(cx: &mut TestAppContext) {
         init_test_settings(cx);
 
         let project = create_test_project(cx, json!({})).await;
@@ -5377,7 +5281,7 @@ fn main() {{
             "Should have no pending completions after cancellation"
         );
 
-        // Verify the retry was cancelled by checking retry state
+        // Verify the retry was canceled by checking retry state
         thread.read_with(cx, |thread, _| {
             if let Some(retry_state) = &thread.retry_state {
                 panic!(
@@ -5404,7 +5308,7 @@ fn main() {{
         });
 
         let fake_model = model.as_fake();
-        simulate_successful_response(&fake_model, cx);
+        simulate_successful_response(fake_model, cx);
 
         thread.read_with(cx, |thread, _| {
             assert!(matches!(thread.summary(), ThreadSummary::Generating));

crates/agent/src/thread_store.rs

@@ -42,7 +42,7 @@ use std::{
 use util::ResultExt as _;
 
 pub static ZED_STATELESS: std::sync::LazyLock<bool> =
-    std::sync::LazyLock::new(|| std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty()));
+    std::sync::LazyLock::new(|| std::env::var("ZED_STATELESS").is_ok_and(|v| !v.is_empty()));
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum DataType {
@@ -74,7 +74,7 @@ impl Column for DataType {
     }
 }
 
-const RULES_FILE_NAMES: [&'static str; 9] = [
+const RULES_FILE_NAMES: [&str; 9] = [
     ".rules",
     ".cursorrules",
     ".windsurfrules",
@@ -205,6 +205,22 @@ 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>,
@@ -565,33 +581,32 @@ impl ThreadStore {
                 return;
             };
 
-            if protocol.capable(context_server::protocol::ServerCapability::Tools) {
-                if let Some(response) = protocol
+            if protocol.capable(context_server::protocol::ServerCapability::Tools)
+                && let Some(response) = protocol
                     .request::<context_server::types::requests::ListTools>(())
                     .await
                     .log_err()
-                {
-                    let tool_ids = tool_working_set
-                        .update(cx, |tool_working_set, cx| {
-                            tool_working_set.extend(
-                                response.tools.into_iter().map(|tool| {
-                                    Arc::new(ContextServerTool::new(
-                                        context_server_store.clone(),
-                                        server.id(),
-                                        tool,
-                                    )) as Arc<dyn Tool>
-                                }),
-                                cx,
-                            )
-                        })
-                        .log_err();
+            {
+                let tool_ids = tool_working_set
+                    .update(cx, |tool_working_set, cx| {
+                        tool_working_set.extend(
+                            response.tools.into_iter().map(|tool| {
+                                Arc::new(ContextServerTool::new(
+                                    context_server_store.clone(),
+                                    server.id(),
+                                    tool,
+                                )) as Arc<dyn Tool>
+                            }),
+                            cx,
+                        )
+                    })
+                    .log_err();
 
-                    if let Some(tool_ids) = tool_ids {
-                        this.update(cx, |this, _| {
-                            this.context_server_tool_ids.insert(server_id, tool_ids);
-                        })
-                        .log_err();
-                    }
+                if let Some(tool_ids) = tool_ids {
+                    this.update(cx, |this, _| {
+                        this.context_server_tool_ids.insert(server_id, tool_ids);
+                    })
+                    .log_err();
                 }
             }
         })
@@ -681,13 +696,14 @@ impl SerializedThreadV0_1_0 {
         let mut messages: Vec<SerializedMessage> = Vec::with_capacity(self.0.messages.len());
 
         for message in self.0.messages {
-            if message.role == Role::User && !message.tool_results.is_empty() {
-                if let Some(last_message) = messages.last_mut() {
-                    debug_assert!(last_message.role == Role::Assistant);
+            if message.role == Role::User
+                && !message.tool_results.is_empty()
+                && let Some(last_message) = messages.last_mut()
+            {
+                debug_assert!(last_message.role == Role::Assistant);
 
-                    last_message.tool_results = message.tool_results;
-                    continue;
-                }
+                last_message.tool_results = message.tool_results;
+                continue;
             }
 
             messages.push(message);
@@ -877,7 +893,7 @@ impl ThreadsDatabase {
 
         let needs_migration_from_heed = mdb_path.exists();
 
-        let connection = if *ZED_STATELESS {
+        let connection = if *ZED_STATELESS || cfg!(any(feature = "test-support", test)) {
             Connection::open_memory(Some("THREAD_FALLBACK_DB"))
         } else {
             Connection::open_file(&sqlite_path.to_string_lossy())

crates/agent/src/tool_use.rs

@@ -112,19 +112,13 @@ impl ToolUseState {
                                 },
                             );
 
-                            if let Some(window) = &mut window {
-                                if let Some(tool) = this.tools.read(cx).tool(tool_use, cx) {
-                                    if let Some(output) = tool_result.output.clone() {
-                                        if let Some(card) = tool.deserialize_card(
-                                            output,
-                                            project.clone(),
-                                            window,
-                                            cx,
-                                        ) {
-                                            this.tool_result_cards.insert(tool_use_id, card);
-                                        }
-                                    }
-                                }
+                            if let Some(window) = &mut window
+                                && let Some(tool) = this.tools.read(cx).tool(tool_use, cx)
+                                && let Some(output) = tool_result.output.clone()
+                                && let Some(card) =
+                                    tool.deserialize_card(output, project.clone(), window, cx)
+                            {
+                                this.tool_result_cards.insert(tool_use_id, card);
                             }
                         }
                     }
@@ -137,7 +131,7 @@ impl ToolUseState {
     }
 
     pub fn cancel_pending(&mut self) -> Vec<PendingToolUse> {
-        let mut cancelled_tool_uses = Vec::new();
+        let mut canceled_tool_uses = Vec::new();
         self.pending_tool_uses_by_id
             .retain(|tool_use_id, tool_use| {
                 if matches!(tool_use.status, PendingToolUseStatus::Error { .. }) {
@@ -155,10 +149,10 @@ impl ToolUseState {
                         is_error: true,
                     },
                 );
-                cancelled_tool_uses.push(tool_use.clone());
+                canceled_tool_uses.push(tool_use.clone());
                 false
             });
-        cancelled_tool_uses
+        canceled_tool_uses
     }
 
     pub fn pending_tool_uses(&self) -> Vec<&PendingToolUse> {
@@ -281,7 +275,7 @@ impl ToolUseState {
     pub fn message_has_tool_results(&self, assistant_message_id: MessageId) -> bool {
         self.tool_uses_by_assistant_message
             .get(&assistant_message_id)
-            .map_or(false, |results| !results.is_empty())
+            .is_some_and(|results| !results.is_empty())
     }
 
     pub fn tool_result(

crates/agent2/Cargo.toml

@@ -1,34 +1,54 @@
 [package]
 name = "agent2"
 version = "0.1.0"
-edition = "2021"
+edition.workspace = true
+publish.workspace = true
 license = "GPL-3.0-or-later"
-publish = false
 
 [lib]
 path = "src/agent2.rs"
 
+[features]
+test-support = ["db/test-support"]
+e2e = []
+
 [lints]
 workspace = true
 
 [dependencies]
 acp_thread.workspace = true
+action_log.workspace = true
+agent.workspace = true
 agent-client-protocol.workspace = true
 agent_servers.workspace = true
+agent_settings.workspace = true
 anyhow.workspace = true
+assistant_context.workspace = true
 assistant_tool.workspace = true
+assistant_tools.workspace = true
+chrono.workspace = true
+client.workspace = true
 cloud_llm_client.workspace = true
 collections.workspace = true
+context_server.workspace = true
+db.workspace = true
 fs.workspace = true
 futures.workspace = true
+git.workspace = true
 gpui.workspace = true
 handlebars = { workspace = true, features = ["rust-embed"] }
+html_to_markdown.workspace = true
+http_client.workspace = true
 indoc.workspace = true
 itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_models.workspace = true
 log.workspace = true
+open.workspace = true
+parking_lot.workspace = true
+paths.workspace = true
+portable-pty.workspace = true
 project.workspace = true
 prompt_store.workspace = true
 rust-embed.workspace = true
@@ -37,24 +57,46 @@ serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
+sqlez.workspace = true
+task.workspace = true
+telemetry.workspace = true
+terminal.workspace = true
+text.workspace = true
 ui.workspace = true
 util.workspace = true
 uuid.workspace = true
 watch.workspace = true
+web_search.workspace = true
+which.workspace = true
 workspace-hack.workspace = true
+zstd.workspace = true
 
 [dev-dependencies]
+agent = { workspace = true, "features" = ["test-support"] }
+agent_servers = { workspace = true, "features" = ["test-support"] }
+assistant_context = { workspace = true, "features" = ["test-support"] }
 ctor.workspace = true
 client = { workspace = true, "features" = ["test-support"] }
 clock = { workspace = true, "features" = ["test-support"] }
+context_server = { workspace = true, "features" = ["test-support"] }
+db = { workspace = true, "features" = ["test-support"] }
+editor = { workspace = true, "features" = ["test-support"] }
 env_logger.workspace = true
 fs = { workspace = true, "features" = ["test-support"] }
+git = { workspace = true, "features" = ["test-support"] }
 gpui = { workspace = true, "features" = ["test-support"] }
 gpui_tokio.workspace = true
 language = { workspace = true, "features" = ["test-support"] }
 language_model = { workspace = true, "features" = ["test-support"] }
+lsp = { workspace = true, "features" = ["test-support"] }
+pretty_assertions.workspace = true
 project = { workspace = true, "features" = ["test-support"] }
 reqwest_client.workspace = true
 settings = { workspace = true, "features" = ["test-support"] }
+tempfile.workspace = true
+terminal = { workspace = true, "features" = ["test-support"] }
+theme = { workspace = true, "features" = ["test-support"] }
+tree-sitter-rust.workspace = true
+unindent = { workspace = true }
 worktree = { workspace = true, "features" = ["test-support"] }
-pretty_assertions.workspace = true
+zlog.workspace = true

crates/agent2/src/agent2.rs

@@ -1,13 +1,19 @@
 mod agent;
+mod db;
+mod history_store;
 mod native_agent_server;
 mod templates;
 mod thread;
+mod tool_schema;
 mod tools;
 
 #[cfg(test)]
 mod tests;
 
 pub use agent::*;
+pub use db::*;
+pub use history_store::*;
 pub use native_agent_server::NativeAgentServer;
+pub use templates::*;
 pub use thread::*;
 pub use tools::*;

crates/agent2/src/db.rs

@@ -0,0 +1,488 @@
+use crate::{AgentMessage, AgentMessageContent, UserMessage, UserMessageContent};
+use acp_thread::UserMessageId;
+use agent::{thread::DetailedSummaryState, thread_store};
+use agent_client_protocol as acp;
+use agent_settings::{AgentProfileId, CompletionMode};
+use anyhow::{Result, anyhow};
+use chrono::{DateTime, Utc};
+use collections::{HashMap, IndexMap};
+use futures::{FutureExt, future::Shared};
+use gpui::{BackgroundExecutor, Global, Task};
+use indoc::indoc;
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use sqlez::{
+    bindable::{Bind, Column},
+    connection::Connection,
+    statement::Statement,
+};
+use std::sync::Arc;
+use ui::{App, SharedString};
+
+pub type DbMessage = crate::Message;
+pub type DbSummary = DetailedSummaryState;
+pub type DbLanguageModel = thread_store::SerializedLanguageModel;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DbThreadMetadata {
+    pub id: acp::SessionId,
+    #[serde(alias = "summary")]
+    pub title: SharedString,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DbThread {
+    pub title: SharedString,
+    pub messages: Vec<DbMessage>,
+    pub updated_at: DateTime<Utc>,
+    #[serde(default)]
+    pub detailed_summary: Option<SharedString>,
+    #[serde(default)]
+    pub initial_project_snapshot: Option<Arc<agent::thread::ProjectSnapshot>>,
+    #[serde(default)]
+    pub cumulative_token_usage: language_model::TokenUsage,
+    #[serde(default)]
+    pub request_token_usage: HashMap<acp_thread::UserMessageId, language_model::TokenUsage>,
+    #[serde(default)]
+    pub model: Option<DbLanguageModel>,
+    #[serde(default)]
+    pub completion_mode: Option<CompletionMode>,
+    #[serde(default)]
+    pub profile: Option<AgentProfileId>,
+}
+
+impl DbThread {
+    pub const VERSION: &'static str = "0.3.0";
+
+    pub fn from_json(json: &[u8]) -> Result<Self> {
+        let saved_thread_json = serde_json::from_slice::<serde_json::Value>(json)?;
+        match saved_thread_json.get("version") {
+            Some(serde_json::Value::String(version)) => match version.as_str() {
+                Self::VERSION => Ok(serde_json::from_value(saved_thread_json)?),
+                _ => Self::upgrade_from_agent_1(agent::SerializedThread::from_json(json)?),
+            },
+            _ => Self::upgrade_from_agent_1(agent::SerializedThread::from_json(json)?),
+        }
+    }
+
+    fn upgrade_from_agent_1(thread: agent::SerializedThread) -> Result<Self> {
+        let mut messages = Vec::new();
+        let mut request_token_usage = HashMap::default();
+
+        let mut last_user_message_id = None;
+        for (ix, msg) in thread.messages.into_iter().enumerate() {
+            let message = match msg.role {
+                language_model::Role::User => {
+                    let mut content = Vec::new();
+
+                    // Convert segments to content
+                    for segment in msg.segments {
+                        match segment {
+                            thread_store::SerializedMessageSegment::Text { text } => {
+                                content.push(UserMessageContent::Text(text));
+                            }
+                            thread_store::SerializedMessageSegment::Thinking { text, .. } => {
+                                // User messages don't have thinking segments, but handle gracefully
+                                content.push(UserMessageContent::Text(text));
+                            }
+                            thread_store::SerializedMessageSegment::RedactedThinking { .. } => {
+                                // User messages don't have redacted thinking, skip.
+                            }
+                        }
+                    }
+
+                    // If no content was added, add context as text if available
+                    if content.is_empty() && !msg.context.is_empty() {
+                        content.push(UserMessageContent::Text(msg.context));
+                    }
+
+                    let id = UserMessageId::new();
+                    last_user_message_id = Some(id.clone());
+
+                    crate::Message::User(UserMessage {
+                        // MessageId from old format can't be meaningfully converted, so generate a new one
+                        id,
+                        content,
+                    })
+                }
+                language_model::Role::Assistant => {
+                    let mut content = Vec::new();
+
+                    // Convert segments to content
+                    for segment in msg.segments {
+                        match segment {
+                            thread_store::SerializedMessageSegment::Text { text } => {
+                                content.push(AgentMessageContent::Text(text));
+                            }
+                            thread_store::SerializedMessageSegment::Thinking {
+                                text,
+                                signature,
+                            } => {
+                                content.push(AgentMessageContent::Thinking { text, signature });
+                            }
+                            thread_store::SerializedMessageSegment::RedactedThinking { data } => {
+                                content.push(AgentMessageContent::RedactedThinking(data));
+                            }
+                        }
+                    }
+
+                    // Convert tool uses
+                    let mut tool_names_by_id = HashMap::default();
+                    for tool_use in msg.tool_uses {
+                        tool_names_by_id.insert(tool_use.id.clone(), tool_use.name.clone());
+                        content.push(AgentMessageContent::ToolUse(
+                            language_model::LanguageModelToolUse {
+                                id: tool_use.id,
+                                name: tool_use.name.into(),
+                                raw_input: serde_json::to_string(&tool_use.input)
+                                    .unwrap_or_default(),
+                                input: tool_use.input,
+                                is_input_complete: true,
+                            },
+                        ));
+                    }
+
+                    // Convert tool results
+                    let mut tool_results = IndexMap::default();
+                    for tool_result in msg.tool_results {
+                        let name = tool_names_by_id
+                            .remove(&tool_result.tool_use_id)
+                            .unwrap_or_else(|| SharedString::from("unknown"));
+                        tool_results.insert(
+                            tool_result.tool_use_id.clone(),
+                            language_model::LanguageModelToolResult {
+                                tool_use_id: tool_result.tool_use_id,
+                                tool_name: name.into(),
+                                is_error: tool_result.is_error,
+                                content: tool_result.content,
+                                output: tool_result.output,
+                            },
+                        );
+                    }
+
+                    if let Some(last_user_message_id) = &last_user_message_id
+                        && let Some(token_usage) = thread.request_token_usage.get(ix).copied()
+                    {
+                        request_token_usage.insert(last_user_message_id.clone(), token_usage);
+                    }
+
+                    crate::Message::Agent(AgentMessage {
+                        content,
+                        tool_results,
+                    })
+                }
+                language_model::Role::System => {
+                    // Skip system messages as they're not supported in the new format
+                    continue;
+                }
+            };
+
+            messages.push(message);
+        }
+
+        Ok(Self {
+            title: thread.summary,
+            messages,
+            updated_at: thread.updated_at,
+            detailed_summary: match thread.detailed_summary_state {
+                DetailedSummaryState::NotGenerated | DetailedSummaryState::Generating { .. } => {
+                    None
+                }
+                DetailedSummaryState::Generated { text, .. } => Some(text),
+            },
+            initial_project_snapshot: thread.initial_project_snapshot,
+            cumulative_token_usage: thread.cumulative_token_usage,
+            request_token_usage,
+            model: thread.model,
+            completion_mode: thread.completion_mode,
+            profile: thread.profile,
+        })
+    }
+}
+
+pub static ZED_STATELESS: std::sync::LazyLock<bool> =
+    std::sync::LazyLock::new(|| std::env::var("ZED_STATELESS").is_ok_and(|v| !v.is_empty()));
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum DataType {
+    #[serde(rename = "json")]
+    Json,
+    #[serde(rename = "zstd")]
+    Zstd,
+}
+
+impl Bind for DataType {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        let value = match self {
+            DataType::Json => "json",
+            DataType::Zstd => "zstd",
+        };
+        value.bind(statement, start_index)
+    }
+}
+
+impl Column for DataType {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let (value, next_index) = String::column(statement, start_index)?;
+        let data_type = match value.as_str() {
+            "json" => DataType::Json,
+            "zstd" => DataType::Zstd,
+            _ => anyhow::bail!("Unknown data type: {}", value),
+        };
+        Ok((data_type, next_index))
+    }
+}
+
+pub(crate) struct ThreadsDatabase {
+    executor: BackgroundExecutor,
+    connection: Arc<Mutex<Connection>>,
+}
+
+struct GlobalThreadsDatabase(Shared<Task<Result<Arc<ThreadsDatabase>, Arc<anyhow::Error>>>>);
+
+impl Global for GlobalThreadsDatabase {}
+
+impl ThreadsDatabase {
+    pub fn connect(cx: &mut App) -> Shared<Task<Result<Arc<ThreadsDatabase>, Arc<anyhow::Error>>>> {
+        if cx.has_global::<GlobalThreadsDatabase>() {
+            return cx.global::<GlobalThreadsDatabase>().0.clone();
+        }
+        let executor = cx.background_executor().clone();
+        let task = executor
+            .spawn({
+                let executor = executor.clone();
+                async move {
+                    match ThreadsDatabase::new(executor) {
+                        Ok(db) => Ok(Arc::new(db)),
+                        Err(err) => Err(Arc::new(err)),
+                    }
+                }
+            })
+            .shared();
+
+        cx.set_global(GlobalThreadsDatabase(task.clone()));
+        task
+    }
+
+    pub fn new(executor: BackgroundExecutor) -> Result<Self> {
+        let connection = if *ZED_STATELESS || cfg!(any(feature = "test-support", test)) {
+            Connection::open_memory(Some("THREAD_FALLBACK_DB"))
+        } else {
+            let threads_dir = paths::data_dir().join("threads");
+            std::fs::create_dir_all(&threads_dir)?;
+            let sqlite_path = threads_dir.join("threads.db");
+            Connection::open_file(&sqlite_path.to_string_lossy())
+        };
+
+        connection.exec(indoc! {"
+            CREATE TABLE IF NOT EXISTS threads (
+                id TEXT PRIMARY KEY,
+                summary TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                data_type TEXT NOT NULL,
+                data BLOB NOT NULL
+            )
+        "})?()
+        .map_err(|e| anyhow!("Failed to create threads table: {}", e))?;
+
+        let db = Self {
+            executor,
+            connection: Arc::new(Mutex::new(connection)),
+        };
+
+        Ok(db)
+    }
+
+    fn save_thread_sync(
+        connection: &Arc<Mutex<Connection>>,
+        id: acp::SessionId,
+        thread: DbThread,
+    ) -> Result<()> {
+        const COMPRESSION_LEVEL: i32 = 3;
+
+        #[derive(Serialize)]
+        struct SerializedThread {
+            #[serde(flatten)]
+            thread: DbThread,
+            version: &'static str,
+        }
+
+        let title = thread.title.to_string();
+        let updated_at = thread.updated_at.to_rfc3339();
+        let json_data = serde_json::to_string(&SerializedThread {
+            thread,
+            version: DbThread::VERSION,
+        })?;
+
+        let connection = connection.lock();
+
+        let compressed = zstd::encode_all(json_data.as_bytes(), COMPRESSION_LEVEL)?;
+        let data_type = DataType::Zstd;
+        let data = compressed;
+
+        let mut insert = connection.exec_bound::<(Arc<str>, String, String, DataType, Vec<u8>)>(indoc! {"
+            INSERT OR REPLACE INTO threads (id, summary, updated_at, data_type, data) VALUES (?, ?, ?, ?, ?)
+        "})?;
+
+        insert((id.0, title, updated_at, data_type, data))?;
+
+        Ok(())
+    }
+
+    pub fn list_threads(&self) -> Task<Result<Vec<DbThreadMetadata>>> {
+        let connection = self.connection.clone();
+
+        self.executor.spawn(async move {
+            let connection = connection.lock();
+
+            let mut select =
+                connection.select_bound::<(), (Arc<str>, String, String)>(indoc! {"
+                SELECT id, summary, updated_at FROM threads ORDER BY updated_at DESC
+            "})?;
+
+            let rows = select(())?;
+            let mut threads = Vec::new();
+
+            for (id, summary, updated_at) in rows {
+                threads.push(DbThreadMetadata {
+                    id: acp::SessionId(id),
+                    title: summary.into(),
+                    updated_at: DateTime::parse_from_rfc3339(&updated_at)?.with_timezone(&Utc),
+                });
+            }
+
+            Ok(threads)
+        })
+    }
+
+    pub fn load_thread(&self, id: acp::SessionId) -> Task<Result<Option<DbThread>>> {
+        let connection = self.connection.clone();
+
+        self.executor.spawn(async move {
+            let connection = connection.lock();
+            let mut select = connection.select_bound::<Arc<str>, (DataType, Vec<u8>)>(indoc! {"
+                SELECT data_type, data FROM threads WHERE id = ? LIMIT 1
+            "})?;
+
+            let rows = select(id.0)?;
+            if let Some((data_type, data)) = rows.into_iter().next() {
+                let json_data = match data_type {
+                    DataType::Zstd => {
+                        let decompressed = zstd::decode_all(&data[..])?;
+                        String::from_utf8(decompressed)?
+                    }
+                    DataType::Json => String::from_utf8(data)?,
+                };
+                let thread = DbThread::from_json(json_data.as_bytes())?;
+                Ok(Some(thread))
+            } else {
+                Ok(None)
+            }
+        })
+    }
+
+    pub fn save_thread(&self, id: acp::SessionId, thread: DbThread) -> Task<Result<()>> {
+        let connection = self.connection.clone();
+
+        self.executor
+            .spawn(async move { Self::save_thread_sync(&connection, id, thread) })
+    }
+
+    pub fn delete_thread(&self, id: acp::SessionId) -> Task<Result<()>> {
+        let connection = self.connection.clone();
+
+        self.executor.spawn(async move {
+            let connection = connection.lock();
+
+            let mut delete = connection.exec_bound::<Arc<str>>(indoc! {"
+                DELETE FROM threads WHERE id = ?
+            "})?;
+
+            delete(id.0)?;
+
+            Ok(())
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use agent::MessageSegment;
+    use agent::context::LoadedContext;
+    use client::Client;
+    use fs::FakeFs;
+    use gpui::AppContext;
+    use gpui::TestAppContext;
+    use http_client::FakeHttpClient;
+    use language_model::Role;
+    use project::Project;
+    use settings::SettingsStore;
+
+    fn init_test(cx: &mut TestAppContext) {
+        env_logger::try_init().ok();
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            Project::init_settings(cx);
+            language::init(cx);
+
+            let http_client = FakeHttpClient::with_404_response();
+            let clock = Arc::new(clock::FakeSystemClock::new());
+            let client = Client::new(clock, http_client, cx);
+            agent::init(cx);
+            agent_settings::init(cx);
+            language_model::init(client, cx);
+        });
+    }
+
+    #[gpui::test]
+    async fn test_retrieving_old_thread(cx: &mut TestAppContext) {
+        init_test(cx);
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, [], cx).await;
+
+        // Save a thread using the old agent.
+        let thread_store = cx.new(|cx| agent::ThreadStore::fake(project, cx));
+        let thread = thread_store.update(cx, |thread_store, cx| thread_store.create_thread(cx));
+        thread.update(cx, |thread, cx| {
+            thread.insert_message(
+                Role::User,
+                vec![MessageSegment::Text("Hey!".into())],
+                LoadedContext::default(),
+                vec![],
+                false,
+                cx,
+            );
+            thread.insert_message(
+                Role::Assistant,
+                vec![MessageSegment::Text("How're you doing?".into())],
+                LoadedContext::default(),
+                vec![],
+                false,
+                cx,
+            )
+        });
+        thread_store
+            .update(cx, |thread_store, cx| thread_store.save_thread(&thread, cx))
+            .await
+            .unwrap();
+
+        // Open that same thread using the new agent.
+        let db = cx.update(ThreadsDatabase::connect).await.unwrap();
+        let threads = db.list_threads().await.unwrap();
+        assert_eq!(threads.len(), 1);
+        let thread = db
+            .load_thread(threads[0].id.clone())
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(thread.messages[0].to_markdown(), "## User\n\nHey!\n");
+        assert_eq!(
+            thread.messages[1].to_markdown(),
+            "## Assistant\n\nHow're you doing?\n"
+        );
+    }
+}

crates/agent2/src/history_store.rs

@@ -0,0 +1,362 @@
+use crate::{DbThreadMetadata, ThreadsDatabase};
+use acp_thread::MentionUri;
+use agent_client_protocol as acp;
+use anyhow::{Context as _, Result, anyhow};
+use assistant_context::{AssistantContext, SavedContextMetadata};
+use chrono::{DateTime, Utc};
+use db::kvp::KEY_VALUE_STORE;
+use gpui::{App, AsyncApp, Entity, SharedString, Task, prelude::*};
+use itertools::Itertools;
+use paths::contexts_dir;
+use serde::{Deserialize, Serialize};
+use std::{collections::VecDeque, path::Path, sync::Arc, time::Duration};
+use ui::ElementId;
+use util::ResultExt as _;
+
+const MAX_RECENTLY_OPENED_ENTRIES: usize = 6;
+const RECENTLY_OPENED_THREADS_KEY: &str = "recent-agent-threads";
+const SAVE_RECENTLY_OPENED_ENTRIES_DEBOUNCE: Duration = Duration::from_millis(50);
+
+const DEFAULT_TITLE: &SharedString = &SharedString::new_static("New Thread");
+
+#[derive(Clone, Debug)]
+pub enum HistoryEntry {
+    AcpThread(DbThreadMetadata),
+    TextThread(SavedContextMetadata),
+}
+
+impl HistoryEntry {
+    pub fn updated_at(&self) -> DateTime<Utc> {
+        match self {
+            HistoryEntry::AcpThread(thread) => thread.updated_at,
+            HistoryEntry::TextThread(context) => context.mtime.to_utc(),
+        }
+    }
+
+    pub fn id(&self) -> HistoryEntryId {
+        match self {
+            HistoryEntry::AcpThread(thread) => HistoryEntryId::AcpThread(thread.id.clone()),
+            HistoryEntry::TextThread(context) => HistoryEntryId::TextThread(context.path.clone()),
+        }
+    }
+
+    pub fn mention_uri(&self) -> MentionUri {
+        match self {
+            HistoryEntry::AcpThread(thread) => MentionUri::Thread {
+                id: thread.id.clone(),
+                name: thread.title.to_string(),
+            },
+            HistoryEntry::TextThread(context) => MentionUri::TextThread {
+                path: context.path.as_ref().to_owned(),
+                name: context.title.to_string(),
+            },
+        }
+    }
+
+    pub fn title(&self) -> &SharedString {
+        match self {
+            HistoryEntry::AcpThread(thread) if thread.title.is_empty() => DEFAULT_TITLE,
+            HistoryEntry::AcpThread(thread) => &thread.title,
+            HistoryEntry::TextThread(context) => &context.title,
+        }
+    }
+}
+
+/// Generic identifier for a history entry.
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub enum HistoryEntryId {
+    AcpThread(acp::SessionId),
+    TextThread(Arc<Path>),
+}
+
+impl Into<ElementId> for HistoryEntryId {
+    fn into(self) -> ElementId {
+        match self {
+            HistoryEntryId::AcpThread(session_id) => ElementId::Name(session_id.0.into()),
+            HistoryEntryId::TextThread(path) => ElementId::Path(path),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+enum SerializedRecentOpen {
+    AcpThread(String),
+    TextThread(String),
+}
+
+pub struct HistoryStore {
+    threads: Vec<DbThreadMetadata>,
+    context_store: Entity<assistant_context::ContextStore>,
+    recently_opened_entries: VecDeque<HistoryEntryId>,
+    _subscriptions: Vec<gpui::Subscription>,
+    _save_recently_opened_entries_task: Task<()>,
+}
+
+impl HistoryStore {
+    pub fn new(
+        context_store: Entity<assistant_context::ContextStore>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let subscriptions = vec![cx.observe(&context_store, |_, _, cx| cx.notify())];
+
+        cx.spawn(async move |this, cx| {
+            let entries = Self::load_recently_opened_entries(cx).await;
+            this.update(cx, |this, cx| {
+                if let Some(entries) = entries.log_err() {
+                    this.recently_opened_entries = entries;
+                }
+
+                this.reload(cx);
+            })
+            .ok();
+        })
+        .detach();
+
+        Self {
+            context_store,
+            recently_opened_entries: VecDeque::default(),
+            threads: Vec::default(),
+            _subscriptions: subscriptions,
+            _save_recently_opened_entries_task: Task::ready(()),
+        }
+    }
+
+    pub fn thread_from_session_id(&self, session_id: &acp::SessionId) -> Option<&DbThreadMetadata> {
+        self.threads.iter().find(|thread| &thread.id == session_id)
+    }
+
+    pub fn delete_thread(
+        &mut self,
+        id: acp::SessionId,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let database_future = ThreadsDatabase::connect(cx);
+        cx.spawn(async move |this, cx| {
+            let database = database_future.await.map_err(|err| anyhow!(err))?;
+            database.delete_thread(id.clone()).await?;
+            this.update(cx, |this, cx| this.reload(cx))
+        })
+    }
+
+    pub fn delete_text_thread(
+        &mut self,
+        path: Arc<Path>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.context_store.update(cx, |context_store, cx| {
+            context_store.delete_local_context(path, cx)
+        })
+    }
+
+    pub fn load_text_thread(
+        &self,
+        path: Arc<Path>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Entity<AssistantContext>>> {
+        self.context_store.update(cx, |context_store, cx| {
+            context_store.open_local_context(path, cx)
+        })
+    }
+
+    pub fn reload(&self, cx: &mut Context<Self>) {
+        let database_future = ThreadsDatabase::connect(cx);
+        cx.spawn(async move |this, cx| {
+            let threads = database_future
+                .await
+                .map_err(|err| anyhow!(err))?
+                .list_threads()
+                .await?;
+
+            this.update(cx, |this, cx| {
+                if this.recently_opened_entries.len() < MAX_RECENTLY_OPENED_ENTRIES {
+                    for thread in threads
+                        .iter()
+                        .take(MAX_RECENTLY_OPENED_ENTRIES - this.recently_opened_entries.len())
+                        .rev()
+                    {
+                        this.push_recently_opened_entry(
+                            HistoryEntryId::AcpThread(thread.id.clone()),
+                            cx,
+                        )
+                    }
+                }
+                this.threads = threads;
+                cx.notify();
+            })
+        })
+        .detach_and_log_err(cx);
+    }
+
+    pub fn entries(&self, cx: &App) -> Vec<HistoryEntry> {
+        let mut history_entries = Vec::new();
+
+        #[cfg(debug_assertions)]
+        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
+            return history_entries;
+        }
+
+        history_entries.extend(self.threads.iter().cloned().map(HistoryEntry::AcpThread));
+        history_entries.extend(
+            self.context_store
+                .read(cx)
+                .unordered_contexts()
+                .cloned()
+                .map(HistoryEntry::TextThread),
+        );
+
+        history_entries.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.updated_at()));
+        history_entries
+    }
+
+    pub fn is_empty(&self, cx: &App) -> bool {
+        self.threads.is_empty()
+            && self
+                .context_store
+                .read(cx)
+                .unordered_contexts()
+                .next()
+                .is_none()
+    }
+
+    pub fn recently_opened_entries(&self, cx: &App) -> Vec<HistoryEntry> {
+        #[cfg(debug_assertions)]
+        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
+            return Vec::new();
+        }
+
+        let thread_entries = self.threads.iter().flat_map(|thread| {
+            self.recently_opened_entries
+                .iter()
+                .enumerate()
+                .flat_map(|(index, entry)| match entry {
+                    HistoryEntryId::AcpThread(id) if &thread.id == id => {
+                        Some((index, HistoryEntry::AcpThread(thread.clone())))
+                    }
+                    _ => None,
+                })
+        });
+
+        let context_entries =
+            self.context_store
+                .read(cx)
+                .unordered_contexts()
+                .flat_map(|context| {
+                    self.recently_opened_entries
+                        .iter()
+                        .enumerate()
+                        .flat_map(|(index, entry)| match entry {
+                            HistoryEntryId::TextThread(path) if &context.path == path => {
+                                Some((index, HistoryEntry::TextThread(context.clone())))
+                            }
+                            _ => None,
+                        })
+                });
+
+        thread_entries
+            .chain(context_entries)
+            // optimization to halt iteration early
+            .take(self.recently_opened_entries.len())
+            .sorted_unstable_by_key(|(index, _)| *index)
+            .map(|(_, entry)| entry)
+            .collect()
+    }
+
+    fn save_recently_opened_entries(&mut self, cx: &mut Context<Self>) {
+        let serialized_entries = self
+            .recently_opened_entries
+            .iter()
+            .filter_map(|entry| match entry {
+                HistoryEntryId::TextThread(path) => path.file_name().map(|file| {
+                    SerializedRecentOpen::TextThread(file.to_string_lossy().to_string())
+                }),
+                HistoryEntryId::AcpThread(id) => {
+                    Some(SerializedRecentOpen::AcpThread(id.to_string()))
+                }
+            })
+            .collect::<Vec<_>>();
+
+        self._save_recently_opened_entries_task = cx.spawn(async move |_, cx| {
+            let content = serde_json::to_string(&serialized_entries).unwrap();
+            cx.background_executor()
+                .timer(SAVE_RECENTLY_OPENED_ENTRIES_DEBOUNCE)
+                .await;
+
+            if cfg!(any(feature = "test-support", test)) {
+                return;
+            }
+            KEY_VALUE_STORE
+                .write_kvp(RECENTLY_OPENED_THREADS_KEY.to_owned(), content)
+                .await
+                .log_err();
+        });
+    }
+
+    fn load_recently_opened_entries(cx: &AsyncApp) -> Task<Result<VecDeque<HistoryEntryId>>> {
+        cx.background_spawn(async move {
+            if cfg!(any(feature = "test-support", test)) {
+                anyhow::bail!("history store does not persist in tests");
+            }
+            let json = KEY_VALUE_STORE
+                .read_kvp(RECENTLY_OPENED_THREADS_KEY)?
+                .unwrap_or("[]".to_string());
+            let entries = serde_json::from_str::<Vec<SerializedRecentOpen>>(&json)
+                .context("deserializing persisted agent panel navigation history")?
+                .into_iter()
+                .take(MAX_RECENTLY_OPENED_ENTRIES)
+                .flat_map(|entry| match entry {
+                    SerializedRecentOpen::AcpThread(id) => Some(HistoryEntryId::AcpThread(
+                        acp::SessionId(id.as_str().into()),
+                    )),
+                    SerializedRecentOpen::TextThread(file_name) => Some(
+                        HistoryEntryId::TextThread(contexts_dir().join(file_name).into()),
+                    ),
+                })
+                .collect();
+            Ok(entries)
+        })
+    }
+
+    pub fn push_recently_opened_entry(&mut self, entry: HistoryEntryId, cx: &mut Context<Self>) {
+        self.recently_opened_entries
+            .retain(|old_entry| old_entry != &entry);
+        self.recently_opened_entries.push_front(entry);
+        self.recently_opened_entries
+            .truncate(MAX_RECENTLY_OPENED_ENTRIES);
+        self.save_recently_opened_entries(cx);
+    }
+
+    pub fn remove_recently_opened_thread(&mut self, id: acp::SessionId, cx: &mut Context<Self>) {
+        self.recently_opened_entries.retain(
+            |entry| !matches!(entry, HistoryEntryId::AcpThread(thread_id) if thread_id == &id),
+        );
+        self.save_recently_opened_entries(cx);
+    }
+
+    pub fn replace_recently_opened_text_thread(
+        &mut self,
+        old_path: &Path,
+        new_path: &Arc<Path>,
+        cx: &mut Context<Self>,
+    ) {
+        for entry in &mut self.recently_opened_entries {
+            match entry {
+                HistoryEntryId::TextThread(path) if path.as_ref() == old_path => {
+                    *entry = HistoryEntryId::TextThread(new_path.clone());
+                    break;
+                }
+                _ => {}
+            }
+        }
+        self.save_recently_opened_entries(cx);
+    }
+
+    pub fn remove_recently_opened_entry(&mut self, entry: &HistoryEntryId, cx: &mut Context<Self>) {
+        self.recently_opened_entries
+            .retain(|old_entry| old_entry != entry);
+        self.save_recently_opened_entries(cx);
+    }
+
+    pub fn recent_entries(&self, limit: usize, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
+        self.entries(cx).into_iter().take(limit).collect()
+    }
+}

crates/agent2/src/native_agent_server.rs

@@ -1,16 +1,25 @@
-use std::path::Path;
-use std::rc::Rc;
+use std::{any::Any, path::Path, rc::Rc, sync::Arc};
 
 use agent_servers::AgentServer;
 use anyhow::Result;
+use fs::Fs;
 use gpui::{App, Entity, Task};
 use project::Project;
 use prompt_store::PromptStore;
 
-use crate::{templates::Templates, NativeAgent, NativeAgentConnection};
+use crate::{HistoryStore, NativeAgent, NativeAgentConnection, templates::Templates};
 
 #[derive(Clone)]
-pub struct NativeAgentServer;
+pub struct NativeAgentServer {
+    fs: Arc<dyn Fs>,
+    history: Entity<HistoryStore>,
+}
+
+impl NativeAgentServer {
+    pub fn new(fs: Arc<dyn Fs>, history: Entity<HistoryStore>) -> Self {
+        Self { fs, history }
+    }
+}
 
 impl AgentServer for NativeAgentServer {
     fn name(&self) -> &'static str {
@@ -18,16 +27,15 @@ impl AgentServer for NativeAgentServer {
     }
 
     fn empty_state_headline(&self) -> &'static str {
-        "Native Agent"
+        "Welcome to the Agent Panel"
     }
 
     fn empty_state_message(&self) -> &'static str {
-        "How can I help you today?"
+        ""
     }
 
     fn logo(&self) -> ui::IconName {
-        // Using the ZedAssistant icon as it's the native built-in agent
-        ui::IconName::ZedAssistant
+        ui::IconName::ZedAgent
     }
 
     fn connect(
@@ -41,6 +49,8 @@ impl AgentServer for NativeAgentServer {
             _root_dir
         );
         let project = project.clone();
+        let fs = self.fs.clone();
+        let history = self.history.clone();
         let prompt_store = PromptStore::global(cx);
         cx.spawn(async move |cx| {
             log::debug!("Creating templates for native agent");
@@ -48,7 +58,8 @@ impl AgentServer for NativeAgentServer {
             let prompt_store = prompt_store.await?;
 
             log::debug!("Creating native agent entity");
-            let agent = NativeAgent::new(project, templates, Some(prompt_store), cx).await?;
+            let agent =
+                NativeAgent::new(project, history, templates, Some(prompt_store), fs, cx).await?;
 
             // Create the connection wrapper
             let connection = NativeAgentConnection(agent);
@@ -57,4 +68,57 @@ impl AgentServer for NativeAgentServer {
             Ok(Rc::new(connection) as Rc<dyn acp_thread::AgentConnection>)
         })
     }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use assistant_context::ContextStore;
+    use gpui::AppContext;
+
+    agent_servers::e2e_tests::common_e2e_tests!(
+        async |fs, project, cx| {
+            let auth = cx.update(|cx| {
+                prompt_store::init(cx);
+                terminal::init(cx);
+
+                let registry = language_model::LanguageModelRegistry::read_global(cx);
+                let auth = registry
+                    .provider(&language_model::ANTHROPIC_PROVIDER_ID)
+                    .unwrap()
+                    .authenticate(cx);
+
+                cx.spawn(async move |_| auth.await)
+            });
+
+            auth.await.unwrap();
+
+            cx.update(|cx| {
+                let registry = language_model::LanguageModelRegistry::global(cx);
+
+                registry.update(cx, |registry, cx| {
+                    registry.select_default_model(
+                        Some(&language_model::SelectedModel {
+                            provider: language_model::ANTHROPIC_PROVIDER_ID,
+                            model: language_model::LanguageModelId("claude-sonnet-4-latest".into()),
+                        }),
+                        cx,
+                    );
+                });
+            });
+
+            let history = cx.update(|cx| {
+                let context_store = cx.new(move |cx| ContextStore::fake(project.clone(), cx));
+                cx.new(move |cx| HistoryStore::new(context_store, cx))
+            });
+
+            NativeAgentServer::new(fs.clone(), history)
+        },
+        allow_option_id = "allow"
+    );
 }

crates/agent2/src/templates.rs

@@ -62,7 +62,7 @@ fn contains(
         handlebars::RenderError::new("contains: missing or invalid query parameter")
     })?;
 
-    if list.contains(&query) {
+    if list.contains(query) {
         out.write("true")?;
     }
 

crates/agent2/src/tests/test_tools.rs

@@ -7,13 +7,14 @@ use std::future;
 #[derive(JsonSchema, Serialize, Deserialize)]
 pub struct EchoToolInput {
     /// The text to echo.
-    text: String,
+    pub text: String,
 }
 
 pub struct EchoTool;
 
 impl AgentTool for EchoTool {
     type Input = EchoToolInput;
+    type Output = String;
 
     fn name(&self) -> SharedString {
         "echo".into()
@@ -23,7 +24,7 @@ impl AgentTool for EchoTool {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _: Self::Input) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
         "Echo".into()
     }
 
@@ -48,13 +49,18 @@ pub struct DelayTool;
 
 impl AgentTool for DelayTool {
     type Input = DelayToolInput;
+    type Output = String;
 
     fn name(&self) -> SharedString {
         "delay".into()
     }
 
-    fn initial_title(&self, input: Self::Input) -> SharedString {
-        format!("Delay {}ms", input.ms).into()
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            format!("Delay {}ms", input.ms).into()
+        } else {
+            "Delay".into()
+        }
     }
 
     fn kind(&self) -> acp::ToolKind {
@@ -84,6 +90,7 @@ pub struct ToolRequiringPermission;
 
 impl AgentTool for ToolRequiringPermission {
     type Input = ToolRequiringPermissionInput;
+    type Output = String;
 
     fn name(&self) -> SharedString {
         "tool_requiring_permission".into()
@@ -93,22 +100,19 @@ impl AgentTool for ToolRequiringPermission {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _input: Self::Input) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
         "This tool requires permission".into()
     }
 
     fn run(
         self: Arc<Self>,
-        input: Self::Input,
+        _input: Self::Input,
         event_stream: ToolCallEventStream,
         cx: &mut App,
-    ) -> Task<Result<String>>
-    where
-        Self: Sized,
-    {
-        let auth_check = self.authorize(input, event_stream);
+    ) -> Task<Result<String>> {
+        let authorize = event_stream.authorize("Authorize?", cx);
         cx.foreground_executor().spawn(async move {
-            auth_check.await?;
+            authorize.await?;
             Ok("Allowed".to_string())
         })
     }
@@ -121,6 +125,7 @@ pub struct InfiniteTool;
 
 impl AgentTool for InfiniteTool {
     type Input = InfiniteToolInput;
+    type Output = String;
 
     fn name(&self) -> SharedString {
         "infinite".into()
@@ -130,8 +135,8 @@ impl AgentTool for InfiniteTool {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _input: Self::Input) -> SharedString {
-        "This is the tool that never ends... it just goes on and on my friends!".into()
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        "Infinite Tool".into()
     }
 
     fn run(
@@ -171,19 +176,20 @@ pub struct WordListTool;
 
 impl AgentTool for WordListTool {
     type Input = WordListInput;
+    type Output = String;
 
     fn name(&self) -> SharedString {
         "word_list".into()
     }
 
-    fn initial_title(&self, _input: Self::Input) -> SharedString {
-        "List of random words".into()
-    }
-
     fn kind(&self) -> acp::ToolKind {
         acp::ToolKind::Other
     }
 
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        "List of random words".into()
+    }
+
     fn run(
         self: Arc<Self>,
         _input: Self::Input,

crates/agent2/src/tool_schema.rs

@@ -0,0 +1,43 @@
+use language_model::LanguageModelToolSchemaFormat;
+use schemars::{
+    JsonSchema, Schema,
+    generate::SchemaSettings,
+    transform::{Transform, transform_subschemas},
+};
+
+pub(crate) fn root_schema_for<T: JsonSchema>(format: LanguageModelToolSchemaFormat) -> Schema {
+    let mut generator = match format {
+        LanguageModelToolSchemaFormat::JsonSchema => SchemaSettings::draft07().into_generator(),
+        LanguageModelToolSchemaFormat::JsonSchemaSubset => SchemaSettings::openapi3()
+            .with(|settings| {
+                settings.meta_schema = None;
+                settings.inline_subschemas = true;
+            })
+            .with_transform(ToJsonSchemaSubsetTransform)
+            .into_generator(),
+    };
+    generator.root_schema_for::<T>()
+}
+
+#[derive(Debug, Clone)]
+struct ToJsonSchemaSubsetTransform;
+
+impl Transform for ToJsonSchemaSubsetTransform {
+    fn transform(&mut self, schema: &mut Schema) {
+        // Ensure that the type field is not an array, this happens when we use
+        // Option<T>, the type will be [T, "null"].
+        if let Some(type_field) = schema.get_mut("type")
+            && let Some(types) = type_field.as_array()
+            && let Some(first_type) = types.first()
+        {
+            *type_field = first_type.clone();
+        }
+
+        // oneOf is not supported, use anyOf instead
+        if let Some(one_of) = schema.remove("oneOf") {
+            schema.insert("anyOf".to_string(), one_of);
+        }
+
+        transform_subschemas(self, schema);
+    }
+}

crates/agent2/src/tools.rs

@@ -1,7 +1,35 @@
+mod context_server_registry;
+mod copy_path_tool;
+mod create_directory_tool;
+mod delete_path_tool;
+mod diagnostics_tool;
+mod edit_file_tool;
+mod fetch_tool;
 mod find_path_tool;
+mod grep_tool;
+mod list_directory_tool;
+mod move_path_tool;
+mod now_tool;
+mod open_tool;
 mod read_file_tool;
+mod terminal_tool;
 mod thinking_tool;
+mod web_search_tool;
 
+pub use context_server_registry::*;
+pub use copy_path_tool::*;
+pub use create_directory_tool::*;
+pub use delete_path_tool::*;
+pub use diagnostics_tool::*;
+pub use edit_file_tool::*;
+pub use fetch_tool::*;
 pub use find_path_tool::*;
+pub use grep_tool::*;
+pub use list_directory_tool::*;
+pub use move_path_tool::*;
+pub use now_tool::*;
+pub use open_tool::*;
 pub use read_file_tool::*;
+pub use terminal_tool::*;
 pub use thinking_tool::*;
+pub use web_search_tool::*;

crates/agent2/src/tools/context_server_registry.rs

@@ -0,0 +1,239 @@
+use crate::{AgentToolOutput, AnyAgentTool, ToolCallEventStream};
+use agent_client_protocol::ToolKind;
+use anyhow::{Result, anyhow, bail};
+use collections::{BTreeMap, HashMap};
+use context_server::ContextServerId;
+use gpui::{App, Context, Entity, SharedString, Task};
+use project::context_server_store::{ContextServerStatus, ContextServerStore};
+use std::sync::Arc;
+use util::ResultExt;
+
+pub struct ContextServerRegistry {
+    server_store: Entity<ContextServerStore>,
+    registered_servers: HashMap<ContextServerId, RegisteredContextServer>,
+    _subscription: gpui::Subscription,
+}
+
+struct RegisteredContextServer {
+    tools: BTreeMap<SharedString, Arc<dyn AnyAgentTool>>,
+    load_tools: Task<Result<()>>,
+}
+
+impl ContextServerRegistry {
+    pub fn new(server_store: Entity<ContextServerStore>, cx: &mut Context<Self>) -> Self {
+        let mut this = Self {
+            server_store: server_store.clone(),
+            registered_servers: HashMap::default(),
+            _subscription: cx.subscribe(&server_store, Self::handle_context_server_store_event),
+        };
+        for server in server_store.read(cx).running_servers() {
+            this.reload_tools_for_server(server.id(), cx);
+        }
+        this
+    }
+
+    pub fn servers(
+        &self,
+    ) -> impl Iterator<
+        Item = (
+            &ContextServerId,
+            &BTreeMap<SharedString, Arc<dyn AnyAgentTool>>,
+        ),
+    > {
+        self.registered_servers
+            .iter()
+            .map(|(id, server)| (id, &server.tools))
+    }
+
+    fn reload_tools_for_server(&mut self, server_id: ContextServerId, cx: &mut Context<Self>) {
+        let Some(server) = self.server_store.read(cx).get_running_server(&server_id) else {
+            return;
+        };
+        let Some(client) = server.client() else {
+            return;
+        };
+        if !client.capable(context_server::protocol::ServerCapability::Tools) {
+            return;
+        }
+
+        let registered_server =
+            self.registered_servers
+                .entry(server_id.clone())
+                .or_insert(RegisteredContextServer {
+                    tools: BTreeMap::default(),
+                    load_tools: Task::ready(Ok(())),
+                });
+        registered_server.load_tools = cx.spawn(async move |this, cx| {
+            let response = client
+                .request::<context_server::types::requests::ListTools>(())
+                .await;
+
+            this.update(cx, |this, cx| {
+                let Some(registered_server) = this.registered_servers.get_mut(&server_id) else {
+                    return;
+                };
+
+                registered_server.tools.clear();
+                if let Some(response) = response.log_err() {
+                    for tool in response.tools {
+                        let tool = Arc::new(ContextServerTool::new(
+                            this.server_store.clone(),
+                            server.id(),
+                            tool,
+                        ));
+                        registered_server.tools.insert(tool.name(), tool);
+                    }
+                    cx.notify();
+                }
+            })
+        });
+    }
+
+    fn handle_context_server_store_event(
+        &mut self,
+        _: Entity<ContextServerStore>,
+        event: &project::context_server_store::Event,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            project::context_server_store::Event::ServerStatusChanged { server_id, status } => {
+                match status {
+                    ContextServerStatus::Starting => {}
+                    ContextServerStatus::Running => {
+                        self.reload_tools_for_server(server_id.clone(), cx);
+                    }
+                    ContextServerStatus::Stopped | ContextServerStatus::Error(_) => {
+                        self.registered_servers.remove(server_id);
+                        cx.notify();
+                    }
+                }
+            }
+        }
+    }
+}
+
+struct ContextServerTool {
+    store: Entity<ContextServerStore>,
+    server_id: ContextServerId,
+    tool: context_server::types::Tool,
+}
+
+impl ContextServerTool {
+    fn new(
+        store: Entity<ContextServerStore>,
+        server_id: ContextServerId,
+        tool: context_server::types::Tool,
+    ) -> Self {
+        Self {
+            store,
+            server_id,
+            tool,
+        }
+    }
+}
+
+impl AnyAgentTool for ContextServerTool {
+    fn name(&self) -> SharedString {
+        self.tool.name.clone().into()
+    }
+
+    fn description(&self) -> SharedString {
+        self.tool.description.clone().unwrap_or_default().into()
+    }
+
+    fn kind(&self) -> ToolKind {
+        ToolKind::Other
+    }
+
+    fn initial_title(&self, _input: serde_json::Value) -> SharedString {
+        format!("Run MCP tool `{}`", self.tool.name).into()
+    }
+
+    fn input_schema(
+        &self,
+        format: language_model::LanguageModelToolSchemaFormat,
+    ) -> Result<serde_json::Value> {
+        let mut schema = self.tool.input_schema.clone();
+        assistant_tool::adapt_schema_to_format(&mut schema, format)?;
+        Ok(match schema {
+            serde_json::Value::Null => {
+                serde_json::json!({ "type": "object", "properties": [] })
+            }
+            serde_json::Value::Object(map) if map.is_empty() => {
+                serde_json::json!({ "type": "object", "properties": [] })
+            }
+            _ => schema,
+        })
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<AgentToolOutput>> {
+        let Some(server) = self.store.read(cx).get_running_server(&self.server_id) else {
+            return Task::ready(Err(anyhow!("Context server not found")));
+        };
+        let tool_name = self.tool.name.clone();
+
+        cx.spawn(async move |_cx| {
+            let Some(protocol) = server.client() else {
+                bail!("Context server not initialized");
+            };
+
+            let arguments = if let serde_json::Value::Object(map) = input {
+                Some(map.into_iter().collect())
+            } else {
+                None
+            };
+
+            log::trace!(
+                "Running tool: {} with arguments: {:?}",
+                tool_name,
+                arguments
+            );
+            let response = protocol
+                .request::<context_server::types::requests::CallTool>(
+                    context_server::types::CallToolParams {
+                        name: tool_name,
+                        arguments,
+                        meta: None,
+                    },
+                )
+                .await?;
+
+            let mut result = String::new();
+            for content in response.content {
+                match content {
+                    context_server::types::ToolResponseContent::Text { text } => {
+                        result.push_str(&text);
+                    }
+                    context_server::types::ToolResponseContent::Image { .. } => {
+                        log::warn!("Ignoring image content from tool response");
+                    }
+                    context_server::types::ToolResponseContent::Audio { .. } => {
+                        log::warn!("Ignoring audio content from tool response");
+                    }
+                    context_server::types::ToolResponseContent::Resource { .. } => {
+                        log::warn!("Ignoring resource content from tool response");
+                    }
+                }
+            }
+            Ok(AgentToolOutput {
+                raw_output: result.clone().into(),
+                llm_output: result.into(),
+            })
+        })
+    }
+
+    fn replay(
+        &self,
+        _input: serde_json::Value,
+        _output: serde_json::Value,
+        _event_stream: ToolCallEventStream,
+        _cx: &mut App,
+    ) -> Result<()> {
+        Ok(())
+    }
+}

crates/agent2/src/tools/copy_path_tool.rs

@@ -0,0 +1,111 @@
+use crate::{AgentTool, ToolCallEventStream};
+use agent_client_protocol::ToolKind;
+use anyhow::{Context as _, Result, anyhow};
+use gpui::{App, AppContext, Entity, SharedString, Task};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use util::markdown::MarkdownInlineCode;
+
+/// Copies a file or directory in the project, and returns confirmation that the copy succeeded.
+/// Directory contents will be copied recursively (like `cp -r`).
+///
+/// This tool should be used when it's desirable to create a copy of a file or directory without modifying the original.
+/// It's much more efficient than doing this by separately reading and then writing the file or directory's contents, so this tool should be preferred over that approach whenever copying is the goal.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct CopyPathToolInput {
+    /// The source path of the file or directory to copy.
+    /// If a directory is specified, its contents will be copied recursively (like `cp -r`).
+    ///
+    /// <example>
+    /// If the project has the following files:
+    ///
+    /// - directory1/a/something.txt
+    /// - directory2/a/things.txt
+    /// - directory3/a/other.txt
+    ///
+    /// You can copy the first file by providing a source_path of "directory1/a/something.txt"
+    /// </example>
+    pub source_path: String,
+    /// The destination path where the file or directory should be copied to.
+    ///
+    /// <example>
+    /// To copy "directory1/a/something.txt" to "directory2/b/copy.txt", provide a destination_path of "directory2/b/copy.txt"
+    /// </example>
+    pub destination_path: String,
+}
+
+pub struct CopyPathTool {
+    project: Entity<Project>,
+}
+
+impl CopyPathTool {
+    pub fn new(project: Entity<Project>) -> Self {
+        Self { project }
+    }
+}
+
+impl AgentTool for CopyPathTool {
+    type Input = CopyPathToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "copy_path".into()
+    }
+
+    fn kind(&self) -> ToolKind {
+        ToolKind::Move
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> ui::SharedString {
+        if let Ok(input) = input {
+            let src = MarkdownInlineCode(&input.source_path);
+            let dest = MarkdownInlineCode(&input.destination_path);
+            format!("Copy {src} to {dest}").into()
+        } else {
+            "Copy path".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        let copy_task = self.project.update(cx, |project, cx| {
+            match project
+                .find_project_path(&input.source_path, cx)
+                .and_then(|project_path| project.entry_for_path(&project_path, cx))
+            {
+                Some(entity) => match project.find_project_path(&input.destination_path, cx) {
+                    Some(project_path) => {
+                        project.copy_entry(entity.id, None, project_path.path, cx)
+                    }
+                    None => Task::ready(Err(anyhow!(
+                        "Destination path {} was outside the project.",
+                        input.destination_path
+                    ))),
+                },
+                None => Task::ready(Err(anyhow!(
+                    "Source path {} was not found in the project.",
+                    input.source_path
+                ))),
+            }
+        });
+
+        cx.background_spawn(async move {
+            let _ = copy_task.await.with_context(|| {
+                format!(
+                    "Copying {} to {}",
+                    input.source_path, input.destination_path
+                )
+            })?;
+            Ok(format!(
+                "Copied {} to {}",
+                input.source_path, input.destination_path
+            ))
+        })
+    }
+}

crates/agent2/src/tools/create_directory_tool.rs

@@ -0,0 +1,86 @@
+use agent_client_protocol::ToolKind;
+use anyhow::{Context as _, Result, anyhow};
+use gpui::{App, Entity, SharedString, Task};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use util::markdown::MarkdownInlineCode;
+
+use crate::{AgentTool, ToolCallEventStream};
+
+/// Creates a new directory at the specified path within the project. Returns confirmation that the directory was created.
+///
+/// This tool creates a directory and all necessary parent directories (similar to `mkdir -p`). It should be used whenever you need to create new directories within the project.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct CreateDirectoryToolInput {
+    /// The path of the new directory.
+    ///
+    /// <example>
+    /// If the project has the following structure:
+    ///
+    /// - directory1/
+    /// - directory2/
+    ///
+    /// You can create a new directory by providing a path of "directory1/new_directory"
+    /// </example>
+    pub path: String,
+}
+
+pub struct CreateDirectoryTool {
+    project: Entity<Project>,
+}
+
+impl CreateDirectoryTool {
+    pub fn new(project: Entity<Project>) -> Self {
+        Self { project }
+    }
+}
+
+impl AgentTool for CreateDirectoryTool {
+    type Input = CreateDirectoryToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "create_directory".into()
+    }
+
+    fn kind(&self) -> ToolKind {
+        ToolKind::Read
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            format!("Create directory {}", MarkdownInlineCode(&input.path)).into()
+        } else {
+            "Create directory".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        let project_path = match self.project.read(cx).find_project_path(&input.path, cx) {
+            Some(project_path) => project_path,
+            None => {
+                return Task::ready(Err(anyhow!("Path to create was outside the project")));
+            }
+        };
+        let destination_path: Arc<str> = input.path.as_str().into();
+
+        let create_entry = self.project.update(cx, |project, cx| {
+            project.create_entry(project_path.clone(), true, cx)
+        });
+
+        cx.spawn(async move |_cx| {
+            create_entry
+                .await
+                .with_context(|| format!("Creating directory {destination_path}"))?;
+
+            Ok(format!("Created directory {destination_path}"))
+        })
+    }
+}

crates/agent2/src/tools/delete_path_tool.rs

@@ -0,0 +1,136 @@
+use crate::{AgentTool, ToolCallEventStream};
+use action_log::ActionLog;
+use agent_client_protocol::ToolKind;
+use anyhow::{Context as _, Result, anyhow};
+use futures::{SinkExt, StreamExt, channel::mpsc};
+use gpui::{App, AppContext, Entity, SharedString, Task};
+use project::{Project, ProjectPath};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+/// Deletes the file or directory (and the directory's contents, recursively) at the specified path in the project, and returns confirmation of the deletion.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct DeletePathToolInput {
+    /// The path of the file or directory to delete.
+    ///
+    /// <example>
+    /// If the project has the following files:
+    ///
+    /// - directory1/a/something.txt
+    /// - directory2/a/things.txt
+    /// - directory3/a/other.txt
+    ///
+    /// You can delete the first file by providing a path of "directory1/a/something.txt"
+    /// </example>
+    pub path: String,
+}
+
+pub struct DeletePathTool {
+    project: Entity<Project>,
+    action_log: Entity<ActionLog>,
+}
+
+impl DeletePathTool {
+    pub fn new(project: Entity<Project>, action_log: Entity<ActionLog>) -> Self {
+        Self {
+            project,
+            action_log,
+        }
+    }
+}
+
+impl AgentTool for DeletePathTool {
+    type Input = DeletePathToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "delete_path".into()
+    }
+
+    fn kind(&self) -> ToolKind {
+        ToolKind::Delete
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            format!("Delete “`{}`”", input.path).into()
+        } else {
+            "Delete path".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        let path = input.path;
+        let Some(project_path) = self.project.read(cx).find_project_path(&path, cx) else {
+            return Task::ready(Err(anyhow!(
+                "Couldn't delete {path} because that path isn't in this project."
+            )));
+        };
+
+        let Some(worktree) = self
+            .project
+            .read(cx)
+            .worktree_for_id(project_path.worktree_id, cx)
+        else {
+            return Task::ready(Err(anyhow!(
+                "Couldn't delete {path} because that path isn't in this project."
+            )));
+        };
+
+        let worktree_snapshot = worktree.read(cx).snapshot();
+        let (mut paths_tx, mut paths_rx) = mpsc::channel(256);
+        cx.background_spawn({
+            let project_path = project_path.clone();
+            async move {
+                for entry in
+                    worktree_snapshot.traverse_from_path(true, false, false, &project_path.path)
+                {
+                    if !entry.path.starts_with(&project_path.path) {
+                        break;
+                    }
+                    paths_tx
+                        .send(ProjectPath {
+                            worktree_id: project_path.worktree_id,
+                            path: entry.path.clone(),
+                        })
+                        .await?;
+                }
+                anyhow::Ok(())
+            }
+        })
+        .detach();
+
+        let project = self.project.clone();
+        let action_log = self.action_log.clone();
+        cx.spawn(async move |cx| {
+            while let Some(path) = paths_rx.next().await {
+                if let Ok(buffer) = project
+                    .update(cx, |project, cx| project.open_buffer(path, cx))?
+                    .await
+                {
+                    action_log.update(cx, |action_log, cx| {
+                        action_log.will_delete_buffer(buffer.clone(), cx)
+                    })?;
+                }
+            }
+
+            let deletion_task = project
+                .update(cx, |project, cx| {
+                    project.delete_file(project_path, false, cx)
+                })?
+                .with_context(|| {
+                    format!("Couldn't delete {path} because that path isn't in this project.")
+                })?;
+            deletion_task
+                .await
+                .with_context(|| format!("Deleting {path}"))?;
+            Ok(format!("Deleted {path}"))
+        })
+    }
+}

crates/agent2/src/tools/diagnostics_tool.rs

@@ -0,0 +1,163 @@
+use crate::{AgentTool, ToolCallEventStream};
+use agent_client_protocol as acp;
+use anyhow::{Result, anyhow};
+use gpui::{App, Entity, Task};
+use language::{DiagnosticSeverity, OffsetRangeExt};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{fmt::Write, path::Path, sync::Arc};
+use ui::SharedString;
+use util::markdown::MarkdownInlineCode;
+
+/// Get errors and warnings for the project or a specific file.
+///
+/// This tool can be invoked after a series of edits to determine if further edits are necessary, or if the user asks to fix errors or warnings in their codebase.
+///
+/// When a path is provided, shows all diagnostics for that specific file.
+/// When no path is provided, shows a summary of error and warning counts for all files in the project.
+///
+/// <example>
+/// To get diagnostics for a specific file:
+/// {
+///     "path": "src/main.rs"
+/// }
+///
+/// To get a project-wide diagnostic summary:
+/// {}
+/// </example>
+///
+/// <guidelines>
+/// - If you think you can fix a diagnostic, make 1-2 attempts and then give up.
+/// - Don't remove code you've generated just because you can't fix an error. The user can help you fix it.
+/// </guidelines>
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct DiagnosticsToolInput {
+    /// The path to get diagnostics for. If not provided, returns a project-wide summary.
+    ///
+    /// This path should never be absolute, and the first component
+    /// of the path should always be a root directory in a project.
+    ///
+    /// <example>
+    /// If the project has the following root directories:
+    ///
+    /// - lorem
+    /// - ipsum
+    ///
+    /// If you wanna access diagnostics for `dolor.txt` in `ipsum`, you should use the path `ipsum/dolor.txt`.
+    /// </example>
+    pub path: Option<String>,
+}
+
+pub struct DiagnosticsTool {
+    project: Entity<Project>,
+}
+
+impl DiagnosticsTool {
+    pub fn new(project: Entity<Project>) -> Self {
+        Self { project }
+    }
+}
+
+impl AgentTool for DiagnosticsTool {
+    type Input = DiagnosticsToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "diagnostics".into()
+    }
+
+    fn kind(&self) -> acp::ToolKind {
+        acp::ToolKind::Read
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Some(path) = input.ok().and_then(|input| match input.path {
+            Some(path) if !path.is_empty() => Some(path),
+            _ => None,
+        }) {
+            format!("Check diagnostics for {}", MarkdownInlineCode(&path)).into()
+        } else {
+            "Check project diagnostics".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        match input.path {
+            Some(path) if !path.is_empty() => {
+                let Some(project_path) = self.project.read(cx).find_project_path(&path, cx) else {
+                    return Task::ready(Err(anyhow!("Could not find path {path} in project",)));
+                };
+
+                let buffer = self
+                    .project
+                    .update(cx, |project, cx| project.open_buffer(project_path, cx));
+
+                cx.spawn(async move |cx| {
+                    let mut output = String::new();
+                    let buffer = buffer.await?;
+                    let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
+
+                    for (_, group) in snapshot.diagnostic_groups(None) {
+                        let entry = &group.entries[group.primary_ix];
+                        let range = entry.range.to_point(&snapshot);
+                        let severity = match entry.diagnostic.severity {
+                            DiagnosticSeverity::ERROR => "error",
+                            DiagnosticSeverity::WARNING => "warning",
+                            _ => continue,
+                        };
+
+                        writeln!(
+                            output,
+                            "{} at line {}: {}",
+                            severity,
+                            range.start.row + 1,
+                            entry.diagnostic.message
+                        )?;
+                    }
+
+                    if output.is_empty() {
+                        Ok("File doesn't have errors or warnings!".to_string())
+                    } else {
+                        Ok(output)
+                    }
+                })
+            }
+            _ => {
+                let project = self.project.read(cx);
+                let mut output = String::new();
+                let mut has_diagnostics = false;
+
+                for (project_path, _, summary) in project.diagnostic_summaries(true, cx) {
+                    if summary.error_count > 0 || summary.warning_count > 0 {
+                        let Some(worktree) = project.worktree_for_id(project_path.worktree_id, cx)
+                        else {
+                            continue;
+                        };
+
+                        has_diagnostics = true;
+                        output.push_str(&format!(
+                            "{}: {} error(s), {} warning(s)\n",
+                            Path::new(worktree.read(cx).root_name())
+                                .join(project_path.path)
+                                .display(),
+                            summary.error_count,
+                            summary.warning_count
+                        ));
+                    }
+                }
+
+                if has_diagnostics {
+                    Task::ready(Ok(output))
+                } else {
+                    Task::ready(Ok("No errors or warnings found in the project.".into()))
+                }
+            }
+        }
+    }
+}

crates/agent2/src/tools/fetch_tool.rs

@@ -0,0 +1,155 @@
+use std::rc::Rc;
+use std::sync::Arc;
+use std::{borrow::Cow, cell::RefCell};
+
+use agent_client_protocol as acp;
+use anyhow::{Context as _, Result, bail};
+use futures::AsyncReadExt as _;
+use gpui::{App, AppContext as _, Task};
+use html_to_markdown::{TagHandler, convert_html_to_markdown, markdown};
+use http_client::{AsyncBody, HttpClientWithUrl};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use ui::SharedString;
+use util::markdown::MarkdownEscaped;
+
+use crate::{AgentTool, ToolCallEventStream};
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+enum ContentType {
+    Html,
+    Plaintext,
+    Json,
+}
+
+/// Fetches a URL and returns the content as Markdown.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct FetchToolInput {
+    /// The URL to fetch.
+    url: String,
+}
+
+pub struct FetchTool {
+    http_client: Arc<HttpClientWithUrl>,
+}
+
+impl FetchTool {
+    pub fn new(http_client: Arc<HttpClientWithUrl>) -> Self {
+        Self { http_client }
+    }
+
+    async fn build_message(http_client: Arc<HttpClientWithUrl>, url: &str) -> Result<String> {
+        let url = if !url.starts_with("https://") && !url.starts_with("http://") {
+            Cow::Owned(format!("https://{url}"))
+        } else {
+            Cow::Borrowed(url)
+        };
+
+        let mut response = http_client.get(&url, AsyncBody::default(), true).await?;
+
+        let mut body = Vec::new();
+        response
+            .body_mut()
+            .read_to_end(&mut body)
+            .await
+            .context("error reading response body")?;
+
+        if response.status().is_client_error() {
+            let text = String::from_utf8_lossy(body.as_slice());
+            bail!(
+                "status error {}, response: {text:?}",
+                response.status().as_u16()
+            );
+        }
+
+        let Some(content_type) = response.headers().get("content-type") else {
+            bail!("missing Content-Type header");
+        };
+        let content_type = content_type
+            .to_str()
+            .context("invalid Content-Type header")?;
+
+        let content_type = if content_type.starts_with("text/plain") {
+            ContentType::Plaintext
+        } else if content_type.starts_with("application/json") {
+            ContentType::Json
+        } else {
+            ContentType::Html
+        };
+
+        match content_type {
+            ContentType::Html => {
+                let mut handlers: Vec<TagHandler> = vec![
+                    Rc::new(RefCell::new(markdown::WebpageChromeRemover)),
+                    Rc::new(RefCell::new(markdown::ParagraphHandler)),
+                    Rc::new(RefCell::new(markdown::HeadingHandler)),
+                    Rc::new(RefCell::new(markdown::ListHandler)),
+                    Rc::new(RefCell::new(markdown::TableHandler::new())),
+                    Rc::new(RefCell::new(markdown::StyledTextHandler)),
+                ];
+                if url.contains("wikipedia.org") {
+                    use html_to_markdown::structure::wikipedia;
+
+                    handlers.push(Rc::new(RefCell::new(wikipedia::WikipediaChromeRemover)));
+                    handlers.push(Rc::new(RefCell::new(wikipedia::WikipediaInfoboxHandler)));
+                    handlers.push(Rc::new(
+                        RefCell::new(wikipedia::WikipediaCodeHandler::new()),
+                    ));
+                } else {
+                    handlers.push(Rc::new(RefCell::new(markdown::CodeHandler)));
+                }
+
+                convert_html_to_markdown(&body[..], &mut handlers)
+            }
+            ContentType::Plaintext => Ok(std::str::from_utf8(&body)?.to_owned()),
+            ContentType::Json => {
+                let json: serde_json::Value = serde_json::from_slice(&body)?;
+
+                Ok(format!(
+                    "```json\n{}\n```",
+                    serde_json::to_string_pretty(&json)?
+                ))
+            }
+        }
+    }
+}
+
+impl AgentTool for FetchTool {
+    type Input = FetchToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "fetch".into()
+    }
+
+    fn kind(&self) -> acp::ToolKind {
+        acp::ToolKind::Fetch
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        match input {
+            Ok(input) => format!("Fetch {}", MarkdownEscaped(&input.url)).into(),
+            Err(_) => "Fetch URL".into(),
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        let text = cx.background_spawn({
+            let http_client = self.http_client.clone();
+            async move { Self::build_message(http_client, &input.url).await }
+        });
+
+        cx.foreground_executor().spawn(async move {
+            let text = text.await?;
+            if text.trim().is_empty() {
+                bail!("no textual content found");
+            }
+            Ok(text)
+        })
+    }
+}

crates/agent2/src/tools/find_path_tool.rs

@@ -1,6 +1,8 @@
+use crate::{AgentTool, ToolCallEventStream};
 use agent_client_protocol as acp;
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use gpui::{App, AppContext, Entity, SharedString, Task};
+use language_model::LanguageModelToolResultContent;
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -8,8 +10,6 @@ use std::fmt::Write;
 use std::{cmp, path::PathBuf, sync::Arc};
 use util::paths::PathMatcher;
 
-use crate::{AgentTool, ToolCallEventStream};
-
 /// Fast file path pattern matching tool that works with any codebase size
 ///
 /// - Supports glob patterns like "**/*.js" or "src/**/*.ts"
@@ -31,7 +31,6 @@ pub struct FindPathToolInput {
     /// You can get back the first two paths by providing a glob of "*thing*.txt"
     /// </example>
     pub glob: String,
-
     /// Optional starting position for paginated results (0-based).
     /// When not provided, starts from the beginning.
     #[serde(default)]
@@ -39,8 +38,35 @@ pub struct FindPathToolInput {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-struct FindPathToolOutput {
-    paths: Vec<PathBuf>,
+pub struct FindPathToolOutput {
+    offset: usize,
+    current_matches_page: Vec<PathBuf>,
+    all_matches_len: usize,
+}
+
+impl From<FindPathToolOutput> for LanguageModelToolResultContent {
+    fn from(output: FindPathToolOutput) -> Self {
+        if output.current_matches_page.is_empty() {
+            "No matches found".into()
+        } else {
+            let mut llm_output = format!("Found {} total matches.", output.all_matches_len);
+            if output.all_matches_len > RESULTS_PER_PAGE {
+                write!(
+                    &mut llm_output,
+                    "\nShowing results {}-{} (provide 'offset' parameter for more results):",
+                    output.offset + 1,
+                    output.offset + output.current_matches_page.len()
+                )
+                .unwrap();
+            }
+
+            for mat in output.current_matches_page {
+                write!(&mut llm_output, "\n{}", mat.display()).unwrap();
+            }
+
+            llm_output.into()
+        }
+    }
 }
 
 const RESULTS_PER_PAGE: usize = 50;
@@ -57,6 +83,7 @@ impl FindPathTool {
 
 impl AgentTool for FindPathTool {
     type Input = FindPathToolInput;
+    type Output = FindPathToolOutput;
 
     fn name(&self) -> SharedString {
         "find_path".into()
@@ -66,8 +93,12 @@ impl AgentTool for FindPathTool {
         acp::ToolKind::Search
     }
 
-    fn initial_title(&self, input: Self::Input) -> SharedString {
-        format!("Find paths matching “`{}`”", input.glob).into()
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        let mut title = "Find paths".to_string();
+        if let Ok(input) = input {
+            title.push_str(&format!(" matching “`{}`”", input.glob));
+        }
+        title.into()
     }
 
     fn run(
@@ -75,7 +106,7 @@ impl AgentTool for FindPathTool {
         input: Self::Input,
         event_stream: ToolCallEventStream,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<FindPathToolOutput>> {
         let search_paths_task = search_paths(&input.glob, self.project.clone(), cx);
 
         cx.background_spawn(async move {
@@ -83,8 +114,8 @@ impl AgentTool for FindPathTool {
             let paginated_matches: &[PathBuf] = &matches[cmp::min(input.offset, matches.len())
                 ..cmp::min(input.offset + RESULTS_PER_PAGE, matches.len())];
 
-            event_stream.send_update(acp::ToolCallUpdateFields {
-                title: Some(if paginated_matches.len() == 0 {
+            event_stream.update_fields(acp::ToolCallUpdateFields {
+                title: Some(if paginated_matches.is_empty() {
                     "No matches".into()
                 } else if paginated_matches.len() == 1 {
                     "1 match".into()
@@ -107,32 +138,14 @@ impl AgentTool for FindPathTool {
                         })
                         .collect(),
                 ),
-                raw_output: Some(serde_json::json!({
-                    "paths": &matches,
-                })),
                 ..Default::default()
             });
 
-            if matches.is_empty() {
-                Ok("No matches found".into())
-            } else {
-                let mut message = format!("Found {} total matches.", matches.len());
-                if matches.len() > RESULTS_PER_PAGE {
-                    write!(
-                        &mut message,
-                        "\nShowing results {}-{} (provide 'offset' parameter for more results):",
-                        input.offset + 1,
-                        input.offset + paginated_matches.len()
-                    )
-                    .unwrap();
-                }
-
-                for mat in matches.iter().skip(input.offset).take(RESULTS_PER_PAGE) {
-                    write!(&mut message, "\n{}", mat.display()).unwrap();
-                }
-
-                Ok(message)
-            }
+            Ok(FindPathToolOutput {
+                offset: input.offset,
+                current_matches_page: paginated_matches.to_vec(),
+                all_matches_len: matches.len(),
+            })
         })
     }
 }

crates/agent2/src/tools/list_directory_tool.rs

@@ -0,0 +1,662 @@
+use crate::{AgentTool, ToolCallEventStream};
+use agent_client_protocol::ToolKind;
+use anyhow::{Result, anyhow};
+use gpui::{App, Entity, SharedString, Task};
+use project::{Project, WorktreeSettings};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::Settings;
+use std::fmt::Write;
+use std::{path::Path, sync::Arc};
+use util::markdown::MarkdownInlineCode;
+
+/// Lists files and directories in a given path. Prefer the `grep` or `find_path` tools when searching the codebase.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct ListDirectoryToolInput {
+    /// The fully-qualified path of the directory to list in the project.
+    ///
+    /// This path should never be absolute, and the first component of the path should always be a root directory in a project.
+    ///
+    /// <example>
+    /// If the project has the following root directories:
+    ///
+    /// - directory1
+    /// - directory2
+    ///
+    /// You can list the contents of `directory1` by using the path `directory1`.
+    /// </example>
+    ///
+    /// <example>
+    /// If the project has the following root directories:
+    ///
+    /// - foo
+    /// - bar
+    ///
+    /// If you wanna list contents in the directory `foo/baz`, you should use the path `foo/baz`.
+    /// </example>
+    pub path: String,
+}
+
+pub struct ListDirectoryTool {
+    project: Entity<Project>,
+}
+
+impl ListDirectoryTool {
+    pub fn new(project: Entity<Project>) -> Self {
+        Self { project }
+    }
+}
+
+impl AgentTool for ListDirectoryTool {
+    type Input = ListDirectoryToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "list_directory".into()
+    }
+
+    fn kind(&self) -> ToolKind {
+        ToolKind::Read
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            let path = MarkdownInlineCode(&input.path);
+            format!("List the {path} directory's contents").into()
+        } else {
+            "List directory".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        // Sometimes models will return these even though we tell it to give a path and not a glob.
+        // When this happens, just list the root worktree directories.
+        if matches!(input.path.as_str(), "." | "" | "./" | "*") {
+            let output = self
+                .project
+                .read(cx)
+                .worktrees(cx)
+                .filter_map(|worktree| {
+                    worktree.read(cx).root_entry().and_then(|entry| {
+                        if entry.is_dir() {
+                            entry.path.to_str()
+                        } else {
+                            None
+                        }
+                    })
+                })
+                .collect::<Vec<_>>()
+                .join("\n");
+
+            return Task::ready(Ok(output));
+        }
+
+        let Some(project_path) = self.project.read(cx).find_project_path(&input.path, cx) else {
+            return Task::ready(Err(anyhow!("Path {} not found in project", input.path)));
+        };
+        let Some(worktree) = self
+            .project
+            .read(cx)
+            .worktree_for_id(project_path.worktree_id, cx)
+        else {
+            return Task::ready(Err(anyhow!("Worktree not found")));
+        };
+
+        // Check if the directory whose contents we're listing is itself excluded or private
+        let global_settings = WorktreeSettings::get_global(cx);
+        if global_settings.is_path_excluded(&project_path.path) {
+            return Task::ready(Err(anyhow!(
+                "Cannot list directory because its path matches the user's global `file_scan_exclusions` setting: {}",
+                &input.path
+            )));
+        }
+
+        if global_settings.is_path_private(&project_path.path) {
+            return Task::ready(Err(anyhow!(
+                "Cannot list directory because its path matches the user's global `private_files` setting: {}",
+                &input.path
+            )));
+        }
+
+        let worktree_settings = WorktreeSettings::get(Some((&project_path).into()), cx);
+        if worktree_settings.is_path_excluded(&project_path.path) {
+            return Task::ready(Err(anyhow!(
+                "Cannot list directory because its path matches the user's worktree`file_scan_exclusions` setting: {}",
+                &input.path
+            )));
+        }
+
+        if worktree_settings.is_path_private(&project_path.path) {
+            return Task::ready(Err(anyhow!(
+                "Cannot list directory because its path matches the user's worktree `private_paths` setting: {}",
+                &input.path
+            )));
+        }
+
+        let worktree_snapshot = worktree.read(cx).snapshot();
+        let worktree_root_name = worktree.read(cx).root_name().to_string();
+
+        let Some(entry) = worktree_snapshot.entry_for_path(&project_path.path) else {
+            return Task::ready(Err(anyhow!("Path not found: {}", input.path)));
+        };
+
+        if !entry.is_dir() {
+            return Task::ready(Err(anyhow!("{} is not a directory.", input.path)));
+        }
+        let worktree_snapshot = worktree.read(cx).snapshot();
+
+        let mut folders = Vec::new();
+        let mut files = Vec::new();
+
+        for entry in worktree_snapshot.child_entries(&project_path.path) {
+            // Skip private and excluded files and directories
+            if global_settings.is_path_private(&entry.path)
+                || global_settings.is_path_excluded(&entry.path)
+            {
+                continue;
+            }
+
+            if self
+                .project
+                .read(cx)
+                .find_project_path(&entry.path, cx)
+                .map(|project_path| {
+                    let worktree_settings = WorktreeSettings::get(Some((&project_path).into()), cx);
+
+                    worktree_settings.is_path_excluded(&project_path.path)
+                        || worktree_settings.is_path_private(&project_path.path)
+                })
+                .unwrap_or(false)
+            {
+                continue;
+            }
+
+            let full_path = Path::new(&worktree_root_name)
+                .join(&entry.path)
+                .display()
+                .to_string();
+            if entry.is_dir() {
+                folders.push(full_path);
+            } else {
+                files.push(full_path);
+            }
+        }
+
+        let mut output = String::new();
+
+        if !folders.is_empty() {
+            writeln!(output, "# Folders:\n{}", folders.join("\n")).unwrap();
+        }
+
+        if !files.is_empty() {
+            writeln!(output, "\n# Files:\n{}", files.join("\n")).unwrap();
+        }
+
+        if output.is_empty() {
+            writeln!(output, "{} is empty.", input.path).unwrap();
+        }
+
+        Task::ready(Ok(output))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::{TestAppContext, UpdateGlobal};
+    use indoc::indoc;
+    use project::{FakeFs, Project, WorktreeSettings};
+    use serde_json::json;
+    use settings::SettingsStore;
+    use util::path;
+
+    fn platform_paths(path_str: &str) -> String {
+        if cfg!(target_os = "windows") {
+            path_str.replace("/", "\\")
+        } else {
+            path_str.to_string()
+        }
+    }
+
+    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]
+    async fn test_list_directory_separates_files_and_dirs(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/project"),
+            json!({
+                "src": {
+                    "main.rs": "fn main() {}",
+                    "lib.rs": "pub fn hello() {}",
+                    "models": {
+                        "user.rs": "struct User {}",
+                        "post.rs": "struct Post {}"
+                    },
+                    "utils": {
+                        "helper.rs": "pub fn help() {}"
+                    }
+                },
+                "tests": {
+                    "integration_test.rs": "#[test] fn test() {}"
+                },
+                "README.md": "# Project",
+                "Cargo.toml": "[package]"
+            }),
+        )
+        .await;
+
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let tool = Arc::new(ListDirectoryTool::new(project));
+
+        // Test listing root directory
+        let input = ListDirectoryToolInput {
+            path: "project".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert_eq!(
+            output,
+            platform_paths(indoc! {"
+                # Folders:
+                project/src
+                project/tests
+
+                # Files:
+                project/Cargo.toml
+                project/README.md
+            "})
+        );
+
+        // Test listing src directory
+        let input = ListDirectoryToolInput {
+            path: "project/src".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert_eq!(
+            output,
+            platform_paths(indoc! {"
+                # Folders:
+                project/src/models
+                project/src/utils
+
+                # Files:
+                project/src/lib.rs
+                project/src/main.rs
+            "})
+        );
+
+        // Test listing directory with only files
+        let input = ListDirectoryToolInput {
+            path: "project/tests".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert!(!output.contains("# Folders:"));
+        assert!(output.contains("# Files:"));
+        assert!(output.contains(&platform_paths("project/tests/integration_test.rs")));
+    }
+
+    #[gpui::test]
+    async fn test_list_directory_empty_directory(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/project"),
+            json!({
+                "empty_dir": {}
+            }),
+        )
+        .await;
+
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let tool = Arc::new(ListDirectoryTool::new(project));
+
+        let input = ListDirectoryToolInput {
+            path: "project/empty_dir".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert_eq!(output, "project/empty_dir is empty.\n");
+    }
+
+    #[gpui::test]
+    async fn test_list_directory_error_cases(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/project"),
+            json!({
+                "file.txt": "content"
+            }),
+        )
+        .await;
+
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let tool = Arc::new(ListDirectoryTool::new(project));
+
+        // Test non-existent path
+        let input = ListDirectoryToolInput {
+            path: "project/nonexistent".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await;
+        assert!(output.unwrap_err().to_string().contains("Path not found"));
+
+        // Test trying to list a file instead of directory
+        let input = ListDirectoryToolInput {
+            path: "project/file.txt".into(),
+        };
+        let output = cx
+            .update(|cx| tool.run(input, ToolCallEventStream::test().0, cx))
+            .await;
+        assert!(
+            output
+                .unwrap_err()
+                .to_string()
+                .contains("is not a directory")
+        );
+    }
+
+    #[gpui::test]
+    async fn test_list_directory_security(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/project"),
+            json!({
+                "normal_dir": {
+                    "file1.txt": "content",
+                    "file2.txt": "content"
+                },
+                ".mysecrets": "SECRET_KEY=abc123",
+                ".secretdir": {
+                    "config": "special configuration",
+                    "secret.txt": "secret content"
+                },
+                ".mymetadata": "custom metadata",
+                "visible_dir": {
+                    "normal.txt": "normal content",
+                    "special.privatekey": "private key content",
+                    "data.mysensitive": "sensitive data",
+                    ".hidden_subdir": {
+                        "hidden_file.txt": "hidden content"
+                    }
+                }
+            }),
+        )
+        .await;
+
+        // Configure settings explicitly
+        cx.update(|cx| {
+            SettingsStore::update_global(cx, |store, cx| {
+                store.update_user_settings::<WorktreeSettings>(cx, |settings| {
+                    settings.file_scan_exclusions = Some(vec![
+                        "**/.secretdir".to_string(),
+                        "**/.mymetadata".to_string(),
+                        "**/.hidden_subdir".to_string(),
+                    ]);
+                    settings.private_files = Some(vec![
+                        "**/.mysecrets".to_string(),
+                        "**/*.privatekey".to_string(),
+                        "**/*.mysensitive".to_string(),
+                    ]);
+                });
+            });
+        });
+
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let tool = Arc::new(ListDirectoryTool::new(project));
+
+        // Listing root directory should exclude private and excluded files
+        let input = ListDirectoryToolInput {
+            path: "project".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+
+        // Should include normal directories
+        assert!(output.contains("normal_dir"), "Should list normal_dir");
+        assert!(output.contains("visible_dir"), "Should list visible_dir");
+
+        // Should NOT include excluded or private files
+        assert!(
+            !output.contains(".secretdir"),
+            "Should not list .secretdir (file_scan_exclusions)"
+        );
+        assert!(
+            !output.contains(".mymetadata"),
+            "Should not list .mymetadata (file_scan_exclusions)"
+        );
+        assert!(
+            !output.contains(".mysecrets"),
+            "Should not list .mysecrets (private_files)"
+        );
+
+        // Trying to list an excluded directory should fail
+        let input = ListDirectoryToolInput {
+            path: "project/.secretdir".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await;
+        assert!(
+            output
+                .unwrap_err()
+                .to_string()
+                .contains("file_scan_exclusions"),
+            "Error should mention file_scan_exclusions"
+        );
+
+        // Listing a directory should exclude private files within it
+        let input = ListDirectoryToolInput {
+            path: "project/visible_dir".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+
+        // Should include normal files
+        assert!(output.contains("normal.txt"), "Should list normal.txt");
+
+        // Should NOT include private files
+        assert!(
+            !output.contains("privatekey"),
+            "Should not list .privatekey files (private_files)"
+        );
+        assert!(
+            !output.contains("mysensitive"),
+            "Should not list .mysensitive files (private_files)"
+        );
+
+        // Should NOT include subdirectories that match exclusions
+        assert!(
+            !output.contains(".hidden_subdir"),
+            "Should not list .hidden_subdir (file_scan_exclusions)"
+        );
+    }
+
+    #[gpui::test]
+    async fn test_list_directory_with_multiple_worktree_settings(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+
+        // Create first worktree with its own private files
+        fs.insert_tree(
+            path!("/worktree1"),
+            json!({
+                ".zed": {
+                    "settings.json": r#"{
+                        "file_scan_exclusions": ["**/fixture.*"],
+                        "private_files": ["**/secret.rs", "**/config.toml"]
+                    }"#
+                },
+                "src": {
+                    "main.rs": "fn main() { println!(\"Hello from worktree1\"); }",
+                    "secret.rs": "const API_KEY: &str = \"secret_key_1\";",
+                    "config.toml": "[database]\nurl = \"postgres://localhost/db1\""
+                },
+                "tests": {
+                    "test.rs": "mod tests { fn test_it() {} }",
+                    "fixture.sql": "CREATE TABLE users (id INT, name VARCHAR(255));"
+                }
+            }),
+        )
+        .await;
+
+        // Create second worktree with different private files
+        fs.insert_tree(
+            path!("/worktree2"),
+            json!({
+                ".zed": {
+                    "settings.json": r#"{
+                        "file_scan_exclusions": ["**/internal.*"],
+                        "private_files": ["**/private.js", "**/data.json"]
+                    }"#
+                },
+                "lib": {
+                    "public.js": "export function greet() { return 'Hello from worktree2'; }",
+                    "private.js": "const SECRET_TOKEN = \"private_token_2\";",
+                    "data.json": "{\"api_key\": \"json_secret_key\"}"
+                },
+                "docs": {
+                    "README.md": "# Public Documentation",
+                    "internal.md": "# Internal Secrets and Configuration"
+                }
+            }),
+        )
+        .await;
+
+        // Set global settings
+        cx.update(|cx| {
+            SettingsStore::update_global(cx, |store, cx| {
+                store.update_user_settings::<WorktreeSettings>(cx, |settings| {
+                    settings.file_scan_exclusions =
+                        Some(vec!["**/.git".to_string(), "**/node_modules".to_string()]);
+                    settings.private_files = Some(vec!["**/.env".to_string()]);
+                });
+            });
+        });
+
+        let project = Project::test(
+            fs.clone(),
+            [path!("/worktree1").as_ref(), path!("/worktree2").as_ref()],
+            cx,
+        )
+        .await;
+
+        // Wait for worktrees to be fully scanned
+        cx.executor().run_until_parked();
+
+        let tool = Arc::new(ListDirectoryTool::new(project));
+
+        // Test listing worktree1/src - should exclude secret.rs and config.toml based on local settings
+        let input = ListDirectoryToolInput {
+            path: "worktree1/src".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert!(output.contains("main.rs"), "Should list main.rs");
+        assert!(
+            !output.contains("secret.rs"),
+            "Should not list secret.rs (local private_files)"
+        );
+        assert!(
+            !output.contains("config.toml"),
+            "Should not list config.toml (local private_files)"
+        );
+
+        // Test listing worktree1/tests - should exclude fixture.sql based on local settings
+        let input = ListDirectoryToolInput {
+            path: "worktree1/tests".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert!(output.contains("test.rs"), "Should list test.rs");
+        assert!(
+            !output.contains("fixture.sql"),
+            "Should not list fixture.sql (local file_scan_exclusions)"
+        );
+
+        // Test listing worktree2/lib - should exclude private.js and data.json based on local settings
+        let input = ListDirectoryToolInput {
+            path: "worktree2/lib".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert!(output.contains("public.js"), "Should list public.js");
+        assert!(
+            !output.contains("private.js"),
+            "Should not list private.js (local private_files)"
+        );
+        assert!(
+            !output.contains("data.json"),
+            "Should not list data.json (local private_files)"
+        );
+
+        // Test listing worktree2/docs - should exclude internal.md based on local settings
+        let input = ListDirectoryToolInput {
+            path: "worktree2/docs".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await
+            .unwrap();
+        assert!(output.contains("README.md"), "Should list README.md");
+        assert!(
+            !output.contains("internal.md"),
+            "Should not list internal.md (local file_scan_exclusions)"
+        );
+
+        // Test trying to list an excluded directory directly
+        let input = ListDirectoryToolInput {
+            path: "worktree1/src/secret.rs".into(),
+        };
+        let output = cx
+            .update(|cx| tool.clone().run(input, ToolCallEventStream::test().0, cx))
+            .await;
+        assert!(
+            output
+                .unwrap_err()
+                .to_string()
+                .contains("Cannot list directory"),
+        );
+    }
+}

crates/agent2/src/tools/move_path_tool.rs

@@ -0,0 +1,120 @@
+use crate::{AgentTool, ToolCallEventStream};
+use agent_client_protocol::ToolKind;
+use anyhow::{Context as _, Result, anyhow};
+use gpui::{App, AppContext, Entity, SharedString, Task};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{path::Path, sync::Arc};
+use util::markdown::MarkdownInlineCode;
+
+/// Moves or rename a file or directory in the project, and returns confirmation that the move succeeded.
+///
+/// If the source and destination directories are the same, but the filename is different, this performs a rename. Otherwise, it performs a move.
+///
+/// This tool should be used when it's desirable to move or rename a file or directory without changing its contents at all.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct MovePathToolInput {
+    /// The source path of the file or directory to move/rename.
+    ///
+    /// <example>
+    /// If the project has the following files:
+    ///
+    /// - directory1/a/something.txt
+    /// - directory2/a/things.txt
+    /// - directory3/a/other.txt
+    ///
+    /// You can move the first file by providing a source_path of "directory1/a/something.txt"
+    /// </example>
+    pub source_path: String,
+
+    /// The destination path where the file or directory should be moved/renamed to.
+    /// If the paths are the same except for the filename, then this will be a rename.
+    ///
+    /// <example>
+    /// To move "directory1/a/something.txt" to "directory2/b/renamed.txt",
+    /// provide a destination_path of "directory2/b/renamed.txt"
+    /// </example>
+    pub destination_path: String,
+}
+
+pub struct MovePathTool {
+    project: Entity<Project>,
+}
+
+impl MovePathTool {
+    pub fn new(project: Entity<Project>) -> Self {
+        Self { project }
+    }
+}
+
+impl AgentTool for MovePathTool {
+    type Input = MovePathToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "move_path".into()
+    }
+
+    fn kind(&self) -> ToolKind {
+        ToolKind::Move
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            let src = MarkdownInlineCode(&input.source_path);
+            let dest = MarkdownInlineCode(&input.destination_path);
+            let src_path = Path::new(&input.source_path);
+            let dest_path = Path::new(&input.destination_path);
+
+            match dest_path
+                .file_name()
+                .and_then(|os_str| os_str.to_os_string().into_string().ok())
+            {
+                Some(filename) if src_path.parent() == dest_path.parent() => {
+                    let filename = MarkdownInlineCode(&filename);
+                    format!("Rename {src} to {filename}").into()
+                }
+                _ => format!("Move {src} to {dest}").into(),
+            }
+        } else {
+            "Move path".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        let rename_task = self.project.update(cx, |project, cx| {
+            match project
+                .find_project_path(&input.source_path, cx)
+                .and_then(|project_path| project.entry_for_path(&project_path, cx))
+            {
+                Some(entity) => match project.find_project_path(&input.destination_path, cx) {
+                    Some(project_path) => project.rename_entry(entity.id, project_path.path, cx),
+                    None => Task::ready(Err(anyhow!(
+                        "Destination path {} was outside the project.",
+                        input.destination_path
+                    ))),
+                },
+                None => Task::ready(Err(anyhow!(
+                    "Source path {} was not found in the project.",
+                    input.source_path
+                ))),
+            }
+        });
+
+        cx.background_spawn(async move {
+            let _ = rename_task.await.with_context(|| {
+                format!("Moving {} to {}", input.source_path, input.destination_path)
+            })?;
+            Ok(format!(
+                "Moved {} to {}",
+                input.source_path, input.destination_path
+            ))
+        })
+    }
+}

crates/agent2/src/tools/now_tool.rs

@@ -0,0 +1,59 @@
+use std::sync::Arc;
+
+use agent_client_protocol as acp;
+use anyhow::Result;
+use chrono::{Local, Utc};
+use gpui::{App, SharedString, Task};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::{AgentTool, ToolCallEventStream};
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum Timezone {
+    /// Use UTC for the datetime.
+    Utc,
+    /// Use local time for the datetime.
+    Local,
+}
+
+/// Returns the current datetime in RFC 3339 format.
+/// Only use this tool when the user specifically asks for it or the current task would benefit from knowing the current datetime.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct NowToolInput {
+    /// The timezone to use for the datetime.
+    timezone: Timezone,
+}
+
+pub struct NowTool;
+
+impl AgentTool for NowTool {
+    type Input = NowToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "now".into()
+    }
+
+    fn kind(&self) -> acp::ToolKind {
+        acp::ToolKind::Other
+    }
+
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        "Get current time".into()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        _event_stream: ToolCallEventStream,
+        _cx: &mut App,
+    ) -> Task<Result<String>> {
+        let now = match input.timezone {
+            Timezone::Utc => Utc::now().to_rfc3339(),
+            Timezone::Local => Local::now().to_rfc3339(),
+        };
+        Task::ready(Ok(format!("The current datetime is {now}.")))
+    }
+}

crates/agent2/src/tools/open_tool.rs

@@ -0,0 +1,166 @@
+use crate::AgentTool;
+use agent_client_protocol::ToolKind;
+use anyhow::{Context as _, Result};
+use gpui::{App, AppContext, Entity, SharedString, Task};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{path::PathBuf, sync::Arc};
+use util::markdown::MarkdownEscaped;
+
+/// This tool opens a file or URL with the default application associated with it on the user's operating system:
+///
+/// - On macOS, it's equivalent to the `open` command
+/// - On Windows, it's equivalent to `start`
+/// - On Linux, it uses something like `xdg-open`, `gio open`, `gnome-open`, `kde-open`, `wslview` as appropriate
+///
+/// For example, it can open a web browser with a URL, open a PDF file with the default PDF viewer, etc.
+///
+/// You MUST ONLY use this tool when the user has explicitly requested opening something. You MUST NEVER assume that the user would like for you to use this tool.
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct OpenToolInput {
+    /// The path or URL to open with the default application.
+    path_or_url: String,
+}
+
+pub struct OpenTool {
+    project: Entity<Project>,
+}
+
+impl OpenTool {
+    pub fn new(project: Entity<Project>) -> Self {
+        Self { project }
+    }
+}
+
+impl AgentTool for OpenTool {
+    type Input = OpenToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "open".into()
+    }
+
+    fn kind(&self) -> ToolKind {
+        ToolKind::Execute
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            format!("Open `{}`", MarkdownEscaped(&input.path_or_url)).into()
+        } else {
+            "Open file or URL".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        event_stream: crate::ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        // If path_or_url turns out to be a path in the project, make it absolute.
+        let abs_path = to_absolute_path(&input.path_or_url, self.project.clone(), cx);
+        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone())), cx);
+        cx.background_spawn(async move {
+            authorize.await?;
+
+            match abs_path {
+                Some(path) => open::that(path),
+                None => open::that(&input.path_or_url),
+            }
+            .context("Failed to open URL or file path")?;
+
+            Ok(format!("Successfully opened {}", input.path_or_url))
+        })
+    }
+}
+
+fn to_absolute_path(
+    potential_path: &str,
+    project: Entity<Project>,
+    cx: &mut App,
+) -> Option<PathBuf> {
+    let project = project.read(cx);
+    project
+        .find_project_path(PathBuf::from(potential_path), cx)
+        .and_then(|project_path| project.absolute_path(&project_path, cx))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::TestAppContext;
+    use project::{FakeFs, Project};
+    use settings::SettingsStore;
+    use std::path::Path;
+    use tempfile::TempDir;
+
+    #[gpui::test]
+    async fn test_to_absolute_path(cx: &mut TestAppContext) {
+        init_test(cx);
+        let temp_dir = TempDir::new().expect("Failed to create temp directory");
+        let temp_path = temp_dir.path().to_string_lossy().to_string();
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            &temp_path,
+            serde_json::json!({
+                "src": {
+                    "main.rs": "fn main() {}",
+                    "lib.rs": "pub fn lib_fn() {}"
+                },
+                "docs": {
+                    "readme.md": "# Project Documentation"
+                }
+            }),
+        )
+        .await;
+
+        // Use the temp_path as the root directory, not just its filename
+        let project = Project::test(fs.clone(), [temp_dir.path()], cx).await;
+
+        // Test cases where the function should return Some
+        cx.update(|cx| {
+            // Project-relative paths should return Some
+            // Create paths using the last segment of the temp path to simulate a project-relative path
+            let root_dir_name = Path::new(&temp_path)
+                .file_name()
+                .unwrap_or_else(|| std::ffi::OsStr::new("temp"))
+                .to_string_lossy();
+
+            assert!(
+                to_absolute_path(&format!("{root_dir_name}/src/main.rs"), project.clone(), cx)
+                    .is_some(),
+                "Failed to resolve main.rs path"
+            );
+
+            assert!(
+                to_absolute_path(
+                    &format!("{root_dir_name}/docs/readme.md",),
+                    project.clone(),
+                    cx,
+                )
+                .is_some(),
+                "Failed to resolve readme.md path"
+            );
+
+            // External URL should return None
+            let result = to_absolute_path("https://example.com", project.clone(), cx);
+            assert_eq!(result, None, "External URLs should return None");
+
+            // Path outside project
+            let result = to_absolute_path("../invalid/path", project.clone(), cx);
+            assert_eq!(result, None, "Paths outside the project should return None");
+        });
+    }
+
+    fn init_test(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            language::init(cx);
+            Project::init_settings(cx);
+        });
+    }
+}

crates/agent2/src/tools/read_file_tool.rs

@@ -1,15 +1,16 @@
-use agent_client_protocol::{self as acp};
-use anyhow::{anyhow, Result};
-use assistant_tool::{outline, ActionLog};
-use gpui::{Entity, Task};
+use action_log::ActionLog;
+use agent_client_protocol::{self as acp, ToolCallUpdateFields};
+use anyhow::{Context as _, Result, anyhow};
+use assistant_tool::outline;
+use gpui::{App, Entity, SharedString, Task};
 use indoc::formatdoc;
-use language::{Anchor, Point};
-use project::{AgentLocation, Project, WorktreeSettings};
+use language::Point;
+use language_model::{LanguageModelImage, LanguageModelToolResultContent};
+use project::{AgentLocation, ImageItem, Project, WorktreeSettings, image_store};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
 use std::sync::Arc;
-use ui::{App, SharedString};
 
 use crate::{AgentTool, ToolCallEventStream};
 
@@ -20,8 +21,7 @@ use crate::{AgentTool, ToolCallEventStream};
 pub struct ReadFileToolInput {
     /// The relative path of the file to read.
     ///
-    /// This path should never be absolute, and the first component
-    /// of the path should always be a root directory in a project.
+    /// This path should never be absolute, and the first component of the path should always be a root directory in a project.
     ///
     /// <example>
     /// If the project has the following root directories:
@@ -33,11 +33,9 @@ pub struct ReadFileToolInput {
     /// If you want to access `file.txt` in `directory2`, you should use the path `directory2/file.txt`.
     /// </example>
     pub path: String,
-
     /// Optional line number to start reading on (1-based index)
     #[serde(default)]
     pub start_line: Option<u32>,
-
     /// Optional line number to end reading on (1-based index, inclusive)
     #[serde(default)]
     pub end_line: Option<u32>,
@@ -59,6 +57,7 @@ impl ReadFileTool {
 
 impl AgentTool for ReadFileTool {
     type Input = ReadFileToolInput;
+    type Output = LanguageModelToolResultContent;
 
     fn name(&self) -> SharedString {
         "read_file".into()
@@ -68,24 +67,28 @@ impl AgentTool for ReadFileTool {
         acp::ToolKind::Read
     }
 
-    fn initial_title(&self, input: Self::Input) -> SharedString {
-        let path = &input.path;
-        match (input.start_line, input.end_line) {
-            (Some(start), Some(end)) => {
-                format!(
-                    "[Read file `{}` (lines {}-{})](@selection:{}:({}-{}))",
-                    path, start, end, path, start, end
-                )
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            let path = &input.path;
+            match (input.start_line, input.end_line) {
+                (Some(start), Some(end)) => {
+                    format!(
+                        "[Read file `{}` (lines {}-{})](@selection:{}:({}-{}))",
+                        path, start, end, path, start, end
+                    )
+                }
+                (Some(start), None) => {
+                    format!(
+                        "[Read file `{}` (from line {})](@selection:{}:({}-{}))",
+                        path, start, path, start, start
+                    )
+                }
+                _ => format!("[Read file `{}`](@file:{})", path, path),
             }
-            (Some(start), None) => {
-                format!(
-                    "[Read file `{}` (from line {})](@selection:{}:({}-{}))",
-                    path, start, path, start, start
-                )
-            }
-            _ => format!("[Read file `{}`](@file:{})", path, path),
+            .into()
+        } else {
+            "Read file".into()
         }
-        .into()
     }
 
     fn run(
@@ -93,7 +96,7 @@ impl AgentTool for ReadFileTool {
         input: Self::Input,
         event_stream: ToolCallEventStream,
         cx: &mut App,
-    ) -> Task<Result<String>> {
+    ) -> Task<Result<LanguageModelToolResultContent>> {
         let Some(project_path) = self.project.read(cx).find_project_path(&input.path, cx) else {
             return Task::ready(Err(anyhow!("Path {} not found in project", &input.path)));
         };
@@ -132,51 +135,27 @@ impl AgentTool for ReadFileTool {
 
         let file_path = input.path.clone();
 
-        event_stream.send_update(acp::ToolCallUpdateFields {
-            locations: Some(vec![acp::ToolCallLocation {
-                path: project_path.path.to_path_buf(),
-                line: input.start_line,
-                // TODO (tracked): use full range
-            }]),
-            ..Default::default()
-        });
+        if image_store::is_image_file(&self.project, &project_path, cx) {
+            return cx.spawn(async move |cx| {
+                let image_entity: Entity<ImageItem> = cx
+                    .update(|cx| {
+                        self.project.update(cx, |project, cx| {
+                            project.open_image(project_path.clone(), cx)
+                        })
+                    })?
+                    .await?;
 
-        // TODO (tracked): images
-        // if image_store::is_image_file(&self.project, &project_path, cx) {
-        //     let model = &self.thread.read(cx).selected_model;
+                let image =
+                    image_entity.read_with(cx, |image_item, _| Arc::clone(&image_item.image))?;
 
-        //     if !model.supports_images() {
-        //         return Task::ready(Err(anyhow!(
-        //             "Attempted to read an image, but Zed doesn't currently support sending images to {}.",
-        //             model.name().0
-        //         )))
-        //         .into();
-        //     }
+                let language_model_image = cx
+                    .update(|cx| LanguageModelImage::from_image(image, cx))?
+                    .await
+                    .context("processing image")?;
 
-        //     return cx.spawn(async move |cx| -> Result<ToolResultOutput> {
-        //         let image_entity: Entity<ImageItem> = cx
-        //             .update(|cx| {
-        //                 self.project.update(cx, |project, cx| {
-        //                     project.open_image(project_path.clone(), cx)
-        //                 })
-        //             })?
-        //             .await?;
-
-        //         let image =
-        //             image_entity.read_with(cx, |image_item, _| Arc::clone(&image_item.image))?;
-
-        //         let language_model_image = cx
-        //             .update(|cx| LanguageModelImage::from_image(image, cx))?
-        //             .await
-        //             .context("processing image")?;
-
-        //         Ok(ToolResultOutput {
-        //             content: ToolResultContent::Image(language_model_image),
-        //             output: None,
-        //         })
-        //     });
-        // }
-        //
+                Ok(language_model_image.into())
+            });
+        }
 
         let project = self.project.clone();
         let action_log = self.action_log.clone();
@@ -184,31 +163,24 @@ impl AgentTool for ReadFileTool {
         cx.spawn(async move |cx| {
             let buffer = cx
                 .update(|cx| {
-                    project.update(cx, |project, cx| project.open_buffer(project_path, cx))
+                    project.update(cx, |project, cx| {
+                        project.open_buffer(project_path.clone(), cx)
+                    })
                 })?
                 .await?;
             if buffer.read_with(cx, |buffer, _| {
                 buffer
                     .file()
                     .as_ref()
-                    .map_or(true, |file| !file.disk_state().exists())
+                    .is_none_or(|file| !file.disk_state().exists())
             })? {
                 anyhow::bail!("{file_path} not found");
             }
 
-            project.update(cx, |project, cx| {
-                project.set_agent_location(
-                    Some(AgentLocation {
-                        buffer: buffer.downgrade(),
-                        position: Anchor::MIN,
-                    }),
-                    cx,
-                );
-            })?;
+            let mut anchor = None;
 
             // Check if specific line ranges are provided
-            if input.start_line.is_some() || input.end_line.is_some() {
-                let mut anchor = None;
+            let result = if input.start_line.is_some() || input.end_line.is_some() {
                 let result = buffer.read_with(cx, |buffer, _cx| {
                     let text = buffer.text();
                     // .max(1) because despite instructions to be 1-indexed, sometimes the model passes 0.
@@ -232,19 +204,7 @@ impl AgentTool for ReadFileTool {
                     log.buffer_read(buffer.clone(), cx);
                 })?;
 
-                if let Some(anchor) = anchor {
-                    project.update(cx, |project, cx| {
-                        project.set_agent_location(
-                            Some(AgentLocation {
-                                buffer: buffer.downgrade(),
-                                position: anchor,
-                            }),
-                            cx,
-                        );
-                    })?;
-                }
-
-                Ok(result)
+                Ok(result.into())
             } 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())?;
@@ -254,15 +214,16 @@ impl AgentTool for ReadFileTool {
                     let result = buffer.read_with(cx, |buffer, _cx| buffer.text())?;
 
                     action_log.update(cx, |log, cx| {
-                        log.buffer_read(buffer, cx);
+                        log.buffer_read(buffer.clone(), cx);
                     })?;
 
-                    Ok(result)
+                    Ok(result.into())
                 } else {
                     // File is too big, so return the outline
                     // and a suggestion to read again with line numbers.
                     let outline =
-                        outline::file_outline(project, file_path, action_log, None, cx).await?;
+                        outline::file_outline(project.clone(), file_path, action_log, None, cx)
+                            .await?;
                     Ok(formatdoc! {"
                         This file was too big to read all at once.
 
@@ -276,20 +237,40 @@ impl AgentTool for ReadFileTool {
 
                         Alternatively, you can fall back to the `grep` tool (if available)
                         to search the file for specific content."
-                    })
+                    }
+                    .into())
                 }
-            }
+            };
+
+            project.update(cx, |project, cx| {
+                if let Some(abs_path) = project.absolute_path(&project_path, cx) {
+                    project.set_agent_location(
+                        Some(AgentLocation {
+                            buffer: buffer.downgrade(),
+                            position: anchor.unwrap_or(text::Anchor::MIN),
+                        }),
+                        cx,
+                    );
+                    event_stream.update_fields(ToolCallUpdateFields {
+                        locations: Some(vec![acp::ToolCallLocation {
+                            path: abs_path,
+                            line: input.start_line.map(|line| line.saturating_sub(1)),
+                        }]),
+                        ..Default::default()
+                    });
+                }
+            })?;
+
+            result
         })
     }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::TestToolCallEventStream;
-
     use super::*;
     use gpui::{AppContext, TestAppContext, UpdateGlobal as _};
-    use language::{tree_sitter_rust, Language, LanguageConfig, LanguageMatcher};
+    use language::{Language, LanguageConfig, LanguageMatcher, tree_sitter_rust};
     use project::{FakeFs, Project};
     use serde_json::json;
     use settings::SettingsStore;
@@ -304,7 +285,7 @@ mod test {
         let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
         let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let tool = Arc::new(ReadFileTool::new(project, action_log));
-        let event_stream = TestToolCallEventStream::new();
+        let (event_stream, _) = ToolCallEventStream::test();
 
         let result = cx
             .update(|cx| {
@@ -313,7 +294,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.run(input, event_stream.stream(), cx)
+                tool.run(input, event_stream, cx)
             })
             .await;
         assert_eq!(
@@ -321,6 +302,7 @@ mod test {
             "root/nonexistent_file.txt not found"
         );
     }
+
     #[gpui::test]
     async fn test_read_small_file(cx: &mut TestAppContext) {
         init_test(cx);
@@ -336,7 +318,6 @@ mod test {
         let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
         let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let tool = Arc::new(ReadFileTool::new(project, action_log));
-        let event_stream = TestToolCallEventStream::new();
         let result = cx
             .update(|cx| {
                 let input = ReadFileToolInput {
@@ -344,10 +325,10 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.run(input, event_stream.stream(), cx)
+                tool.run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
-        assert_eq!(result.unwrap(), "This is a small file content");
+        assert_eq!(result.unwrap(), "This is a small file content".into());
     }
 
     #[gpui::test]
@@ -367,18 +348,18 @@ mod test {
         language_registry.add(Arc::new(rust_lang()));
         let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let tool = Arc::new(ReadFileTool::new(project, action_log));
-        let event_stream = TestToolCallEventStream::new();
-        let content = cx
+        let result = cx
             .update(|cx| {
                 let input = ReadFileToolInput {
                     path: "root/large_file.rs".into(),
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await
             .unwrap();
+        let content = result.to_str().unwrap();
 
         assert_eq!(
             content.lines().skip(4).take(6).collect::<Vec<_>>(),
@@ -399,10 +380,11 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.run(input, event_stream.stream(), cx)
+                tool.run(input, ToolCallEventStream::test().0, cx)
             })
-            .await;
-        let content = result.unwrap();
+            .await
+            .unwrap();
+        let content = result.to_str().unwrap();
         let expected_content = (0..1000)
             .flat_map(|i| {
                 vec![
@@ -438,7 +420,6 @@ mod test {
 
         let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let tool = Arc::new(ReadFileTool::new(project, action_log));
-        let event_stream = TestToolCallEventStream::new();
         let result = cx
             .update(|cx| {
                 let input = ReadFileToolInput {
@@ -446,10 +427,10 @@ mod test {
                     start_line: Some(2),
                     end_line: Some(4),
                 };
-                tool.run(input, event_stream.stream(), cx)
+                tool.run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
-        assert_eq!(result.unwrap(), "Line 2\nLine 3\nLine 4");
+        assert_eq!(result.unwrap(), "Line 2\nLine 3\nLine 4".into());
     }
 
     #[gpui::test]
@@ -467,7 +448,6 @@ mod test {
         let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
         let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let tool = Arc::new(ReadFileTool::new(project, action_log));
-        let event_stream = TestToolCallEventStream::new();
 
         // start_line of 0 should be treated as 1
         let result = cx
@@ -477,10 +457,10 @@ mod test {
                     start_line: Some(0),
                     end_line: Some(2),
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
-        assert_eq!(result.unwrap(), "Line 1\nLine 2");
+        assert_eq!(result.unwrap(), "Line 1\nLine 2".into());
 
         // end_line of 0 should result in at least 1 line
         let result = cx
@@ -490,10 +470,10 @@ mod test {
                     start_line: Some(1),
                     end_line: Some(0),
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
-        assert_eq!(result.unwrap(), "Line 1");
+        assert_eq!(result.unwrap(), "Line 1".into());
 
         // when start_line > end_line, should still return at least 1 line
         let result = cx
@@ -503,10 +483,10 @@ mod test {
                     start_line: Some(3),
                     end_line: Some(2),
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
-        assert_eq!(result.unwrap(), "Line 3");
+        assert_eq!(result.unwrap(), "Line 3".into());
     }
 
     fn init_test(cx: &mut TestAppContext) {
@@ -612,7 +592,6 @@ mod test {
         let project = Project::test(fs.clone(), [path!("/project_root").as_ref()], cx).await;
         let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let tool = Arc::new(ReadFileTool::new(project, action_log));
-        let event_stream = TestToolCallEventStream::new();
 
         // Reading a file outside the project worktree should fail
         let result = cx
@@ -622,7 +601,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -638,7 +617,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -654,7 +633,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -669,7 +648,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -685,7 +664,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -700,7 +679,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -715,7 +694,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -731,11 +710,11 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(result.is_ok(), "Should be able to read normal files");
-        assert_eq!(result.unwrap(), "Normal file content");
+        assert_eq!(result.unwrap(), "Normal file content".into());
 
         // Path traversal attempts with .. should fail
         let result = cx
@@ -745,7 +724,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.run(input, event_stream.stream(), cx)
+                tool.run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert!(
@@ -826,7 +805,6 @@ mod test {
 
         let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let tool = Arc::new(ReadFileTool::new(project.clone(), action_log.clone()));
-        let event_stream = TestToolCallEventStream::new();
 
         // Test reading allowed files in worktree1
         let result = cx
@@ -836,12 +814,15 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await
             .unwrap();
 
-        assert_eq!(result, "fn main() { println!(\"Hello from worktree1\"); }");
+        assert_eq!(
+            result,
+            "fn main() { println!(\"Hello from worktree1\"); }".into()
+        );
 
         // Test reading private file in worktree1 should fail
         let result = cx
@@ -851,7 +832,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
 
@@ -872,7 +853,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
 
@@ -893,14 +874,14 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await
             .unwrap();
 
         assert_eq!(
             result,
-            "export function greet() { return 'Hello from worktree2'; }"
+            "export function greet() { return 'Hello from worktree2'; }".into()
         );
 
         // Test reading private file in worktree2 should fail
@@ -911,7 +892,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
 
@@ -932,7 +913,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
 
@@ -954,7 +935,7 @@ mod test {
                     start_line: None,
                     end_line: None,
                 };
-                tool.clone().run(input, event_stream.stream(), cx)
+                tool.clone().run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
 

crates/agent2/src/tools/terminal_tool.rs

@@ -0,0 +1,468 @@
+use agent_client_protocol as acp;
+use anyhow::Result;
+use futures::{FutureExt as _, future::Shared};
+use gpui::{App, AppContext, Entity, SharedString, Task};
+use project::{Project, terminals::TerminalKind};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use util::{ResultExt, get_system_shell, markdown::MarkdownInlineCode};
+
+use crate::{AgentTool, ToolCallEventStream};
+
+const COMMAND_OUTPUT_LIMIT: usize = 16 * 1024;
+
+/// Executes a shell one-liner and returns the combined output.
+///
+/// This tool spawns a process using the user's shell, reads from stdout and stderr (preserving the order of writes), and returns a string with the combined output result.
+///
+/// The output results will be shown to the user already, only list it again if necessary, avoid being redundant.
+///
+/// Make sure you use the `cd` parameter to navigate to one of the root directories of the project. NEVER do it as part of the `command` itself, otherwise it will error.
+///
+/// Do not use this tool for commands that run indefinitely, such as servers (like `npm run start`, `npm run dev`, `python -m http.server`, etc) or file watchers that don't terminate on their own.
+///
+/// Remember that each invocation of this tool will spawn a new shell process, so you can't rely on any state from previous invocations.
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct TerminalToolInput {
+    /// The one-liner command to execute.
+    command: String,
+    /// Working directory for the command. This must be one of the root directories of the project.
+    cd: String,
+}
+
+pub struct TerminalTool {
+    project: Entity<Project>,
+    determine_shell: Shared<Task<String>>,
+}
+
+impl TerminalTool {
+    pub fn new(project: Entity<Project>, cx: &mut App) -> Self {
+        let determine_shell = cx.background_spawn(async move {
+            if cfg!(windows) {
+                return get_system_shell();
+            }
+
+            if which::which("bash").is_ok() {
+                "bash".into()
+            } else {
+                get_system_shell()
+            }
+        });
+        Self {
+            project,
+            determine_shell: determine_shell.shared(),
+        }
+    }
+}
+
+impl AgentTool for TerminalTool {
+    type Input = TerminalToolInput;
+    type Output = String;
+
+    fn name(&self) -> SharedString {
+        "terminal".into()
+    }
+
+    fn kind(&self) -> acp::ToolKind {
+        acp::ToolKind::Execute
+    }
+
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        if let Ok(input) = input {
+            let mut lines = input.command.lines();
+            let first_line = lines.next().unwrap_or_default();
+            let remaining_line_count = lines.count();
+            match remaining_line_count {
+                0 => MarkdownInlineCode(first_line).to_string().into(),
+                1 => MarkdownInlineCode(&format!(
+                    "{} - {} more line",
+                    first_line, remaining_line_count
+                ))
+                .to_string()
+                .into(),
+                n => MarkdownInlineCode(&format!("{} - {} more lines", first_line, n))
+                    .to_string()
+                    .into(),
+            }
+        } else {
+            "Run terminal command".into()
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        let language_registry = self.project.read(cx).languages().clone();
+        let working_dir = match working_dir(&input, &self.project, cx) {
+            Ok(dir) => dir,
+            Err(err) => return Task::ready(Err(err)),
+        };
+        let program = self.determine_shell.clone();
+        let command = if cfg!(windows) {
+            format!("$null | & {{{}}}", input.command.replace("\"", "'"))
+        } else if let Some(cwd) = working_dir
+            .as_ref()
+            .and_then(|cwd| cwd.as_os_str().to_str())
+        {
+            // Make sure once we're *inside* the shell, we cd into `cwd`
+            format!("(cd {cwd}; {}) </dev/null", input.command)
+        } else {
+            format!("({}) </dev/null", input.command)
+        };
+        let args = vec!["-c".into(), command];
+
+        let env = match &working_dir {
+            Some(dir) => self.project.update(cx, |project, cx| {
+                project.directory_environment(dir.as_path().into(), cx)
+            }),
+            None => Task::ready(None).shared(),
+        };
+
+        let env = cx.spawn(async move |_| {
+            let mut env = env.await.unwrap_or_default();
+            if cfg!(unix) {
+                env.insert("PAGER".into(), "cat".into());
+            }
+            env
+        });
+
+        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone())), cx);
+
+        cx.spawn({
+            async move |cx| {
+                authorize.await?;
+
+                let program = program.await;
+                let env = env.await;
+                let terminal = self
+                    .project
+                    .update(cx, |project, cx| {
+                        project.create_terminal(
+                            TerminalKind::Task(task::SpawnInTerminal {
+                                command: Some(program),
+                                args,
+                                cwd: working_dir.clone(),
+                                env,
+                                ..Default::default()
+                            }),
+                            cx,
+                        )
+                    })?
+                    .await?;
+                let acp_terminal = cx.new(|cx| {
+                    acp_thread::Terminal::new(
+                        input.command.clone(),
+                        working_dir.clone(),
+                        terminal.clone(),
+                        language_registry,
+                        cx,
+                    )
+                })?;
+                event_stream.update_terminal(acp_terminal.clone());
+
+                let exit_status = terminal
+                    .update(cx, |terminal, cx| terminal.wait_for_completed_task(cx))?
+                    .await;
+                let (content, content_line_count) = terminal.read_with(cx, |terminal, _| {
+                    (terminal.get_content(), terminal.total_lines())
+                })?;
+
+                let (processed_content, finished_with_empty_output) = process_content(
+                    &content,
+                    &input.command,
+                    exit_status.map(portable_pty::ExitStatus::from),
+                );
+
+                acp_terminal
+                    .update(cx, |terminal, cx| {
+                        terminal.finish(
+                            exit_status,
+                            content.len(),
+                            processed_content.len(),
+                            content_line_count,
+                            finished_with_empty_output,
+                            cx,
+                        );
+                    })
+                    .log_err();
+
+                Ok(processed_content)
+            }
+        })
+    }
+}
+
+fn process_content(
+    content: &str,
+    command: &str,
+    exit_status: Option<portable_pty::ExitStatus>,
+) -> (String, bool) {
+    let should_truncate = content.len() > COMMAND_OUTPUT_LIMIT;
+
+    let content = if should_truncate {
+        let mut end_ix = COMMAND_OUTPUT_LIMIT.min(content.len());
+        while !content.is_char_boundary(end_ix) {
+            end_ix -= 1;
+        }
+        // Don't truncate mid-line, clear the remainder of the last line
+        end_ix = content[..end_ix].rfind('\n').unwrap_or(end_ix);
+        &content[..end_ix]
+    } else {
+        content
+    };
+    let content = content.trim();
+    let is_empty = content.is_empty();
+    let content = format!("```\n{content}\n```");
+    let content = if should_truncate {
+        format!(
+            "Command output too long. The first {} bytes:\n\n{content}",
+            content.len(),
+        )
+    } else {
+        content
+    };
+
+    let content = match exit_status {
+        Some(exit_status) if exit_status.success() => {
+            if is_empty {
+                "Command executed successfully.".to_string()
+            } else {
+                content
+            }
+        }
+        Some(exit_status) => {
+            if is_empty {
+                format!(
+                    "Command \"{command}\" failed with exit code {}.",
+                    exit_status.exit_code()
+                )
+            } else {
+                format!(
+                    "Command \"{command}\" failed with exit code {}.\n\n{content}",
+                    exit_status.exit_code()
+                )
+            }
+        }
+        None => {
+            format!(
+                "Command failed or was interrupted.\nPartial output captured:\n\n{}",
+                content,
+            )
+        }
+    };
+    (content, is_empty)
+}
+
+fn working_dir(
+    input: &TerminalToolInput,
+    project: &Entity<Project>,
+    cx: &mut App,
+) -> Result<Option<PathBuf>> {
+    let project = project.read(cx);
+    let cd = &input.cd;
+
+    if cd == "." || cd.is_empty() {
+        // Accept "." or "" as meaning "the one worktree" if we only have one worktree.
+        let mut worktrees = project.worktrees(cx);
+
+        match worktrees.next() {
+            Some(worktree) => {
+                anyhow::ensure!(
+                    worktrees.next().is_none(),
+                    "'.' is ambiguous in multi-root workspaces. Please specify a root directory explicitly.",
+                );
+                Ok(Some(worktree.read(cx).abs_path().to_path_buf()))
+            }
+            None => Ok(None),
+        }
+    } else {
+        let input_path = Path::new(cd);
+
+        if input_path.is_absolute() {
+            // Absolute paths are allowed, but only if they're in one of the project's worktrees.
+            if project
+                .worktrees(cx)
+                .any(|worktree| input_path.starts_with(&worktree.read(cx).abs_path()))
+            {
+                return Ok(Some(input_path.into()));
+            }
+        } else if let Some(worktree) = project.worktree_for_root_name(cd, cx) {
+            return Ok(Some(worktree.read(cx).abs_path().to_path_buf()));
+        }
+
+        anyhow::bail!("`cd` directory {cd:?} was not in any of the project's worktrees.");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use agent_settings::AgentSettings;
+    use editor::EditorSettings;
+    use fs::RealFs;
+    use gpui::{BackgroundExecutor, TestAppContext};
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+    use settings::{Settings, SettingsStore};
+    use terminal::terminal_settings::TerminalSettings;
+    use theme::ThemeSettings;
+    use util::test::TempTree;
+
+    use crate::ThreadEvent;
+
+    use super::*;
+
+    fn init_test(executor: &BackgroundExecutor, cx: &mut TestAppContext) {
+        zlog::init_test();
+
+        executor.allow_parking();
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            language::init(cx);
+            Project::init_settings(cx);
+            ThemeSettings::register(cx);
+            TerminalSettings::register(cx);
+            EditorSettings::register(cx);
+            AgentSettings::register(cx);
+        });
+    }
+
+    #[gpui::test]
+    async fn test_interactive_command(executor: BackgroundExecutor, cx: &mut TestAppContext) {
+        if cfg!(windows) {
+            return;
+        }
+
+        init_test(&executor, cx);
+
+        let fs = Arc::new(RealFs::new(None, executor));
+        let tree = TempTree::new(json!({
+            "project": {},
+        }));
+        let project: Entity<Project> =
+            Project::test(fs, [tree.path().join("project").as_path()], cx).await;
+
+        let input = TerminalToolInput {
+            command: "cat".to_owned(),
+            cd: tree
+                .path()
+                .join("project")
+                .as_path()
+                .to_string_lossy()
+                .to_string(),
+        };
+        let (event_stream_tx, mut event_stream_rx) = ToolCallEventStream::test();
+        let result = cx
+            .update(|cx| Arc::new(TerminalTool::new(project, cx)).run(input, event_stream_tx, cx));
+
+        let auth = event_stream_rx.expect_authorization().await;
+        auth.response.send(auth.options[0].id.clone()).unwrap();
+        event_stream_rx.expect_terminal().await;
+        assert_eq!(result.await.unwrap(), "Command executed successfully.");
+    }
+
+    #[gpui::test]
+    async fn test_working_directory(executor: BackgroundExecutor, cx: &mut TestAppContext) {
+        if cfg!(windows) {
+            return;
+        }
+
+        init_test(&executor, cx);
+
+        let fs = Arc::new(RealFs::new(None, executor));
+        let tree = TempTree::new(json!({
+            "project": {},
+            "other-project": {},
+        }));
+        let project: Entity<Project> =
+            Project::test(fs, [tree.path().join("project").as_path()], cx).await;
+
+        let check = |input, expected, cx: &mut TestAppContext| {
+            let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
+            let result = cx.update(|cx| {
+                Arc::new(TerminalTool::new(project.clone(), cx)).run(input, stream_tx, cx)
+            });
+            cx.run_until_parked();
+            let event = stream_rx.try_next();
+            if let Ok(Some(Ok(ThreadEvent::ToolCallAuthorization(auth)))) = event {
+                auth.response.send(auth.options[0].id.clone()).unwrap();
+            }
+
+            cx.spawn(async move |_| {
+                let output = result.await;
+                assert_eq!(output.ok(), expected);
+            })
+        };
+
+        check(
+            TerminalToolInput {
+                command: "pwd".into(),
+                cd: ".".into(),
+            },
+            Some(format!(
+                "```\n{}\n```",
+                tree.path().join("project").display()
+            )),
+            cx,
+        )
+        .await;
+
+        check(
+            TerminalToolInput {
+                command: "pwd".into(),
+                cd: "other-project".into(),
+            },
+            None, // other-project is a dir, but *not* a worktree (yet)
+            cx,
+        )
+        .await;
+
+        // Absolute path above the worktree root
+        check(
+            TerminalToolInput {
+                command: "pwd".into(),
+                cd: tree.path().to_string_lossy().into(),
+            },
+            None,
+            cx,
+        )
+        .await;
+
+        project
+            .update(cx, |project, cx| {
+                project.create_worktree(tree.path().join("other-project"), true, cx)
+            })
+            .await
+            .unwrap();
+
+        check(
+            TerminalToolInput {
+                command: "pwd".into(),
+                cd: "other-project".into(),
+            },
+            Some(format!(
+                "```\n{}\n```",
+                tree.path().join("other-project").display()
+            )),
+            cx,
+        )
+        .await;
+
+        check(
+            TerminalToolInput {
+                command: "pwd".into(),
+                cd: ".".into(),
+            },
+            None,
+            cx,
+        )
+        .await;
+    }
+}

crates/agent2/src/tools/thinking_tool.rs

@@ -11,8 +11,7 @@ use crate::{AgentTool, ToolCallEventStream};
 /// Use this tool when you need to work through complex problems, develop strategies, or outline approaches before taking action.
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ThinkingToolInput {
-    /// Content to think about. This should be a description of what to think about or
-    /// a problem to solve.
+    /// Content to think about. This should be a description of what to think about or a problem to solve.
     content: String,
 }
 
@@ -20,6 +19,7 @@ pub struct ThinkingTool;
 
 impl AgentTool for ThinkingTool {
     type Input = ThinkingToolInput;
+    type Output = String;
 
     fn name(&self) -> SharedString {
         "thinking".into()
@@ -29,7 +29,7 @@ impl AgentTool for ThinkingTool {
         acp::ToolKind::Think
     }
 
-    fn initial_title(&self, _input: Self::Input) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
         "Thinking".into()
     }
 
@@ -39,7 +39,7 @@ impl AgentTool for ThinkingTool {
         event_stream: ToolCallEventStream,
         _cx: &mut App,
     ) -> Task<Result<String>> {
-        event_stream.send_update(acp::ToolCallUpdateFields {
+        event_stream.update_fields(acp::ToolCallUpdateFields {
             content: Some(vec![input.content.into()]),
             ..Default::default()
         });

crates/agent2/src/tools/web_search_tool.rs

@@ -0,0 +1,127 @@
+use std::sync::Arc;
+
+use crate::{AgentTool, ToolCallEventStream};
+use agent_client_protocol as acp;
+use anyhow::{Result, anyhow};
+use cloud_llm_client::WebSearchResponse;
+use gpui::{App, AppContext, Task};
+use language_model::{
+    LanguageModelProviderId, LanguageModelToolResultContent, ZED_CLOUD_PROVIDER_ID,
+};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use ui::prelude::*;
+use web_search::WebSearchRegistry;
+
+/// Search the web for information using your query.
+/// Use this when you need real-time information, facts, or data that might not be in your training.
+/// Results will include snippets and links from relevant web pages.
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct WebSearchToolInput {
+    /// The search term or question to query on the web.
+    query: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct WebSearchToolOutput(WebSearchResponse);
+
+impl From<WebSearchToolOutput> for LanguageModelToolResultContent {
+    fn from(value: WebSearchToolOutput) -> Self {
+        serde_json::to_string(&value.0)
+            .expect("Failed to serialize WebSearchResponse")
+            .into()
+    }
+}
+
+pub struct WebSearchTool;
+
+impl AgentTool for WebSearchTool {
+    type Input = WebSearchToolInput;
+    type Output = WebSearchToolOutput;
+
+    fn name(&self) -> SharedString {
+        "web_search".into()
+    }
+
+    fn kind(&self) -> acp::ToolKind {
+        acp::ToolKind::Fetch
+    }
+
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+        "Searching the Web".into()
+    }
+
+    /// We currently only support Zed Cloud as a provider.
+    fn supported_provider(&self, provider: &LanguageModelProviderId) -> bool {
+        provider == &ZED_CLOUD_PROVIDER_ID
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: Self::Input,
+        event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output>> {
+        let Some(provider) = WebSearchRegistry::read_global(cx).active_provider() else {
+            return Task::ready(Err(anyhow!("Web search is not available.")));
+        };
+
+        let search_task = provider.search(input.query, cx);
+        cx.background_spawn(async move {
+            let response = match search_task.await {
+                Ok(response) => response,
+                Err(err) => {
+                    event_stream.update_fields(acp::ToolCallUpdateFields {
+                        title: Some("Web Search Failed".to_string()),
+                        ..Default::default()
+                    });
+                    return Err(err);
+                }
+            };
+
+            emit_update(&response, &event_stream);
+            Ok(WebSearchToolOutput(response))
+        })
+    }
+
+    fn replay(
+        &self,
+        _input: Self::Input,
+        output: Self::Output,
+        event_stream: ToolCallEventStream,
+        _cx: &mut App,
+    ) -> Result<()> {
+        emit_update(&output.0, &event_stream);
+        Ok(())
+    }
+}
+
+fn emit_update(response: &WebSearchResponse, event_stream: &ToolCallEventStream) {
+    let result_text = if response.results.len() == 1 {
+        "1 result".to_string()
+    } else {
+        format!("{} results", response.results.len())
+    };
+    event_stream.update_fields(acp::ToolCallUpdateFields {
+        title: Some(format!("Searched the web: {result_text}")),
+        content: Some(
+            response
+                .results
+                .iter()
+                .map(|result| acp::ToolCallContent::Content {
+                    content: acp::ContentBlock::ResourceLink(acp::ResourceLink {
+                        name: result.title.clone(),
+                        uri: result.url.clone(),
+                        title: Some(result.title.clone()),
+                        description: Some(result.text.clone()),
+                        mime_type: None,
+                        annotations: None,
+                        size: None,
+                    }),
+                })
+                .collect(),
+        ),
+        ..Default::default()
+    });
+}

crates/agent_servers/Cargo.toml

@@ -6,7 +6,7 @@ publish.workspace = true
 license = "GPL-3.0-or-later"
 
 [features]
-test-support = ["acp_thread/test-support", "gpui/test-support", "project/test-support"]
+test-support = ["acp_thread/test-support", "gpui/test-support", "project/test-support", "dep:env_logger", "fs", "client/test-support", "dep:gpui_tokio", "reqwest_client/test-support"]
 e2e = []
 
 [lints]
@@ -18,20 +18,31 @@ doctest = false
 
 [dependencies]
 acp_thread.workspace = true
+action_log.workspace = true
 agent-client-protocol.workspace = true
+agent_settings.workspace = true
 agentic-coding-protocol.workspace = true
 anyhow.workspace = true
+client = { workspace = true, optional = true }
 collections.workspace = true
 context_server.workspace = true
+env_logger = { workspace = true, optional = true }
+fs = { workspace = true, optional = true }
 futures.workspace = true
 gpui.workspace = true
+gpui_tokio = { workspace = true, optional = true }
 indoc.workspace = true
 itertools.workspace = true
+language.workspace = true
+language_model.workspace = true
+language_models.workspace = true
 log.workspace = true
 paths.workspace = true
 project.workspace = true
 rand.workspace = true
+reqwest_client = { workspace = true, optional = true }
 schemars.workspace = true
+semver.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
@@ -51,8 +62,12 @@ libc.workspace = true
 nix.workspace = true
 
 [dev-dependencies]
+client = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
+fs.workspace = true
 language.workspace = true
 indoc.workspace = true
 acp_thread = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
+gpui_tokio.workspace = true
+reqwest_client = { workspace = true, features = ["test-support"] }

crates/agent_servers/src/acp.rs

@@ -19,14 +19,14 @@ pub async fn connect(
     root_dir: &Path,
     cx: &mut AsyncApp,
 ) -> Result<Rc<dyn AgentConnection>> {
-    let conn = v1::AcpConnection::stdio(server_name, command.clone(), &root_dir, cx).await;
+    let conn = v1::AcpConnection::stdio(server_name, command.clone(), root_dir, cx).await;
 
     match conn {
         Ok(conn) => Ok(Rc::new(conn) as _),
         Err(err) if err.is::<UnsupportedVersion>() => {
             // Consider re-using initialize response and subprocess when adding another version here
             let conn: Rc<dyn AgentConnection> =
-                Rc::new(v0::AcpConnection::stdio(server_name, command, &root_dir, cx).await?);
+                Rc::new(v0::AcpConnection::stdio(server_name, command, root_dir, cx).await?);
             Ok(conn)
         }
         Err(err) => Err(err),

crates/agent_servers/src/acp/v0.rs

@@ -1,11 +1,12 @@
 // Translates old acp agents into the new schema
+use action_log::ActionLog;
 use agent_client_protocol as acp;
 use agentic_coding_protocol::{self as acp_old, AgentRequest as _};
 use anyhow::{Context as _, Result, anyhow};
 use futures::channel::oneshot;
 use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity};
 use project::Project;
-use std::{cell::RefCell, path::Path, rc::Rc};
+use std::{any::Any, cell::RefCell, path::Path, rc::Rc};
 use ui::App;
 use util::ResultExt as _;
 
@@ -135,9 +136,9 @@ impl acp_old::Client for OldAcpClientDelegate {
         let response = cx
             .update(|cx| {
                 self.thread.borrow().update(cx, |thread, cx| {
-                    thread.request_tool_call_authorization(tool_call, acp_options, cx)
+                    thread.request_tool_call_authorization(tool_call.into(), acp_options, cx)
                 })
-            })?
+            })??
             .context("Failed to update thread")?
             .await;
 
@@ -148,7 +149,7 @@ impl acp_old::Client for OldAcpClientDelegate {
 
         Ok(acp_old::RequestToolCallConfirmationResponse {
             id: acp_old::ToolCallId(old_acp_id),
-            outcome: outcome,
+            outcome,
         })
     }
 
@@ -168,7 +169,7 @@ impl acp_old::Client for OldAcpClientDelegate {
                     cx,
                 )
             })
-        })?
+        })??
         .context("Failed to update thread")?;
 
         Ok(acp_old::PushToolCallResponse {
@@ -265,7 +266,7 @@ impl acp_old::Client for OldAcpClientDelegate {
 
 fn into_new_tool_call(id: acp::ToolCallId, request: acp_old::PushToolCallParams) -> acp::ToolCall {
     acp::ToolCall {
-        id: id,
+        id,
         title: request.label,
         kind: acp_kind_from_old_icon(request.icon),
         status: acp::ToolCallStatus::InProgress,
@@ -423,7 +424,7 @@ impl AgentConnection for AcpConnection {
         self: Rc<Self>,
         project: Entity<Project>,
         _cwd: &Path,
-        cx: &mut AsyncApp,
+        cx: &mut App,
     ) -> Task<Result<Entity<AcpThread>>> {
         let task = self.connection.request_any(
             acp_old::InitializeParams {
@@ -437,13 +438,14 @@ impl AgentConnection for AcpConnection {
             let result = acp_old::InitializeParams::response_from_any(result)?;
 
             if !result.is_authenticated {
-                anyhow::bail!(AuthRequired)
+                anyhow::bail!(AuthRequired::new())
             }
 
             cx.update(|cx| {
                 let thread = cx.new(|cx| {
                     let session_id = acp::SessionId("acp-old-no-id".into());
-                    AcpThread::new(self.name, self.clone(), project, session_id, cx)
+                    let action_log = cx.new(|_| ActionLog::new(project.clone()));
+                    AcpThread::new(self.name, self.clone(), project, action_log, session_id)
                 });
                 current_thread.replace(thread.downgrade());
                 thread
@@ -467,6 +469,7 @@ impl AgentConnection for AcpConnection {
 
     fn prompt(
         &self,
+        _id: Option<acp_thread::UserMessageId>,
         params: acp::PromptRequest,
         cx: &mut App,
     ) -> Task<Result<acp::PromptResponse>> {
@@ -495,6 +498,14 @@ impl AgentConnection for AcpConnection {
         })
     }
 
+    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+        acp::PromptCapabilities {
+            image: false,
+            audio: false,
+            embedded_context: false,
+        }
+    }
+
     fn cancel(&self, _session_id: &acp::SessionId, cx: &mut App) {
         let task = self
             .connection
@@ -506,4 +517,8 @@ impl AgentConnection for AcpConnection {
             })
             .detach_and_log_err(cx)
     }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }

crates/agent_servers/src/acp/v1.rs

@@ -1,28 +1,34 @@
-use agent_client_protocol::{self as acp, Agent as _};
+use action_log::ActionLog;
+use agent_client_protocol::{self as acp, Agent as _, ErrorCode};
 use anyhow::anyhow;
 use collections::HashMap;
+use futures::AsyncBufReadExt as _;
 use futures::channel::oneshot;
+use futures::io::BufReader;
 use project::Project;
-use std::cell::RefCell;
+use serde::Deserialize;
 use std::path::Path;
 use std::rc::Rc;
+use std::{any::Any, cell::RefCell};
 
 use anyhow::{Context as _, Result};
 use gpui::{App, AppContext as _, AsyncApp, Entity, Task, WeakEntity};
 
 use crate::{AgentServerCommand, acp::UnsupportedVersion};
-use acp_thread::{AcpThread, AgentConnection, AuthRequired};
+use acp_thread::{AcpThread, AgentConnection, AuthRequired, LoadError};
 
 pub struct AcpConnection {
     server_name: &'static str,
     connection: Rc<acp::ClientSideConnection>,
     sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
     auth_methods: Vec<acp::AuthMethod>,
+    prompt_capabilities: acp::PromptCapabilities,
     _io_task: Task<Result<()>>,
 }
 
 pub struct AcpSession {
     thread: WeakEntity<AcpThread>,
+    suppress_abort_err: bool,
 }
 
 const MINIMUM_SUPPORTED_VERSION: acp::ProtocolVersion = acp::V1;
@@ -40,12 +46,13 @@ impl AcpConnection {
             .current_dir(root_dir)
             .stdin(std::process::Stdio::piped())
             .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::piped())
             .kill_on_drop(true)
             .spawn()?;
 
-        let stdout = child.stdout.take().expect("Failed to take stdout");
-        let stdin = child.stdin.take().expect("Failed to take stdin");
+        let stdout = child.stdout.take().context("Failed to take stdout")?;
+        let stdin = child.stdin.take().context("Failed to take stdin")?;
+        let stderr = child.stderr.take().context("Failed to take stderr")?;
         log::trace!("Spawned (pid: {})", child.id());
 
         let sessions = Rc::new(RefCell::new(HashMap::default()));
@@ -63,6 +70,18 @@ impl AcpConnection {
 
         let io_task = cx.background_spawn(io_task);
 
+        cx.background_spawn(async move {
+            let mut stderr = BufReader::new(stderr);
+            let mut line = String::new();
+            while let Ok(n) = stderr.read_line(&mut line).await
+                && n > 0
+            {
+                log::warn!("agent stderr: {}", &line);
+                line.clear();
+            }
+        })
+        .detach();
+
         cx.spawn({
             let sessions = sessions.clone();
             async move |cx| {
@@ -71,7 +90,9 @@ impl AcpConnection {
                 for session in sessions.borrow().values() {
                     session
                         .thread
-                        .update(cx, |thread, cx| thread.emit_server_exited(status, cx))
+                        .update(cx, |thread, cx| {
+                            thread.emit_load_error(LoadError::Exited { status }, cx)
+                        })
                         .ok();
                 }
 
@@ -101,6 +122,7 @@ impl AcpConnection {
             connection: connection.into(),
             server_name,
             sessions,
+            prompt_capabilities: response.agent_capabilities.prompt_capabilities,
             _io_task: io_task,
         })
     }
@@ -111,7 +133,7 @@ impl AgentConnection for AcpConnection {
         self: Rc<Self>,
         project: Entity<Project>,
         cwd: &Path,
-        cx: &mut AsyncApp,
+        cx: &mut App,
     ) -> Task<Result<Entity<AcpThread>>> {
         let conn = self.connection.clone();
         let sessions = self.sessions.clone();
@@ -125,26 +147,33 @@ impl AgentConnection for AcpConnection {
                 .await
                 .map_err(|err| {
                     if err.code == acp::ErrorCode::AUTH_REQUIRED.code {
-                        anyhow!(AuthRequired)
+                        let mut error = AuthRequired::new();
+
+                        if err.message != acp::ErrorCode::AUTH_REQUIRED.message {
+                            error = error.with_description(err.message);
+                        }
+
+                        anyhow!(error)
                     } else {
                         anyhow!(err)
                     }
                 })?;
 
             let session_id = response.session_id;
-
-            let thread = cx.new(|cx| {
+            let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
+            let thread = cx.new(|_cx| {
                 AcpThread::new(
                     self.server_name,
                     self.clone(),
                     project,
+                    action_log,
                     session_id.clone(),
-                    cx,
                 )
             })?;
 
             let session = AcpSession {
                 thread: thread.downgrade(),
+                suppress_abort_err: false,
             };
             sessions.borrow_mut().insert(session_id, session);
 
@@ -171,17 +200,69 @@ impl AgentConnection for AcpConnection {
 
     fn prompt(
         &self,
+        _id: Option<acp_thread::UserMessageId>,
         params: acp::PromptRequest,
         cx: &mut App,
     ) -> Task<Result<acp::PromptResponse>> {
         let conn = self.connection.clone();
+        let sessions = self.sessions.clone();
+        let session_id = params.session_id.clone();
         cx.foreground_executor().spawn(async move {
-            let response = conn.prompt(params).await?;
-            Ok(response)
+            let result = conn.prompt(params).await;
+
+            let mut suppress_abort_err = false;
+
+            if let Some(session) = sessions.borrow_mut().get_mut(&session_id) {
+                suppress_abort_err = session.suppress_abort_err;
+                session.suppress_abort_err = false;
+            }
+
+            match result {
+                Ok(response) => Ok(response),
+                Err(err) => {
+                    if err.code != ErrorCode::INTERNAL_ERROR.code {
+                        anyhow::bail!(err)
+                    }
+
+                    let Some(data) = &err.data else {
+                        anyhow::bail!(err)
+                    };
+
+                    // Temporary workaround until the following PR is generally available:
+                    // https://github.com/google-gemini/gemini-cli/pull/6656
+
+                    #[derive(Deserialize)]
+                    #[serde(deny_unknown_fields)]
+                    struct ErrorDetails {
+                        details: Box<str>,
+                    }
+
+                    match serde_json::from_value(data.clone()) {
+                        Ok(ErrorDetails { details }) => {
+                            if suppress_abort_err && details.contains("This operation was aborted")
+                            {
+                                Ok(acp::PromptResponse {
+                                    stop_reason: acp::StopReason::Cancelled,
+                                })
+                            } else {
+                                Err(anyhow!(details))
+                            }
+                        }
+                        Err(_) => Err(anyhow!(err)),
+                    }
+                }
+            }
         })
     }
 
+    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+        self.prompt_capabilities
+    }
+
     fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
+        if let Some(session) = self.sessions.borrow_mut().get_mut(session_id) {
+            session.suppress_abort_err = true;
+        }
         let conn = self.connection.clone();
         let params = acp::CancelNotification {
             session_id: session_id.clone(),
@@ -190,6 +271,10 @@ impl AgentConnection for AcpConnection {
             .spawn(async move { conn.cancel(params).await })
             .detach();
     }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }
 
 struct ClientDelegate {
@@ -213,7 +298,7 @@ impl acp::Client for ClientDelegate {
                 thread.request_tool_call_authorization(arguments.tool_call, arguments.options, cx)
             })?;
 
-        let result = rx.await;
+        let result = rx?.await;
 
         let outcome = match result {
             Ok(option) => acp::RequestPermissionOutcome::Selected { option_id: option },

crates/agent_servers/src/agent_servers.rs

@@ -3,8 +3,8 @@ mod claude;
 mod gemini;
 mod settings;
 
-#[cfg(test)]
-mod e2e_tests;
+#[cfg(any(test, feature = "test-support"))]
+pub mod e2e_tests;
 
 pub use claude::*;
 pub use gemini::*;
@@ -18,6 +18,7 @@ use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{
+    any::Any,
     path::{Path, PathBuf},
     rc::Rc,
     sync::Arc,
@@ -40,6 +41,14 @@ pub trait AgentServer: Send {
         project: &Entity<Project>,
         cx: &mut App,
     ) -> Task<Result<Rc<dyn AgentConnection>>>;
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
+}
+
+impl dyn AgentServer {
+    pub fn downcast<T: 'static + AgentServer + Sized>(self: Rc<Self>) -> Option<Rc<T>> {
+        self.into_any().downcast().ok()
+    }
 }
 
 impl std::fmt::Debug for AgentServerCommand {
@@ -95,7 +104,7 @@ impl AgentServerCommand {
         cx: &mut AsyncApp,
     ) -> Option<Self> {
         if let Some(agent_settings) = settings {
-            return Some(Self {
+            Some(Self {
                 path: agent_settings.command.path,
                 args: agent_settings
                     .command
@@ -104,7 +113,7 @@ impl AgentServerCommand {
                     .chain(extra_args.iter().map(|arg| arg.to_string()))
                     .collect(),
                 env: agent_settings.command.env,
-            });
+            })
         } else {
             match find_bin_in_path(path_bin_name, project, cx).await {
                 Some(path) => Some(Self {

crates/agent_servers/src/claude.rs

@@ -1,19 +1,27 @@
+mod edit_tool;
 mod mcp_server;
+mod permission_tool;
+mod read_tool;
 pub mod tools;
+mod write_tool;
 
+use action_log::ActionLog;
 use collections::HashMap;
 use context_server::listener::McpServerTool;
+use language_models::provider::anthropic::AnthropicLanguageModelProvider;
 use project::Project;
 use settings::SettingsStore;
 use smol::process::Child;
+use std::any::Any;
 use std::cell::RefCell;
 use std::fmt::Display;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::rc::Rc;
+use util::command::new_smol_command;
 use uuid::Uuid;
 
 use agent_client_protocol as acp;
-use anyhow::{Result, anyhow};
+use anyhow::{Context as _, Result, anyhow};
 use futures::channel::oneshot;
 use futures::{AsyncBufReadExt, AsyncWriteExt};
 use futures::{
@@ -29,7 +37,7 @@ use util::{ResultExt, debug_panic};
 use crate::claude::mcp_server::{ClaudeZedMcpServer, McpConfig};
 use crate::claude::tools::ClaudeTool;
 use crate::{AgentServer, AgentServerCommand, AllAgentServersSettings};
-use acp_thread::{AcpThread, AgentConnection};
+use acp_thread::{AcpThread, AgentConnection, AuthRequired, LoadError, MentionUri};
 
 #[derive(Clone)]
 pub struct ClaudeCode;
@@ -63,6 +71,10 @@ impl AgentServer for ClaudeCode {
 
         Task::ready(Ok(Rc::new(connection) as _))
     }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }
 
 struct ClaudeAgentConnection {
@@ -74,12 +86,47 @@ impl AgentConnection for ClaudeAgentConnection {
         self: Rc<Self>,
         project: Entity<Project>,
         cwd: &Path,
-        cx: &mut AsyncApp,
+        cx: &mut App,
     ) -> Task<Result<Entity<AcpThread>>> {
         let cwd = cwd.to_owned();
         cx.spawn(async move |cx| {
+            let settings = cx.read_global(|settings: &SettingsStore, _| {
+                settings.get::<AllAgentServersSettings>(None).claude.clone()
+            })?;
+
+            let Some(command) = AgentServerCommand::resolve(
+                "claude",
+                &[],
+                Some(&util::paths::home_dir().join(".claude/local/claude")),
+                settings,
+                &project,
+                cx,
+            )
+            .await
+            else {
+                return Err(LoadError::NotInstalled {
+                    error_message: "Failed to find Claude Code binary".into(),
+                    install_message: "Install Claude Code".into(),
+                    install_command: "npm install -g @anthropic-ai/claude-code@latest".into(),
+                }.into());
+            };
+
+            let api_key =
+                cx.update(AnthropicLanguageModelProvider::api_key)?
+                    .await
+                    .map_err(|err| {
+                        if err.is::<language_model::AuthenticateError>() {
+                            anyhow!(AuthRequired::new().with_language_model_provider(
+                                language_model::ANTHROPIC_PROVIDER_ID
+                            ))
+                        } else {
+                            anyhow!(err)
+                        }
+                    })?;
+
             let (mut thread_tx, thread_rx) = watch::channel(WeakEntity::new_invalid());
-            let permission_mcp_server = ClaudeZedMcpServer::new(thread_rx.clone(), cx).await?;
+            let fs = project.read_with(cx, |project, _cx| project.fs().clone())?;
+            let permission_mcp_server = ClaudeZedMcpServer::new(thread_rx.clone(), fs, cx).await?;
 
             let mut mcp_servers = HashMap::default();
             mcp_servers.insert(
@@ -97,23 +144,6 @@ impl AgentConnection for ClaudeAgentConnection {
                 .await?;
             mcp_config_file.flush().await?;
 
-            let settings = cx.read_global(|settings: &SettingsStore, _| {
-                settings.get::<AllAgentServersSettings>(None).claude.clone()
-            })?;
-
-            let Some(command) = AgentServerCommand::resolve(
-                "claude",
-                &[],
-                Some(&util::paths::home_dir().join(".claude/local/claude")),
-                settings,
-                &project,
-                cx,
-            )
-            .await
-            else {
-                anyhow::bail!("Failed to find claude binary");
-            };
-
             let (incoming_message_tx, mut incoming_message_rx) = mpsc::unbounded();
             let (outgoing_tx, outgoing_rx) = mpsc::unbounded();
 
@@ -125,16 +155,30 @@ impl AgentConnection for ClaudeAgentConnection {
                 &command,
                 ClaudeSessionMode::Start,
                 session_id.clone(),
+                api_key,
                 &mcp_config_path,
                 &cwd,
             )?;
 
-            let stdin = child.stdin.take().unwrap();
-            let stdout = child.stdout.take().unwrap();
+            let stdout = child.stdout.take().context("Failed to take stdout")?;
+            let stdin = child.stdin.take().context("Failed to take stdin")?;
+            let stderr = child.stderr.take().context("Failed to take stderr")?;
 
             let pid = child.id();
             log::trace!("Spawned (pid: {})", pid);
 
+            cx.background_spawn(async move {
+                let mut stderr = BufReader::new(stderr);
+                let mut line = String::new();
+                while let Ok(n) = stderr.read_line(&mut line).await
+                    && n > 0
+                {
+                    log::warn!("agent stderr: {}", &line);
+                    line.clear();
+                }
+            })
+            .detach();
+
             cx.background_spawn(async move {
                 let mut outgoing_rx = Some(outgoing_rx);
 
@@ -169,20 +213,50 @@ impl AgentConnection for ClaudeAgentConnection {
                         .await
                     }
 
-                    if let Some(status) = child.status().await.log_err() {
-                        if let Some(thread) = thread_rx.recv().await.ok() {
-                            thread
-                                .update(cx, |thread, cx| {
-                                    thread.emit_server_exited(status, cx);
-                                })
-                                .ok();
-                        }
+                    if let Some(status) = child.status().await.log_err()
+                        && let Some(thread) = thread_rx.recv().await.ok()
+                    {
+                        let version = claude_version(command.path.clone(), cx).await.log_err();
+                        let help = claude_help(command.path.clone(), cx).await.log_err();
+                        thread
+                            .update(cx, |thread, cx| {
+                                let error = if let Some(version) = version
+                                    && let Some(help) = help
+                                    && (!help.contains("--input-format")
+                                        || !help.contains("--session-id"))
+                                {
+                                    LoadError::Unsupported {
+                                    error_message: format!(
+                                            "Your installed version of Claude Code ({}, version {}) does not have required features for use with Zed.",
+                                            command.path.to_string_lossy(),
+                                            version,
+                                        )
+                                        .into(),
+                                        upgrade_message: "Upgrade Claude Code to latest".into(),
+                                        upgrade_command: format!(
+                                            "{} update",
+                                            command.path.to_string_lossy()
+                                        ),
+                                    }
+                                } else {
+                                    LoadError::Exited { status }
+                                };
+                                thread.emit_load_error(error, cx);
+                            })
+                            .ok();
                     }
                 }
             });
 
-            let thread = cx.new(|cx| {
-                AcpThread::new("Claude Code", self.clone(), project, session_id.clone(), cx)
+            let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
+            let thread = cx.new(|_cx| {
+                AcpThread::new(
+                    "Claude Code",
+                    self.clone(),
+                    project,
+                    action_log,
+                    session_id.clone(),
+                )
             })?;
 
             thread_tx.send(thread.downgrade())?;
@@ -210,6 +284,7 @@ impl AgentConnection for ClaudeAgentConnection {
 
     fn prompt(
         &self,
+        _id: Option<acp_thread::UserMessageId>,
         params: acp::PromptRequest,
         cx: &mut App,
     ) -> Task<Result<acp::PromptResponse>> {
@@ -224,27 +299,12 @@ impl AgentConnection for ClaudeAgentConnection {
         let (end_tx, end_rx) = oneshot::channel();
         session.turn_state.replace(TurnState::InProgress { end_tx });
 
-        let mut content = String::new();
-        for chunk in params.prompt {
-            match chunk {
-                acp::ContentBlock::Text(text_content) => {
-                    content.push_str(&text_content.text);
-                }
-                acp::ContentBlock::ResourceLink(resource_link) => {
-                    content.push_str(&format!("@{}", resource_link.uri));
-                }
-                acp::ContentBlock::Audio(_)
-                | acp::ContentBlock::Image(_)
-                | acp::ContentBlock::Resource(_) => {
-                    // TODO
-                }
-            }
-        }
+        let content = acp_content_to_claude(params.prompt);
 
         if let Err(err) = session.outgoing_tx.unbounded_send(SdkMessage::User {
             message: Message {
                 role: Role::User,
-                content: Content::UntaggedText(content),
+                content: Content::Chunks(content),
                 id: None,
                 model: None,
                 stop_reason: None,
@@ -259,9 +319,17 @@ impl AgentConnection for ClaudeAgentConnection {
         cx.foreground_executor().spawn(async move { end_rx.await? })
     }
 
+    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+        acp::PromptCapabilities {
+            image: true,
+            audio: false,
+            embedded_context: true,
+        }
+    }
+
     fn cancel(&self, session_id: &acp::SessionId, _cx: &mut App) {
         let sessions = self.sessions.borrow();
-        let Some(session) = sessions.get(&session_id) else {
+        let Some(session) = sessions.get(session_id) else {
             log::warn!("Attempted to cancel nonexistent session {}", session_id);
             return;
         };
@@ -270,7 +338,7 @@ impl AgentConnection for ClaudeAgentConnection {
 
         let turn_state = session.turn_state.take();
         let TurnState::InProgress { end_tx } = turn_state else {
-            // Already cancelled or idle, put it back
+            // Already canceled or idle, put it back
             session.turn_state.replace(turn_state);
             return;
         };
@@ -288,6 +356,10 @@ impl AgentConnection for ClaudeAgentConnection {
             })
             .log_err();
     }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }
 
 #[derive(Clone, Copy)]
@@ -301,6 +373,7 @@ fn spawn_claude(
     command: &AgentServerCommand,
     mode: ClaudeSessionMode,
     session_id: acp::SessionId,
+    api_key: language_models::provider::anthropic::ApiKey,
     mcp_config_path: &Path,
     root_dir: &Path,
 ) -> Result<Child> {
@@ -318,34 +391,55 @@ fn spawn_claude(
             &format!(
                 "mcp__{}__{}",
                 mcp_server::SERVER_NAME,
-                mcp_server::PermissionTool::NAME,
+                permission_tool::PermissionTool::NAME,
             ),
             "--allowedTools",
             &format!(
-                "mcp__{}__{},mcp__{}__{}",
+                "mcp__{}__{}",
                 mcp_server::SERVER_NAME,
-                mcp_server::EditTool::NAME,
-                mcp_server::SERVER_NAME,
-                mcp_server::ReadTool::NAME
+                read_tool::ReadTool::NAME
             ),
             "--disallowedTools",
-            "Read,Edit",
+            "Read,Write,Edit,MultiEdit",
         ])
         .args(match mode {
             ClaudeSessionMode::Start => ["--session-id".to_string(), session_id.to_string()],
             ClaudeSessionMode::Resume => ["--resume".to_string(), session_id.to_string()],
         })
         .args(command.args.iter().map(|arg| arg.as_str()))
+        .envs(command.env.iter().flatten())
+        .env("ANTHROPIC_API_KEY", api_key.key)
         .current_dir(root_dir)
         .stdin(std::process::Stdio::piped())
         .stdout(std::process::Stdio::piped())
-        .stderr(std::process::Stdio::inherit())
+        .stderr(std::process::Stdio::piped())
         .kill_on_drop(true)
         .spawn()?;
 
     Ok(child)
 }
 
+fn claude_version(path: PathBuf, cx: &mut AsyncApp) -> Task<Result<semver::Version>> {
+    cx.background_spawn(async move {
+        let output = new_smol_command(path).arg("--version").output().await?;
+        let output = String::from_utf8(output.stdout)?;
+        let version = output
+            .trim()
+            .strip_suffix(" (Claude Code)")
+            .context("parsing Claude version")?;
+        let version = semver::Version::parse(version)?;
+        anyhow::Ok(version)
+    })
+}
+
+fn claude_help(path: PathBuf, cx: &mut AsyncApp) -> Task<Result<String>> {
+    cx.background_spawn(async move {
+        let output = new_smol_command(path).arg("--help").output().await?;
+        let output = String::from_utf8(output.stdout)?;
+        anyhow::Ok(output)
+    })
+}
+
 struct ClaudeAgentSession {
     outgoing_tx: UnboundedSender<SdkMessage>,
     turn_state: Rc<RefCell<TurnState>>,
@@ -370,7 +464,7 @@ enum TurnState {
 }
 
 impl TurnState {
-    fn is_cancelled(&self) -> bool {
+    fn is_canceled(&self) -> bool {
         matches!(self, TurnState::CancelConfirmed { .. })
     }
 
@@ -420,10 +514,10 @@ impl ClaudeAgentSession {
                 for chunk in message.content.chunks() {
                     match chunk {
                         ContentChunk::Text { text } | ContentChunk::UntaggedText(text) => {
-                            if !turn_state.borrow().is_cancelled() {
+                            if !turn_state.borrow().is_canceled() {
                                 thread
                                     .update(cx, |thread, cx| {
-                                        thread.push_user_content_block(text.into(), cx)
+                                        thread.push_user_content_block(None, text.into(), cx)
                                     })
                                     .log_err();
                             }
@@ -435,17 +529,24 @@ impl ClaudeAgentSession {
                             let content = content.to_string();
                             thread
                                 .update(cx, |thread, cx| {
+                                    let id = acp::ToolCallId(tool_use_id.into());
+                                    let set_new_content = !content.is_empty()
+                                        && thread.tool_call(&id).is_none_or(|(_, tool_call)| {
+                                            // preserve rich diff if we have one
+                                            tool_call.diffs().next().is_none()
+                                        });
+
                                     thread.update_tool_call(
                                         acp::ToolCallUpdate {
-                                            id: acp::ToolCallId(tool_use_id.into()),
+                                            id,
                                             fields: acp::ToolCallUpdateFields {
-                                                status: if turn_state.borrow().is_cancelled() {
-                                                    // Do not set to completed if turn was cancelled
+                                                status: if turn_state.borrow().is_canceled() {
+                                                    // Do not set to completed if turn was canceled
                                                     None
                                                 } else {
                                                     Some(acp::ToolCallStatus::Completed)
                                                 },
-                                                content: (!content.is_empty())
+                                                content: set_new_content
                                                     .then(|| vec![content.into()]),
                                                 ..Default::default()
                                             },
@@ -463,10 +564,17 @@ impl ClaudeAgentSession {
                                 chunk
                             );
                         }
+                        ContentChunk::Image { source } => {
+                            if !turn_state.borrow().is_canceled() {
+                                thread
+                                    .update(cx, |thread, cx| {
+                                        thread.push_user_content_block(None, source.into(), cx)
+                                    })
+                                    .log_err();
+                            }
+                        }
 
-                        ContentChunk::Image
-                        | ContentChunk::Document
-                        | ContentChunk::WebSearchToolResult => {
+                        ContentChunk::Document | ContentChunk::WebSearchToolResult => {
                             thread
                                 .update(cx, |thread, cx| {
                                     thread.push_assistant_content_block(
@@ -541,8 +649,9 @@ impl ClaudeAgentSession {
                                         thread.upsert_tool_call(
                                             claude_tool.as_acp(acp::ToolCallId(id.into())),
                                             cx,
-                                        );
+                                        )?;
                                     }
+                                    anyhow::Ok(())
                                 })
                                 .log_err();
                         }
@@ -551,7 +660,14 @@ impl ClaudeAgentSession {
                                 "Should not get tool results with role: assistant. should we handle this?"
                             );
                         }
-                        ContentChunk::Image | ContentChunk::Document => {
+                        ContentChunk::Image { source } => {
+                            thread
+                                .update(cx, |thread, cx| {
+                                    thread.push_assistant_content_block(source.into(), false, cx)
+                                })
+                                .log_err();
+                        }
+                        ContentChunk::Document => {
                             thread
                                 .update(cx, |thread, cx| {
                                     thread.push_assistant_content_block(
@@ -572,14 +688,13 @@ impl ClaudeAgentSession {
                 ..
             } => {
                 let turn_state = turn_state.take();
-                let was_cancelled = turn_state.is_cancelled();
+                let was_canceled = turn_state.is_canceled();
                 let Some(end_turn_tx) = turn_state.end_tx() else {
                     debug_panic!("Received `SdkMessage::Result` but there wasn't an active turn");
                     return;
                 };
 
-                if is_error || (!was_cancelled && subtype == ResultErrorType::ErrorDuringExecution)
-                {
+                if is_error || (!was_canceled && subtype == ResultErrorType::ErrorDuringExecution) {
                     end_turn_tx
                         .send(Err(anyhow!(
                             "Error: {}",
@@ -680,7 +795,7 @@ impl Content {
     pub fn chunks(self) -> impl Iterator<Item = ContentChunk> {
         match self {
             Self::Chunks(chunks) => chunks.into_iter(),
-            Self::UntaggedText(text) => vec![ContentChunk::Text { text: text.clone() }].into_iter(),
+            Self::UntaggedText(text) => vec![ContentChunk::Text { text }].into_iter(),
         }
     }
 }
@@ -718,14 +833,44 @@ enum ContentChunk {
         thinking: String,
     },
     RedactedThinking,
+    Image {
+        source: ImageSource,
+    },
     // TODO
-    Image,
     Document,
     WebSearchToolResult,
     #[serde(untagged)]
     UntaggedText(String),
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+enum ImageSource {
+    Base64 { data: String, media_type: String },
+    Url { url: String },
+}
+
+impl Into<acp::ContentBlock> for ImageSource {
+    fn into(self) -> acp::ContentBlock {
+        match self {
+            ImageSource::Base64 { data, media_type } => {
+                acp::ContentBlock::Image(acp::ImageContent {
+                    annotations: None,
+                    data,
+                    mime_type: media_type,
+                    uri: None,
+                })
+            }
+            ImageSource::Url { url } => acp::ContentBlock::Image(acp::ImageContent {
+                annotations: None,
+                data: "".to_string(),
+                mime_type: "".to_string(),
+                uri: Some(url),
+            }),
+        }
+    }
+}
+
 impl Display for ContentChunk {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -734,7 +879,7 @@ impl Display for ContentChunk {
             ContentChunk::RedactedThinking => write!(f, "Thinking: [REDACTED]"),
             ContentChunk::UntaggedText(text) => write!(f, "{}", text),
             ContentChunk::ToolResult { content, .. } => write!(f, "{}", content),
-            ContentChunk::Image
+            ContentChunk::Image { .. }
             | ContentChunk::Document
             | ContentChunk::ToolUse { .. }
             | ContentChunk::WebSearchToolResult => {
@@ -846,6 +991,75 @@ impl Display for ResultErrorType {
     }
 }
 
+fn acp_content_to_claude(prompt: Vec<acp::ContentBlock>) -> Vec<ContentChunk> {
+    let mut content = Vec::with_capacity(prompt.len());
+    let mut context = Vec::with_capacity(prompt.len());
+
+    for chunk in prompt {
+        match chunk {
+            acp::ContentBlock::Text(text_content) => {
+                content.push(ContentChunk::Text {
+                    text: text_content.text,
+                });
+            }
+            acp::ContentBlock::ResourceLink(resource_link) => {
+                match MentionUri::parse(&resource_link.uri) {
+                    Ok(uri) => {
+                        content.push(ContentChunk::Text {
+                            text: format!("{}", uri.as_link()),
+                        });
+                    }
+                    Err(_) => {
+                        content.push(ContentChunk::Text {
+                            text: resource_link.uri,
+                        });
+                    }
+                }
+            }
+            acp::ContentBlock::Resource(resource) => match resource.resource {
+                acp::EmbeddedResourceResource::TextResourceContents(resource) => {
+                    match MentionUri::parse(&resource.uri) {
+                        Ok(uri) => {
+                            content.push(ContentChunk::Text {
+                                text: format!("{}", uri.as_link()),
+                            });
+                        }
+                        Err(_) => {
+                            content.push(ContentChunk::Text {
+                                text: resource.uri.clone(),
+                            });
+                        }
+                    }
+
+                    context.push(ContentChunk::Text {
+                        text: format!(
+                            "\n<context ref=\"{}\">\n{}\n</context>",
+                            resource.uri, resource.text
+                        ),
+                    });
+                }
+                acp::EmbeddedResourceResource::BlobResourceContents(_) => {
+                    // Unsupported by SDK
+                }
+            },
+            acp::ContentBlock::Image(acp::ImageContent {
+                data, mime_type, ..
+            }) => content.push(ContentChunk::Image {
+                source: ImageSource::Base64 {
+                    data,
+                    media_type: mime_type,
+                },
+            }),
+            acp::ContentBlock::Audio(_) => {
+                // Unsupported by SDK
+            }
+        }
+    }
+
+    content.extend(context);
+    content
+}
+
 fn new_request_id() -> String {
     use rand::Rng;
     // In the Claude Code TS SDK they just generate a random 12 character string,
@@ -879,7 +1093,7 @@ pub(crate) mod tests {
     use gpui::TestAppContext;
     use serde_json::json;
 
-    crate::common_e2e_tests!(ClaudeCode, allow_option_id = "allow");
+    crate::common_e2e_tests!(async |_, _, _| ClaudeCode, allow_option_id = "allow");
 
     pub fn local_command() -> AgentServerCommand {
         AgentServerCommand {
@@ -911,7 +1125,7 @@ pub(crate) mod tests {
 
         thread.read_with(cx, |thread, _| {
             entries_len = thread.plan().entries.len();
-            assert!(thread.plan().entries.len() > 0, "Empty plan");
+            assert!(!thread.plan().entries.is_empty(), "Empty plan");
         });
 
         thread
@@ -1062,4 +1276,100 @@ pub(crate) mod tests {
             _ => panic!("Expected ToolResult variant"),
         }
     }
+
+    #[test]
+    fn test_acp_content_to_claude() {
+        let acp_content = vec![
+            acp::ContentBlock::Text(acp::TextContent {
+                text: "Hello world".to_string(),
+                annotations: None,
+            }),
+            acp::ContentBlock::Image(acp::ImageContent {
+                data: "base64data".to_string(),
+                mime_type: "image/png".to_string(),
+                annotations: None,
+                uri: None,
+            }),
+            acp::ContentBlock::ResourceLink(acp::ResourceLink {
+                uri: "file:///path/to/example.rs".to_string(),
+                name: "example.rs".to_string(),
+                annotations: None,
+                description: None,
+                mime_type: None,
+                size: None,
+                title: None,
+            }),
+            acp::ContentBlock::Resource(acp::EmbeddedResource {
+                annotations: None,
+                resource: acp::EmbeddedResourceResource::TextResourceContents(
+                    acp::TextResourceContents {
+                        mime_type: None,
+                        text: "fn main() { println!(\"Hello!\"); }".to_string(),
+                        uri: "file:///path/to/code.rs".to_string(),
+                    },
+                ),
+            }),
+            acp::ContentBlock::ResourceLink(acp::ResourceLink {
+                uri: "invalid_uri_format".to_string(),
+                name: "invalid.txt".to_string(),
+                annotations: None,
+                description: None,
+                mime_type: None,
+                size: None,
+                title: None,
+            }),
+        ];
+
+        let claude_content = acp_content_to_claude(acp_content);
+
+        assert_eq!(claude_content.len(), 6);
+
+        match &claude_content[0] {
+            ContentChunk::Text { text } => assert_eq!(text, "Hello world"),
+            _ => panic!("Expected Text chunk"),
+        }
+
+        match &claude_content[1] {
+            ContentChunk::Image { source } => match source {
+                ImageSource::Base64 { data, media_type } => {
+                    assert_eq!(data, "base64data");
+                    assert_eq!(media_type, "image/png");
+                }
+                _ => panic!("Expected Base64 image source"),
+            },
+            _ => panic!("Expected Image chunk"),
+        }
+
+        match &claude_content[2] {
+            ContentChunk::Text { text } => {
+                assert!(text.contains("example.rs"));
+                assert!(text.contains("file:///path/to/example.rs"));
+            }
+            _ => panic!("Expected Text chunk for ResourceLink"),
+        }
+
+        match &claude_content[3] {
+            ContentChunk::Text { text } => {
+                assert!(text.contains("code.rs"));
+                assert!(text.contains("file:///path/to/code.rs"));
+            }
+            _ => panic!("Expected Text chunk for Resource"),
+        }
+
+        match &claude_content[4] {
+            ContentChunk::Text { text } => {
+                assert_eq!(text, "invalid_uri_format");
+            }
+            _ => panic!("Expected Text chunk for invalid URI"),
+        }
+
+        match &claude_content[5] {
+            ContentChunk::Text { text } => {
+                assert!(text.contains("<context ref=\"file:///path/to/code.rs\">"));
+                assert!(text.contains("fn main() { println!(\"Hello!\"); }"));
+                assert!(text.contains("</context>"));
+            }
+            _ => panic!("Expected Text chunk for context"),
+        }
+    }
 }

crates/agent_servers/src/claude/edit_tool.rs

@@ -0,0 +1,178 @@
+use acp_thread::AcpThread;
+use anyhow::Result;
+use context_server::{
+    listener::{McpServerTool, ToolResponse},
+    types::{ToolAnnotations, ToolResponseContent},
+};
+use gpui::{AsyncApp, WeakEntity};
+use language::unified_diff;
+use util::markdown::MarkdownCodeBlock;
+
+use crate::tools::EditToolParams;
+
+#[derive(Clone)]
+pub struct EditTool {
+    thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
+}
+
+impl EditTool {
+    pub fn new(thread_rx: watch::Receiver<WeakEntity<AcpThread>>) -> Self {
+        Self { thread_rx }
+    }
+}
+
+impl McpServerTool for EditTool {
+    type Input = EditToolParams;
+    type Output = ();
+
+    const NAME: &'static str = "Edit";
+
+    fn annotations(&self) -> ToolAnnotations {
+        ToolAnnotations {
+            title: Some("Edit file".to_string()),
+            read_only_hint: Some(false),
+            destructive_hint: Some(false),
+            open_world_hint: Some(false),
+            idempotent_hint: Some(false),
+        }
+    }
+
+    async fn run(
+        &self,
+        input: Self::Input,
+        cx: &mut AsyncApp,
+    ) -> Result<ToolResponse<Self::Output>> {
+        let mut thread_rx = self.thread_rx.clone();
+        let Some(thread) = thread_rx.recv().await?.upgrade() else {
+            anyhow::bail!("Thread closed");
+        };
+
+        let content = thread
+            .update(cx, |thread, cx| {
+                thread.read_text_file(input.abs_path.clone(), None, None, true, cx)
+            })?
+            .await?;
+
+        let (new_content, diff) = cx
+            .background_executor()
+            .spawn(async move {
+                let new_content = content.replace(&input.old_text, &input.new_text);
+                if new_content == content {
+                    return Err(anyhow::anyhow!("Failed to find `old_text`",));
+                }
+                let diff = unified_diff(&content, &new_content);
+
+                Ok((new_content, diff))
+            })
+            .await?;
+
+        thread
+            .update(cx, |thread, cx| {
+                thread.write_text_file(input.abs_path, new_content, cx)
+            })?
+            .await?;
+
+        Ok(ToolResponse {
+            content: vec![ToolResponseContent::Text {
+                text: MarkdownCodeBlock {
+                    tag: "diff",
+                    text: diff.as_str().trim_end_matches('\n'),
+                }
+                .to_string(),
+            }],
+            structured_content: (),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::rc::Rc;
+
+    use acp_thread::{AgentConnection, StubAgentConnection};
+    use gpui::{Entity, TestAppContext};
+    use indoc::indoc;
+    use project::{FakeFs, Project};
+    use serde_json::json;
+    use settings::SettingsStore;
+    use util::path;
+
+    use super::*;
+
+    #[gpui::test]
+    async fn old_text_not_found(cx: &mut TestAppContext) {
+        let (_thread, tool) = init_test(cx).await;
+
+        let result = tool
+            .run(
+                EditToolParams {
+                    abs_path: path!("/root/file.txt").into(),
+                    old_text: "hi".into(),
+                    new_text: "bye".into(),
+                },
+                &mut cx.to_async(),
+            )
+            .await;
+
+        assert_eq!(result.unwrap_err().to_string(), "Failed to find `old_text`");
+    }
+
+    #[gpui::test]
+    async fn found_and_replaced(cx: &mut TestAppContext) {
+        let (_thread, tool) = init_test(cx).await;
+
+        let result = tool
+            .run(
+                EditToolParams {
+                    abs_path: path!("/root/file.txt").into(),
+                    old_text: "hello".into(),
+                    new_text: "hi".into(),
+                },
+                &mut cx.to_async(),
+            )
+            .await;
+
+        assert_eq!(
+            result.unwrap().content[0].text().unwrap(),
+            indoc! {
+                r"
+                ```diff
+                @@ -1,1 +1,1 @@
+                -hello
+                +hi
+                ```
+                "
+            }
+        );
+    }
+
+    async fn init_test(cx: &mut TestAppContext) -> (Entity<AcpThread>, EditTool) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            language::init(cx);
+            Project::init_settings(cx);
+        });
+
+        let connection = Rc::new(StubAgentConnection::new());
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/root"),
+            json!({
+                "file.txt": "hello"
+            }),
+        )
+        .await;
+        let project = Project::test(fs, [path!("/root").as_ref()], cx).await;
+        let (mut thread_tx, thread_rx) = watch::channel(WeakEntity::new_invalid());
+
+        let thread = cx
+            .update(|cx| connection.new_thread(project, path!("/test").as_ref(), cx))
+            .await
+            .unwrap();
+
+        thread_tx.send(thread.downgrade()).unwrap();
+
+        (thread, EditTool::new(thread_rx))
+    }
+}

crates/agent_servers/src/claude/mcp_server.rs

@@ -1,18 +1,22 @@
 use std::path::PathBuf;
+use std::sync::Arc;
 
-use crate::claude::tools::{ClaudeTool, EditToolParams, ReadToolParams};
+use crate::claude::edit_tool::EditTool;
+use crate::claude::permission_tool::PermissionTool;
+use crate::claude::read_tool::ReadTool;
+use crate::claude::write_tool::WriteTool;
 use acp_thread::AcpThread;
-use agent_client_protocol as acp;
-use anyhow::{Context, Result};
+#[cfg(not(test))]
+use anyhow::Context as _;
+use anyhow::Result;
 use collections::HashMap;
-use context_server::listener::{McpServerTool, ToolResponse};
 use context_server::types::{
     Implementation, InitializeParams, InitializeResponse, ProtocolVersion, ServerCapabilities,
-    ToolAnnotations, ToolResponseContent, ToolsCapabilities, requests,
+    ToolsCapabilities, requests,
 };
 use gpui::{App, AsyncApp, Task, WeakEntity};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use project::Fs;
+use serde::Serialize;
 
 pub struct ClaudeZedMcpServer {
     server: context_server::listener::McpServer,
@@ -23,20 +27,16 @@ pub const SERVER_NAME: &str = "zed";
 impl ClaudeZedMcpServer {
     pub async fn new(
         thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
+        fs: Arc<dyn Fs>,
         cx: &AsyncApp,
     ) -> Result<Self> {
         let mut mcp_server = context_server::listener::McpServer::new(cx).await?;
         mcp_server.handle_request::<requests::Initialize>(Self::handle_initialize);
 
-        mcp_server.add_tool(PermissionTool {
-            thread_rx: thread_rx.clone(),
-        });
-        mcp_server.add_tool(ReadTool {
-            thread_rx: thread_rx.clone(),
-        });
-        mcp_server.add_tool(EditTool {
-            thread_rx: thread_rx.clone(),
-        });
+        mcp_server.add_tool(PermissionTool::new(fs.clone(), thread_rx.clone()));
+        mcp_server.add_tool(ReadTool::new(thread_rx.clone()));
+        mcp_server.add_tool(EditTool::new(thread_rx.clone()));
+        mcp_server.add_tool(WriteTool::new(thread_rx.clone()));
 
         Ok(Self { server: mcp_server })
     }
@@ -97,206 +97,3 @@ pub struct McpServerConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub env: Option<HashMap<String, String>>,
 }
-
-// Tools
-
-#[derive(Clone)]
-pub struct PermissionTool {
-    thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
-}
-
-#[derive(Deserialize, JsonSchema, Debug)]
-pub struct PermissionToolParams {
-    tool_name: String,
-    input: serde_json::Value,
-    tool_use_id: Option<String>,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct PermissionToolResponse {
-    behavior: PermissionToolBehavior,
-    updated_input: serde_json::Value,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "snake_case")]
-enum PermissionToolBehavior {
-    Allow,
-    Deny,
-}
-
-impl McpServerTool for PermissionTool {
-    type Input = PermissionToolParams;
-    type Output = ();
-
-    const NAME: &'static str = "Confirmation";
-
-    fn description(&self) -> &'static str {
-        "Request permission for tool calls"
-    }
-
-    async fn run(
-        &self,
-        input: Self::Input,
-        cx: &mut AsyncApp,
-    ) -> Result<ToolResponse<Self::Output>> {
-        let mut thread_rx = self.thread_rx.clone();
-        let Some(thread) = thread_rx.recv().await?.upgrade() else {
-            anyhow::bail!("Thread closed");
-        };
-
-        let claude_tool = ClaudeTool::infer(&input.tool_name, input.input.clone());
-        let tool_call_id = acp::ToolCallId(input.tool_use_id.context("Tool ID required")?.into());
-        let allow_option_id = acp::PermissionOptionId("allow".into());
-        let reject_option_id = acp::PermissionOptionId("reject".into());
-
-        let chosen_option = thread
-            .update(cx, |thread, cx| {
-                thread.request_tool_call_authorization(
-                    claude_tool.as_acp(tool_call_id),
-                    vec![
-                        acp::PermissionOption {
-                            id: allow_option_id.clone(),
-                            name: "Allow".into(),
-                            kind: acp::PermissionOptionKind::AllowOnce,
-                        },
-                        acp::PermissionOption {
-                            id: reject_option_id.clone(),
-                            name: "Reject".into(),
-                            kind: acp::PermissionOptionKind::RejectOnce,
-                        },
-                    ],
-                    cx,
-                )
-            })?
-            .await?;
-
-        let response = if chosen_option == allow_option_id {
-            PermissionToolResponse {
-                behavior: PermissionToolBehavior::Allow,
-                updated_input: input.input,
-            }
-        } else {
-            debug_assert_eq!(chosen_option, reject_option_id);
-            PermissionToolResponse {
-                behavior: PermissionToolBehavior::Deny,
-                updated_input: input.input,
-            }
-        };
-
-        Ok(ToolResponse {
-            content: vec![ToolResponseContent::Text {
-                text: serde_json::to_string(&response)?,
-            }],
-            structured_content: (),
-        })
-    }
-}
-
-#[derive(Clone)]
-pub struct ReadTool {
-    thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
-}
-
-impl McpServerTool for ReadTool {
-    type Input = ReadToolParams;
-    type Output = ();
-
-    const NAME: &'static str = "Read";
-
-    fn description(&self) -> &'static str {
-        "Read the contents of a file. In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents."
-    }
-
-    fn annotations(&self) -> ToolAnnotations {
-        ToolAnnotations {
-            title: Some("Read file".to_string()),
-            read_only_hint: Some(true),
-            destructive_hint: Some(false),
-            open_world_hint: Some(false),
-            idempotent_hint: None,
-        }
-    }
-
-    async fn run(
-        &self,
-        input: Self::Input,
-        cx: &mut AsyncApp,
-    ) -> Result<ToolResponse<Self::Output>> {
-        let mut thread_rx = self.thread_rx.clone();
-        let Some(thread) = thread_rx.recv().await?.upgrade() else {
-            anyhow::bail!("Thread closed");
-        };
-
-        let content = thread
-            .update(cx, |thread, cx| {
-                thread.read_text_file(input.abs_path, input.offset, input.limit, false, cx)
-            })?
-            .await?;
-
-        Ok(ToolResponse {
-            content: vec![ToolResponseContent::Text { text: content }],
-            structured_content: (),
-        })
-    }
-}
-
-#[derive(Clone)]
-pub struct EditTool {
-    thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
-}
-
-impl McpServerTool for EditTool {
-    type Input = EditToolParams;
-    type Output = ();
-
-    const NAME: &'static str = "Edit";
-
-    fn description(&self) -> &'static str {
-        "Edits a file. In sessions with mcp__zed__Edit always use it instead of Edit as it will show the diff to the user better."
-    }
-
-    fn annotations(&self) -> ToolAnnotations {
-        ToolAnnotations {
-            title: Some("Edit file".to_string()),
-            read_only_hint: Some(false),
-            destructive_hint: Some(false),
-            open_world_hint: Some(false),
-            idempotent_hint: Some(false),
-        }
-    }
-
-    async fn run(
-        &self,
-        input: Self::Input,
-        cx: &mut AsyncApp,
-    ) -> Result<ToolResponse<Self::Output>> {
-        let mut thread_rx = self.thread_rx.clone();
-        let Some(thread) = thread_rx.recv().await?.upgrade() else {
-            anyhow::bail!("Thread closed");
-        };
-
-        let content = thread
-            .update(cx, |thread, cx| {
-                thread.read_text_file(input.abs_path.clone(), None, None, true, cx)
-            })?
-            .await?;
-
-        let new_content = content.replace(&input.old_text, &input.new_text);
-        if new_content == content {
-            return Err(anyhow::anyhow!("The old_text was not found in the content"));
-        }
-
-        thread
-            .update(cx, |thread, cx| {
-                thread.write_text_file(input.abs_path, new_content, cx)
-            })?
-            .await?;
-
-        Ok(ToolResponse {
-            content: vec![],
-            structured_content: (),
-        })
-    }
-}

crates/agent_servers/src/claude/permission_tool.rs

@@ -0,0 +1,158 @@
+use std::sync::Arc;
+
+use acp_thread::AcpThread;
+use agent_client_protocol as acp;
+use agent_settings::AgentSettings;
+use anyhow::{Context as _, Result};
+use context_server::{
+    listener::{McpServerTool, ToolResponse},
+    types::ToolResponseContent,
+};
+use gpui::{AsyncApp, WeakEntity};
+use project::Fs;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{Settings as _, update_settings_file};
+use util::debug_panic;
+
+use crate::tools::ClaudeTool;
+
+#[derive(Clone)]
+pub struct PermissionTool {
+    fs: Arc<dyn Fs>,
+    thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
+}
+
+/// Request permission for tool calls
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct PermissionToolParams {
+    tool_name: String,
+    input: serde_json::Value,
+    tool_use_id: Option<String>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PermissionToolResponse {
+    behavior: PermissionToolBehavior,
+    updated_input: serde_json::Value,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+enum PermissionToolBehavior {
+    Allow,
+    Deny,
+}
+
+impl PermissionTool {
+    pub fn new(fs: Arc<dyn Fs>, thread_rx: watch::Receiver<WeakEntity<AcpThread>>) -> Self {
+        Self { fs, thread_rx }
+    }
+}
+
+impl McpServerTool for PermissionTool {
+    type Input = PermissionToolParams;
+    type Output = ();
+
+    const NAME: &'static str = "Confirmation";
+
+    async fn run(
+        &self,
+        input: Self::Input,
+        cx: &mut AsyncApp,
+    ) -> Result<ToolResponse<Self::Output>> {
+        if agent_settings::AgentSettings::try_read_global(cx, |settings| {
+            settings.always_allow_tool_actions
+        })
+        .unwrap_or(false)
+        {
+            let response = PermissionToolResponse {
+                behavior: PermissionToolBehavior::Allow,
+                updated_input: input.input,
+            };
+
+            return Ok(ToolResponse {
+                content: vec![ToolResponseContent::Text {
+                    text: serde_json::to_string(&response)?,
+                }],
+                structured_content: (),
+            });
+        }
+
+        let mut thread_rx = self.thread_rx.clone();
+        let Some(thread) = thread_rx.recv().await?.upgrade() else {
+            anyhow::bail!("Thread closed");
+        };
+
+        let claude_tool = ClaudeTool::infer(&input.tool_name, input.input.clone());
+        let tool_call_id = acp::ToolCallId(input.tool_use_id.context("Tool ID required")?.into());
+
+        const ALWAYS_ALLOW: &str = "always_allow";
+        const ALLOW: &str = "allow";
+        const REJECT: &str = "reject";
+
+        let chosen_option = thread
+            .update(cx, |thread, cx| {
+                thread.request_tool_call_authorization(
+                    claude_tool.as_acp(tool_call_id).into(),
+                    vec![
+                        acp::PermissionOption {
+                            id: acp::PermissionOptionId(ALWAYS_ALLOW.into()),
+                            name: "Always Allow".into(),
+                            kind: acp::PermissionOptionKind::AllowAlways,
+                        },
+                        acp::PermissionOption {
+                            id: acp::PermissionOptionId(ALLOW.into()),
+                            name: "Allow".into(),
+                            kind: acp::PermissionOptionKind::AllowOnce,
+                        },
+                        acp::PermissionOption {
+                            id: acp::PermissionOptionId(REJECT.into()),
+                            name: "Reject".into(),
+                            kind: acp::PermissionOptionKind::RejectOnce,
+                        },
+                    ],
+                    cx,
+                )
+            })??
+            .await?;
+
+        let response = match chosen_option.0.as_ref() {
+            ALWAYS_ALLOW => {
+                cx.update(|cx| {
+                    update_settings_file::<AgentSettings>(self.fs.clone(), cx, |settings, _| {
+                        settings.set_always_allow_tool_actions(true);
+                    });
+                })?;
+
+                PermissionToolResponse {
+                    behavior: PermissionToolBehavior::Allow,
+                    updated_input: input.input,
+                }
+            }
+            ALLOW => PermissionToolResponse {
+                behavior: PermissionToolBehavior::Allow,
+                updated_input: input.input,
+            },
+            REJECT => PermissionToolResponse {
+                behavior: PermissionToolBehavior::Deny,
+                updated_input: input.input,
+            },
+            opt => {
+                debug_panic!("Unexpected option: {}", opt);
+                PermissionToolResponse {
+                    behavior: PermissionToolBehavior::Deny,
+                    updated_input: input.input,
+                }
+            }
+        };
+
+        Ok(ToolResponse {
+            content: vec![ToolResponseContent::Text {
+                text: serde_json::to_string(&response)?,
+            }],
+            structured_content: (),
+        })
+    }
+}

crates/agent_servers/src/claude/read_tool.rs

@@ -0,0 +1,59 @@
+use acp_thread::AcpThread;
+use anyhow::Result;
+use context_server::{
+    listener::{McpServerTool, ToolResponse},
+    types::{ToolAnnotations, ToolResponseContent},
+};
+use gpui::{AsyncApp, WeakEntity};
+
+use crate::tools::ReadToolParams;
+
+#[derive(Clone)]
+pub struct ReadTool {
+    thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
+}
+
+impl ReadTool {
+    pub fn new(thread_rx: watch::Receiver<WeakEntity<AcpThread>>) -> Self {
+        Self { thread_rx }
+    }
+}
+
+impl McpServerTool for ReadTool {
+    type Input = ReadToolParams;
+    type Output = ();
+
+    const NAME: &'static str = "Read";
+
+    fn annotations(&self) -> ToolAnnotations {
+        ToolAnnotations {
+            title: Some("Read file".to_string()),
+            read_only_hint: Some(true),
+            destructive_hint: Some(false),
+            open_world_hint: Some(false),
+            idempotent_hint: None,
+        }
+    }
+
+    async fn run(
+        &self,
+        input: Self::Input,
+        cx: &mut AsyncApp,
+    ) -> Result<ToolResponse<Self::Output>> {
+        let mut thread_rx = self.thread_rx.clone();
+        let Some(thread) = thread_rx.recv().await?.upgrade() else {
+            anyhow::bail!("Thread closed");
+        };
+
+        let content = thread
+            .update(cx, |thread, cx| {
+                thread.read_text_file(input.abs_path, input.offset, input.limit, false, cx)
+            })?
+            .await?;
+
+        Ok(ToolResponse {
+            content: vec![ToolResponseContent::Text { text: content }],
+            structured_content: (),
+        })
+    }
+}

crates/agent_servers/src/claude/tools.rs

@@ -34,6 +34,7 @@ impl ClaudeTool {
             // Known tools
             "mcp__zed__Read" => Self::ReadFile(serde_json::from_value(input).log_err()),
             "mcp__zed__Edit" => Self::Edit(serde_json::from_value(input).log_err()),
+            "mcp__zed__Write" => Self::Write(serde_json::from_value(input).log_err()),
             "MultiEdit" => Self::MultiEdit(serde_json::from_value(input).log_err()),
             "Write" => Self::Write(serde_json::from_value(input).log_err()),
             "LS" => Self::Ls(serde_json::from_value(input).log_err()),
@@ -57,7 +58,7 @@ impl ClaudeTool {
                     Self::Terminal(None)
                 } else {
                     Self::Other {
-                        name: tool_name.to_string(),
+                        name: tool_name,
                         input,
                     }
                 }
@@ -93,7 +94,7 @@ impl ClaudeTool {
             }
             Self::MultiEdit(None) => "Multi Edit".into(),
             Self::Write(Some(params)) => {
-                format!("Write {}", params.file_path.display())
+                format!("Write {}", params.abs_path.display())
             }
             Self::Write(None) => "Write".into(),
             Self::Glob(Some(params)) => {
@@ -153,7 +154,7 @@ impl ClaudeTool {
             }],
             Self::Write(Some(params)) => vec![acp::ToolCallContent::Diff {
                 diff: acp::Diff {
-                    path: params.file_path.clone(),
+                    path: params.abs_path.clone(),
                     old_text: None,
                     new_text: params.content.clone(),
                 },
@@ -229,7 +230,10 @@ impl ClaudeTool {
                     line: None,
                 }]
             }
-            Self::Write(Some(WriteToolParams { file_path, .. })) => {
+            Self::Write(Some(WriteToolParams {
+                abs_path: file_path,
+                ..
+            })) => {
                 vec![acp::ToolCallLocation {
                     path: file_path.clone(),
                     line: None,
@@ -302,6 +306,20 @@ impl ClaudeTool {
     }
 }
 
+/// Edit a file.
+///
+/// In sessions with mcp__zed__Edit always use it instead of Edit as it will
+/// allow the user to conveniently review changes.
+///
+/// File editing instructions:
+/// - The `old_text` param must match existing file content, including indentation.
+/// - The `old_text` param must come from the actual file, not an outline.
+/// - The `old_text` section must not be empty.
+/// - Be minimal with replacements:
+///     - For unique lines, include only those lines.
+///     - For non-unique lines, include enough context to identify them.
+/// - Do not escape quotes, newlines, or other characters.
+/// - Only edit the specified file.
 #[derive(Deserialize, JsonSchema, Debug)]
 pub struct EditToolParams {
     /// The absolute path to the file to read.
@@ -312,6 +330,11 @@ pub struct EditToolParams {
     pub new_text: String,
 }
 
+/// Reads the content of the given file in the project.
+///
+/// Never attempt to read a path that hasn't been previously mentioned.
+///
+/// In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents.
 #[derive(Deserialize, JsonSchema, Debug)]
 pub struct ReadToolParams {
     /// The absolute path to the file to read.
@@ -324,11 +347,15 @@ pub struct ReadToolParams {
     pub limit: Option<u32>,
 }
 
+/// Writes content to the specified file in the project.
+///
+/// In sessions with mcp__zed__Write always use it instead of Write as it will
+/// allow the user to conveniently review changes.
 #[derive(Deserialize, JsonSchema, Debug)]
 pub struct WriteToolParams {
-    /// Absolute path for new file
-    pub file_path: PathBuf,
-    /// File content
+    /// The absolute path of the file to write.
+    pub abs_path: PathBuf,
+    /// The full content to write.
     pub content: String,
 }
 

crates/agent_servers/src/claude/write_tool.rs

@@ -0,0 +1,59 @@
+use acp_thread::AcpThread;
+use anyhow::Result;
+use context_server::{
+    listener::{McpServerTool, ToolResponse},
+    types::ToolAnnotations,
+};
+use gpui::{AsyncApp, WeakEntity};
+
+use crate::tools::WriteToolParams;
+
+#[derive(Clone)]
+pub struct WriteTool {
+    thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
+}
+
+impl WriteTool {
+    pub fn new(thread_rx: watch::Receiver<WeakEntity<AcpThread>>) -> Self {
+        Self { thread_rx }
+    }
+}
+
+impl McpServerTool for WriteTool {
+    type Input = WriteToolParams;
+    type Output = ();
+
+    const NAME: &'static str = "Write";
+
+    fn annotations(&self) -> ToolAnnotations {
+        ToolAnnotations {
+            title: Some("Write file".to_string()),
+            read_only_hint: Some(false),
+            destructive_hint: Some(false),
+            open_world_hint: Some(false),
+            idempotent_hint: Some(false),
+        }
+    }
+
+    async fn run(
+        &self,
+        input: Self::Input,
+        cx: &mut AsyncApp,
+    ) -> Result<ToolResponse<Self::Output>> {
+        let mut thread_rx = self.thread_rx.clone();
+        let Some(thread) = thread_rx.recv().await?.upgrade() else {
+            anyhow::bail!("Thread closed");
+        };
+
+        thread
+            .update(cx, |thread, cx| {
+                thread.write_text_file(input.abs_path, input.content, cx)
+            })?
+            .await?;
+
+        Ok(ToolResponse {
+            content: vec![],
+            structured_content: (),
+        })
+    }
+}

crates/agent_servers/src/e2e_tests.rs

@@ -4,21 +4,30 @@ use std::{
     time::Duration,
 };
 
-use crate::{AgentServer, AgentServerSettings, AllAgentServersSettings};
+use crate::AgentServer;
 use acp_thread::{AcpThread, AgentThreadEntry, ToolCall, ToolCallStatus};
 use agent_client_protocol as acp;
 
 use futures::{FutureExt, StreamExt, channel::mpsc, select};
-use gpui::{Entity, TestAppContext};
+use gpui::{AppContext, Entity, TestAppContext};
 use indoc::indoc;
 use project::{FakeFs, Project};
-use settings::{Settings, SettingsStore};
 use util::path;
 
-pub async fn test_basic(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
-    let fs = init_test(cx).await;
-    let project = Project::test(fs, [], cx).await;
-    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+pub async fn test_basic<T, F>(server: F, cx: &mut TestAppContext)
+where
+    T: AgentServer + 'static,
+    F: AsyncFn(&Arc<dyn fs::Fs>, &Entity<Project>, &mut TestAppContext) -> T,
+{
+    let fs = init_test(cx).await as Arc<dyn fs::Fs>;
+    let project = Project::test(fs.clone(), [], cx).await;
+    let thread = new_test_thread(
+        server(&fs, &project, cx).await,
+        project.clone(),
+        "/private/tmp",
+        cx,
+    )
+    .await;
 
     thread
         .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx))
@@ -42,8 +51,12 @@ pub async fn test_basic(server: impl AgentServer + 'static, cx: &mut TestAppCont
     });
 }
 
-pub async fn test_path_mentions(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
-    let _fs = init_test(cx).await;
+pub async fn test_path_mentions<T, F>(server: F, cx: &mut TestAppContext)
+where
+    T: AgentServer + 'static,
+    F: AsyncFn(&Arc<dyn fs::Fs>, &Entity<Project>, &mut TestAppContext) -> T,
+{
+    let fs = init_test(cx).await as _;
 
     let tempdir = tempfile::tempdir().unwrap();
     std::fs::write(
@@ -56,7 +69,13 @@ pub async fn test_path_mentions(server: impl AgentServer + 'static, cx: &mut Tes
     )
     .expect("failed to write file");
     let project = Project::example([tempdir.path()], &mut cx.to_async()).await;
-    let thread = new_test_thread(server, project.clone(), tempdir.path(), cx).await;
+    let thread = new_test_thread(
+        server(&fs, &project, cx).await,
+        project.clone(),
+        tempdir.path(),
+        cx,
+    )
+    .await;
     thread
         .update(cx, |thread, cx| {
             thread.send(
@@ -110,15 +129,25 @@ pub async fn test_path_mentions(server: impl AgentServer + 'static, cx: &mut Tes
     drop(tempdir);
 }
 
-pub async fn test_tool_call(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
-    let _fs = init_test(cx).await;
+pub async fn test_tool_call<T, F>(server: F, cx: &mut TestAppContext)
+where
+    T: AgentServer + 'static,
+    F: AsyncFn(&Arc<dyn fs::Fs>, &Entity<Project>, &mut TestAppContext) -> T,
+{
+    let fs = init_test(cx).await as _;
 
     let tempdir = tempfile::tempdir().unwrap();
     let foo_path = tempdir.path().join("foo");
     std::fs::write(&foo_path, "Lorem ipsum dolor").expect("failed to write file");
 
     let project = Project::example([tempdir.path()], &mut cx.to_async()).await;
-    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+    let thread = new_test_thread(
+        server(&fs, &project, cx).await,
+        project.clone(),
+        "/private/tmp",
+        cx,
+    )
+    .await;
 
     thread
         .update(cx, |thread, cx| {
@@ -134,7 +163,9 @@ pub async fn test_tool_call(server: impl AgentServer + 'static, cx: &mut TestApp
             matches!(
                 entry,
                 AgentThreadEntry::ToolCall(ToolCall {
-                    status: ToolCallStatus::Allowed { .. },
+                    status: ToolCallStatus::Pending
+                        | ToolCallStatus::InProgress
+                        | ToolCallStatus::Completed,
                     ..
                 })
             )
@@ -150,14 +181,23 @@ pub async fn test_tool_call(server: impl AgentServer + 'static, cx: &mut TestApp
     drop(tempdir);
 }
 
-pub async fn test_tool_call_with_permission(
-    server: impl AgentServer + 'static,
+pub async fn test_tool_call_with_permission<T, F>(
+    server: F,
     allow_option_id: acp::PermissionOptionId,
     cx: &mut TestAppContext,
-) {
-    let fs = init_test(cx).await;
-    let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
-    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+) where
+    T: AgentServer + 'static,
+    F: AsyncFn(&Arc<dyn fs::Fs>, &Entity<Project>, &mut TestAppContext) -> T,
+{
+    let fs = init_test(cx).await as Arc<dyn fs::Fs>;
+    let project = Project::test(fs.clone(), [path!("/private/tmp").as_ref()], cx).await;
+    let thread = new_test_thread(
+        server(&fs, &project, cx).await,
+        project.clone(),
+        "/private/tmp",
+        cx,
+    )
+    .await;
     let full_turn = thread.update(cx, |thread, cx| {
         thread.send_raw(
             r#"Run exactly `touch hello.txt && echo "Hello, world!" | tee hello.txt` in the terminal."#,
@@ -212,7 +252,9 @@ pub async fn test_tool_call_with_permission(
         assert!(thread.entries().iter().any(|entry| matches!(
             entry,
             AgentThreadEntry::ToolCall(ToolCall {
-                status: ToolCallStatus::Allowed { .. },
+                status: ToolCallStatus::Pending
+                    | ToolCallStatus::InProgress
+                    | ToolCallStatus::Completed,
                 ..
             })
         )));
@@ -223,7 +265,9 @@ pub async fn test_tool_call_with_permission(
     thread.read_with(cx, |thread, cx| {
         let AgentThreadEntry::ToolCall(ToolCall {
             content,
-            status: ToolCallStatus::Allowed { .. },
+            status: ToolCallStatus::Pending
+                | ToolCallStatus::InProgress
+                | ToolCallStatus::Completed,
             ..
         }) = thread
             .entries()
@@ -241,11 +285,21 @@ pub async fn test_tool_call_with_permission(
     });
 }
 
-pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
-    let fs = init_test(cx).await;
+pub async fn test_cancel<T, F>(server: F, cx: &mut TestAppContext)
+where
+    T: AgentServer + 'static,
+    F: AsyncFn(&Arc<dyn fs::Fs>, &Entity<Project>, &mut TestAppContext) -> T,
+{
+    let fs = init_test(cx).await as Arc<dyn fs::Fs>;
 
-    let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
-    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+    let project = Project::test(fs.clone(), [path!("/private/tmp").as_ref()], cx).await;
+    let thread = new_test_thread(
+        server(&fs, &project, cx).await,
+        project.clone(),
+        "/private/tmp",
+        cx,
+    )
+    .await;
     let _ = thread.update(cx, |thread, cx| {
         thread.send_raw(
             r#"Run exactly `touch hello.txt && echo "Hello, world!" | tee hello.txt` in the terminal."#,
@@ -310,10 +364,20 @@ pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppCon
     });
 }
 
-pub async fn test_thread_drop(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
-    let fs = init_test(cx).await;
-    let project = Project::test(fs, [], cx).await;
-    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+pub async fn test_thread_drop<T, F>(server: F, cx: &mut TestAppContext)
+where
+    T: AgentServer + 'static,
+    F: AsyncFn(&Arc<dyn fs::Fs>, &Entity<Project>, &mut TestAppContext) -> T,
+{
+    let fs = init_test(cx).await as Arc<dyn fs::Fs>;
+    let project = Project::test(fs.clone(), [], cx).await;
+    let thread = new_test_thread(
+        server(&fs, &project, cx).await,
+        project.clone(),
+        "/private/tmp",
+        cx,
+    )
+    .await;
 
     thread
         .update(cx, |thread, cx| thread.send_raw("Hello from test!", cx))
@@ -380,25 +444,39 @@ macro_rules! common_e2e_tests {
         }
     };
 }
+pub use common_e2e_tests;
 
 // Helpers
 
 pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {
+    #[cfg(test)]
+    use settings::Settings;
+
     env_logger::try_init().ok();
 
     cx.update(|cx| {
-        let settings_store = SettingsStore::test(cx);
+        let settings_store = settings::SettingsStore::test(cx);
         cx.set_global(settings_store);
         Project::init_settings(cx);
         language::init(cx);
+        gpui_tokio::init(cx);
+        let http_client = reqwest_client::ReqwestClient::user_agent("agent tests").unwrap();
+        cx.set_http_client(Arc::new(http_client));
+        client::init_settings(cx);
+        let client = client::Client::production(cx);
+        let user_store = cx.new(|cx| client::UserStore::new(client.clone(), cx));
+        language_model::init(client.clone(), cx);
+        language_models::init(user_store, client, cx);
+        agent_settings::init(cx);
         crate::settings::init(cx);
 
+        #[cfg(test)]
         crate::AllAgentServersSettings::override_global(
-            AllAgentServersSettings {
-                claude: Some(AgentServerSettings {
+            crate::AllAgentServersSettings {
+                claude: Some(crate::AgentServerSettings {
                     command: crate::claude::tests::local_command(),
                 }),
-                gemini: Some(AgentServerSettings {
+                gemini: Some(crate::AgentServerSettings {
                     command: crate::gemini::tests::local_command(),
                 }),
             },
@@ -422,12 +500,9 @@ pub async fn new_test_thread(
         .await
         .unwrap();
 
-    let thread = connection
-        .new_thread(project.clone(), current_dir.as_ref(), &mut cx.to_async())
+    cx.update(|cx| connection.new_thread(project.clone(), current_dir.as_ref(), cx))
         .await
-        .unwrap();
-
-    thread
+        .unwrap()
 }
 
 pub async fn run_until_first_tool_call(
@@ -465,7 +540,7 @@ pub fn get_zed_path() -> PathBuf {
 
     while zed_path
         .file_name()
-        .map_or(true, |name| name.to_string_lossy() != "debug")
+        .is_none_or(|name| name.to_string_lossy() != "debug")
     {
         if !zed_path.pop() {
             panic!("Could not find target directory");

crates/agent_servers/src/gemini.rs

@@ -1,10 +1,11 @@
-use std::path::Path;
 use std::rc::Rc;
+use std::{any::Any, path::Path};
 
 use crate::{AgentServer, AgentServerCommand};
 use acp_thread::{AgentConnection, LoadError};
 use anyhow::Result;
 use gpui::{Entity, Task};
+use language_models::provider::google::GoogleLanguageModelProvider;
 use project::Project;
 use settings::SettingsStore;
 use ui::App;
@@ -18,15 +19,15 @@ const ACP_ARG: &str = "--experimental-acp";
 
 impl AgentServer for Gemini {
     fn name(&self) -> &'static str {
-        "Gemini"
+        "Gemini CLI"
     }
 
     fn empty_state_headline(&self) -> &'static str {
-        "Welcome to Gemini"
+        "Welcome to Gemini CLI"
     }
 
     fn empty_state_message(&self) -> &'static str {
-        "Ask questions, edit files, run commands.\nBe specific for the best results."
+        "Ask questions, edit files, run commands"
     }
 
     fn logo(&self) -> ui::IconName {
@@ -47,12 +48,20 @@ impl AgentServer for Gemini {
                 settings.get::<AllAgentServersSettings>(None).gemini.clone()
             })?;
 
-            let Some(command) =
+            let Some(mut command) =
                 AgentServerCommand::resolve("gemini", &[ACP_ARG], None, settings, &project, cx).await
             else {
-                anyhow::bail!("Failed to find gemini binary");
+                return Err(LoadError::NotInstalled {
+                    error_message: "Failed to find Gemini CLI binary".into(),
+                    install_message: "Install Gemini CLI".into(),
+                    install_command: "npm install -g @google/gemini-cli@preview".into()
+                }.into());
             };
 
+            if let Some(api_key)= cx.update(GoogleLanguageModelProvider::api_key)?.await.ok() {
+                command.env.get_or_insert_default().insert("GEMINI_API_KEY".to_owned(), api_key.key);
+            }
+
             let result = crate::acp::connect(server_name, command.clone(), &root_dir, cx).await;
             if result.is_err() {
                 let version_fut = util::command::new_smol_command(&command.path)
@@ -75,17 +84,22 @@ impl AgentServer for Gemini {
                 if !supported {
                     return Err(LoadError::Unsupported {
                         error_message: format!(
-                            "Your installed version of Gemini {} doesn't support the Agentic Coding Protocol (ACP).",
+                            "Your installed version of Gemini CLI ({}, version {}) doesn't support the Agentic Coding Protocol (ACP).",
+                            command.path.to_string_lossy(),
                             current_version
                         ).into(),
-                        upgrade_message: "Upgrade Gemini to Latest".into(),
-                        upgrade_command: "npm install -g @google/gemini-cli@latest".into(),
+                        upgrade_message: "Upgrade Gemini CLI to latest".into(),
+                        upgrade_command: "npm install -g @google/gemini-cli@preview".into(),
                     }.into())
                 }
             }
             result
         })
     }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }
 
 #[cfg(test)]
@@ -94,7 +108,7 @@ pub(crate) mod tests {
     use crate::AgentServerCommand;
     use std::path::Path;
 
-    crate::common_e2e_tests!(Gemini, allow_option_id = "proceed_once");
+    crate::common_e2e_tests!(async |_, _, _| Gemini, allow_option_id = "proceed_once");
 
     pub fn local_command() -> AgentServerCommand {
         let cli_path = Path::new(env!("CARGO_MANIFEST_DIR"))

crates/agent_settings/src/agent_profile.rs

@@ -48,6 +48,20 @@ pub struct AgentProfileSettings {
     pub context_servers: IndexMap<Arc<str>, ContextServerPreset>,
 }
 
+impl AgentProfileSettings {
+    pub fn is_tool_enabled(&self, tool_name: &str) -> bool {
+        self.tools.get(tool_name) == Some(&true)
+    }
+
+    pub fn is_context_server_tool_enabled(&self, server_id: &str, tool_name: &str) -> bool {
+        self.enable_all_context_servers
+            || self
+                .context_servers
+                .get(server_id)
+                .is_some_and(|preset| preset.tools.get(tool_name) == Some(&true))
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct ContextServerPreset {
     pub tools: IndexMap<Arc<str>, bool>,

crates/agent_settings/src/agent_settings.rs

@@ -15,6 +15,8 @@ pub use crate::agent_profile::*;
 
 pub const SUMMARIZE_THREAD_PROMPT: &str =
     include_str!("../../agent/src/prompts/summarize_thread_prompt.txt");
+pub const SUMMARIZE_THREAD_DETAILED_PROMPT: &str =
+    include_str!("../../agent/src/prompts/summarize_thread_detailed_prompt.txt");
 
 pub fn init(cx: &mut App) {
     AgentSettings::register(cx);
@@ -116,15 +118,15 @@ pub struct LanguageModelParameters {
 
 impl LanguageModelParameters {
     pub fn matches(&self, model: &Arc<dyn LanguageModel>) -> bool {
-        if let Some(provider) = &self.provider {
-            if provider.0 != model.provider_id().0 {
-                return false;
-            }
+        if let Some(provider) = &self.provider
+            && provider.0 != model.provider_id().0
+        {
+            return false;
         }
-        if let Some(setting_model) = &self.model {
-            if *setting_model != model.id().0 {
-                return false;
-            }
+        if let Some(setting_model) = &self.model
+            && *setting_model != model.id().0
+        {
+            return false;
         }
         true
     }
@@ -309,7 +311,7 @@ pub struct AgentSettingsContent {
     ///
     /// Default: true
     expand_terminal_card: Option<bool>,
-    /// Whether to always use cmd-enter (or ctrl-enter on Linux) to send messages in the agent panel.
+    /// Whether to always use cmd-enter (or ctrl-enter on Linux or Windows) to send messages in the agent panel.
     ///
     /// Default: false
     use_modifier_to_send: Option<bool>,
@@ -442,10 +444,6 @@ impl Settings for AgentSettings {
                 &mut settings.inline_alternatives,
                 value.inline_alternatives.clone(),
             );
-            merge(
-                &mut settings.always_allow_tool_actions,
-                value.always_allow_tool_actions,
-            );
             merge(
                 &mut settings.notify_when_agent_waiting,
                 value.notify_when_agent_waiting,
@@ -507,6 +505,19 @@ impl Settings for AgentSettings {
             }
         }
 
+        debug_assert!(
+            !sources.default.always_allow_tool_actions.unwrap_or(false),
+            "For security, agent.always_allow_tool_actions should always be false in default.json. If it's true, that is a bug that should be fixed!"
+        );
+
+        // For security reasons, only trust the user's global settings for whether to always allow tool actions.
+        // If this could be overridden locally, an attacker could (e.g. by committing to source control and
+        // convincing you to switch branches) modify your project-local settings to disable the agent's safety checks.
+        settings.always_allow_tool_actions = sources
+            .user
+            .and_then(|setting| setting.always_allow_tool_actions)
+            .unwrap_or(false);
+
         Ok(settings)
     }
 

crates/agent_ui/Cargo.toml

@@ -17,6 +17,7 @@ test-support = ["gpui/test-support", "language/test-support"]
 
 [dependencies]
 acp_thread.workspace = true
+action_log.workspace = true
 agent-client-protocol.workspace = true
 agent.workspace = true
 agent2.workspace = true
@@ -49,7 +50,6 @@ fuzzy.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
 http_client.workspace = true
-indexed_docs.workspace = true
 indoc.workspace = true
 inventory.workspace = true
 itertools.workspace = true
@@ -92,6 +92,7 @@ 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
@@ -101,8 +102,13 @@ workspace.workspace = true
 zed_actions.workspace = true
 
 [dev-dependencies]
+acp_thread = { workspace = true, features = ["test-support"] }
+agent = { workspace = true, features = ["test-support"] }
+agent2 = { workspace = true, features = ["test-support"] }
+assistant_context = { workspace = true, features = ["test-support"] }
 assistant_tools.workspace = true
 buffer_diff = { workspace = true, features = ["test-support"] }
+db = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, "features" = ["test-support"] }
 indoc.workspace = true

crates/agent_ui/src/acp.rs

@@ -1,6 +1,12 @@
 mod completion_provider;
-mod message_history;
+mod entry_view_state;
+mod message_editor;
+mod model_selector;
+mod model_selector_popover;
+mod thread_history;
 mod thread_view;
 
-pub use message_history::MessageHistory;
+pub use model_selector::AcpModelSelector;
+pub use model_selector_popover::AcpModelSelectorPopover;
+pub use thread_history::*;
 pub use thread_view::AcpThreadView;

crates/agent_ui/src/acp/entry_view_state.rs

@@ -0,0 +1,477 @@
+use std::ops::Range;
+
+use acp_thread::{AcpThread, AgentThreadEntry};
+use agent_client_protocol::ToolCallId;
+use agent2::HistoryStore;
+use collections::HashMap;
+use editor::{Editor, EditorMode, MinimapVisibility};
+use gpui::{
+    AnyEntity, App, AppContext as _, Entity, EntityId, EventEmitter, Focusable,
+    TextStyleRefinement, WeakEntity, Window,
+};
+use language::language_settings::SoftWrap;
+use project::Project;
+use prompt_store::PromptStore;
+use settings::Settings as _;
+use terminal_view::TerminalView;
+use theme::ThemeSettings;
+use ui::{Context, TextSize};
+use workspace::Workspace;
+
+use crate::acp::message_editor::{MessageEditor, MessageEditorEvent};
+
+pub struct EntryViewState {
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    history_store: Entity<HistoryStore>,
+    prompt_store: Option<Entity<PromptStore>>,
+    entries: Vec<Entry>,
+    prevent_slash_commands: bool,
+}
+
+impl EntryViewState {
+    pub fn new(
+        workspace: WeakEntity<Workspace>,
+        project: Entity<Project>,
+        history_store: Entity<HistoryStore>,
+        prompt_store: Option<Entity<PromptStore>>,
+        prevent_slash_commands: bool,
+    ) -> Self {
+        Self {
+            workspace,
+            project,
+            history_store,
+            prompt_store,
+            entries: Vec::new(),
+            prevent_slash_commands,
+        }
+    }
+
+    pub fn entry(&self, index: usize) -> Option<&Entry> {
+        self.entries.get(index)
+    }
+
+    pub fn sync_entry(
+        &mut self,
+        index: usize,
+        thread: &Entity<AcpThread>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(thread_entry) = thread.read(cx).entries().get(index) else {
+            return;
+        };
+
+        match thread_entry {
+            AgentThreadEntry::UserMessage(message) => {
+                let has_id = message.id.is_some();
+                let chunks = message.chunks.clone();
+                if let Some(Entry::UserMessage(editor)) = self.entries.get_mut(index) {
+                    if !editor.focus_handle(cx).is_focused(window) {
+                        // Only update if we are not editing.
+                        // If we are, cancelling the edit will set the message to the newest content.
+                        editor.update(cx, |editor, cx| {
+                            editor.set_message(chunks, window, cx);
+                        });
+                    }
+                } else {
+                    let message_editor = cx.new(|cx| {
+                        let mut editor = MessageEditor::new(
+                            self.workspace.clone(),
+                            self.project.clone(),
+                            self.history_store.clone(),
+                            self.prompt_store.clone(),
+                            "Edit message － @ to include context",
+                            self.prevent_slash_commands,
+                            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 id = tool_call.id.clone();
+                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(|| {
+                        let element = create_terminal(
+                            self.workspace.clone(),
+                            self.project.clone(),
+                            terminal.clone(),
+                            window,
+                            cx,
+                        )
+                        .into_any();
+                        cx.emit(EntryViewEvent {
+                            entry_index: index,
+                            view_event: ViewEvent::NewTerminal(id.clone()),
+                        });
+                        element
+                    });
+                }
+
+                for diff in diffs {
+                    views.entry(diff.entity_id()).or_insert_with(|| {
+                        let element = create_editor_diff(diff.clone(), window, cx).into_any();
+                        cx.emit(EntryViewEvent {
+                            entry_index: index,
+                            view_event: ViewEvent::NewDiff(id.clone()),
+                        });
+                        element
+                    });
+                }
+            }
+            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>) {
+        self.entries.drain(range);
+    }
+
+    pub fn settings_changed(&mut self, cx: &mut App) {
+        for entry in self.entries.iter() {
+            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();
+                            })
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl EventEmitter<EntryViewEvent> for EntryViewState {}
+
+pub struct EntryViewEvent {
+    pub entry_index: usize,
+    pub view_event: ViewEvent,
+}
+
+pub enum ViewEvent {
+    NewDiff(ToolCallId),
+    NewTerminal(ToolCallId),
+    MessageEditorEvent(Entity<MessageEditor>, MessageEditorEvent),
+}
+
+#[derive(Debug)]
+pub enum Entry {
+    UserMessage(Entity<MessageEditor>),
+    Content(HashMap<EntityId, AnyEntity>),
+}
+
+impl Entry {
+    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())
+    }
+
+    pub fn terminal(
+        &self,
+        terminal: &Entity<acp_thread::Terminal>,
+    ) -> Option<Entity<TerminalView>> {
+        self.content_map()?
+            .get(&terminal.entity_id())
+            .cloned()
+            .map(|entity| entity.downcast::<TerminalView>().unwrap())
+    }
+
+    fn content_map(&self) -> Option<&HashMap<EntityId, AnyEntity>> {
+        match self {
+            Self::Content(map) => Some(map),
+            _ => None,
+        }
+    }
+
+    fn empty() -> Self {
+        Self::Content(HashMap::default())
+    }
+
+    #[cfg(test)]
+    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(
+            TextSize::Small
+                .rems(cx)
+                .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx))
+                .into(),
+        ),
+        ..Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, rc::Rc};
+
+    use acp_thread::{AgentConnection, StubAgentConnection};
+    use agent_client_protocol as acp;
+    use agent_settings::AgentSettings;
+    use agent2::HistoryStore;
+    use assistant_context::ContextStore;
+    use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind};
+    use editor::{EditorSettings, RowInfo};
+    use fs::FakeFs;
+    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;
+    use serde_json::json;
+    use settings::{Settings as _, SettingsStore};
+    use theme::ThemeSettings;
+    use util::path;
+    use workspace::Workspace;
+
+    #[gpui::test]
+    async fn test_diff_sync(cx: &mut TestAppContext) {
+        init_test(cx);
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            "/project",
+            json!({
+                "hello.txt": "hi world"
+            }),
+        )
+        .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 tool_call = acp::ToolCall {
+            id: acp::ToolCallId("tool".into()),
+            title: "Tool call".into(),
+            kind: acp::ToolKind::Other,
+            status: acp::ToolCallStatus::InProgress,
+            content: vec![acp::ToolCallContent::Diff {
+                diff: acp::Diff {
+                    path: "/project/hello.txt".into(),
+                    old_text: Some("hi world".into()),
+                    new_text: "hello world".into(),
+                },
+            }],
+            locations: vec![],
+            raw_input: None,
+            raw_output: None,
+        };
+        let connection = Rc::new(StubAgentConnection::new());
+        let thread = cx
+            .update(|_, cx| {
+                connection
+                    .clone()
+                    .new_thread(project.clone(), Path::new(path!("/project")), cx)
+            })
+            .await
+            .unwrap();
+        let session_id = thread.update(cx, |thread, _| thread.session_id().clone());
+
+        cx.update(|_, cx| {
+            connection.send_update(session_id, acp::SessionUpdate::ToolCall(tool_call), cx)
+        });
+
+        let context_store = cx.new(|cx| ContextStore::fake(project.clone(), cx));
+        let history_store = cx.new(|cx| HistoryStore::new(context_store, cx));
+
+        let view_state = cx.new(|_cx| {
+            EntryViewState::new(
+                workspace.downgrade(),
+                project.clone(),
+                history_store,
+                None,
+                false,
+            )
+        });
+
+        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)
+                .unwrap()
+                .diffs()
+                .next()
+                .unwrap()
+                .clone()
+        });
+
+        cx.run_until_parked();
+
+        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"
+        );
+        let row_infos = diff_editor.read_with(cx, |editor, cx| {
+            let multibuffer = editor.buffer().read(cx);
+            multibuffer
+                .snapshot(cx)
+                .row_infos(MultiBufferRow(0))
+                .collect::<Vec<_>>()
+        });
+        assert_matches!(
+            row_infos.as_slice(),
+            [
+                RowInfo {
+                    multibuffer_row: Some(MultiBufferRow(0)),
+                    diff_status: Some(DiffHunkStatus {
+                        kind: DiffHunkStatusKind::Deleted,
+                        ..
+                    }),
+                    ..
+                },
+                RowInfo {
+                    multibuffer_row: Some(MultiBufferRow(1)),
+                    diff_status: Some(DiffHunkStatus {
+                        kind: DiffHunkStatusKind::Added,
+                        ..
+                    }),
+                    ..
+                }
+            ]
+        );
+    }
+
+    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);
+            AgentSettings::register(cx);
+            workspace::init_settings(cx);
+            ThemeSettings::register(cx);
+            release_channel::init(SemanticVersion::default(), cx);
+            EditorSettings::register(cx);
+        });
+    }
+}

crates/agent_ui/src/acp/message_history.rs

@@ -1,92 +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)]
-    pub fn items(&self) -> &[T] {
-        &self.items
-    }
-}
-#[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/acp/model_selector.rs

@@ -0,0 +1,472 @@
+use std::{cmp::Reverse, rc::Rc, sync::Arc};
+
+use acp_thread::{AgentModelInfo, AgentModelList, AgentModelSelector};
+use agent_client_protocol as acp;
+use anyhow::Result;
+use collections::IndexMap;
+use futures::FutureExt;
+use fuzzy::{StringMatchCandidate, match_strings};
+use gpui::{Action, AsyncWindowContext, BackgroundExecutor, DismissEvent, Task, WeakEntity};
+use ordered_float::OrderedFloat;
+use picker::{Picker, PickerDelegate};
+use ui::{
+    AnyElement, App, Context, IntoElement, ListItem, ListItemSpacing, SharedString, Window,
+    prelude::*, rems,
+};
+use util::ResultExt;
+
+pub type AcpModelSelector = Picker<AcpModelPickerDelegate>;
+
+pub fn acp_model_selector(
+    session_id: acp::SessionId,
+    selector: Rc<dyn AgentModelSelector>,
+    window: &mut Window,
+    cx: &mut Context<AcpModelSelector>,
+) -> AcpModelSelector {
+    let delegate = AcpModelPickerDelegate::new(session_id, selector, window, cx);
+    Picker::list(delegate, window, cx)
+        .show_scrollbar(true)
+        .width(rems(20.))
+        .max_height(Some(rems(20.).into()))
+}
+
+enum AcpModelPickerEntry {
+    Separator(SharedString),
+    Model(AgentModelInfo),
+}
+
+pub struct AcpModelPickerDelegate {
+    session_id: acp::SessionId,
+    selector: Rc<dyn AgentModelSelector>,
+    filtered_entries: Vec<AcpModelPickerEntry>,
+    models: Option<AgentModelList>,
+    selected_index: usize,
+    selected_model: Option<AgentModelInfo>,
+    _refresh_models_task: Task<()>,
+}
+
+impl AcpModelPickerDelegate {
+    fn new(
+        session_id: acp::SessionId,
+        selector: Rc<dyn AgentModelSelector>,
+        window: &mut Window,
+        cx: &mut Context<AcpModelSelector>,
+    ) -> Self {
+        let mut rx = selector.watch(cx);
+        let refresh_models_task = cx.spawn_in(window, {
+            let session_id = session_id.clone();
+            async move |this, cx| {
+                async fn refresh(
+                    this: &WeakEntity<Picker<AcpModelPickerDelegate>>,
+                    session_id: &acp::SessionId,
+                    cx: &mut AsyncWindowContext,
+                ) -> Result<()> {
+                    let (models_task, selected_model_task) = this.update(cx, |this, cx| {
+                        (
+                            this.delegate.selector.list_models(cx),
+                            this.delegate.selector.selected_model(session_id, cx),
+                        )
+                    })?;
+
+                    let (models, selected_model) = futures::join!(models_task, selected_model_task);
+
+                    this.update_in(cx, |this, window, cx| {
+                        this.delegate.models = models.ok();
+                        this.delegate.selected_model = selected_model.ok();
+                        this.delegate.update_matches(this.query(cx), window, cx)
+                    })?
+                    .await;
+
+                    Ok(())
+                }
+
+                refresh(&this, &session_id, cx).await.log_err();
+                while let Ok(()) = rx.recv().await {
+                    refresh(&this, &session_id, cx).await.log_err();
+                }
+            }
+        });
+
+        Self {
+            session_id,
+            selector,
+            filtered_entries: Vec::new(),
+            models: None,
+            selected_model: None,
+            selected_index: 0,
+            _refresh_models_task: refresh_models_task,
+        }
+    }
+
+    pub fn active_model(&self) -> Option<&AgentModelInfo> {
+        self.selected_model.as_ref()
+    }
+}
+
+impl PickerDelegate for AcpModelPickerDelegate {
+    type ListItem = AnyElement;
+
+    fn match_count(&self) -> usize {
+        self.filtered_entries.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.selected_index = ix.min(self.filtered_entries.len().saturating_sub(1));
+        cx.notify();
+    }
+
+    fn can_select(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) -> bool {
+        match self.filtered_entries.get(ix) {
+            Some(AcpModelPickerEntry::Model(_)) => true,
+            Some(AcpModelPickerEntry::Separator(_)) | None => false,
+        }
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Select a model…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        cx.spawn_in(window, async move |this, cx| {
+            let filtered_models = match this
+                .read_with(cx, |this, cx| {
+                    this.delegate.models.clone().map(move |models| {
+                        fuzzy_search(models, query, cx.background_executor().clone())
+                    })
+                })
+                .ok()
+                .flatten()
+            {
+                Some(task) => task.await,
+                None => AgentModelList::Flat(vec![]),
+            };
+
+            this.update_in(cx, |this, window, cx| {
+                this.delegate.filtered_entries =
+                    info_list_to_picker_entries(filtered_models).collect();
+                // Finds the currently selected model in the list
+                let new_index = this
+                    .delegate
+                    .selected_model
+                    .as_ref()
+                    .and_then(|selected| {
+                        this.delegate.filtered_entries.iter().position(|entry| {
+                            if let AcpModelPickerEntry::Model(model_info) = entry {
+                                model_info.id == selected.id
+                            } else {
+                                false
+                            }
+                        })
+                    })
+                    .unwrap_or(0);
+                this.set_selected_index(new_index, Some(picker::Direction::Down), true, window, cx);
+                cx.notify();
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        if let Some(AcpModelPickerEntry::Model(model_info)) =
+            self.filtered_entries.get(self.selected_index)
+        {
+            self.selector
+                .select_model(self.session_id.clone(), model_info.id.clone(), cx)
+                .detach_and_log_err(cx);
+            self.selected_model = Some(model_info.clone());
+            let current_index = self.selected_index;
+            self.set_selected_index(current_index, window, cx);
+
+            cx.emit(DismissEvent);
+        }
+    }
+
+    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        cx.emit(DismissEvent);
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        match self.filtered_entries.get(ix)? {
+            AcpModelPickerEntry::Separator(title) => Some(
+                div()
+                    .px_2()
+                    .pb_1()
+                    .when(ix > 1, |this| {
+                        this.mt_1()
+                            .pt_2()
+                            .border_t_1()
+                            .border_color(cx.theme().colors().border_variant)
+                    })
+                    .child(
+                        Label::new(title)
+                            .size(LabelSize::XSmall)
+                            .color(Color::Muted),
+                    )
+                    .into_any_element(),
+            ),
+            AcpModelPickerEntry::Model(model_info) => {
+                let is_selected = Some(model_info) == self.selected_model.as_ref();
+
+                let model_icon_color = if is_selected {
+                    Color::Accent
+                } else {
+                    Color::Muted
+                };
+
+                Some(
+                    ListItem::new(ix)
+                        .inset(true)
+                        .spacing(ListItemSpacing::Sparse)
+                        .toggle_state(selected)
+                        .start_slot::<Icon>(model_info.icon.map(|icon| {
+                            Icon::new(icon)
+                                .color(model_icon_color)
+                                .size(IconSize::Small)
+                        }))
+                        .child(
+                            h_flex()
+                                .w_full()
+                                .pl_0p5()
+                                .gap_1p5()
+                                .w(px(240.))
+                                .child(Label::new(model_info.name.clone()).truncate()),
+                        )
+                        .end_slot(div().pr_3().when(is_selected, |this| {
+                            this.child(
+                                Icon::new(IconName::Check)
+                                    .color(Color::Accent)
+                                    .size(IconSize::Small),
+                            )
+                        }))
+                        .into_any_element(),
+                )
+            }
+        }
+    }
+
+    fn render_footer(
+        &self,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<gpui::AnyElement> {
+        Some(
+            h_flex()
+                .w_full()
+                .border_t_1()
+                .border_color(cx.theme().colors().border_variant)
+                .p_1()
+                .gap_4()
+                .justify_between()
+                .child(
+                    Button::new("configure", "Configure")
+                        .icon(IconName::Settings)
+                        .icon_size(IconSize::Small)
+                        .icon_color(Color::Muted)
+                        .icon_position(IconPosition::Start)
+                        .on_click(|_, window, cx| {
+                            window.dispatch_action(
+                                zed_actions::agent::OpenSettings.boxed_clone(),
+                                cx,
+                            );
+                        }),
+                )
+                .into_any(),
+        )
+    }
+}
+
+fn info_list_to_picker_entries(
+    model_list: AgentModelList,
+) -> impl Iterator<Item = AcpModelPickerEntry> {
+    match model_list {
+        AgentModelList::Flat(list) => {
+            itertools::Either::Left(list.into_iter().map(AcpModelPickerEntry::Model))
+        }
+        AgentModelList::Grouped(index_map) => {
+            itertools::Either::Right(index_map.into_iter().flat_map(|(group_name, models)| {
+                std::iter::once(AcpModelPickerEntry::Separator(group_name.0))
+                    .chain(models.into_iter().map(AcpModelPickerEntry::Model))
+            }))
+        }
+    }
+}
+
+async fn fuzzy_search(
+    model_list: AgentModelList,
+    query: String,
+    executor: BackgroundExecutor,
+) -> AgentModelList {
+    async fn fuzzy_search_list(
+        model_list: Vec<AgentModelInfo>,
+        query: &str,
+        executor: BackgroundExecutor,
+    ) -> Vec<AgentModelInfo> {
+        let candidates = model_list
+            .iter()
+            .enumerate()
+            .map(|(ix, model)| {
+                StringMatchCandidate::new(ix, &format!("{}/{}", model.id, model.name))
+            })
+            .collect::<Vec<_>>();
+        let mut matches = match_strings(
+            &candidates,
+            query,
+            false,
+            true,
+            100,
+            &Default::default(),
+            executor,
+        )
+        .await;
+
+        matches.sort_unstable_by_key(|mat| {
+            let candidate = &candidates[mat.candidate_id];
+            (Reverse(OrderedFloat(mat.score)), candidate.id)
+        });
+
+        matches
+            .into_iter()
+            .map(|mat| model_list[mat.candidate_id].clone())
+            .collect()
+    }
+
+    match model_list {
+        AgentModelList::Flat(model_list) => {
+            AgentModelList::Flat(fuzzy_search_list(model_list, &query, executor).await)
+        }
+        AgentModelList::Grouped(index_map) => {
+            let groups =
+                futures::future::join_all(index_map.into_iter().map(|(group_name, models)| {
+                    fuzzy_search_list(models, &query, executor.clone())
+                        .map(|results| (group_name, results))
+                }))
+                .await;
+            AgentModelList::Grouped(IndexMap::from_iter(
+                groups
+                    .into_iter()
+                    .filter(|(_, results)| !results.is_empty()),
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use gpui::TestAppContext;
+
+    use super::*;
+
+    fn create_model_list(grouped_models: Vec<(&str, Vec<&str>)>) -> AgentModelList {
+        AgentModelList::Grouped(IndexMap::from_iter(grouped_models.into_iter().map(
+            |(group, models)| {
+                (
+                    acp_thread::AgentModelGroupName(group.to_string().into()),
+                    models
+                        .into_iter()
+                        .map(|model| acp_thread::AgentModelInfo {
+                            id: acp_thread::AgentModelId(model.to_string().into()),
+                            name: model.to_string().into(),
+                            icon: None,
+                        })
+                        .collect::<Vec<_>>(),
+                )
+            },
+        )))
+    }
+
+    fn assert_models_eq(result: AgentModelList, expected: Vec<(&str, Vec<&str>)>) {
+        let AgentModelList::Grouped(groups) = result else {
+            panic!("Expected LanguageModelInfoList::Grouped, got {:?}", result);
+        };
+
+        assert_eq!(
+            groups.len(),
+            expected.len(),
+            "Number of groups doesn't match"
+        );
+
+        for (i, (expected_group, expected_models)) in expected.iter().enumerate() {
+            let (actual_group, actual_models) = groups.get_index(i).unwrap();
+            assert_eq!(
+                actual_group.0.as_ref(),
+                *expected_group,
+                "Group at position {} doesn't match expected group",
+                i
+            );
+            assert_eq!(
+                actual_models.len(),
+                expected_models.len(),
+                "Number of models in group {} doesn't match",
+                expected_group
+            );
+
+            for (j, expected_model_name) in expected_models.iter().enumerate() {
+                assert_eq!(
+                    actual_models[j].name, *expected_model_name,
+                    "Model at position {} in group {} doesn't match expected model",
+                    j, expected_group
+                );
+            }
+        }
+    }
+
+    #[gpui::test]
+    async fn test_fuzzy_match(cx: &mut TestAppContext) {
+        let models = create_model_list(vec![
+            (
+                "zed",
+                vec![
+                    "Claude 3.7 Sonnet",
+                    "Claude 3.7 Sonnet Thinking",
+                    "gpt-4.1",
+                    "gpt-4.1-nano",
+                ],
+            ),
+            ("openai", vec!["gpt-3.5-turbo", "gpt-4.1", "gpt-4.1-nano"]),
+            ("ollama", vec!["mistral", "deepseek"]),
+        ]);
+
+        // Results should preserve models order whenever possible.
+        // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
+        // similarity scores, but `zed/gpt-4.1` was higher in the models list,
+        // so it should appear first in the results.
+        let results = fuzzy_search(models.clone(), "41".into(), cx.executor()).await;
+        assert_models_eq(
+            results,
+            vec![
+                ("zed", vec!["gpt-4.1", "gpt-4.1-nano"]),
+                ("openai", vec!["gpt-4.1", "gpt-4.1-nano"]),
+            ],
+        );
+
+        // Fuzzy search
+        let results = fuzzy_search(models.clone(), "4n".into(), cx.executor()).await;
+        assert_models_eq(
+            results,
+            vec![
+                ("zed", vec!["gpt-4.1-nano"]),
+                ("openai", vec!["gpt-4.1-nano"]),
+            ],
+        );
+    }
+}

crates/agent_ui/src/acp/model_selector_popover.rs

@@ -0,0 +1,85 @@
+use std::rc::Rc;
+
+use acp_thread::AgentModelSelector;
+use agent_client_protocol as acp;
+use gpui::{Entity, FocusHandle};
+use picker::popover_menu::PickerPopoverMenu;
+use ui::{
+    ButtonLike, Context, IntoElement, PopoverMenuHandle, SharedString, Tooltip, Window, prelude::*,
+};
+use zed_actions::agent::ToggleModelSelector;
+
+use crate::acp::{AcpModelSelector, model_selector::acp_model_selector};
+
+pub struct AcpModelSelectorPopover {
+    selector: Entity<AcpModelSelector>,
+    menu_handle: PopoverMenuHandle<AcpModelSelector>,
+    focus_handle: FocusHandle,
+}
+
+impl AcpModelSelectorPopover {
+    pub(crate) fn new(
+        session_id: acp::SessionId,
+        selector: Rc<dyn AgentModelSelector>,
+        menu_handle: PopoverMenuHandle<AcpModelSelector>,
+        focus_handle: FocusHandle,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        Self {
+            selector: cx.new(move |cx| acp_model_selector(session_id, selector, window, cx)),
+            menu_handle,
+            focus_handle,
+        }
+    }
+
+    pub fn toggle(&self, window: &mut Window, cx: &mut Context<Self>) {
+        self.menu_handle.toggle(window, cx);
+    }
+}
+
+impl Render for AcpModelSelectorPopover {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let model = self.selector.read(cx).delegate.active_model();
+        let model_name = model
+            .as_ref()
+            .map(|model| model.name.clone())
+            .unwrap_or_else(|| SharedString::from("Select a Model"));
+
+        let model_icon = model.as_ref().and_then(|model| model.icon);
+
+        let focus_handle = self.focus_handle.clone();
+
+        PickerPopoverMenu::new(
+            self.selector.clone(),
+            ButtonLike::new("active-model")
+                .when_some(model_icon, |this, icon| {
+                    this.child(Icon::new(icon).color(Color::Muted).size(IconSize::XSmall))
+                })
+                .child(
+                    Label::new(model_name)
+                        .color(Color::Muted)
+                        .size(LabelSize::Small)
+                        .ml_0p5(),
+                )
+                .child(
+                    Icon::new(IconName::ChevronDown)
+                        .color(Color::Muted)
+                        .size(IconSize::XSmall),
+                ),
+            move |window, cx| {
+                Tooltip::for_action_in(
+                    "Change Model",
+                    &ToggleModelSelector,
+                    &focus_handle,
+                    window,
+                    cx,
+                )
+            },
+            gpui::Corner::BottomRight,
+            cx,
+        )
+        .with_handle(self.menu_handle.clone())
+        .render(window, cx)
+    }
+}

crates/agent_ui/src/acp/thread_history.rs

@@ -0,0 +1,902 @@
+use crate::acp::AcpThreadView;
+use crate::{AgentPanel, RemoveSelectedThread};
+use agent2::{HistoryEntry, HistoryStore};
+use chrono::{Datelike as _, Local, NaiveDate, TimeDelta};
+use editor::{Editor, EditorEvent};
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::{
+    App, Empty, Entity, EventEmitter, FocusHandle, Focusable, ScrollStrategy, Stateful, Task,
+    UniformListScrollHandle, WeakEntity, Window, uniform_list,
+};
+use std::{fmt::Display, ops::Range, sync::Arc};
+use time::{OffsetDateTime, UtcOffset};
+use ui::{
+    HighlightedLabel, IconButtonShape, ListItem, ListItemSpacing, Scrollbar, ScrollbarState,
+    Tooltip, prelude::*,
+};
+use util::ResultExt;
+
+pub struct AcpThreadHistory {
+    pub(crate) history_store: Entity<HistoryStore>,
+    scroll_handle: UniformListScrollHandle,
+    selected_index: usize,
+    hovered_index: Option<usize>,
+    search_editor: Entity<Editor>,
+    all_entries: Arc<Vec<HistoryEntry>>,
+    // When the search is empty, we display date separators between history entries
+    // This vector contains an enum of either a separator or an actual entry
+    separated_items: Vec<ListItemType>,
+    // Maps entry indexes to list item indexes
+    separated_item_indexes: Vec<u32>,
+    _separated_items_task: Option<Task<()>>,
+    search_state: SearchState,
+    scrollbar_visibility: bool,
+    scrollbar_state: ScrollbarState,
+    local_timezone: UtcOffset,
+    _subscriptions: Vec<gpui::Subscription>,
+}
+
+enum SearchState {
+    Empty,
+    Searching {
+        query: SharedString,
+        _task: Task<()>,
+    },
+    Searched {
+        query: SharedString,
+        matches: Vec<StringMatch>,
+    },
+}
+
+enum ListItemType {
+    BucketSeparator(TimeBucket),
+    Entry {
+        index: usize,
+        format: EntryTimeFormat,
+    },
+}
+
+pub enum ThreadHistoryEvent {
+    Open(HistoryEntry),
+}
+
+impl EventEmitter<ThreadHistoryEvent> for AcpThreadHistory {}
+
+impl AcpThreadHistory {
+    pub(crate) fn new(
+        history_store: Entity<agent2::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.into(), cx);
+                }
+            });
+
+        let history_store_subscription = cx.observe(&history_store, |this, _, cx| {
+            this.update_all_entries(cx);
+        });
+
+        let scroll_handle = UniformListScrollHandle::default();
+        let scrollbar_state = ScrollbarState::new(scroll_handle.clone());
+
+        let mut this = Self {
+            history_store,
+            scroll_handle,
+            selected_index: 0,
+            hovered_index: None,
+            search_state: SearchState::Empty,
+            all_entries: Default::default(),
+            separated_items: Default::default(),
+            separated_item_indexes: Default::default(),
+            search_editor,
+            scrollbar_visibility: true,
+            scrollbar_state,
+            local_timezone: UtcOffset::from_whole_seconds(
+                chrono::Local::now().offset().local_minus_utc(),
+            )
+            .unwrap(),
+            _subscriptions: vec![search_editor_subscription, history_store_subscription],
+            _separated_items_task: None,
+        };
+        this.update_all_entries(cx);
+        this
+    }
+
+    fn update_all_entries(&mut self, cx: &mut Context<Self>) {
+        let new_entries: Arc<Vec<HistoryEntry>> = self
+            .history_store
+            .update(cx, |store, cx| store.entries(cx))
+            .into();
+
+        self._separated_items_task.take();
+
+        let mut items = Vec::with_capacity(new_entries.len() + 1);
+        let mut indexes = Vec::with_capacity(new_entries.len() + 1);
+
+        let bg_task = cx.background_spawn(async move {
+            let mut bucket = None;
+            let today = Local::now().naive_local().date();
+
+            for (index, entry) in new_entries.iter().enumerate() {
+                let entry_date = entry
+                    .updated_at()
+                    .with_timezone(&Local)
+                    .naive_local()
+                    .date();
+                let entry_bucket = TimeBucket::from_dates(today, entry_date);
+
+                if Some(entry_bucket) != bucket {
+                    bucket = Some(entry_bucket);
+                    items.push(ListItemType::BucketSeparator(entry_bucket));
+                }
+
+                indexes.push(items.len() as u32);
+                items.push(ListItemType::Entry {
+                    index,
+                    format: entry_bucket.into(),
+                });
+            }
+            (new_entries, items, indexes)
+        });
+
+        let task = cx.spawn(async move |this, cx| {
+            let (new_entries, items, indexes) = bg_task.await;
+            this.update(cx, |this, cx| {
+                let previously_selected_entry =
+                    this.all_entries.get(this.selected_index).map(|e| e.id());
+
+                this.all_entries = new_entries;
+                this.separated_items = items;
+                this.separated_item_indexes = indexes;
+
+                match &this.search_state {
+                    SearchState::Empty => {
+                        if this.selected_index >= this.all_entries.len() {
+                            this.set_selected_entry_index(
+                                this.all_entries.len().saturating_sub(1),
+                                cx,
+                            );
+                        } else if let Some(prev_id) = previously_selected_entry
+                            && let Some(new_ix) = this
+                                .all_entries
+                                .iter()
+                                .position(|probe| probe.id() == prev_id)
+                        {
+                            this.set_selected_entry_index(new_ix, cx);
+                        }
+                    }
+                    SearchState::Searching { query, .. } | SearchState::Searched { query, .. } => {
+                        this.search(query.clone(), cx);
+                    }
+                }
+
+                cx.notify();
+            })
+            .log_err();
+        });
+        self._separated_items_task = Some(task);
+    }
+
+    fn search(&mut self, query: SharedString, cx: &mut Context<Self>) {
+        if query.is_empty() {
+            self.search_state = SearchState::Empty;
+            cx.notify();
+            return;
+        }
+
+        let all_entries = self.all_entries.clone();
+
+        let fuzzy_search_task = cx.background_spawn({
+            let query = query.clone();
+            let executor = cx.background_executor().clone();
+            async move {
+                let mut candidates = Vec::with_capacity(all_entries.len());
+
+                for (idx, entry) in all_entries.iter().enumerate() {
+                    candidates.push(StringMatchCandidate::new(idx, entry.title()));
+                }
+
+                const MAX_MATCHES: usize = 100;
+
+                fuzzy::match_strings(
+                    &candidates,
+                    &query,
+                    false,
+                    true,
+                    MAX_MATCHES,
+                    &Default::default(),
+                    executor,
+                )
+                .await
+            }
+        });
+
+        let task = cx.spawn({
+            let query = query.clone();
+            async move |this, cx| {
+                let matches = fuzzy_search_task.await;
+
+                this.update(cx, |this, cx| {
+                    let SearchState::Searching {
+                        query: current_query,
+                        _task,
+                    } = &this.search_state
+                    else {
+                        return;
+                    };
+
+                    if &query == current_query {
+                        this.search_state = SearchState::Searched {
+                            query: query.clone(),
+                            matches,
+                        };
+
+                        this.set_selected_entry_index(0, cx);
+                        cx.notify();
+                    };
+                })
+                .log_err();
+            }
+        });
+
+        self.search_state = SearchState::Searching { query, _task: task };
+        cx.notify();
+    }
+
+    fn matched_count(&self) -> usize {
+        match &self.search_state {
+            SearchState::Empty => self.all_entries.len(),
+            SearchState::Searching { .. } => 0,
+            SearchState::Searched { matches, .. } => matches.len(),
+        }
+    }
+
+    fn list_item_count(&self) -> usize {
+        match &self.search_state {
+            SearchState::Empty => self.separated_items.len(),
+            SearchState::Searching { .. } => 0,
+            SearchState::Searched { matches, .. } => matches.len(),
+        }
+    }
+
+    fn search_produced_no_matches(&self) -> bool {
+        match &self.search_state {
+            SearchState::Empty => false,
+            SearchState::Searching { .. } => false,
+            SearchState::Searched { matches, .. } => matches.is_empty(),
+        }
+    }
+
+    fn get_match(&self, ix: usize) -> Option<&HistoryEntry> {
+        match &self.search_state {
+            SearchState::Empty => self.all_entries.get(ix),
+            SearchState::Searching { .. } => None,
+            SearchState::Searched { matches, .. } => matches
+                .get(ix)
+                .and_then(|m| self.all_entries.get(m.candidate_id)),
+        }
+    }
+
+    pub fn select_previous(
+        &mut self,
+        _: &menu::SelectPrevious,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self.matched_count();
+        if count > 0 {
+            if self.selected_index == 0 {
+                self.set_selected_entry_index(count - 1, cx);
+            } else {
+                self.set_selected_entry_index(self.selected_index - 1, cx);
+            }
+        }
+    }
+
+    pub fn select_next(
+        &mut self,
+        _: &menu::SelectNext,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self.matched_count();
+        if count > 0 {
+            if self.selected_index == count - 1 {
+                self.set_selected_entry_index(0, cx);
+            } else {
+                self.set_selected_entry_index(self.selected_index + 1, 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_entry_index(0, 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_entry_index(count - 1, cx);
+        }
+    }
+
+    fn set_selected_entry_index(&mut self, entry_index: usize, cx: &mut Context<Self>) {
+        self.selected_index = entry_index;
+
+        let scroll_ix = match self.search_state {
+            SearchState::Empty | SearchState::Searching { .. } => self
+                .separated_item_indexes
+                .get(entry_index)
+                .map(|ix| *ix as usize)
+                .unwrap_or(entry_index + 1),
+            SearchState::Searched { .. } => entry_index,
+        };
+
+        self.scroll_handle
+            .scroll_to_item(scroll_ix, ScrollStrategy::Top);
+
+        cx.notify();
+    }
+
+    fn render_scrollbar(&self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        if !(self.scrollbar_visibility || self.scrollbar_state.is_dragging()) {
+            return None;
+        }
+
+        Some(
+            div()
+                .occlude()
+                .id("thread-history-scroll")
+                .h_full()
+                .bg(cx.theme().colors().panel_background.opacity(0.8))
+                .border_l_1()
+                .border_color(cx.theme().colors().border_variant)
+                .absolute()
+                .right_1()
+                .top_0()
+                .bottom_0()
+                .w_4()
+                .pl_1()
+                .cursor_default()
+                .on_mouse_move(cx.listener(|_, _, _window, cx| {
+                    cx.notify();
+                    cx.stop_propagation()
+                }))
+                .on_hover(|_, _window, cx| {
+                    cx.stop_propagation();
+                })
+                .on_any_mouse_down(|_, _window, cx| {
+                    cx.stop_propagation();
+                })
+                .on_scroll_wheel(cx.listener(|_, _, _window, cx| {
+                    cx.notify();
+                }))
+                .children(Scrollbar::vertical(self.scrollbar_state.clone())),
+        )
+    }
+
+    fn confirm(&mut self, _: &menu::Confirm, _window: &mut Window, cx: &mut Context<Self>) {
+        self.confirm_entry(self.selected_index, cx);
+    }
+
+    fn confirm_entry(&mut self, ix: usize, cx: &mut Context<Self>) {
+        let Some(entry) = self.get_match(ix) else {
+            return;
+        };
+        cx.emit(ThreadHistoryEvent::Open(entry.clone()));
+    }
+
+    fn remove_selected_thread(
+        &mut self,
+        _: &RemoveSelectedThread,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.remove_thread(self.selected_index, cx)
+    }
+
+    fn remove_thread(&mut self, ix: usize, cx: &mut Context<Self>) {
+        let Some(entry) = self.get_match(ix) else {
+            return;
+        };
+
+        let task = match entry {
+            HistoryEntry::AcpThread(thread) => self
+                .history_store
+                .update(cx, |this, cx| this.delete_thread(thread.id.clone(), cx)),
+            HistoryEntry::TextThread(context) => self.history_store.update(cx, |this, cx| {
+                this.delete_text_thread(context.path.clone(), cx)
+            }),
+        };
+        task.detach_and_log_err(cx);
+    }
+
+    fn list_items(
+        &mut self,
+        range: Range<usize>,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Vec<AnyElement> {
+        match &self.search_state {
+            SearchState::Empty => self
+                .separated_items
+                .get(range)
+                .iter()
+                .flat_map(|items| {
+                    items
+                        .iter()
+                        .map(|item| self.render_list_item(item, vec![], cx))
+                })
+                .collect(),
+            SearchState::Searched { matches, .. } => matches[range]
+                .iter()
+                .filter_map(|m| {
+                    let entry = self.all_entries.get(m.candidate_id)?;
+                    Some(self.render_history_entry(
+                        entry,
+                        EntryTimeFormat::DateAndTime,
+                        m.candidate_id,
+                        m.positions.clone(),
+                        cx,
+                    ))
+                })
+                .collect(),
+            SearchState::Searching { .. } => {
+                vec![]
+            }
+        }
+    }
+
+    fn render_list_item(
+        &self,
+        item: &ListItemType,
+        highlight_positions: Vec<usize>,
+        cx: &Context<Self>,
+    ) -> AnyElement {
+        match item {
+            ListItemType::Entry { index, format } => match self.all_entries.get(*index) {
+                Some(entry) => self
+                    .render_history_entry(entry, *format, *index, highlight_positions, cx)
+                    .into_any(),
+                None => Empty.into_any_element(),
+            },
+            ListItemType::BucketSeparator(bucket) => div()
+                .px(DynamicSpacing::Base06.rems(cx))
+                .pt_2()
+                .pb_1()
+                .child(
+                    Label::new(bucket.to_string())
+                        .size(LabelSize::XSmall)
+                        .color(Color::Muted),
+                )
+                .into_any_element(),
+        }
+    }
+
+    fn render_history_entry(
+        &self,
+        entry: &HistoryEntry,
+        format: EntryTimeFormat,
+        list_entry_ix: usize,
+        highlight_positions: Vec<usize>,
+        cx: &Context<Self>,
+    ) -> AnyElement {
+        let selected = list_entry_ix == self.selected_index;
+        let hovered = Some(list_entry_ix) == self.hovered_index;
+        let timestamp = entry.updated_at().timestamp();
+        let thread_timestamp = format.format_timestamp(timestamp, self.local_timezone);
+
+        h_flex()
+            .w_full()
+            .pb_1()
+            .child(
+                ListItem::new(list_entry_ix)
+                    .rounded()
+                    .toggle_state(selected)
+                    .spacing(ListItemSpacing::Sparse)
+                    .start_slot(
+                        h_flex()
+                            .w_full()
+                            .gap_2()
+                            .justify_between()
+                            .child(
+                                HighlightedLabel::new(entry.title(), highlight_positions)
+                                    .size(LabelSize::Small)
+                                    .truncate(),
+                            )
+                            .child(
+                                Label::new(thread_timestamp)
+                                    .color(Color::Muted)
+                                    .size(LabelSize::XSmall),
+                            ),
+                    )
+                    .on_hover(cx.listener(move |this, is_hovered, _window, cx| {
+                        if *is_hovered {
+                            this.hovered_index = Some(list_entry_ix);
+                        } else if this.hovered_index == Some(list_entry_ix) {
+                            this.hovered_index = None;
+                        }
+
+                        cx.notify();
+                    }))
+                    .end_slot::<IconButton>(if hovered || selected {
+                        Some(
+                            IconButton::new("delete", IconName::Trash)
+                                .shape(IconButtonShape::Square)
+                                .icon_size(IconSize::XSmall)
+                                .icon_color(Color::Muted)
+                                .tooltip(move |window, cx| {
+                                    Tooltip::for_action("Delete", &RemoveSelectedThread, window, cx)
+                                })
+                                .on_click(cx.listener(move |this, _, _, cx| {
+                                    this.remove_thread(list_entry_ix, cx)
+                                })),
+                        )
+                    } else {
+                        None
+                    })
+                    .on_click(
+                        cx.listener(move |this, _, _, cx| this.confirm_entry(list_entry_ix, cx)),
+                    ),
+            )
+            .into_any_element()
+    }
+}
+
+impl Focusable for AcpThreadHistory {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.search_editor.focus_handle(cx)
+    }
+}
+
+impl Render for AcpThreadHistory {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .key_context("ThreadHistory")
+            .size_full()
+            .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))
+            .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()
+                    .id("list-container")
+                    .relative()
+                    .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.search_produced_no_matches() {
+                    view.justify_center().child(
+                        h_flex().w_full().justify_center().child(
+                            Label::new("No threads match your search.").size(LabelSize::Small),
+                        ),
+                    )
+                } else {
+                    view.pr_5()
+                        .child(
+                            uniform_list(
+                                "thread-history",
+                                self.list_item_count(),
+                                cx.processor(|this, range: Range<usize>, window, cx| {
+                                    this.list_items(range, window, cx)
+                                }),
+                            )
+                            .p_1()
+                            .track_scroll(self.scroll_handle.clone())
+                            .flex_grow(),
+                        )
+                        .when_some(self.render_scrollbar(cx), |div, scrollbar| {
+                            div.child(scrollbar)
+                        })
+                }
+            })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct AcpHistoryEntryElement {
+    entry: HistoryEntry,
+    thread_view: WeakEntity<AcpThreadView>,
+    selected: bool,
+    hovered: bool,
+    on_hover: Box<dyn Fn(&bool, &mut Window, &mut App) + 'static>,
+}
+
+impl AcpHistoryEntryElement {
+    pub fn new(entry: HistoryEntry, thread_view: WeakEntity<AcpThreadView>) -> Self {
+        Self {
+            entry,
+            thread_view,
+            selected: false,
+            hovered: false,
+            on_hover: Box::new(|_, _, _| {}),
+        }
+    }
+
+    pub fn hovered(mut self, hovered: bool) -> Self {
+        self.hovered = hovered;
+        self
+    }
+
+    pub fn on_hover(mut self, on_hover: impl Fn(&bool, &mut Window, &mut App) + 'static) -> Self {
+        self.on_hover = Box::new(on_hover);
+        self
+    }
+}
+
+impl RenderOnce for AcpHistoryEntryElement {
+    fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
+        let id = self.entry.id();
+        let title = self.entry.title();
+        let timestamp = self.entry.updated_at();
+
+        let formatted_time = {
+            let now = chrono::Utc::now();
+            let duration = now.signed_duration_since(timestamp);
+
+            if duration.num_days() > 0 {
+                format!("{}d", duration.num_days())
+            } else if duration.num_hours() > 0 {
+                format!("{}h ago", duration.num_hours())
+            } else if duration.num_minutes() > 0 {
+                format!("{}m ago", duration.num_minutes())
+            } else {
+                "Just now".to_string()
+            }
+        };
+
+        ListItem::new(id)
+            .rounded()
+            .toggle_state(self.selected)
+            .spacing(ListItemSpacing::Sparse)
+            .start_slot(
+                h_flex()
+                    .w_full()
+                    .gap_2()
+                    .justify_between()
+                    .child(Label::new(title).size(LabelSize::Small).truncate())
+                    .child(
+                        Label::new(formatted_time)
+                            .color(Color::Muted)
+                            .size(LabelSize::XSmall),
+                    ),
+            )
+            .on_hover(self.on_hover)
+            .end_slot::<IconButton>(if self.hovered || self.selected {
+                Some(
+                    IconButton::new("delete", IconName::Trash)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::XSmall)
+                        .icon_color(Color::Muted)
+                        .tooltip(move |window, cx| {
+                            Tooltip::for_action("Delete", &RemoveSelectedThread, window, cx)
+                        })
+                        .on_click({
+                            let thread_view = self.thread_view.clone();
+                            let entry = self.entry.clone();
+
+                            move |_event, _window, cx| {
+                                if let Some(thread_view) = thread_view.upgrade() {
+                                    thread_view.update(cx, |thread_view, cx| {
+                                        thread_view.delete_history_entry(entry.clone(), cx);
+                                    });
+                                }
+                            }
+                        }),
+                )
+            } else {
+                None
+            })
+            .on_click({
+                let thread_view = self.thread_view.clone();
+                let entry = self.entry;
+
+                move |_event, window, cx| {
+                    if let Some(workspace) = thread_view
+                        .upgrade()
+                        .and_then(|view| view.read(cx).workspace().upgrade())
+                    {
+                        match &entry {
+                            HistoryEntry::AcpThread(thread_metadata) => {
+                                if let Some(panel) = workspace.read(cx).panel::<AgentPanel>(cx) {
+                                    panel.update(cx, |panel, cx| {
+                                        panel.load_agent_thread(
+                                            thread_metadata.clone(),
+                                            window,
+                                            cx,
+                                        );
+                                    });
+                                }
+                            }
+                            HistoryEntry::TextThread(context) => {
+                                if let Some(panel) = workspace.read(cx).panel::<AgentPanel>(cx) {
+                                    panel.update(cx, |panel, cx| {
+                                        panel
+                                            .open_saved_prompt_editor(
+                                                context.path.clone(),
+                                                window,
+                                                cx,
+                                            )
+                                            .detach_and_log_err(cx);
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            })
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum EntryTimeFormat {
+    DateAndTime,
+    TimeOnly,
+}
+
+impl EntryTimeFormat {
+    fn format_timestamp(&self, timestamp: i64, timezone: UtcOffset) -> String {
+        let timestamp = OffsetDateTime::from_unix_timestamp(timestamp).unwrap();
+
+        match self {
+            EntryTimeFormat::DateAndTime => time_format::format_localized_timestamp(
+                timestamp,
+                OffsetDateTime::now_utc(),
+                timezone,
+                time_format::TimestampFormat::EnhancedAbsolute,
+            ),
+            EntryTimeFormat::TimeOnly => time_format::format_time(timestamp),
+        }
+    }
+}
+
+impl From<TimeBucket> for EntryTimeFormat {
+    fn from(bucket: TimeBucket) -> Self {
+        match bucket {
+            TimeBucket::Today => EntryTimeFormat::TimeOnly,
+            TimeBucket::Yesterday => EntryTimeFormat::TimeOnly,
+            TimeBucket::ThisWeek => EntryTimeFormat::DateAndTime,
+            TimeBucket::PastWeek => EntryTimeFormat::DateAndTime,
+            TimeBucket::All => EntryTimeFormat::DateAndTime,
+        }
+    }
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+enum TimeBucket {
+    Today,
+    Yesterday,
+    ThisWeek,
+    PastWeek,
+    All,
+}
+
+impl TimeBucket {
+    fn from_dates(reference: NaiveDate, date: NaiveDate) -> Self {
+        if date == reference {
+            return TimeBucket::Today;
+        }
+
+        if date == reference - TimeDelta::days(1) {
+            return TimeBucket::Yesterday;
+        }
+
+        let week = date.iso_week();
+
+        if reference.iso_week() == week {
+            return TimeBucket::ThisWeek;
+        }
+
+        let last_week = (reference - TimeDelta::days(7)).iso_week();
+
+        if week == last_week {
+            return TimeBucket::PastWeek;
+        }
+
+        TimeBucket::All
+    }
+}
+
+impl Display for TimeBucket {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TimeBucket::Today => write!(f, "Today"),
+            TimeBucket::Yesterday => write!(f, "Yesterday"),
+            TimeBucket::ThisWeek => write!(f, "This Week"),
+            TimeBucket::PastWeek => write!(f, "Past Week"),
+            TimeBucket::All => write!(f, "All"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::NaiveDate;
+
+    #[test]
+    fn test_time_bucket_from_dates() {
+        let today = NaiveDate::from_ymd_opt(2023, 1, 15).unwrap();
+
+        let date = today;
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::Today);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 14).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::Yesterday);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 13).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::ThisWeek);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 11).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::ThisWeek);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 8).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::PastWeek);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 5).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::PastWeek);
+
+        // All: not in this week or last week
+        let date = NaiveDate::from_ymd_opt(2023, 1, 1).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::All);
+
+        // Test year boundary cases
+        let new_year = NaiveDate::from_ymd_opt(2023, 1, 1).unwrap();
+
+        let date = NaiveDate::from_ymd_opt(2022, 12, 31).unwrap();
+        assert_eq!(
+            TimeBucket::from_dates(new_year, date),
+            TimeBucket::Yesterday
+        );
+
+        let date = NaiveDate::from_ymd_opt(2022, 12, 28).unwrap();
+        assert_eq!(TimeBucket::from_dates(new_year, date), TimeBucket::ThisWeek);
+    }
+}

crates/agent_ui/src/active_thread.rs

@@ -434,7 +434,7 @@ fn render_markdown_code_block(
                             .child(content)
                             .child(
                                 Icon::new(IconName::ArrowUpRight)
-                                    .size(IconSize::XSmall)
+                                    .size(IconSize::Small)
                                     .color(Color::Ignored),
                             ),
                     )
@@ -491,7 +491,7 @@ fn render_markdown_code_block(
             .on_click({
                 let active_thread = active_thread.clone();
                 let parsed_markdown = parsed_markdown.clone();
-                let code_block_range = metadata.content_range.clone();
+                let code_block_range = metadata.content_range;
                 move |_event, _window, cx| {
                     active_thread.update(cx, |this, cx| {
                         this.copied_code_block_ids.insert((message_id, ix));
@@ -532,7 +532,6 @@ fn render_markdown_code_block(
                 "Expand Code"
             }))
             .on_click({
-                let active_thread = active_thread.clone();
                 move |_event, _window, cx| {
                     active_thread.update(cx, |this, cx| {
                         this.toggle_codeblock_expanded(message_id, ix);
@@ -780,13 +779,11 @@ impl ActiveThread {
 
         let list_state = ListState::new(0, ListAlignment::Bottom, px(2048.));
 
-        let workspace_subscription = if let Some(workspace) = workspace.upgrade() {
-            Some(cx.observe_release(&workspace, |this, _, cx| {
+        let workspace_subscription = workspace.upgrade().map(|workspace| {
+            cx.observe_release(&workspace, |this, _, cx| {
                 this.dismiss_notifications(cx);
-            }))
-        } else {
-            None
-        };
+            })
+        });
 
         let mut this = Self {
             language_registry,
@@ -916,7 +913,7 @@ impl ActiveThread {
     ) {
         let rendered = self
             .rendered_tool_uses
-            .entry(tool_use_id.clone())
+            .entry(tool_use_id)
             .or_insert_with(|| RenderedToolUse {
                 label: cx.new(|cx| {
                     Markdown::new("".into(), Some(self.language_registry.clone()), None, cx)
@@ -1044,12 +1041,12 @@ impl ActiveThread {
                 );
             }
             ThreadEvent::StreamedAssistantText(message_id, text) => {
-                if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(&message_id) {
+                if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(message_id) {
                     rendered_message.append_text(text, cx);
                 }
             }
             ThreadEvent::StreamedAssistantThinking(message_id, text) => {
-                if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(&message_id) {
+                if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(message_id) {
                     rendered_message.append_thinking(text, cx);
                 }
             }
@@ -1072,8 +1069,8 @@ impl ActiveThread {
             }
             ThreadEvent::MessageEdited(message_id) => {
                 self.clear_last_error();
-                if let Some(index) = self.messages.iter().position(|id| id == message_id) {
-                    if let Some(rendered_message) = self.thread.update(cx, |thread, cx| {
+                if let Some(index) = self.messages.iter().position(|id| id == message_id)
+                    && let Some(rendered_message) = self.thread.update(cx, |thread, cx| {
                         thread.message(*message_id).map(|message| {
                             let mut rendered_message = RenderedMessage {
                                 language_registry: self.language_registry.clone(),
@@ -1084,14 +1081,14 @@ impl ActiveThread {
                             }
                             rendered_message
                         })
-                    }) {
-                        self.list_state.splice(index..index + 1, 1);
-                        self.rendered_messages_by_id
-                            .insert(*message_id, rendered_message);
-                        self.scroll_to_bottom(cx);
-                        self.save_thread(cx);
-                        cx.notify();
-                    }
+                    })
+                {
+                    self.list_state.splice(index..index + 1, 1);
+                    self.rendered_messages_by_id
+                        .insert(*message_id, rendered_message);
+                    self.scroll_to_bottom(cx);
+                    self.save_thread(cx);
+                    cx.notify();
                 }
             }
             ThreadEvent::MessageDeleted(message_id) => {
@@ -1218,7 +1215,7 @@ impl ActiveThread {
         match AgentSettings::get_global(cx).notify_when_agent_waiting {
             NotifyWhenAgentWaiting::PrimaryScreen => {
                 if let Some(primary) = cx.primary_display() {
-                    self.pop_up(icon, caption.into(), title.clone(), window, primary, cx);
+                    self.pop_up(icon, caption.into(), title, window, primary, cx);
                 }
             }
             NotifyWhenAgentWaiting::AllScreens => {
@@ -1272,62 +1269,61 @@ impl ActiveThread {
                 })
             })
             .log_err()
+            && let Some(pop_up) = screen_window.entity(cx).log_err()
         {
-            if let Some(pop_up) = screen_window.entity(cx).log_err() {
-                self.notification_subscriptions
-                    .entry(screen_window)
-                    .or_insert_with(Vec::new)
-                    .push(cx.subscribe_in(&pop_up, window, {
-                        |this, _, event, window, cx| match event {
-                            AgentNotificationEvent::Accepted => {
-                                let handle = window.window_handle();
-                                cx.activate(true);
+            self.notification_subscriptions
+                .entry(screen_window)
+                .or_insert_with(Vec::new)
+                .push(cx.subscribe_in(&pop_up, window, {
+                    |this, _, event, window, cx| match event {
+                        AgentNotificationEvent::Accepted => {
+                            let handle = window.window_handle();
+                            cx.activate(true);
 
-                                let workspace_handle = this.workspace.clone();
+                            let workspace_handle = this.workspace.clone();
 
-                                // If there are multiple Zed windows, activate the correct one.
-                                cx.defer(move |cx| {
-                                    handle
-                                        .update(cx, |_view, window, _cx| {
-                                            window.activate_window();
+                            // If there are multiple Zed windows, activate the correct one.
+                            cx.defer(move |cx| {
+                                handle
+                                    .update(cx, |_view, window, _cx| {
+                                        window.activate_window();
 
-                                            if let Some(workspace) = workspace_handle.upgrade() {
-                                                workspace.update(_cx, |workspace, cx| {
-                                                    workspace.focus_panel::<AgentPanel>(window, cx);
-                                                });
-                                            }
-                                        })
-                                        .log_err();
-                                });
+                                        if let Some(workspace) = workspace_handle.upgrade() {
+                                            workspace.update(_cx, |workspace, cx| {
+                                                workspace.focus_panel::<AgentPanel>(window, cx);
+                                            });
+                                        }
+                                    })
+                                    .log_err();
+                            });
 
-                                this.dismiss_notifications(cx);
-                            }
-                            AgentNotificationEvent::Dismissed => {
-                                this.dismiss_notifications(cx);
-                            }
+                            this.dismiss_notifications(cx);
                         }
-                    }));
+                        AgentNotificationEvent::Dismissed => {
+                            this.dismiss_notifications(cx);
+                        }
+                    }
+                }));
 
-                self.notifications.push(screen_window);
+            self.notifications.push(screen_window);
 
-                // If the user manually refocuses the original window, dismiss the popup.
-                self.notification_subscriptions
-                    .entry(screen_window)
-                    .or_insert_with(Vec::new)
-                    .push({
-                        let pop_up_weak = pop_up.downgrade();
+            // If the user manually refocuses the original window, dismiss the popup.
+            self.notification_subscriptions
+                .entry(screen_window)
+                .or_insert_with(Vec::new)
+                .push({
+                    let pop_up_weak = pop_up.downgrade();
 
-                        cx.observe_window_activation(window, move |_, window, cx| {
-                            if window.is_window_active() {
-                                if let Some(pop_up) = pop_up_weak.upgrade() {
-                                    pop_up.update(cx, |_, cx| {
-                                        cx.emit(AgentNotificationEvent::Dismissed);
-                                    });
-                                }
-                            }
-                        })
-                    });
-            }
+                    cx.observe_window_activation(window, move |_, window, cx| {
+                        if window.is_window_active()
+                            && let Some(pop_up) = pop_up_weak.upgrade()
+                        {
+                            pop_up.update(cx, |_, cx| {
+                                cx.emit(AgentNotificationEvent::Dismissed);
+                            });
+                        }
+                    })
+                });
         }
     }
 
@@ -1374,12 +1370,12 @@ impl ActiveThread {
             editor.focus_handle(cx).focus(window);
             editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
         });
-        let buffer_edited_subscription = cx.subscribe(&editor, |this, _, event, cx| match event {
-            EditorEvent::BufferEdited => {
-                this.update_editing_message_token_count(true, cx);
-            }
-            _ => {}
-        });
+        let buffer_edited_subscription =
+            cx.subscribe(&editor, |this, _, event: &EditorEvent, cx| {
+                if event == &EditorEvent::BufferEdited {
+                    this.update_editing_message_token_count(true, cx);
+                }
+            });
 
         let context_picker_menu_handle = PopoverMenuHandle::default();
         let context_strip = cx.new(|cx| {
@@ -1766,7 +1762,7 @@ impl ActiveThread {
                 .thread
                 .read(cx)
                 .message(message_id)
-                .map(|msg| msg.to_string())
+                .map(|msg| msg.to_message_content())
                 .unwrap_or_default();
 
             telemetry::event!(
@@ -1896,8 +1892,9 @@ impl ActiveThread {
             (colors.editor_background, colors.panel_background)
         };
 
-        let open_as_markdown = IconButton::new(("open-as-markdown", ix), IconName::DocumentText)
-            .icon_size(IconSize::XSmall)
+        let open_as_markdown = IconButton::new(("open-as-markdown", ix), IconName::FileMarkdown)
+            .shape(ui::IconButtonShape::Square)
+            .icon_size(IconSize::Small)
             .icon_color(Color::Ignored)
             .tooltip(Tooltip::text("Open Thread as Markdown"))
             .on_click({
@@ -1911,8 +1908,9 @@ impl ActiveThread {
                 }
             });
 
-        let scroll_to_top = IconButton::new(("scroll_to_top", ix), IconName::ArrowUpAlt)
-            .icon_size(IconSize::XSmall)
+        let scroll_to_top = IconButton::new(("scroll_to_top", ix), IconName::ArrowUp)
+            .shape(ui::IconButtonShape::Square)
+            .icon_size(IconSize::Small)
             .icon_color(Color::Ignored)
             .tooltip(Tooltip::text("Scroll To Top"))
             .on_click(cx.listener(move |this, _, _, cx| {
@@ -1926,6 +1924,7 @@ impl ActiveThread {
             .py_2()
             .px(RESPONSE_PADDING_X)
             .mr_1()
+            .gap_1()
             .opacity(0.4)
             .hover(|style| style.opacity(1.))
             .gap_1p5()
@@ -1949,7 +1948,8 @@ impl ActiveThread {
                     h_flex()
                         .child(
                             IconButton::new(("feedback-thumbs-up", ix), IconName::ThumbsUp)
-                                .icon_size(IconSize::XSmall)
+                                .shape(ui::IconButtonShape::Square)
+                                .icon_size(IconSize::Small)
                                 .icon_color(match feedback {
                                     ThreadFeedback::Positive => Color::Accent,
                                     ThreadFeedback::Negative => Color::Ignored,
@@ -1966,7 +1966,8 @@ impl ActiveThread {
                         )
                         .child(
                             IconButton::new(("feedback-thumbs-down", ix), IconName::ThumbsDown)
-                                .icon_size(IconSize::XSmall)
+                                .shape(ui::IconButtonShape::Square)
+                                .icon_size(IconSize::Small)
                                 .icon_color(match feedback {
                                     ThreadFeedback::Positive => Color::Ignored,
                                     ThreadFeedback::Negative => Color::Accent,
@@ -1999,7 +2000,8 @@ impl ActiveThread {
                     h_flex()
                         .child(
                             IconButton::new(("feedback-thumbs-up", ix), IconName::ThumbsUp)
-                                .icon_size(IconSize::XSmall)
+                                .shape(ui::IconButtonShape::Square)
+                                .icon_size(IconSize::Small)
                                 .icon_color(Color::Ignored)
                                 .tooltip(Tooltip::text("Helpful Response"))
                                 .on_click(cx.listener(move |this, _, window, cx| {
@@ -2013,7 +2015,8 @@ impl ActiveThread {
                         )
                         .child(
                             IconButton::new(("feedback-thumbs-down", ix), IconName::ThumbsDown)
-                                .icon_size(IconSize::XSmall)
+                                .shape(ui::IconButtonShape::Square)
+                                .icon_size(IconSize::Small)
                                 .icon_color(Color::Ignored)
                                 .tooltip(Tooltip::text("Not Helpful"))
                                 .on_click(cx.listener(move |this, _, window, cx| {
@@ -2106,7 +2109,7 @@ impl ActiveThread {
                                         .gap_1()
                                         .children(message_content)
                                         .when_some(editing_message_state, |this, state| {
-                                            let focus_handle = state.editor.focus_handle(cx).clone();
+                                            let focus_handle = state.editor.focus_handle(cx);
 
                                             this.child(
                                                 h_flex()
@@ -2167,7 +2170,6 @@ impl ActiveThread {
                                                                 .icon_color(Color::Muted)
                                                                 .icon_size(IconSize::Small)
                                                                 .tooltip({
-                                                                    let focus_handle = focus_handle.clone();
                                                                     move |window, cx| {
                                                                         Tooltip::for_action_in(
                                                                             "Regenerate",
@@ -2240,9 +2242,7 @@ impl ActiveThread {
         let after_editing_message = self
             .editing_message
             .as_ref()
-            .map_or(false, |(editing_message_id, _)| {
-                message_id > *editing_message_id
-            });
+            .is_some_and(|(editing_message_id, _)| message_id > *editing_message_id);
 
         let backdrop = div()
             .id(("backdrop", ix))
@@ -2262,13 +2262,12 @@ impl ActiveThread {
                     let mut error = None;
                     if let Some(last_restore_checkpoint) =
                         self.thread.read(cx).last_restore_checkpoint()
+                        && last_restore_checkpoint.message_id() == message_id
                     {
-                        if last_restore_checkpoint.message_id() == message_id {
-                            match last_restore_checkpoint {
-                                LastRestoreCheckpoint::Pending { .. } => is_pending = true,
-                                LastRestoreCheckpoint::Error { error: err, .. } => {
-                                    error = Some(err.clone());
-                                }
+                        match last_restore_checkpoint {
+                            LastRestoreCheckpoint::Pending { .. } => is_pending = true,
+                            LastRestoreCheckpoint::Error { error: err, .. } => {
+                                error = Some(err.clone());
                             }
                         }
                     }
@@ -2309,7 +2308,7 @@ impl ActiveThread {
                             .into_any_element()
                     } else if let Some(error) = error {
                         restore_checkpoint_button
-                            .tooltip(Tooltip::text(error.to_string()))
+                            .tooltip(Tooltip::text(error))
                             .into_any_element()
                     } else {
                         restore_checkpoint_button.into_any_element()
@@ -2350,7 +2349,6 @@ impl ActiveThread {
                                     this.submit_feedback_message(message_id, cx);
                                     cx.notify();
                                 }))
-                                .on_action(cx.listener(Self::confirm_editing_message))
                                 .mb_2()
                                 .mx_4()
                                 .p_2()
@@ -2466,7 +2464,7 @@ impl ActiveThread {
                                 message_id,
                                 index,
                                 content.clone(),
-                                &scroll_handle,
+                                scroll_handle,
                                 Some(index) == pending_thinking_segment_index,
                                 window,
                                 cx,
@@ -2590,7 +2588,7 @@ impl ActiveThread {
             .id(("message-container", ix))
             .py_1()
             .px_2p5()
-            .child(Banner::new().severity(ui::Severity::Warning).child(message))
+            .child(Banner::new().severity(Severity::Warning).child(message))
     }
 
     fn render_message_thinking_segment(
@@ -2750,7 +2748,7 @@ impl ActiveThread {
                                 h_flex()
                                     .gap_1p5()
                                     .child(
-                                        Icon::new(IconName::LightBulb)
+                                        Icon::new(IconName::ToolThink)
                                             .size(IconSize::XSmall)
                                             .color(Color::Muted),
                                     )
@@ -3362,7 +3360,7 @@ impl ActiveThread {
                                 .mr_0p5(),
                         )
                         .child(
-                            IconButton::new("open-prompt-library", IconName::ArrowUpRightAlt)
+                            IconButton::new("open-prompt-library", IconName::ArrowUpRight)
                                 .shape(ui::IconButtonShape::Square)
                                 .icon_size(IconSize::XSmall)
                                 .icon_color(Color::Ignored)
@@ -3397,7 +3395,7 @@ impl ActiveThread {
                                 .mr_0p5(),
                         )
                         .child(
-                            IconButton::new("open-rule", IconName::ArrowUpRightAlt)
+                            IconButton::new("open-rule", IconName::ArrowUpRight)
                                 .shape(ui::IconButtonShape::Square)
                                 .icon_size(IconSize::XSmall)
                                 .icon_color(Color::Ignored)
@@ -4013,7 +4011,7 @@ mod tests {
 
         cx.run_until_parked();
 
-        // Verify that the previous completion was cancelled
+        // Verify that the previous completion was canceled
         assert_eq!(cancellation_events.lock().unwrap().len(), 1);
 
         // Verify that a new request was started after cancellation

crates/agent_ui/src/agent_configuration.rs

@@ -96,7 +96,7 @@ impl AgentConfiguration {
         let mut expanded_provider_configurations = HashMap::default();
         if LanguageModelRegistry::read_global(cx)
             .provider(&ZED_CLOUD_PROVIDER_ID)
-            .map_or(false, |cloud_provider| cloud_provider.must_accept_terms(cx))
+            .is_some_and(|cloud_provider| cloud_provider.must_accept_terms(cx))
         {
             expanded_provider_configurations.insert(ZED_CLOUD_PROVIDER_ID, true);
         }
@@ -137,7 +137,11 @@ impl AgentConfiguration {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let configuration_view = provider.configuration_view(window, cx);
+        let configuration_view = provider.configuration_view(
+            language_model::ConfigurationViewTargetAgent::ZedAgent,
+            window,
+            cx,
+        );
         self.configuration_views_by_provider
             .insert(provider.id(), configuration_view);
     }
@@ -161,8 +165,8 @@ impl AgentConfiguration {
         provider: &Arc<dyn LanguageModelProvider>,
         cx: &mut Context<Self>,
     ) -> impl IntoElement + use<> {
-        let provider_id = provider.id().0.clone();
-        let provider_name = provider.name().0.clone();
+        let provider_id = provider.id().0;
+        let provider_name = provider.name().0;
         let provider_id_string = SharedString::from(format!("provider-disclosure-{provider_id}"));
 
         let configuration_view = self
@@ -188,7 +192,7 @@ impl AgentConfiguration {
         let is_signed_in = self
             .workspace
             .read_with(cx, |workspace, _| {
-                workspace.client().status().borrow().is_connected()
+                !workspace.client().status().borrow().is_signed_out()
             })
             .unwrap_or(false);
 
@@ -265,7 +269,7 @@ impl AgentConfiguration {
                                     .closed_icon(IconName::ChevronDown),
                             )
                             .on_click(cx.listener({
-                                let provider_id = provider.id().clone();
+                                let provider_id = provider.id();
                                 move |this, _event, _window, _cx| {
                                     let is_expanded = this
                                         .expanded_provider_configurations
@@ -300,6 +304,7 @@ impl AgentConfiguration {
             )
             .child(
                 div()
+                    .w_full()
                     .px_2()
                     .when(is_expanded, |parent| match configuration_view {
                         Some(configuration_view) => parent.child(configuration_view),
@@ -465,7 +470,7 @@ impl AgentConfiguration {
             "modifier-send",
             "Use modifier to submit a message",
             Some(
-                "Make a modifier (cmd-enter on macOS, ctrl-enter on Linux) required to send messages.".into(),
+                "Make a modifier (cmd-enter on macOS, ctrl-enter on Linux or Windows) required to send messages.".into(),
             ),
             use_modifier_to_send,
             move |state, _window, cx| {
@@ -573,7 +578,7 @@ impl AgentConfiguration {
                             .style(ButtonStyle::Filled)
                             .layer(ElevationIndex::ModalSurface)
                             .full_width()
-                            .icon(IconName::Hammer)
+                            .icon(IconName::ToolHammer)
                             .icon_size(IconSize::Small)
                             .icon_position(IconPosition::Start)
                             .on_click(|_event, window, cx| {
@@ -660,7 +665,7 @@ impl AgentConfiguration {
                     .size(IconSize::XSmall)
                     .color(Color::Accent)
                     .with_animation(
-                        SharedString::from(format!("{}-starting", context_server_id.0.clone(),)),
+                        SharedString::from(format!("{}-starting", context_server_id.0,)),
                         Animation::new(Duration::from_secs(3)).repeat(),
                         |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
                     )
@@ -860,7 +865,6 @@ impl AgentConfiguration {
                                     .on_click({
                                         let context_server_manager =
                                             self.context_server_store.clone();
-                                        let context_server_id = context_server_id.clone();
                                         let fs = self.fs.clone();
 
                                         move |state, _window, cx| {
@@ -953,7 +957,7 @@ impl AgentConfiguration {
                 }
 
                 parent.child(v_flex().py_1p5().px_1().gap_1().children(
-                    tools.into_iter().enumerate().map(|(ix, tool)| {
+                    tools.iter().enumerate().map(|(ix, tool)| {
                         h_flex()
                             .id(("tool-item", ix))
                             .px_1()
@@ -1035,7 +1039,6 @@ fn extension_only_provides_context_server(manifest: &ExtensionManifest) -> bool
         && manifest.grammars.is_empty()
         && manifest.language_servers.is_empty()
         && manifest.slash_commands.is_empty()
-        && manifest.indexed_docs_providers.is_empty()
         && manifest.snippets.is_none()
         && manifest.debug_locators.is_empty()
 }
@@ -1071,7 +1074,6 @@ fn show_unable_to_uninstall_extension_with_context_server(
         cx,
         move |this, _cx| {
             let workspace_handle = workspace_handle.clone();
-            let context_server_id = context_server_id.clone();
 
             this.icon(ToastIcon::new(IconName::Warning).color(Color::Warning))
                 .dismiss_button(true)

crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs

@@ -7,10 +7,12 @@ use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Render, T
 use language_model::LanguageModelRegistry;
 use language_models::{
     AllLanguageModelSettings, OpenAiCompatibleSettingsContent,
-    provider::open_ai_compatible::AvailableModel,
+    provider::open_ai_compatible::{AvailableModel, ModelCapabilities},
 };
 use settings::update_settings_file;
-use ui::{Banner, KeyBinding, Modal, ModalFooter, ModalHeader, Section, prelude::*};
+use ui::{
+    Banner, Checkbox, KeyBinding, Modal, ModalFooter, ModalHeader, Section, ToggleState, prelude::*,
+};
 use ui_input::SingleLineInput;
 use workspace::{ModalView, Workspace};
 
@@ -69,11 +71,19 @@ impl AddLlmProviderInput {
     }
 }
 
+struct ModelCapabilityToggles {
+    pub supports_tools: ToggleState,
+    pub supports_images: ToggleState,
+    pub supports_parallel_tool_calls: ToggleState,
+    pub supports_prompt_cache_key: ToggleState,
+}
+
 struct ModelInput {
     name: Entity<SingleLineInput>,
     max_completion_tokens: Entity<SingleLineInput>,
     max_output_tokens: Entity<SingleLineInput>,
     max_tokens: Entity<SingleLineInput>,
+    capabilities: ModelCapabilityToggles,
 }
 
 impl ModelInput {
@@ -100,11 +110,23 @@ impl ModelInput {
             cx,
         );
         let max_tokens = single_line_input("Max Tokens", "Max Tokens", Some("200000"), window, cx);
+        let ModelCapabilities {
+            tools,
+            images,
+            parallel_tool_calls,
+            prompt_cache_key,
+        } = ModelCapabilities::default();
         Self {
             name: model_name,
             max_completion_tokens,
             max_output_tokens,
             max_tokens,
+            capabilities: ModelCapabilityToggles {
+                supports_tools: tools.into(),
+                supports_images: images.into(),
+                supports_parallel_tool_calls: parallel_tool_calls.into(),
+                supports_prompt_cache_key: prompt_cache_key.into(),
+            },
         }
     }
 
@@ -136,6 +158,12 @@ impl ModelInput {
                 .text(cx)
                 .parse::<u64>()
                 .map_err(|_| SharedString::from("Max Tokens must be a number"))?,
+            capabilities: ModelCapabilities {
+                tools: self.capabilities.supports_tools.selected(),
+                images: self.capabilities.supports_images.selected(),
+                parallel_tool_calls: self.capabilities.supports_parallel_tool_calls.selected(),
+                prompt_cache_key: self.capabilities.supports_prompt_cache_key.selected(),
+            },
         })
     }
 }
@@ -322,6 +350,55 @@ impl AddLlmProviderModal {
                     .child(model.max_output_tokens.clone()),
             )
             .child(model.max_tokens.clone())
+            .child(
+                v_flex()
+                    .gap_1()
+                    .child(
+                        Checkbox::new(("supports-tools", ix), model.capabilities.supports_tools)
+                            .label("Supports tools")
+                            .on_click(cx.listener(move |this, checked, _window, cx| {
+                                this.input.models[ix].capabilities.supports_tools = *checked;
+                                cx.notify();
+                            })),
+                    )
+                    .child(
+                        Checkbox::new(("supports-images", ix), model.capabilities.supports_images)
+                            .label("Supports images")
+                            .on_click(cx.listener(move |this, checked, _window, cx| {
+                                this.input.models[ix].capabilities.supports_images = *checked;
+                                cx.notify();
+                            })),
+                    )
+                    .child(
+                        Checkbox::new(
+                            ("supports-parallel-tool-calls", ix),
+                            model.capabilities.supports_parallel_tool_calls,
+                        )
+                        .label("Supports parallel_tool_calls")
+                        .on_click(cx.listener(
+                            move |this, checked, _window, cx| {
+                                this.input.models[ix]
+                                    .capabilities
+                                    .supports_parallel_tool_calls = *checked;
+                                cx.notify();
+                            },
+                        )),
+                    )
+                    .child(
+                        Checkbox::new(
+                            ("supports-prompt-cache-key", ix),
+                            model.capabilities.supports_prompt_cache_key,
+                        )
+                        .label("Supports prompt_cache_key")
+                        .on_click(cx.listener(
+                            move |this, checked, _window, cx| {
+                                this.input.models[ix].capabilities.supports_prompt_cache_key =
+                                    *checked;
+                                cx.notify();
+                            },
+                        )),
+                    ),
+            )
             .when(has_more_than_one_model, |this| {
                 this.child(
                     Button::new(("remove-model", ix), "Remove Model")
@@ -377,7 +454,7 @@ impl Render for AddLlmProviderModal {
                         this.section(
                             Section::new().child(
                                 Banner::new()
-                                    .severity(ui::Severity::Warning)
+                                    .severity(Severity::Warning)
                                     .child(div().text_xs().child(error)),
                             ),
                         )
@@ -562,6 +639,93 @@ mod tests {
         );
     }
 
+    #[gpui::test]
+    async fn test_model_input_default_capabilities(cx: &mut TestAppContext) {
+        let cx = setup_test(cx).await;
+
+        cx.update(|window, cx| {
+            let model_input = ModelInput::new(window, cx);
+            model_input.name.update(cx, |input, cx| {
+                input.editor().update(cx, |editor, cx| {
+                    editor.set_text("somemodel", window, cx);
+                });
+            });
+            assert_eq!(
+                model_input.capabilities.supports_tools,
+                ToggleState::Selected
+            );
+            assert_eq!(
+                model_input.capabilities.supports_images,
+                ToggleState::Unselected
+            );
+            assert_eq!(
+                model_input.capabilities.supports_parallel_tool_calls,
+                ToggleState::Unselected
+            );
+            assert_eq!(
+                model_input.capabilities.supports_prompt_cache_key,
+                ToggleState::Unselected
+            );
+
+            let parsed_model = model_input.parse(cx).unwrap();
+            assert!(parsed_model.capabilities.tools);
+            assert!(!parsed_model.capabilities.images);
+            assert!(!parsed_model.capabilities.parallel_tool_calls);
+            assert!(!parsed_model.capabilities.prompt_cache_key);
+        });
+    }
+
+    #[gpui::test]
+    async fn test_model_input_deselected_capabilities(cx: &mut TestAppContext) {
+        let cx = setup_test(cx).await;
+
+        cx.update(|window, cx| {
+            let mut model_input = ModelInput::new(window, cx);
+            model_input.name.update(cx, |input, cx| {
+                input.editor().update(cx, |editor, cx| {
+                    editor.set_text("somemodel", window, cx);
+                });
+            });
+
+            model_input.capabilities.supports_tools = ToggleState::Unselected;
+            model_input.capabilities.supports_images = ToggleState::Unselected;
+            model_input.capabilities.supports_parallel_tool_calls = ToggleState::Unselected;
+            model_input.capabilities.supports_prompt_cache_key = ToggleState::Unselected;
+
+            let parsed_model = model_input.parse(cx).unwrap();
+            assert!(!parsed_model.capabilities.tools);
+            assert!(!parsed_model.capabilities.images);
+            assert!(!parsed_model.capabilities.parallel_tool_calls);
+            assert!(!parsed_model.capabilities.prompt_cache_key);
+        });
+    }
+
+    #[gpui::test]
+    async fn test_model_input_with_name_and_capabilities(cx: &mut TestAppContext) {
+        let cx = setup_test(cx).await;
+
+        cx.update(|window, cx| {
+            let mut model_input = ModelInput::new(window, cx);
+            model_input.name.update(cx, |input, cx| {
+                input.editor().update(cx, |editor, cx| {
+                    editor.set_text("somemodel", window, cx);
+                });
+            });
+
+            model_input.capabilities.supports_tools = ToggleState::Selected;
+            model_input.capabilities.supports_images = ToggleState::Unselected;
+            model_input.capabilities.supports_parallel_tool_calls = ToggleState::Selected;
+            model_input.capabilities.supports_prompt_cache_key = ToggleState::Unselected;
+
+            let parsed_model = model_input.parse(cx).unwrap();
+            assert_eq!(parsed_model.name, "somemodel");
+            assert!(parsed_model.capabilities.tools);
+            assert!(!parsed_model.capabilities.images);
+            assert!(parsed_model.capabilities.parallel_tool_calls);
+            assert!(!parsed_model.capabilities.prompt_cache_key);
+        });
+    }
+
     async fn setup_test(cx: &mut TestAppContext) -> &mut VisualTestContext {
         cx.update(|cx| {
             let store = SettingsStore::test(cx);

crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs

@@ -163,10 +163,10 @@ impl ConfigurationSource {
                     .read(cx)
                     .text(cx);
                 let settings = serde_json_lenient::from_str::<serde_json::Value>(&text)?;
-                if let Some(settings_validator) = settings_validator {
-                    if let Err(error) = settings_validator.validate(&settings) {
-                        return Err(anyhow::anyhow!(error.to_string()));
-                    }
+                if let Some(settings_validator) = settings_validator
+                    && let Err(error) = settings_validator.validate(&settings)
+                {
+                    return Err(anyhow::anyhow!(error.to_string()));
                 }
                 Ok((
                     id.clone(),
@@ -261,7 +261,6 @@ impl ConfigureContextServerModal {
         _cx: &mut Context<Workspace>,
     ) {
         workspace.register_action({
-            let language_registry = language_registry.clone();
             move |_workspace, _: &AddContextServer, window, cx| {
                 let workspace_handle = cx.weak_entity();
                 let language_registry = language_registry.clone();
@@ -438,7 +437,7 @@ impl ConfigureContextServerModal {
                         format!("{} configured successfully.", id.0),
                         cx,
                         |this, _cx| {
-                            this.icon(ToastIcon::new(IconName::Hammer).color(Color::Muted))
+                            this.icon(ToastIcon::new(IconName::ToolHammer).color(Color::Muted))
                                 .action("Dismiss", |_, _| {})
                         },
                     );
@@ -487,7 +486,7 @@ impl ConfigureContextServerModal {
     }
 
     fn render_modal_description(&self, window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
-        const MODAL_DESCRIPTION: &'static str = "Visit the MCP server configuration docs to find all necessary arguments and environment variables.";
+        const MODAL_DESCRIPTION: &str = "Visit the MCP server configuration docs to find all necessary arguments and environment variables.";
 
         if let ConfigurationSource::Extension {
             installation_instructions: Some(installation_instructions),
@@ -567,7 +566,7 @@ impl ConfigureContextServerModal {
                         Button::new("open-repository", "Open Repository")
                             .icon(IconName::ArrowUpRight)
                             .icon_color(Color::Muted)
-                            .icon_size(IconSize::XSmall)
+                            .icon_size(IconSize::Small)
                             .tooltip({
                                 let repository_url = repository_url.clone();
                                 move |window, cx| {
@@ -716,24 +715,24 @@ fn wait_for_context_server(
         project::context_server_store::Event::ServerStatusChanged { server_id, status } => {
             match status {
                 ContextServerStatus::Running => {
-                    if server_id == &context_server_id {
-                        if let Some(tx) = tx.lock().unwrap().take() {
-                            let _ = tx.send(Ok(()));
-                        }
+                    if server_id == &context_server_id
+                        && let Some(tx) = tx.lock().unwrap().take()
+                    {
+                        let _ = tx.send(Ok(()));
                     }
                 }
                 ContextServerStatus::Stopped => {
-                    if server_id == &context_server_id {
-                        if let Some(tx) = tx.lock().unwrap().take() {
-                            let _ = tx.send(Err("Context server stopped running".into()));
-                        }
+                    if server_id == &context_server_id
+                        && let Some(tx) = tx.lock().unwrap().take()
+                    {
+                        let _ = tx.send(Err("Context server stopped running".into()));
                     }
                 }
                 ContextServerStatus::Error(error) => {
-                    if server_id == &context_server_id {
-                        if let Some(tx) = tx.lock().unwrap().take() {
-                            let _ = tx.send(Err(error.clone()));
-                        }
+                    if server_id == &context_server_id
+                        && let Some(tx) = tx.lock().unwrap().take()
+                    {
+                        let _ = tx.send(Err(error.clone()));
                     }
                 }
                 _ => {}

crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs

@@ -464,7 +464,7 @@ impl ManageProfilesModal {
                 },
             ))
             .child(ListSeparator)
-            .child(h_flex().p_2().child(mode.name_editor.clone()))
+            .child(h_flex().p_2().child(mode.name_editor))
     }
 
     fn render_view_profile(
@@ -594,7 +594,7 @@ impl ManageProfilesModal {
                                         .inset(true)
                                         .spacing(ListItemSpacing::Sparse)
                                         .start_slot(
-                                            Icon::new(IconName::Hammer)
+                                            Icon::new(IconName::ToolHammer)
                                                 .size(IconSize::Small)
                                                 .color(Color::Muted),
                                         )
@@ -763,7 +763,7 @@ impl Render for ManageProfilesModal {
                         .pb_1()
                         .child(ProfileModalHeader::new(
                             format!("{profile_name} — Configure MCP Tools"),
-                            Some(IconName::Hammer),
+                            Some(IconName::ToolHammer),
                         ))
                         .child(ListSeparator)
                         .child(tool_picker.clone())

crates/agent_ui/src/agent_configuration/tool_picker.rs

@@ -191,10 +191,10 @@ impl PickerDelegate for ToolPickerDelegate {
                         BTreeMap::default();
 
                     for item in all_items.iter() {
-                        if let PickerItem::Tool { server_id, name } = item.clone() {
-                            if name.contains(&query) {
-                                tools_by_provider.entry(server_id).or_default().push(name);
-                            }
+                        if let PickerItem::Tool { server_id, name } = item.clone()
+                            && name.contains(&query)
+                        {
+                            tools_by_provider.entry(server_id).or_default().push(name);
                         }
                     }
 

crates/agent_ui/src/agent_diff.rs

@@ -1,9 +1,9 @@
 use crate::{Keep, KeepAll, OpenAgentDiff, Reject, RejectAll};
 use acp_thread::{AcpThread, AcpThreadEvent};
+use action_log::ActionLog;
 use agent::{Thread, ThreadEvent, ThreadSummary};
 use agent_settings::AgentSettings;
 use anyhow::Result;
-use assistant_tool::ActionLog;
 use buffer_diff::DiffHunkStatus;
 use collections::{HashMap, HashSet};
 use editor::{
@@ -185,7 +185,7 @@ impl AgentDiffPane {
         let focus_handle = cx.focus_handle();
         let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
 
-        let project = thread.project(cx).clone();
+        let project = thread.project(cx);
         let editor = cx.new(|cx| {
             let mut editor =
                 Editor::for_multibuffer(multibuffer.clone(), Some(project.clone()), window, cx);
@@ -196,27 +196,24 @@ impl AgentDiffPane {
             editor
         });
 
-        let action_log = thread.action_log(cx).clone();
+        let action_log = thread.action_log(cx);
 
         let mut this = Self {
-            _subscriptions: [
-                Some(
-                    cx.observe_in(&action_log, window, |this, _action_log, window, cx| {
-                        this.update_excerpts(window, cx)
-                    }),
-                ),
+            _subscriptions: vec![
+                cx.observe_in(&action_log, window, |this, _action_log, window, cx| {
+                    this.update_excerpts(window, cx)
+                }),
                 match &thread {
-                    AgentDiffThread::Native(thread) => {
-                        Some(cx.subscribe(&thread, |this, _thread, event, cx| {
-                            this.handle_thread_event(event, cx)
-                        }))
-                    }
-                    AgentDiffThread::AcpThread(_) => None,
+                    AgentDiffThread::Native(thread) => cx
+                        .subscribe(thread, |this, _thread, event, cx| {
+                            this.handle_native_thread_event(event, cx)
+                        }),
+                    AgentDiffThread::AcpThread(thread) => cx
+                        .subscribe(thread, |this, _thread, event, cx| {
+                            this.handle_acp_thread_event(event, cx)
+                        }),
                 },
-            ]
-            .into_iter()
-            .flatten()
-            .collect(),
+            ],
             title: SharedString::default(),
             multibuffer,
             editor,
@@ -288,7 +285,7 @@ impl AgentDiffPane {
                     && buffer
                         .read(cx)
                         .file()
-                        .map_or(false, |file| file.disk_state() == DiskState::Deleted)
+                        .is_some_and(|file| file.disk_state() == DiskState::Deleted)
                 {
                     editor.fold_buffer(snapshot.text.remote_id(), cx)
                 }
@@ -324,10 +321,15 @@ impl AgentDiffPane {
         }
     }
 
-    fn handle_thread_event(&mut self, event: &ThreadEvent, cx: &mut Context<Self>) {
-        match event {
-            ThreadEvent::SummaryGenerated => self.update_title(cx),
-            _ => {}
+    fn handle_native_thread_event(&mut self, event: &ThreadEvent, cx: &mut Context<Self>) {
+        if let ThreadEvent::SummaryGenerated = event {
+            self.update_title(cx)
+        }
+    }
+
+    fn handle_acp_thread_event(&mut self, event: &AcpThreadEvent, cx: &mut Context<Self>) {
+        if let AcpThreadEvent::TitleUpdated = event {
+            self.update_title(cx)
         }
     }
 
@@ -398,7 +400,7 @@ fn keep_edits_in_selection(
         .disjoint_anchor_ranges()
         .collect::<Vec<_>>();
 
-    keep_edits_in_ranges(editor, buffer_snapshot, &thread, ranges, window, cx)
+    keep_edits_in_ranges(editor, buffer_snapshot, thread, ranges, window, cx)
 }
 
 fn reject_edits_in_selection(
@@ -412,7 +414,7 @@ fn reject_edits_in_selection(
         .selections
         .disjoint_anchor_ranges()
         .collect::<Vec<_>>();
-    reject_edits_in_ranges(editor, buffer_snapshot, &thread, ranges, window, cx)
+    reject_edits_in_ranges(editor, buffer_snapshot, thread, ranges, window, cx)
 }
 
 fn keep_edits_in_ranges(
@@ -503,8 +505,7 @@ fn update_editor_selection(
                         &[last_kept_hunk_end..editor::Anchor::max()],
                         buffer_snapshot,
                     )
-                    .skip(1)
-                    .next()
+                    .nth(1)
             })
             .or_else(|| {
                 let first_kept_hunk = diff_hunks.first()?;
@@ -1001,7 +1002,7 @@ impl AgentDiffToolbar {
             return;
         };
 
-        *state = agent_diff.read(cx).editor_state(&editor);
+        *state = agent_diff.read(cx).editor_state(editor);
         self.update_location(cx);
         cx.notify();
     }
@@ -1044,23 +1045,23 @@ impl ToolbarItemView for AgentDiffToolbar {
                 return self.location(cx);
             }
 
-            if let Some(editor) = item.act_as::<Editor>(cx) {
-                if editor.read(cx).mode().is_full() {
-                    let agent_diff = AgentDiff::global(cx);
+            if let Some(editor) = item.act_as::<Editor>(cx)
+                && editor.read(cx).mode().is_full()
+            {
+                let agent_diff = AgentDiff::global(cx);
 
-                    self.active_item = Some(AgentDiffToolbarItem::Editor {
-                        editor: editor.downgrade(),
-                        state: agent_diff.read(cx).editor_state(&editor.downgrade()),
-                        _diff_subscription: cx.observe(&agent_diff, Self::handle_diff_notify),
-                    });
+                self.active_item = Some(AgentDiffToolbarItem::Editor {
+                    editor: editor.downgrade(),
+                    state: agent_diff.read(cx).editor_state(&editor.downgrade()),
+                    _diff_subscription: cx.observe(&agent_diff, Self::handle_diff_notify),
+                });
 
-                    return self.location(cx);
-                }
+                return self.location(cx);
             }
         }
 
         self.active_item = None;
-        return self.location(cx);
+        self.location(cx)
     }
 
     fn pane_focus_update(
@@ -1311,7 +1312,7 @@ impl AgentDiff {
                 let entity = cx.new(|_cx| Self::default());
                 let global = AgentDiffGlobal(entity.clone());
                 cx.set_global(global);
-                entity.clone()
+                entity
             })
     }
 
@@ -1333,7 +1334,7 @@ impl AgentDiff {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let action_log = thread.action_log(cx).clone();
+        let action_log = thread.action_log(cx);
 
         let action_log_subscription = cx.observe_in(&action_log, window, {
             let workspace = workspace.clone();
@@ -1343,13 +1344,13 @@ impl AgentDiff {
         });
 
         let thread_subscription = match &thread {
-            AgentDiffThread::Native(thread) => cx.subscribe_in(&thread, window, {
+            AgentDiffThread::Native(thread) => cx.subscribe_in(thread, window, {
                 let workspace = workspace.clone();
                 move |this, _thread, event, window, cx| {
                     this.handle_native_thread_event(&workspace, event, window, cx)
                 }
             }),
-            AgentDiffThread::AcpThread(thread) => cx.subscribe_in(&thread, window, {
+            AgentDiffThread::AcpThread(thread) => cx.subscribe_in(thread, window, {
                 let workspace = workspace.clone();
                 move |this, thread, event, window, cx| {
                     this.handle_acp_thread_event(&workspace, thread, event, window, cx)
@@ -1357,11 +1358,11 @@ impl AgentDiff {
             }),
         };
 
-        if let Some(workspace_thread) = self.workspace_threads.get_mut(&workspace) {
+        if let Some(workspace_thread) = self.workspace_threads.get_mut(workspace) {
             // replace thread and action log subscription, but keep editors
             workspace_thread.thread = thread.downgrade();
             workspace_thread._thread_subscriptions = (action_log_subscription, thread_subscription);
-            self.update_reviewing_editors(&workspace, window, cx);
+            self.update_reviewing_editors(workspace, window, cx);
             return;
         }
 
@@ -1506,7 +1507,7 @@ impl AgentDiff {
                     .read(cx)
                     .entries()
                     .last()
-                    .map_or(false, |entry| entry.diffs().next().is_some())
+                    .is_some_and(|entry| entry.diffs().next().is_some())
                 {
                     self.update_reviewing_editors(workspace, window, cx);
                 }
@@ -1516,15 +1517,19 @@ impl AgentDiff {
                     .read(cx)
                     .entries()
                     .get(*ix)
-                    .map_or(false, |entry| entry.diffs().next().is_some())
+                    .is_some_and(|entry| entry.diffs().next().is_some())
                 {
                     self.update_reviewing_editors(workspace, window, cx);
                 }
             }
-            AcpThreadEvent::Stopped
+            AcpThreadEvent::Stopped | AcpThreadEvent::Error | AcpThreadEvent::LoadError(_) => {
+                self.update_reviewing_editors(workspace, window, cx);
+            }
+            AcpThreadEvent::TitleUpdated
+            | AcpThreadEvent::TokenUsageUpdated
+            | AcpThreadEvent::EntriesRemoved(_)
             | AcpThreadEvent::ToolAuthorizationRequired
-            | AcpThreadEvent::Error
-            | AcpThreadEvent::ServerExited(_) => {}
+            | AcpThreadEvent::Retry(_) => {}
         }
     }
 
@@ -1535,21 +1540,11 @@ impl AgentDiff {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        match event {
-            workspace::Event::ItemAdded { item } => {
-                if let Some(editor) = item.downcast::<Editor>() {
-                    if let Some(buffer) = Self::full_editor_buffer(editor.read(cx), cx) {
-                        self.register_editor(
-                            workspace.downgrade(),
-                            buffer.clone(),
-                            editor,
-                            window,
-                            cx,
-                        );
-                    }
-                }
-            }
-            _ => {}
+        if let workspace::Event::ItemAdded { item } = event
+            && let Some(editor) = item.downcast::<Editor>()
+            && let Some(buffer) = Self::full_editor_buffer(editor.read(cx), cx)
+        {
+            self.register_editor(workspace.downgrade(), buffer, editor, window, cx);
         }
     }
 
@@ -1648,7 +1643,7 @@ impl AgentDiff {
                 continue;
             };
 
-            for (weak_editor, _) in buffer_editors {
+            for weak_editor in buffer_editors.keys() {
                 let Some(editor) = weak_editor.upgrade() else {
                     continue;
                 };
@@ -1676,7 +1671,7 @@ impl AgentDiff {
                         editor.register_addon(EditorAgentDiffAddon);
                     });
                 } else {
-                    unaffected.remove(&weak_editor);
+                    unaffected.remove(weak_editor);
                 }
 
                 if new_state == EditorState::Reviewing && previous_state != Some(new_state) {
@@ -1709,7 +1704,7 @@ impl AgentDiff {
                 .read_with(cx, |editor, _cx| editor.workspace())
                 .ok()
                 .flatten()
-                .map_or(false, |editor_workspace| {
+                .is_some_and(|editor_workspace| {
                     editor_workspace.entity_id() == workspace.entity_id()
                 });
 
@@ -1729,7 +1724,7 @@ impl AgentDiff {
 
     fn editor_state(&self, editor: &WeakEntity<Editor>) -> EditorState {
         self.reviewing_editors
-            .get(&editor)
+            .get(editor)
             .cloned()
             .unwrap_or(EditorState::Idle)
     }
@@ -1849,26 +1844,26 @@ impl AgentDiff {
 
         let thread = thread.upgrade()?;
 
-        if let PostReviewState::AllReviewed = review(&editor, &thread, window, cx) {
-            if let Some(curr_buffer) = editor.read(cx).buffer().read(cx).as_singleton() {
-                let changed_buffers = thread.action_log(cx).read(cx).changed_buffers(cx);
+        if let PostReviewState::AllReviewed = review(&editor, &thread, window, cx)
+            && let Some(curr_buffer) = editor.read(cx).buffer().read(cx).as_singleton()
+        {
+            let changed_buffers = thread.action_log(cx).read(cx).changed_buffers(cx);
 
-                let mut keys = changed_buffers.keys().cycle();
-                keys.find(|k| *k == &curr_buffer);
-                let next_project_path = keys
-                    .next()
-                    .filter(|k| *k != &curr_buffer)
-                    .and_then(|after| after.read(cx).project_path(cx));
+            let mut keys = changed_buffers.keys().cycle();
+            keys.find(|k| *k == &curr_buffer);
+            let next_project_path = keys
+                .next()
+                .filter(|k| *k != &curr_buffer)
+                .and_then(|after| after.read(cx).project_path(cx));
 
-                if let Some(path) = next_project_path {
-                    let task = workspace.open_path(path, None, true, window, cx);
-                    let task = cx.spawn(async move |_, _cx| task.await.map(|_| ()));
-                    return Some(task);
-                }
+            if let Some(path) = next_project_path {
+                let task = workspace.open_path(path, None, true, window, cx);
+                let task = cx.spawn(async move |_, _cx| task.await.map(|_| ()));
+                return Some(task);
             }
         }
 
-        return Some(Task::ready(Ok(())));
+        Some(Task::ready(Ok(())))
     }
 }
 

crates/agent_ui/src/agent_model_selector.rs

@@ -66,10 +66,8 @@ impl AgentModelSelector {
                                     fs.clone(),
                                     cx,
                                     move |settings, _cx| {
-                                        settings.set_inline_assistant_model(
-                                            provider.clone(),
-                                            model_id.clone(),
-                                        );
+                                        settings
+                                            .set_inline_assistant_model(provider.clone(), model_id);
                                     },
                                 );
                             }

crates/agent_ui/src/agent_ui.rs

@@ -5,7 +5,6 @@ mod agent_diff;
 mod agent_model_selector;
 mod agent_panel;
 mod buffer_codegen;
-mod burn_mode_tooltip;
 mod context_picker;
 mod context_server_configuration;
 mod context_strip;
@@ -64,6 +63,8 @@ actions!(
         NewTextThread,
         /// Toggles the context picker interface for adding files, symbols, or other context.
         ToggleContextPicker,
+        /// Toggles the menu to create new agent threads.
+        ToggleNewThreadMenu,
         /// Toggles the navigation menu for switching between threads and views.
         ToggleNavigationMenu,
         /// Toggles the options menu for agent settings and preferences.
@@ -127,6 +128,12 @@ actions!(
     ]
 );
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Action)]
+#[action(namespace = agent)]
+#[action(deprecated_aliases = ["assistant::QuoteSelection"])]
+/// Quotes the current selection in the agent panel's message editor.
+pub struct QuoteSelection;
+
 /// Creates a new conversation thread, optionally based on an existing thread.
 #[derive(Default, Clone, PartialEq, Deserialize, JsonSchema, Action)]
 #[action(namespace = agent)]
@@ -145,7 +152,14 @@ pub struct NewExternalAgentThread {
     agent: Option<ExternalAgent>,
 }
 
-#[derive(Default, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, PartialEq, Deserialize, JsonSchema, Action)]
+#[action(namespace = agent)]
+#[serde(deny_unknown_fields)]
+pub struct NewNativeAgentThreadFromSummary {
+    from_session_id: agent_client_protocol::SessionId,
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 enum ExternalAgent {
     #[default]
@@ -155,11 +169,15 @@ enum ExternalAgent {
 }
 
 impl ExternalAgent {
-    pub fn server(&self) -> Rc<dyn agent_servers::AgentServer> {
+    pub fn server(
+        &self,
+        fs: Arc<dyn fs::Fs>,
+        history: Entity<agent2::HistoryStore>,
+    ) -> Rc<dyn agent_servers::AgentServer> {
         match self {
             ExternalAgent::Gemini => Rc::new(agent_servers::Gemini),
             ExternalAgent::ClaudeCode => Rc::new(agent_servers::ClaudeCode),
-            ExternalAgent::NativeAgent => Rc::new(agent2::NativeAgentServer),
+            ExternalAgent::NativeAgent => Rc::new(agent2::NativeAgentServer::new(fs, history)),
         }
     }
 }
@@ -235,13 +253,7 @@ pub fn init(
         client.telemetry().clone(),
         cx,
     );
-    terminal_inline_assistant::init(
-        fs.clone(),
-        prompt_builder.clone(),
-        client.telemetry().clone(),
-        cx,
-    );
-    indexed_docs::init(cx);
+    terminal_inline_assistant::init(fs.clone(), prompt_builder, client.telemetry().clone(), cx);
     cx.observe_new(move |workspace, window, cx| {
         ConfigureContextServerModal::register(workspace, language_registry.clone(), window, cx)
     })
@@ -320,7 +332,7 @@ fn init_language_model_settings(cx: &mut App) {
     cx.subscribe(
         &LanguageModelRegistry::global(cx),
         |_, event: &language_model::Event, cx| match event {
-            language_model::Event::ProviderStateChanged
+            language_model::Event::ProviderStateChanged(_)
             | language_model::Event::AddedProvider(_)
             | language_model::Event::RemovedProvider(_) => {
                 update_active_language_model_from_settings(cx);
@@ -387,7 +399,6 @@ fn register_slash_commands(cx: &mut App) {
     slash_command_registry.register_command(assistant_slash_commands::FetchSlashCommand, true);
 
     cx.observe_flag::<assistant_slash_commands::StreamingExampleSlashCommandFeatureFlag, _>({
-        let slash_command_registry = slash_command_registry.clone();
         move |is_enabled, _cx| {
             if is_enabled {
                 slash_command_registry.register_command(
@@ -408,12 +419,6 @@ fn update_slash_commands_from_settings(cx: &mut App) {
     let slash_command_registry = SlashCommandRegistry::global(cx);
     let settings = SlashCommandSettings::get_global(cx);
 
-    if settings.docs.enabled {
-        slash_command_registry.register_command(assistant_slash_commands::DocsSlashCommand, true);
-    } else {
-        slash_command_registry.unregister_command(assistant_slash_commands::DocsSlashCommand);
-    }
-
     if settings.cargo_workspace.enabled {
         slash_command_registry
             .register_command(assistant_slash_commands::CargoWorkspaceSlashCommand, true);

crates/agent_ui/src/buffer_codegen.rs

@@ -352,12 +352,12 @@ impl CodegenAlternative {
         event: &multi_buffer::Event,
         cx: &mut Context<Self>,
     ) {
-        if let multi_buffer::Event::TransactionUndone { transaction_id } = event {
-            if self.transformation_transaction_id == Some(*transaction_id) {
-                self.transformation_transaction_id = None;
-                self.generation = Task::ready(());
-                cx.emit(CodegenEvent::Undone);
-            }
+        if let multi_buffer::Event::TransactionUndone { transaction_id } = event
+            && self.transformation_transaction_id == Some(*transaction_id)
+        {
+            self.transformation_transaction_id = None;
+            self.generation = Task::ready(());
+            cx.emit(CodegenEvent::Undone);
         }
     }
 
@@ -388,7 +388,7 @@ impl CodegenAlternative {
             } else {
                 let request = self.build_request(&model, user_prompt, cx)?;
                 cx.spawn(async move |_, cx| {
-                    Ok(model.stream_completion_text(request.await, &cx).await?)
+                    Ok(model.stream_completion_text(request.await, cx).await?)
                 })
                 .boxed_local()
             };
@@ -447,7 +447,7 @@ impl CodegenAlternative {
             }
         });
 
-        let temperature = AgentSettings::temperature_for_model(&model, cx);
+        let temperature = AgentSettings::temperature_for_model(model, cx);
 
         Ok(cx.spawn(async move |_cx| {
             let mut request_message = LanguageModelRequestMessage {
@@ -576,38 +576,34 @@ impl CodegenAlternative {
                                 let mut lines = chunk.split('\n').peekable();
                                 while let Some(line) = lines.next() {
                                     new_text.push_str(line);
-                                    if line_indent.is_none() {
-                                        if let Some(non_whitespace_ch_ix) =
+                                    if line_indent.is_none()
+                                        && let Some(non_whitespace_ch_ix) =
                                             new_text.find(|ch: char| !ch.is_whitespace())
-                                        {
-                                            line_indent = Some(non_whitespace_ch_ix);
-                                            base_indent = base_indent.or(line_indent);
+                                    {
+                                        line_indent = Some(non_whitespace_ch_ix);
+                                        base_indent = base_indent.or(line_indent);
 
-                                            let line_indent = line_indent.unwrap();
-                                            let base_indent = base_indent.unwrap();
-                                            let indent_delta =
-                                                line_indent as i32 - base_indent as i32;
-                                            let mut corrected_indent_len = cmp::max(
-                                                0,
-                                                suggested_line_indent.len as i32 + indent_delta,
-                                            )
-                                                as usize;
-                                            if first_line {
-                                                corrected_indent_len = corrected_indent_len
-                                                    .saturating_sub(
-                                                        selection_start.column as usize,
-                                                    );
-                                            }
-
-                                            let indent_char = suggested_line_indent.char();
-                                            let mut indent_buffer = [0; 4];
-                                            let indent_str =
-                                                indent_char.encode_utf8(&mut indent_buffer);
-                                            new_text.replace_range(
-                                                ..line_indent,
-                                                &indent_str.repeat(corrected_indent_len),
-                                            );
+                                        let line_indent = line_indent.unwrap();
+                                        let base_indent = base_indent.unwrap();
+                                        let indent_delta = line_indent as i32 - base_indent as i32;
+                                        let mut corrected_indent_len = cmp::max(
+                                            0,
+                                            suggested_line_indent.len as i32 + indent_delta,
+                                        )
+                                            as usize;
+                                        if first_line {
+                                            corrected_indent_len = corrected_indent_len
+                                                .saturating_sub(selection_start.column as usize);
                                         }
+
+                                        let indent_char = suggested_line_indent.char();
+                                        let mut indent_buffer = [0; 4];
+                                        let indent_str =
+                                            indent_char.encode_utf8(&mut indent_buffer);
+                                        new_text.replace_range(
+                                            ..line_indent,
+                                            &indent_str.repeat(corrected_indent_len),
+                                        );
                                     }
 
                                     if line_indent.is_some() {
@@ -1028,7 +1024,7 @@ where
                                 chunk.push('\n');
                             }
 
-                            chunk.push_str(&line);
+                            chunk.push_str(line);
                         }
 
                         consumed += line.len();
@@ -1133,7 +1129,7 @@ mod tests {
             )
         });
 
-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let chunks_tx = simulate_response_stream(&codegen, cx);
 
         let mut new_text = concat!(
             "       let mut x = 0;\n",
@@ -1200,7 +1196,7 @@ mod tests {
             )
         });
 
-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let chunks_tx = simulate_response_stream(&codegen, cx);
 
         cx.background_executor.run_until_parked();
 
@@ -1269,7 +1265,7 @@ mod tests {
             )
         });
 
-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let chunks_tx = simulate_response_stream(&codegen, cx);
 
         cx.background_executor.run_until_parked();
 
@@ -1338,7 +1334,7 @@ mod tests {
             )
         });
 
-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let chunks_tx = simulate_response_stream(&codegen, cx);
         let new_text = concat!(
             "func main() {\n",
             "\tx := 0\n",
@@ -1395,7 +1391,7 @@ mod tests {
             )
         });
 
-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let chunks_tx = simulate_response_stream(&codegen, cx);
         chunks_tx
             .unbounded_send("let mut x = 0;\nx += 1;".to_string())
             .unwrap();
@@ -1477,7 +1473,7 @@ mod tests {
     }
 
     fn simulate_response_stream(
-        codegen: Entity<CodegenAlternative>,
+        codegen: &Entity<CodegenAlternative>,
         cx: &mut TestAppContext,
     ) -> mpsc::UnboundedSender<String> {
         let (chunks_tx, chunks_rx) = mpsc::unbounded();

crates/agent_ui/src/burn_mode_tooltip.rs

@@ -1,61 +0,0 @@
-use gpui::{Context, FontWeight, IntoElement, Render, Window};
-use ui::{prelude::*, tooltip_container};
-
-pub struct BurnModeTooltip {
-    selected: bool,
-}
-
-impl BurnModeTooltip {
-    pub fn new() -> Self {
-        Self { selected: false }
-    }
-
-    pub fn selected(mut self, selected: bool) -> Self {
-        self.selected = selected;
-        self
-    }
-}
-
-impl Render for BurnModeTooltip {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let (icon, color) = if self.selected {
-            (IconName::ZedBurnModeOn, Color::Error)
-        } else {
-            (IconName::ZedBurnMode, Color::Default)
-        };
-
-        let turned_on = h_flex()
-            .h_4()
-            .px_1()
-            .border_1()
-            .border_color(cx.theme().colors().border)
-            .bg(cx.theme().colors().text_accent.opacity(0.1))
-            .rounded_sm()
-            .child(
-                Label::new("ON")
-                    .size(LabelSize::XSmall)
-                    .weight(FontWeight::SEMIBOLD)
-                    .color(Color::Accent),
-            );
-
-        let title = h_flex()
-            .gap_1p5()
-            .child(Icon::new(icon).size(IconSize::Small).color(color))
-            .child(Label::new("Burn Mode"))
-            .when(self.selected, |title| title.child(turned_on));
-
-        tooltip_container(window, cx, |this, _, _| {
-            this
-                .child(title)
-                .child(
-                    div()
-                        .max_w_64()
-                        .child(
-                            Label::new("Enables models to use large context windows, unlimited tool calls, and other capabilities for expanded reasoning.")
-                                .size(LabelSize::Small)
-                                .color(Color::Muted)
-                        )
-                )
-        })
-    }
-}

crates/agent_ui/src/context_picker.rs

@@ -1,18 +1,19 @@
 mod completion_provider;
-mod fetch_context_picker;
+pub(crate) mod fetch_context_picker;
 pub(crate) mod file_context_picker;
-mod rules_context_picker;
-mod symbol_context_picker;
-mod thread_context_picker;
+pub(crate) mod rules_context_picker;
+pub(crate) mod symbol_context_picker;
+pub(crate) 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};
+use editor::{Anchor, Editor, ExcerptId, FoldPlaceholder, ToOffset};
 use fetch_context_picker::FetchContextPicker;
 use file_context_picker::FileContextPicker;
 use file_context_picker::render_file_context_entry;
@@ -45,7 +46,7 @@ use agent::{
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ContextPickerEntry {
+pub(crate) enum ContextPickerEntry {
     Mode(ContextPickerMode),
     Action(ContextPickerAction),
 }
@@ -74,7 +75,7 @@ impl ContextPickerEntry {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ContextPickerMode {
+pub(crate) enum ContextPickerMode {
     File,
     Symbol,
     Fetch,
@@ -83,7 +84,7 @@ enum ContextPickerMode {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ContextPickerAction {
+pub(crate) enum ContextPickerAction {
     AddSelections,
 }
 
@@ -102,7 +103,7 @@ impl ContextPickerAction {
 
     pub fn icon(&self) -> IconName {
         match self {
-            Self::AddSelections => IconName::Context,
+            Self::AddSelections => IconName::Reader,
         }
     }
 }
@@ -147,7 +148,7 @@ impl ContextPickerMode {
         match self {
             Self::File => IconName::File,
             Self::Symbol => IconName::Code,
-            Self::Fetch => IconName::Globe,
+            Self::Fetch => IconName::ToolWeb,
             Self::Thread => IconName::Thread,
             Self::Rules => RULES_ICON,
         }
@@ -227,7 +228,7 @@ impl ContextPicker {
     }
 
     fn build_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Entity<ContextMenu> {
-        let context_picker = cx.entity().clone();
+        let context_picker = cx.entity();
 
         let menu = ContextMenu::build(window, cx, move |menu, _window, cx| {
             let recent = self.recent_entries(cx);
@@ -384,12 +385,11 @@ impl ContextPicker {
     }
 
     pub fn select_first(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        match &self.mode {
-            ContextPickerState::Default(entity) => entity.update(cx, |entity, cx| {
+        // Other variants already select their first entry on open automatically
+        if let ContextPickerState::Default(entity) = &self.mode {
+            entity.update(cx, |entity, cx| {
                 entity.select_first(&Default::default(), window, cx)
-            }),
-            // Other variants already select their first entry on open automatically
-            _ => {}
+            })
         }
     }
 
@@ -531,7 +531,7 @@ impl ContextPicker {
             return vec![];
         };
 
-        recent_context_picker_entries(
+        recent_context_picker_entries_with_store(
             context_store,
             self.thread_store.clone(),
             self.text_thread_store.clone(),
@@ -585,7 +585,8 @@ impl Render for ContextPicker {
             })
     }
 }
-enum RecentEntry {
+
+pub(crate) enum RecentEntry {
     File {
         project_path: ProjectPath,
         path_prefix: Arc<str>,
@@ -593,7 +594,7 @@ enum RecentEntry {
     Thread(ThreadContextEntry),
 }
 
-fn available_context_picker_entries(
+pub(crate) fn available_context_picker_entries(
     prompt_store: &Option<Entity<PromptStore>>,
     thread_store: &Option<WeakEntity<ThreadStore>>,
     workspace: &Entity<Workspace>,
@@ -608,9 +609,7 @@ fn available_context_picker_entries(
         .read(cx)
         .active_item(cx)
         .and_then(|item| item.downcast::<Editor>())
-        .map_or(false, |editor| {
-            editor.update(cx, |editor, cx| editor.has_non_empty_selection(cx))
-        });
+        .is_some_and(|editor| editor.update(cx, |editor, cx| editor.has_non_empty_selection(cx)));
     if has_selection {
         entries.push(ContextPickerEntry::Action(
             ContextPickerAction::AddSelections,
@@ -630,24 +629,56 @@ fn available_context_picker_entries(
     entries
 }
 
-fn recent_context_picker_entries(
+fn recent_context_picker_entries_with_store(
     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(|(path, _)| !current_files.contains(path))
+            .filter(|(_, abs_path)| {
+                abs_path
+                    .as_ref()
+                    .is_none_or(|path| !exclude_paths.contains(path.as_path()))
+            })
             .take(4)
             .filter_map(|(project_path, _)| {
                 project
@@ -659,8 +690,6 @@ 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()));
@@ -672,7 +701,7 @@ 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 && !current_threads.contains(id)
+                    Some(id) != active_thread_id && !exclude_threads.contains(id)
                 }
                 ThreadContextEntry::Context { .. } => true,
             })
@@ -710,7 +739,7 @@ fn add_selections_as_context(
     })
 }
 
-fn selection_ranges(
+pub(crate) fn selection_ranges(
     workspace: &Entity<Workspace>,
     cx: &mut App,
 ) -> Vec<(Entity<Buffer>, Range<text::Anchor>)> {
@@ -789,13 +818,8 @@ pub fn crease_for_mention(
 
     let render_trailer = move |_row, _unfold, _window: &mut Window, _cx: &mut App| Empty.into_any();
 
-    Crease::inline(
-        range,
-        placeholder.clone(),
-        fold_toggle("mention"),
-        render_trailer,
-    )
-    .with_metadata(CreaseMetadata { icon_path, label })
+    Crease::inline(range, placeholder, fold_toggle("mention"), render_trailer)
+        .with_metadata(CreaseMetadata { icon_path, label })
 }
 
 fn render_fold_icon_button(
@@ -805,42 +829,9 @@ fn render_fold_icon_button(
 ) -> Arc<dyn Send + Sync + Fn(FoldId, Range<Anchor>, &mut App) -> AnyElement> {
     Arc::new({
         move |fold_id, fold_range, cx| {
-            let is_in_text_selection = editor.upgrade().is_some_and(|editor| {
-                editor.update(cx, |editor, cx| {
-                    let snapshot = editor
-                        .buffer()
-                        .update(cx, |multi_buffer, cx| multi_buffer.snapshot(cx));
-
-                    let is_in_pending_selection = || {
-                        editor
-                            .selections
-                            .pending
-                            .as_ref()
-                            .is_some_and(|pending_selection| {
-                                pending_selection
-                                    .selection
-                                    .range()
-                                    .includes(&fold_range, &snapshot)
-                            })
-                    };
-
-                    let mut is_in_complete_selection = || {
-                        editor
-                            .selections
-                            .disjoint_in_range::<usize>(fold_range.clone(), cx)
-                            .into_iter()
-                            .any(|selection| {
-                                // This is needed to cover a corner case, if we just check for an existing
-                                // selection in the fold range, having a cursor at the start of the fold
-                                // marks it as selected. Non-empty selections don't cause this.
-                                let length = selection.end - selection.start;
-                                length > 0
-                            })
-                    };
-
-                    is_in_pending_selection() || is_in_complete_selection()
-                })
-            });
+            let is_in_text_selection = editor
+                .update(cx, |editor, cx| editor.is_range_selected(&fold_range, cx))
+                .unwrap_or_default();
 
             ButtonLike::new(fold_id)
                 .style(ButtonStyle::Filled)

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, selection_ranges,
+    available_context_picker_entries, recent_context_picker_entries_with_store, selection_ranges,
 };
 use crate::message_editor::ContextCreasesAddon;
 
@@ -79,8 +79,7 @@ fn search(
 ) -> Task<Vec<Match>> {
     match mode {
         Some(ContextPickerMode::File) => {
-            let search_files_task =
-                search_files(query.clone(), cancellation_flag.clone(), &workspace, cx);
+            let search_files_task = search_files(query, cancellation_flag, &workspace, cx);
             cx.background_spawn(async move {
                 search_files_task
                     .await
@@ -91,8 +90,7 @@ fn search(
         }
 
         Some(ContextPickerMode::Symbol) => {
-            let search_symbols_task =
-                search_symbols(query.clone(), cancellation_flag.clone(), &workspace, cx);
+            let search_symbols_task = search_symbols(query, cancellation_flag, &workspace, cx);
             cx.background_spawn(async move {
                 search_symbols_task
                     .await
@@ -108,13 +106,8 @@ fn search(
                 .and_then(|t| t.upgrade())
                 .zip(text_thread_context_store.as_ref().and_then(|t| t.upgrade()))
             {
-                let search_threads_task = search_threads(
-                    query.clone(),
-                    cancellation_flag.clone(),
-                    thread_store,
-                    context_store,
-                    cx,
-                );
+                let search_threads_task =
+                    search_threads(query, cancellation_flag, thread_store, context_store, cx);
                 cx.background_spawn(async move {
                     search_threads_task
                         .await
@@ -137,8 +130,7 @@ fn search(
 
         Some(ContextPickerMode::Rules) => {
             if let Some(prompt_store) = prompt_store.as_ref() {
-                let search_rules_task =
-                    search_rules(query.clone(), cancellation_flag.clone(), prompt_store, cx);
+                let search_rules_task = search_rules(query, cancellation_flag, prompt_store, cx);
                 cx.background_spawn(async move {
                     search_rules_task
                         .await
@@ -196,7 +188,7 @@ fn search(
                 let executor = cx.background_executor().clone();
 
                 let search_files_task =
-                    search_files(query.clone(), cancellation_flag.clone(), &workspace, cx);
+                    search_files(query.clone(), cancellation_flag, &workspace, cx);
 
                 let entries =
                     available_context_picker_entries(&prompt_store, &thread_store, &workspace, cx);
@@ -283,7 +275,7 @@ impl ContextPickerCompletionProvider {
     ) -> Option<Completion> {
         match entry {
             ContextPickerEntry::Mode(mode) => Some(Completion {
-                replace_range: source_range.clone(),
+                replace_range: source_range,
                 new_text: format!("@{} ", mode.keyword()),
                 label: CodeLabel::plain(mode.label().to_string(), None),
                 icon_path: Some(mode.icon().path().into()),
@@ -330,9 +322,6 @@ impl ContextPickerCompletionProvider {
                         );
 
                         let callback = Arc::new({
-                            let context_store = context_store.clone();
-                            let selections = selections.clone();
-                            let selection_infos = selection_infos.clone();
                             move |_, window: &mut Window, cx: &mut App| {
                                 context_store.update(cx, |context_store, cx| {
                                     for (buffer, range) in &selections {
@@ -371,7 +360,7 @@ impl ContextPickerCompletionProvider {
                                                 line_range.end.row + 1
                                             )
                                             .into(),
-                                            IconName::Context.path().into(),
+                                            IconName::Reader.path().into(),
                                             range,
                                             editor.downgrade(),
                                         );
@@ -441,7 +430,7 @@ impl ContextPickerCompletionProvider {
                 excerpt_id,
                 source_range.start,
                 new_text_len - 1,
-                editor.clone(),
+                editor,
                 context_store.clone(),
                 move |window, cx| match &thread_entry {
                     ThreadContextEntry::Thread { id, .. } => {
@@ -510,7 +499,7 @@ impl ContextPickerCompletionProvider {
                 excerpt_id,
                 source_range.start,
                 new_text_len - 1,
-                editor.clone(),
+                editor,
                 context_store.clone(),
                 move |_, cx| {
                     let user_prompt_id = rules.prompt_id;
@@ -539,15 +528,15 @@ impl ContextPickerCompletionProvider {
             label: CodeLabel::plain(url_to_fetch.to_string(), None),
             documentation: None,
             source: project::CompletionSource::Custom,
-            icon_path: Some(IconName::Globe.path().into()),
+            icon_path: Some(IconName::ToolWeb.path().into()),
             insert_text_mode: None,
             confirm: Some(confirm_completion_callback(
-                IconName::Globe.path().into(),
+                IconName::ToolWeb.path().into(),
                 url_to_fetch.clone(),
                 excerpt_id,
                 source_range.start,
                 new_text_len - 1,
-                editor.clone(),
+                editor,
                 context_store.clone(),
                 move |_, cx| {
                     let context_store = context_store.clone();
@@ -704,16 +693,16 @@ impl ContextPickerCompletionProvider {
                 excerpt_id,
                 source_range.start,
                 new_text_len - 1,
-                editor.clone(),
+                editor,
                 context_store.clone(),
                 move |_, cx| {
                     let symbol = symbol.clone();
                     let context_store = context_store.clone();
                     let workspace = workspace.clone();
                     let result = super::symbol_context_picker::add_symbol(
-                        symbol.clone(),
+                        symbol,
                         false,
-                        workspace.clone(),
+                        workspace,
                         context_store.downgrade(),
                         cx,
                     );
@@ -728,11 +717,11 @@ fn build_code_label_for_full_path(file_name: &str, directory: Option<&str>, cx:
     let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
     let mut label = CodeLabel::default();
 
-    label.push_str(&file_name, None);
+    label.push_str(file_name, None);
     label.push_str(" ", None);
 
     if let Some(directory) = directory {
-        label.push_str(&directory, comment_id);
+        label.push_str(directory, comment_id);
     }
 
     label.filter_range = 0..label.text().len();
@@ -787,7 +776,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(
+        let recent_entries = recent_context_picker_entries_with_store(
             context_store.clone(),
             thread_store.clone(),
             text_thread_store.clone(),
@@ -1020,7 +1009,7 @@ impl MentionCompletion {
             && line
                 .chars()
                 .nth(last_mention_start - 1)
-                .map_or(false, |c| !c.is_whitespace())
+                .is_some_and(|c| !c.is_whitespace())
         {
             return None;
         }
@@ -1162,7 +1151,7 @@ mod tests {
 
     impl Focusable for AtMentionEditor {
         fn focus_handle(&self, cx: &App) -> FocusHandle {
-            self.0.read(cx).focus_handle(cx).clone()
+            self.0.read(cx).focus_handle(cx)
         }
     }
 
@@ -1480,7 +1469,7 @@ mod tests {
         let completions = editor.current_completions().expect("Missing completions");
         completions
             .into_iter()
-            .map(|completion| completion.label.text.to_string())
+            .map(|completion| completion.label.text)
             .collect::<Vec<_>>()
     }
 

crates/agent_ui/src/context_picker/fetch_context_picker.rs

@@ -226,9 +226,10 @@ impl PickerDelegate for FetchContextPickerDelegate {
         _window: &mut Window,
         cx: &mut Context<Picker<Self>>,
     ) -> Option<Self::ListItem> {
-        let added = self.context_store.upgrade().map_or(false, |context_store| {
-            context_store.read(cx).includes_url(&self.url)
-        });
+        let added = self
+            .context_store
+            .upgrade()
+            .is_some_and(|context_store| context_store.read(cx).includes_url(&self.url));
 
         Some(
             ListItem::new(ix)

crates/agent_ui/src/context_picker/file_context_picker.rs

@@ -239,9 +239,7 @@ pub(crate) fn search_files(
 
                 PathMatchCandidateSet {
                     snapshot: worktree.snapshot(),
-                    include_ignored: worktree
-                        .root_entry()
-                        .map_or(false, |entry| entry.is_ignored),
+                    include_ignored: worktree.root_entry().is_some_and(|entry| entry.is_ignored),
                     include_root_name: true,
                     candidates: project::Candidates::Entries,
                 }
@@ -315,7 +313,7 @@ pub fn render_file_context_entry(
     context_store: WeakEntity<ContextStore>,
     cx: &App,
 ) -> Stateful<Div> {
-    let (file_name, directory) = extract_file_name_and_directory(&path, path_prefix);
+    let (file_name, directory) = extract_file_name_and_directory(path, path_prefix);
 
     let added = context_store.upgrade().and_then(|context_store| {
         let project_path = ProjectPath {
@@ -334,7 +332,7 @@ pub fn render_file_context_entry(
     let file_icon = if is_directory {
         FileIcons::get_folder_icon(false, cx)
     } else {
-        FileIcons::get_icon(&path, cx)
+        FileIcons::get_icon(path, cx)
     }
     .map(Icon::from_path)
     .unwrap_or_else(|| Icon::new(IconName::File));

crates/agent_ui/src/context_picker/rules_context_picker.rs

@@ -159,7 +159,7 @@ pub fn render_thread_context_entry(
     context_store: WeakEntity<ContextStore>,
     cx: &mut App,
 ) -> Div {
-    let added = context_store.upgrade().map_or(false, |context_store| {
+    let added = context_store.upgrade().is_some_and(|context_store| {
         context_store
             .read(cx)
             .includes_user_rules(user_rules.prompt_id)

crates/agent_ui/src/context_picker/symbol_context_picker.rs

@@ -289,12 +289,12 @@ pub(crate) fn search_symbols(
                         .iter()
                         .enumerate()
                         .map(|(id, symbol)| {
-                            StringMatchCandidate::new(id, &symbol.label.filter_text())
+                            StringMatchCandidate::new(id, symbol.label.filter_text())
                         })
                         .partition(|candidate| {
                             project
                                 .entry_for_path(&symbols[candidate.id].path, cx)
-                                .map_or(false, |e| !e.is_ignored)
+                                .is_some_and(|e| !e.is_ignored)
                         })
                 })
                 .log_err()

crates/agent_ui/src/context_picker/thread_context_picker.rs

@@ -167,7 +167,7 @@ impl PickerDelegate for ThreadContextPickerDelegate {
                     return;
                 };
                 let open_thread_task =
-                    thread_store.update(cx, |this, cx| this.open_thread(&id, window, cx));
+                    thread_store.update(cx, |this, cx| this.open_thread(id, window, cx));
 
                 cx.spawn(async move |this, cx| {
                     let thread = open_thread_task.await?;
@@ -236,12 +236,10 @@ pub fn render_thread_context_entry(
     let is_added = match entry {
         ThreadContextEntry::Thread { id, .. } => context_store
             .upgrade()
-            .map_or(false, |ctx_store| ctx_store.read(cx).includes_thread(&id)),
-        ThreadContextEntry::Context { path, .. } => {
-            context_store.upgrade().map_or(false, |ctx_store| {
-                ctx_store.read(cx).includes_text_thread(path)
-            })
-        }
+            .is_some_and(|ctx_store| ctx_store.read(cx).includes_thread(id)),
+        ThreadContextEntry::Context { path, .. } => context_store
+            .upgrade()
+            .is_some_and(|ctx_store| ctx_store.read(cx).includes_text_thread(path)),
     };
 
     h_flex()
@@ -338,7 +336,7 @@ pub(crate) fn search_threads(
             let candidates = threads
                 .iter()
                 .enumerate()
-                .map(|(id, (_, thread))| StringMatchCandidate::new(id, &thread.title()))
+                .map(|(id, (_, thread))| StringMatchCandidate::new(id, thread.title()))
                 .collect::<Vec<_>>();
             let matches = fuzzy::match_strings(
                 &candidates,

crates/agent_ui/src/context_strip.rs

@@ -145,7 +145,7 @@ impl ContextStrip {
         }
 
         let file_name = active_buffer.file()?.file_name(cx);
-        let icon_path = FileIcons::get_icon(&Path::new(&file_name), cx);
+        let icon_path = FileIcons::get_icon(Path::new(&file_name), cx);
         Some(SuggestedContext::File {
             name: file_name.to_string_lossy().into_owned().into(),
             buffer: active_buffer_entity.downgrade(),
@@ -368,16 +368,16 @@ impl ContextStrip {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if let Some(suggested) = self.suggested_context(cx) {
-            if self.is_suggested_focused(&self.added_contexts(cx)) {
-                self.add_suggested_context(&suggested, cx);
-            }
+        if let Some(suggested) = self.suggested_context(cx)
+            && self.is_suggested_focused(&self.added_contexts(cx))
+        {
+            self.add_suggested_context(&suggested, cx);
         }
     }
 
     fn add_suggested_context(&mut self, suggested: &SuggestedContext, cx: &mut Context<Self>) {
         self.context_store.update(cx, |context_store, cx| {
-            context_store.add_suggested_context(&suggested, cx)
+            context_store.add_suggested_context(suggested, cx)
         });
         cx.notify();
     }

crates/agent_ui/src/inline_assistant.rs

@@ -72,7 +72,7 @@ pub fn init(
         let Some(window) = window else {
             return;
         };
-        let workspace = cx.entity().clone();
+        let workspace = cx.entity();
         InlineAssistant::update_global(cx, |inline_assistant, cx| {
             inline_assistant.register_workspace(&workspace, window, cx)
         });
@@ -182,13 +182,13 @@ impl InlineAssistant {
         match event {
             workspace::Event::UserSavedItem { item, .. } => {
                 // When the user manually saves an editor, automatically accepts all finished transformations.
-                if let Some(editor) = item.upgrade().and_then(|item| item.act_as::<Editor>(cx)) {
-                    if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {
-                        for assist_id in editor_assists.assist_ids.clone() {
-                            let assist = &self.assists[&assist_id];
-                            if let CodegenStatus::Done = assist.codegen.read(cx).status(cx) {
-                                self.finish_assist(assist_id, false, window, cx)
-                            }
+                if let Some(editor) = item.upgrade().and_then(|item| item.act_as::<Editor>(cx))
+                    && let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade())
+                {
+                    for assist_id in editor_assists.assist_ids.clone() {
+                        let assist = &self.assists[&assist_id];
+                        if let CodegenStatus::Done = assist.codegen.read(cx).status(cx) {
+                            self.finish_assist(assist_id, false, window, cx)
                         }
                     }
                 }
@@ -342,13 +342,11 @@ impl InlineAssistant {
                         )
                         .await
                         .ok();
-                    if let Some(answer) = answer {
-                        if answer == 0 {
-                            cx.update(|window, cx| {
-                                window.dispatch_action(Box::new(OpenSettings), cx)
-                            })
+                    if let Some(answer) = answer
+                        && answer == 0
+                    {
+                        cx.update(|window, cx| window.dispatch_action(Box::new(OpenSettings), cx))
                             .ok();
-                        }
                     }
                     anyhow::Ok(())
                 })
@@ -435,11 +433,11 @@ impl InlineAssistant {
                 }
             }
 
-            if let Some(prev_selection) = selections.last_mut() {
-                if selection.start <= prev_selection.end {
-                    prev_selection.end = selection.end;
-                    continue;
-                }
+            if let Some(prev_selection) = selections.last_mut()
+                && selection.start <= prev_selection.end
+            {
+                prev_selection.end = selection.end;
+                continue;
             }
 
             let latest_selection = newest_selection.get_or_insert_with(|| selection.clone());
@@ -526,9 +524,9 @@ impl InlineAssistant {
 
             if assist_to_focus.is_none() {
                 let focus_assist = if newest_selection.reversed {
-                    range.start.to_point(&snapshot) == newest_selection.start
+                    range.start.to_point(snapshot) == newest_selection.start
                 } else {
-                    range.end.to_point(&snapshot) == newest_selection.end
+                    range.end.to_point(snapshot) == newest_selection.end
                 };
                 if focus_assist {
                     assist_to_focus = Some(assist_id);
@@ -550,7 +548,7 @@ impl InlineAssistant {
         let editor_assists = self
             .assists_by_editor
             .entry(editor.downgrade())
-            .or_insert_with(|| EditorInlineAssists::new(&editor, window, cx));
+            .or_insert_with(|| EditorInlineAssists::new(editor, window, cx));
         let mut assist_group = InlineAssistGroup::new();
         for (assist_id, range, prompt_editor, prompt_block_id, end_block_id) in assists {
             let codegen = prompt_editor.read(cx).codegen().clone();
@@ -649,7 +647,7 @@ impl InlineAssistant {
         let editor_assists = self
             .assists_by_editor
             .entry(editor.downgrade())
-            .or_insert_with(|| EditorInlineAssists::new(&editor, window, cx));
+            .or_insert_with(|| EditorInlineAssists::new(editor, window, cx));
 
         let mut assist_group = InlineAssistGroup::new();
         self.assists.insert(
@@ -985,14 +983,13 @@ impl InlineAssistant {
             EditorEvent::SelectionsChanged { .. } => {
                 for assist_id in editor_assists.assist_ids.clone() {
                     let assist = &self.assists[&assist_id];
-                    if let Some(decorations) = assist.decorations.as_ref() {
-                        if decorations
+                    if let Some(decorations) = assist.decorations.as_ref()
+                        && decorations
                             .prompt_editor
                             .focus_handle(cx)
                             .is_focused(window)
-                        {
-                            return;
-                        }
+                    {
+                        return;
                     }
                 }
 
@@ -1123,7 +1120,7 @@ impl InlineAssistant {
             if editor_assists
                 .scroll_lock
                 .as_ref()
-                .map_or(false, |lock| lock.assist_id == assist_id)
+                .is_some_and(|lock| lock.assist_id == assist_id)
             {
                 editor_assists.scroll_lock = None;
             }
@@ -1503,20 +1500,18 @@ impl InlineAssistant {
         window: &mut Window,
         cx: &mut App,
     ) -> Option<InlineAssistTarget> {
-        if let Some(terminal_panel) = workspace.panel::<TerminalPanel>(cx) {
-            if terminal_panel
+        if let Some(terminal_panel) = workspace.panel::<TerminalPanel>(cx)
+            && terminal_panel
                 .read(cx)
                 .focus_handle(cx)
                 .contains_focused(window, cx)
-            {
-                if let Some(terminal_view) = terminal_panel.read(cx).pane().and_then(|pane| {
-                    pane.read(cx)
-                        .active_item()
-                        .and_then(|t| t.downcast::<TerminalView>())
-                }) {
-                    return Some(InlineAssistTarget::Terminal(terminal_view));
-                }
-            }
+            && let Some(terminal_view) = terminal_panel.read(cx).pane().and_then(|pane| {
+                pane.read(cx)
+                    .active_item()
+                    .and_then(|t| t.downcast::<TerminalView>())
+            })
+        {
+            return Some(InlineAssistTarget::Terminal(terminal_view));
         }
 
         let context_editor = agent_panel
@@ -1537,13 +1532,11 @@ impl InlineAssistant {
             .and_then(|item| item.act_as::<Editor>(cx))
         {
             Some(InlineAssistTarget::Editor(workspace_editor))
-        } else if let Some(terminal_view) = workspace
-            .active_item(cx)
-            .and_then(|item| item.act_as::<TerminalView>(cx))
-        {
-            Some(InlineAssistTarget::Terminal(terminal_view))
         } else {
-            None
+            workspace
+                .active_item(cx)
+                .and_then(|item| item.act_as::<TerminalView>(cx))
+                .map(InlineAssistTarget::Terminal)
         }
     }
 }
@@ -1698,7 +1691,7 @@ impl InlineAssist {
             }),
             range,
             codegen: codegen.clone(),
-            workspace: workspace.clone(),
+            workspace,
             _subscriptions: vec![
                 window.on_focus_in(&prompt_editor_focus_handle, cx, move |_, cx| {
                     InlineAssistant::update_global(cx, |this, cx| {
@@ -1741,22 +1734,20 @@ impl InlineAssist {
                                 return;
                             };
 
-                            if let CodegenStatus::Error(error) = codegen.read(cx).status(cx) {
-                                if assist.decorations.is_none() {
-                                    if let Some(workspace) = assist.workspace.upgrade() {
-                                        let error = format!("Inline assistant error: {}", error);
-                                        workspace.update(cx, |workspace, cx| {
-                                            struct InlineAssistantError;
+                            if let CodegenStatus::Error(error) = codegen.read(cx).status(cx)
+                                && assist.decorations.is_none()
+                                && let Some(workspace) = assist.workspace.upgrade()
+                            {
+                                let error = format!("Inline assistant error: {}", error);
+                                workspace.update(cx, |workspace, cx| {
+                                    struct InlineAssistantError;
 
-                                            let id =
-                                                NotificationId::composite::<InlineAssistantError>(
-                                                    assist_id.0,
-                                                );
+                                    let id = NotificationId::composite::<InlineAssistantError>(
+                                        assist_id.0,
+                                    );
 
-                                            workspace.show_toast(Toast::new(id, error), cx);
-                                        })
-                                    }
-                                }
+                                    workspace.show_toast(Toast::new(id, error), cx);
+                                })
                             }
 
                             if assist.decorations.is_none() {
@@ -1821,18 +1812,18 @@ impl CodeActionProvider for AssistantCodeActionProvider {
             has_diagnostics = true;
         }
         if has_diagnostics {
-            if let Some(symbols_containing_start) = snapshot.symbols_containing(range.start, None) {
-                if let Some(symbol) = symbols_containing_start.last() {
-                    range.start = cmp::min(range.start, symbol.range.start.to_point(&snapshot));
-                    range.end = cmp::max(range.end, symbol.range.end.to_point(&snapshot));
-                }
+            if let Some(symbols_containing_start) = snapshot.symbols_containing(range.start, None)
+                && let Some(symbol) = symbols_containing_start.last()
+            {
+                range.start = cmp::min(range.start, symbol.range.start.to_point(&snapshot));
+                range.end = cmp::max(range.end, symbol.range.end.to_point(&snapshot));
             }
 
-            if let Some(symbols_containing_end) = snapshot.symbols_containing(range.end, None) {
-                if let Some(symbol) = symbols_containing_end.last() {
-                    range.start = cmp::min(range.start, symbol.range.start.to_point(&snapshot));
-                    range.end = cmp::max(range.end, symbol.range.end.to_point(&snapshot));
-                }
+            if let Some(symbols_containing_end) = snapshot.symbols_containing(range.end, None)
+                && let Some(symbol) = symbols_containing_end.last()
+            {
+                range.start = cmp::min(range.start, symbol.range.start.to_point(&snapshot));
+                range.end = cmp::max(range.end, symbol.range.end.to_point(&snapshot));
             }
 
             Task::ready(Ok(vec![CodeAction {

crates/agent_ui/src/inline_prompt_editor.rs

@@ -75,7 +75,7 @@ impl<T: 'static> Render for PromptEditor<T> {
                 let codegen = codegen.read(cx);
 
                 if codegen.alternative_count(cx) > 1 {
-                    buttons.push(self.render_cycle_controls(&codegen, cx));
+                    buttons.push(self.render_cycle_controls(codegen, cx));
                 }
 
                 let editor_margins = editor_margins.lock();
@@ -345,7 +345,7 @@ impl<T: 'static> PromptEditor<T> {
                 let prompt = self.editor.read(cx).text(cx);
                 if self
                     .prompt_history_ix
-                    .map_or(true, |ix| self.prompt_history[ix] != prompt)
+                    .is_none_or(|ix| self.prompt_history[ix] != prompt)
                 {
                     self.prompt_history_ix.take();
                     self.pending_prompt = prompt;
@@ -541,7 +541,7 @@ impl<T: 'static> PromptEditor<T> {
                     match &self.mode {
                         PromptEditorMode::Terminal { .. } => vec![
                             accept,
-                            IconButton::new("confirm", IconName::PlayOutlined)
+                            IconButton::new("confirm", IconName::PlayFilled)
                                 .icon_color(Color::Info)
                                 .shape(IconButtonShape::Square)
                                 .tooltip(|window, cx| {
@@ -1229,27 +1229,27 @@ pub enum GenerationMode {
 impl GenerationMode {
     fn start_label(self) -> &'static str {
         match self {
-            GenerationMode::Generate { .. } => "Generate",
+            GenerationMode::Generate => "Generate",
             GenerationMode::Transform => "Transform",
         }
     }
     fn tooltip_interrupt(self) -> &'static str {
         match self {
-            GenerationMode::Generate { .. } => "Interrupt Generation",
+            GenerationMode::Generate => "Interrupt Generation",
             GenerationMode::Transform => "Interrupt Transform",
         }
     }
 
     fn tooltip_restart(self) -> &'static str {
         match self {
-            GenerationMode::Generate { .. } => "Restart Generation",
+            GenerationMode::Generate => "Restart Generation",
             GenerationMode::Transform => "Restart Transform",
         }
     }
 
     fn tooltip_accept(self) -> &'static str {
         match self {
-            GenerationMode::Generate { .. } => "Accept Generation",
+            GenerationMode::Generate => "Accept Generation",
             GenerationMode::Transform => "Accept Transform",
         }
     }

crates/agent_ui/src/language_model_selector.rs

@@ -1,5 +1,6 @@
 use std::{cmp::Reverse, sync::Arc};
 
+use cloud_llm_client::Plan;
 use collections::{HashSet, IndexMap};
 use feature_flags::ZedProFeatureFlag;
 use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
@@ -10,7 +11,6 @@ use language_model::{
 };
 use ordered_float::OrderedFloat;
 use picker::{Picker, PickerDelegate};
-use proto::Plan;
 use ui::{ListItem, ListItemSpacing, prelude::*};
 
 const TRY_ZED_PRO_URL: &str = "https://zed.dev/pro";
@@ -93,7 +93,7 @@ impl LanguageModelPickerDelegate {
         let entries = models.entries();
 
         Self {
-            on_model_changed: on_model_changed.clone(),
+            on_model_changed,
             all_models: Arc::new(models),
             selected_index: Self::get_active_model_index(&entries, get_active_model(cx)),
             filtered_entries: entries,
@@ -104,7 +104,7 @@ impl LanguageModelPickerDelegate {
                 window,
                 |picker, _, event, window, cx| {
                     match event {
-                        language_model::Event::ProviderStateChanged
+                        language_model::Event::ProviderStateChanged(_)
                         | language_model::Event::AddedProvider(_)
                         | language_model::Event::RemovedProvider(_) => {
                             let query = picker.query(cx);
@@ -296,7 +296,7 @@ impl ModelMatcher {
     pub fn fuzzy_search(&self, query: &str) -> Vec<ModelInfo> {
         let mut matches = self.bg_executor.block(match_strings(
             &self.candidates,
-            &query,
+            query,
             false,
             true,
             100,
@@ -514,7 +514,7 @@ impl PickerDelegate for LanguageModelPickerDelegate {
                                 .pl_0p5()
                                 .gap_1p5()
                                 .w(px(240.))
-                                .child(Label::new(model_info.model.name().0.clone()).truncate()),
+                                .child(Label::new(model_info.model.name().0).truncate()),
                         )
                         .end_slot(div().pr_3().when(is_selected, |this| {
                             this.child(
@@ -536,7 +536,7 @@ impl PickerDelegate for LanguageModelPickerDelegate {
     ) -> Option<gpui::AnyElement> {
         use feature_flags::FeatureFlagAppExt;
 
-        let plan = proto::Plan::ZedPro;
+        let plan = Plan::ZedPro;
 
         Some(
             h_flex()
@@ -557,7 +557,7 @@ impl PickerDelegate for LanguageModelPickerDelegate {
                                 window
                                     .dispatch_action(Box::new(zed_actions::OpenAccountSettings), cx)
                             }),
-                        Plan::Free | Plan::ZedProTrial => Button::new(
+                        Plan::ZedFree | Plan::ZedProTrial => Button::new(
                             "try-pro",
                             if plan == Plan::ZedProTrial {
                                 "Upgrade to Pro"

crates/agent_ui/src/message_editor.rs

@@ -6,7 +6,7 @@ use crate::agent_diff::AgentDiffThread;
 use crate::agent_model_selector::AgentModelSelector;
 use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip};
 use crate::ui::{
-    MaxModeTooltip,
+    BurnModeTooltip,
     preview::{AgentPreview, UsageCallout},
 };
 use agent::history_store::HistoryStore;
@@ -14,7 +14,7 @@ use agent::{
     context::{AgentContextKey, ContextLoadResult, load_context},
     context_store::ContextStoreEvent,
 };
-use agent_settings::{AgentSettings, CompletionMode};
+use agent_settings::{AgentProfileId, AgentSettings, CompletionMode};
 use ai_onboarding::ApiKeysWithProviders;
 use buffer_diff::BufferDiff;
 use cloud_llm_client::CompletionIntent;
@@ -55,7 +55,7 @@ use zed_actions::agent::ToggleModelSelector;
 
 use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider, crease_for_mention};
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
-use crate::profile_selector::ProfileSelector;
+use crate::profile_selector::{ProfileProvider, ProfileSelector};
 use crate::{
     ActiveThread, AgentDiffPane, ChatWithFollow, ExpandMessageEditor, Follow, KeepAll,
     ModelUsageContext, NewThread, OpenAgentDiff, RejectAll, RemoveAllContext, ToggleBurnMode,
@@ -117,7 +117,7 @@ pub(crate) fn create_editor(
         let mut editor = Editor::new(
             editor::EditorMode::AutoHeight {
                 min_lines,
-                max_lines: max_lines,
+                max_lines,
             },
             buffer,
             None,
@@ -152,6 +152,24 @@ pub(crate) fn create_editor(
     editor
 }
 
+impl ProfileProvider for Entity<Thread> {
+    fn profiles_supported(&self, cx: &App) -> bool {
+        self.read(cx)
+            .configured_model()
+            .is_some_and(|model| model.model.supports_tools())
+    }
+
+    fn profile_id(&self, cx: &App) -> AgentProfileId {
+        self.read(cx).profile().id().clone()
+    }
+
+    fn set_profile(&self, profile_id: AgentProfileId, cx: &mut App) {
+        self.update(cx, |this, cx| {
+            this.set_profile(profile_id, cx);
+        });
+    }
+}
+
 impl MessageEditor {
     pub fn new(
         fs: Arc<dyn Fs>,
@@ -197,9 +215,10 @@ impl MessageEditor {
 
         let subscriptions = vec![
             cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
-            cx.subscribe(&editor, |this, _, event, cx| match event {
-                EditorEvent::BufferEdited => this.handle_message_changed(cx),
-                _ => {}
+            cx.subscribe(&editor, |this, _, event: &EditorEvent, cx| {
+                if event == &EditorEvent::BufferEdited {
+                    this.handle_message_changed(cx)
+                }
             }),
             cx.observe(&context_store, |this, _, cx| {
                 // When context changes, reload it for token counting.
@@ -221,14 +240,15 @@ impl MessageEditor {
             )
         });
 
-        let profile_selector =
-            cx.new(|cx| ProfileSelector::new(fs, thread.clone(), editor.focus_handle(cx), cx));
+        let profile_selector = cx.new(|cx| {
+            ProfileSelector::new(fs, Arc::new(thread.clone()), editor.focus_handle(cx), cx)
+        });
 
         Self {
             editor: editor.clone(),
             project: thread.read(cx).project().clone(),
             thread,
-            incompatible_tools_state: incompatible_tools.clone(),
+            incompatible_tools_state: incompatible_tools,
             workspace,
             context_store,
             prompt_store,
@@ -422,11 +442,11 @@ impl MessageEditor {
             thread.cancel_editing(cx);
         });
 
-        let cancelled = self.thread.update(cx, |thread, cx| {
+        let canceled = self.thread.update(cx, |thread, cx| {
             thread.cancel_last_completion(Some(window.window_handle()), cx)
         });
 
-        if cancelled {
+        if canceled {
             self.set_editor_is_expanded(false, cx);
             self.send_to_model(window, cx);
         }
@@ -605,7 +625,7 @@ impl MessageEditor {
                     this.toggle_burn_mode(&ToggleBurnMode, window, cx);
                 }))
                 .tooltip(move |_window, cx| {
-                    cx.new(|_| MaxModeTooltip::new().selected(burn_mode_enabled))
+                    cx.new(|_| BurnModeTooltip::new().selected(burn_mode_enabled))
                         .into()
                 })
                 .into_any_element(),
@@ -671,11 +691,7 @@ impl MessageEditor {
             .as_ref()
             .map(|model| {
                 self.incompatible_tools_state.update(cx, |state, cx| {
-                    state
-                        .incompatible_tools(&model.model, cx)
-                        .iter()
-                        .cloned()
-                        .collect::<Vec<_>>()
+                    state.incompatible_tools(&model.model, cx).to_vec()
                 })
             })
             .unwrap_or_default();
@@ -725,7 +741,7 @@ impl MessageEditor {
                     .when(focus_handle.is_focused(window), |this| {
                         this.child(
                             IconButton::new("toggle-height", expand_icon)
-                                .icon_size(IconSize::XSmall)
+                                .icon_size(IconSize::Small)
                                 .icon_color(Color::Muted)
                                 .tooltip({
                                     let focus_handle = focus_handle.clone();
@@ -823,7 +839,6 @@ impl MessageEditor {
                                     .child(self.profile_selector.clone())
                                     .child(self.model_selector.clone())
                                     .map({
-                                        let focus_handle = focus_handle.clone();
                                         move |parent| {
                                             if is_generating {
                                                 parent
@@ -831,7 +846,7 @@ impl MessageEditor {
                                                         parent.child(
                                                             IconButton::new(
                                                                 "stop-generation",
-                                                                IconName::StopFilled,
+                                                                IconName::Stop,
                                                             )
                                                             .icon_color(Color::Error)
                                                             .style(ButtonStyle::Tinted(
@@ -1117,7 +1132,7 @@ impl MessageEditor {
             )
             .when(is_edit_changes_expanded, |parent| {
                 parent.child(
-                    v_flex().children(changed_buffers.into_iter().enumerate().flat_map(
+                    v_flex().children(changed_buffers.iter().enumerate().flat_map(
                         |(index, (buffer, _diff))| {
                             let file = buffer.read(cx).file()?;
                             let path = file.path();
@@ -1147,7 +1162,7 @@ impl MessageEditor {
                                     .buffer_font(cx)
                             });
 
-                            let file_icon = FileIcons::get_icon(&path, cx)
+                            let file_icon = FileIcons::get_icon(path, cx)
                                 .map(Icon::from_path)
                                 .map(|icon| icon.color(Color::Muted).size(IconSize::Small))
                                 .unwrap_or_else(|| {
@@ -1274,7 +1289,7 @@ impl MessageEditor {
         self.thread
             .read(cx)
             .configured_model()
-            .map_or(false, |model| model.provider.id() == ZED_CLOUD_PROVIDER_ID)
+            .is_some_and(|model| model.provider.id() == ZED_CLOUD_PROVIDER_ID)
     }
 
     fn render_usage_callout(&self, line_height: Pixels, cx: &mut Context<Self>) -> Option<Div> {
@@ -1304,14 +1319,10 @@ impl MessageEditor {
         token_usage_ratio: TokenUsageRatio,
         cx: &mut Context<Self>,
     ) -> Option<Div> {
-        let icon = if token_usage_ratio == TokenUsageRatio::Exceeded {
-            Icon::new(IconName::X)
-                .color(Color::Error)
-                .size(IconSize::XSmall)
+        let (icon, severity) = if token_usage_ratio == TokenUsageRatio::Exceeded {
+            (IconName::Close, Severity::Error)
         } else {
-            Icon::new(IconName::Warning)
-                .color(Color::Warning)
-                .size(IconSize::XSmall)
+            (IconName::Warning, Severity::Warning)
         };
 
         let title = if token_usage_ratio == TokenUsageRatio::Exceeded {
@@ -1326,30 +1337,34 @@ impl MessageEditor {
             "To continue, start a new thread from a summary."
         };
 
-        let mut callout = Callout::new()
+        let callout = Callout::new()
             .line_height(line_height)
+            .severity(severity)
             .icon(icon)
             .title(title)
             .description(description)
-            .primary_action(
-                Button::new("start-new-thread", "Start New Thread")
-                    .label_size(LabelSize::Small)
-                    .on_click(cx.listener(|this, _, window, cx| {
-                        let from_thread_id = Some(this.thread.read(cx).id().clone());
-                        window.dispatch_action(Box::new(NewThread { from_thread_id }), cx);
-                    })),
+            .actions_slot(
+                h_flex()
+                    .gap_0p5()
+                    .when(self.is_using_zed_provider(cx), |this| {
+                        this.child(
+                            IconButton::new("burn-mode-callout", IconName::ZedBurnMode)
+                                .icon_size(IconSize::XSmall)
+                                .on_click(cx.listener(|this, _event, window, cx| {
+                                    this.toggle_burn_mode(&ToggleBurnMode, window, cx);
+                                })),
+                        )
+                    })
+                    .child(
+                        Button::new("start-new-thread", "Start New Thread")
+                            .label_size(LabelSize::Small)
+                            .on_click(cx.listener(|this, _, window, cx| {
+                                let from_thread_id = Some(this.thread.read(cx).id().clone());
+                                window.dispatch_action(Box::new(NewThread { from_thread_id }), cx);
+                            })),
+                    ),
             );
 
-        if self.is_using_zed_provider(cx) {
-            callout = callout.secondary_action(
-                IconButton::new("burn-mode-callout", IconName::ZedBurnMode)
-                    .icon_size(IconSize::XSmall)
-                    .on_click(cx.listener(|this, _event, window, cx| {
-                        this.toggle_burn_mode(&ToggleBurnMode, window, cx);
-                    })),
-            );
-        }
-
         Some(
             div()
                 .border_t_1()
@@ -1385,7 +1400,7 @@ impl MessageEditor {
             })
             .ok();
         });
-        // Replace existing load task, if any, causing it to be cancelled.
+        // Replace existing load task, if any, causing it to be canceled.
         let load_task = load_task.shared();
         self.load_context_task = Some(load_task.clone());
         cx.spawn(async move |this, cx| {
@@ -1427,7 +1442,7 @@ impl MessageEditor {
                     let message_text = editor.read(cx).text(cx);
 
                     if message_text.is_empty()
-                        && loaded_context.map_or(true, |loaded_context| loaded_context.is_empty())
+                        && loaded_context.is_none_or(|loaded_context| loaded_context.is_empty())
                     {
                         return None;
                     }
@@ -1540,9 +1555,8 @@ impl ContextCreasesAddon {
         cx: &mut Context<Editor>,
     ) {
         self.creases.entry(key).or_default().extend(creases);
-        self._subscription = Some(cx.subscribe(
-            &context_store,
-            |editor, _, event, cx| match event {
+        self._subscription = Some(
+            cx.subscribe(context_store, |editor, _, event, cx| match event {
                 ContextStoreEvent::ContextRemoved(key) => {
                     let Some(this) = editor.addon_mut::<Self>() else {
                         return;
@@ -1562,8 +1576,8 @@ impl ContextCreasesAddon {
                     editor.edit(ranges.into_iter().zip(replacement_texts), cx);
                     cx.notify();
                 }
-            },
-        ))
+            }),
+        )
     }
 
     pub fn into_inner(self) -> HashMap<AgentContextKey, Vec<(CreaseId, SharedString)>> {
@@ -1591,7 +1605,8 @@ pub fn extract_message_creases(
         .collect::<HashMap<_, _>>();
     // Filter the addon's list of creases based on what the editor reports,
     // since the addon might have removed creases in it.
-    let creases = editor.display_map.update(cx, |display_map, cx| {
+
+    editor.display_map.update(cx, |display_map, cx| {
         display_map
             .snapshot(cx)
             .crease_snapshot
@@ -1615,8 +1630,7 @@ pub fn extract_message_creases(
                 }
             })
             .collect()
-    });
-    creases
+    })
 }
 
 impl EventEmitter<MessageEditorEvent> for MessageEditor {}
@@ -1668,7 +1682,7 @@ impl Render for MessageEditor {
         let has_history = self
             .history_store
             .as_ref()
-            .and_then(|hs| hs.update(cx, |hs, cx| hs.entries(cx).len() > 0).ok())
+            .and_then(|hs| hs.update(cx, |hs, cx| !hs.entries(cx).is_empty()).ok())
             .unwrap_or(false)
             || self
                 .thread
@@ -1681,7 +1695,7 @@ impl Render for MessageEditor {
                 !has_history && is_signed_out && has_configured_providers,
                 |this| this.child(cx.new(ApiKeysWithProviders::new)),
             )
-            .when(changed_buffers.len() > 0, |parent| {
+            .when(!changed_buffers.is_empty(), |parent| {
                 parent.child(self.render_edits_bar(&changed_buffers, window, cx))
             })
             .child(self.render_editor(window, cx))
@@ -1786,7 +1800,7 @@ impl AgentPreview for MessageEditor {
                             .bg(cx.theme().colors().panel_background)
                             .border_1()
                             .border_color(cx.theme().colors().border)
-                            .child(default_message_editor.clone())
+                            .child(default_message_editor)
                             .into_any_element(),
                     )])
                     .into_any_element(),

crates/agent_ui/src/profile_selector.rs

@@ -1,12 +1,8 @@
 use crate::{ManageProfiles, ToggleProfileSelector};
-use agent::{
-    Thread,
-    agent_profile::{AgentProfile, AvailableProfiles},
-};
+use agent::agent_profile::{AgentProfile, AvailableProfiles};
 use agent_settings::{AgentDockPosition, AgentProfileId, AgentSettings, builtin_profiles};
 use fs::Fs;
-use gpui::{Action, Empty, Entity, FocusHandle, Subscription, prelude::*};
-use language_model::LanguageModelRegistry;
+use gpui::{Action, Entity, FocusHandle, Subscription, prelude::*};
 use settings::{Settings as _, SettingsStore, update_settings_file};
 use std::sync::Arc;
 use ui::{
@@ -14,10 +10,22 @@ use ui::{
     prelude::*,
 };
 
+/// Trait for types that can provide and manage agent profiles
+pub trait ProfileProvider {
+    /// Get the current profile ID
+    fn profile_id(&self, cx: &App) -> AgentProfileId;
+
+    /// Set the profile ID
+    fn set_profile(&self, profile_id: AgentProfileId, cx: &mut App);
+
+    /// Check if profiles are supported in the current context (e.g. if the model that is selected has tool support)
+    fn profiles_supported(&self, cx: &App) -> bool;
+}
+
 pub struct ProfileSelector {
     profiles: AvailableProfiles,
     fs: Arc<dyn Fs>,
-    thread: Entity<Thread>,
+    provider: Arc<dyn ProfileProvider>,
     menu_handle: PopoverMenuHandle<ContextMenu>,
     focus_handle: FocusHandle,
     _subscriptions: Vec<Subscription>,
@@ -26,7 +34,7 @@ pub struct ProfileSelector {
 impl ProfileSelector {
     pub fn new(
         fs: Arc<dyn Fs>,
-        thread: Entity<Thread>,
+        provider: Arc<dyn ProfileProvider>,
         focus_handle: FocusHandle,
         cx: &mut Context<Self>,
     ) -> Self {
@@ -37,7 +45,7 @@ impl ProfileSelector {
         Self {
             profiles: AgentProfile::available_profiles(cx),
             fs,
-            thread,
+            provider,
             menu_handle: PopoverMenuHandle::default(),
             focus_handle,
             _subscriptions: vec![settings_subscription],
@@ -113,10 +121,10 @@ impl ProfileSelector {
             builtin_profiles::MINIMAL => Some("Chat about anything with no tools."),
             _ => None,
         };
-        let thread_profile_id = self.thread.read(cx).profile().id();
+        let thread_profile_id = self.provider.profile_id(cx);
 
         let entry = ContextMenuEntry::new(profile_name.clone())
-            .toggleable(IconPosition::End, &profile_id == thread_profile_id);
+            .toggleable(IconPosition::End, profile_id == thread_profile_id);
 
         let entry = if let Some(doc_text) = documentation {
             entry.documentation_aside(documentation_side(settings.dock), move |_| {
@@ -128,19 +136,16 @@ impl ProfileSelector {
 
         entry.handler({
             let fs = self.fs.clone();
-            let thread = self.thread.clone();
-            let profile_id = profile_id.clone();
+            let provider = self.provider.clone();
             move |_window, cx| {
                 update_settings_file::<AgentSettings>(fs.clone(), cx, {
                     let profile_id = profile_id.clone();
                     move |settings, _cx| {
-                        settings.set_profile(profile_id.clone());
+                        settings.set_profile(profile_id);
                     }
                 });
 
-                thread.update(cx, |this, cx| {
-                    this.set_profile(profile_id.clone(), cx);
-                });
+                provider.set_profile(profile_id.clone(), cx);
             }
         })
     }
@@ -149,23 +154,15 @@ impl ProfileSelector {
 impl Render for ProfileSelector {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let settings = AgentSettings::get_global(cx);
-        let profile_id = self.thread.read(cx).profile().id();
-        let profile = settings.profiles.get(profile_id);
+        let profile_id = self.provider.profile_id(cx);
+        let profile = settings.profiles.get(&profile_id);
 
         let selected_profile = profile
             .map(|profile| profile.name.clone())
             .unwrap_or_else(|| "Unknown".into());
 
-        let configured_model = self.thread.read(cx).configured_model().or_else(|| {
-            let model_registry = LanguageModelRegistry::read_global(cx);
-            model_registry.default_model()
-        });
-        let Some(configured_model) = configured_model else {
-            return Empty.into_any_element();
-        };
-
-        if configured_model.model.supports_tools() {
-            let this = cx.entity().clone();
+        if self.provider.profiles_supported(cx) {
+            let this = cx.entity();
             let focus_handle = self.focus_handle.clone();
             let trigger_button = Button::new("profile-selector-model", selected_profile)
                 .label_size(LabelSize::Small)
@@ -177,7 +174,6 @@ impl Render for ProfileSelector {
 
             PopoverMenu::new("profile-selector")
                 .trigger_with_tooltip(trigger_button, {
-                    let focus_handle = focus_handle.clone();
                     move |window, cx| {
                         Tooltip::for_action_in(
                             "Toggle Profile Menu",

crates/agent_ui/src/slash_command.rs

@@ -88,8 +88,6 @@ impl SlashCommandCompletionProvider {
                                 .map(|(editor, workspace)| {
                                     let command_name = mat.string.clone();
                                     let command_range = command_range.clone();
-                                    let editor = editor.clone();
-                                    let workspace = workspace.clone();
                                     Arc::new(
                                             move |intent: CompletionIntent,
                                             window: &mut Window,
@@ -158,7 +156,7 @@ impl SlashCommandCompletionProvider {
         if let Some(command) = self.slash_commands.command(command_name, cx) {
             let completions = command.complete_argument(
                 arguments,
-                new_cancel_flag.clone(),
+                new_cancel_flag,
                 self.workspace.clone(),
                 window,
                 cx,