Rename assistant2 to agent (#27887)

This PR renames the `assistant2` crate to `agent`.

Release Notes:

- N/A

crates/agent/Cargo.toml

@@ -0,0 +1,98 @@
+[package]
+name = "agent"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/assistant.rs"
+doctest = false
+
+[features]
+test-support = [
+    "gpui/test-support",
+    "language/test-support",
+]
+
+[dependencies]
+anyhow.workspace = true
+assistant_context_editor.workspace = true
+assistant_settings.workspace = true
+assistant_slash_command.workspace = true
+assistant_tool.workspace = true
+async-watch.workspace = true
+buffer_diff.workspace = true
+chrono.workspace = true
+client.workspace = true
+clock.workspace = true
+collections.workspace = true
+command_palette_hooks.workspace = true
+context_server.workspace = true
+convert_case.workspace = true
+db.workspace = true
+editor.workspace = true
+feature_flags.workspace = true
+file_icons.workspace = true
+fs.workspace = true
+futures.workspace = true
+fuzzy.workspace = true
+git.workspace = true
+gpui.workspace = true
+heed.workspace = true
+html_to_markdown.workspace = true
+http_client.workspace = true
+indexmap.workspace = true
+itertools.workspace = true
+language.workspace = true
+language_model.workspace = true
+language_model_selector.workspace = true
+log.workspace = true
+lsp.workspace = true
+markdown.workspace = true
+menu.workspace = true
+multi_buffer.workspace = true
+ordered-float.workspace = true
+parking_lot.workspace = true
+paths.workspace = true
+picker.workspace = true
+project.workspace = true
+prompt_library.workspace = true
+prompt_store.workspace = true
+proto.workspace = true
+release_channel.workspace = true
+rope.workspace = true
+schemars.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+smallvec.workspace = true
+smol.workspace = true
+streaming_diff.workspace = true
+telemetry.workspace = true
+telemetry_events.workspace = true
+terminal.workspace = true
+terminal_view.workspace = true
+text.workspace = true
+theme.workspace = true
+time.workspace = true
+time_format.workspace = true
+ui.workspace = true
+util.workspace = true
+uuid.workspace = true
+vim_mode_setting.workspace = true
+workspace.workspace = true
+zed_actions.workspace = true
+
+[dev-dependencies]
+buffer_diff = { workspace = true, features = ["test-support"] }
+editor = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, "features" = ["test-support"] }
+indoc.workspace = true
+language = { workspace = true, "features" = ["test-support"] }
+language_model = { workspace = true, "features" = ["test-support"] }
+project = { workspace = true, features = ["test-support"] }
+rand.workspace = true

crates/agent/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/agent/src/assistant.rs

@@ -0,0 +1,146 @@
+mod active_thread;
+mod assistant_configuration;
+mod assistant_diff;
+mod assistant_model_selector;
+mod assistant_panel;
+mod buffer_codegen;
+mod context;
+mod context_picker;
+mod context_store;
+mod context_strip;
+mod history_store;
+mod inline_assistant;
+mod inline_prompt_editor;
+mod message_editor;
+mod profile_selector;
+mod terminal_codegen;
+mod terminal_inline_assistant;
+mod thread;
+mod thread_history;
+mod thread_store;
+mod tool_use;
+mod ui;
+
+use std::sync::Arc;
+
+use assistant_settings::AssistantSettings;
+use client::Client;
+use command_palette_hooks::CommandPaletteFilter;
+use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt};
+use fs::Fs;
+use gpui::{App, actions, impl_actions};
+use prompt_store::PromptBuilder;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use settings::Settings as _;
+use thread::ThreadId;
+
+pub use crate::active_thread::ActiveThread;
+use crate::assistant_configuration::{AddContextServerModal, ManageProfilesModal};
+pub use crate::assistant_panel::{AssistantPanel, ConcreteAssistantPanelDelegate};
+pub use crate::inline_assistant::InlineAssistant;
+pub use crate::thread::{Message, RequestKind, Thread, ThreadEvent};
+pub use crate::thread_store::ThreadStore;
+pub use assistant_diff::{AssistantDiff, AssistantDiffToolbar};
+
+actions!(
+    agent,
+    [
+        NewPromptEditor,
+        ToggleContextPicker,
+        ToggleProfileSelector,
+        RemoveAllContext,
+        OpenHistory,
+        OpenConfiguration,
+        AddContextServer,
+        RemoveSelectedThread,
+        Chat,
+        ChatMode,
+        CycleNextInlineAssist,
+        CyclePreviousInlineAssist,
+        FocusUp,
+        FocusDown,
+        FocusLeft,
+        FocusRight,
+        RemoveFocusedContext,
+        AcceptSuggestedContext,
+        OpenActiveThreadAsMarkdown,
+        OpenAssistantDiff,
+        Keep,
+        Reject,
+        RejectAll,
+        KeepAll
+    ]
+);
+
+#[derive(Default, Clone, PartialEq, Deserialize, JsonSchema)]
+pub struct NewThread {
+    #[serde(default)]
+    from_thread_id: Option<ThreadId>,
+}
+
+#[derive(PartialEq, Clone, Default, Debug, Deserialize, JsonSchema)]
+pub struct ManageProfiles {
+    #[serde(default)]
+    pub customize_tools: Option<Arc<str>>,
+}
+
+impl ManageProfiles {
+    pub fn customize_tools(profile_id: Arc<str>) -> Self {
+        Self {
+            customize_tools: Some(profile_id),
+        }
+    }
+}
+
+impl_actions!(agent, [NewThread, ManageProfiles]);
+
+const NAMESPACE: &str = "agent";
+
+/// Initializes the `agent` crate.
+pub fn init(
+    fs: Arc<dyn Fs>,
+    client: Arc<Client>,
+    prompt_builder: Arc<PromptBuilder>,
+    cx: &mut App,
+) {
+    AssistantSettings::register(cx);
+    thread_store::init(cx);
+    assistant_panel::init(cx);
+
+    inline_assistant::init(
+        fs.clone(),
+        prompt_builder.clone(),
+        client.telemetry().clone(),
+        cx,
+    );
+    terminal_inline_assistant::init(
+        fs.clone(),
+        prompt_builder.clone(),
+        client.telemetry().clone(),
+        cx,
+    );
+    cx.observe_new(AddContextServerModal::register).detach();
+    cx.observe_new(ManageProfilesModal::register).detach();
+
+    feature_gate_agent_actions(cx);
+}
+
+fn feature_gate_agent_actions(cx: &mut App) {
+    CommandPaletteFilter::update_global(cx, |filter, _cx| {
+        filter.hide_namespace(NAMESPACE);
+    });
+
+    cx.observe_flag::<Assistant2FeatureFlag, _>(move |is_enabled, cx| {
+        if is_enabled {
+            CommandPaletteFilter::update_global(cx, |filter, _cx| {
+                filter.show_namespace(NAMESPACE);
+            });
+        } else {
+            CommandPaletteFilter::update_global(cx, |filter, _cx| {
+                filter.hide_namespace(NAMESPACE);
+            });
+        }
+    })
+    .detach();
+}

crates/agent/src/assistant_configuration.rs

@@ -0,0 +1,385 @@
+mod add_context_server_modal;
+mod manage_profiles_modal;
+mod tool_picker;
+
+use std::sync::Arc;
+
+use assistant_tool::{ToolSource, ToolWorkingSet};
+use collections::HashMap;
+use context_server::manager::ContextServerManager;
+use gpui::{Action, AnyView, App, Entity, EventEmitter, FocusHandle, Focusable, Subscription};
+use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
+use ui::{Disclosure, Divider, DividerColor, ElevationIndex, Indicator, Switch, prelude::*};
+use util::ResultExt as _;
+use zed_actions::ExtensionCategoryFilter;
+
+pub(crate) use add_context_server_modal::AddContextServerModal;
+pub(crate) use manage_profiles_modal::ManageProfilesModal;
+
+use crate::AddContextServer;
+
+pub struct AssistantConfiguration {
+    focus_handle: FocusHandle,
+    configuration_views_by_provider: HashMap<LanguageModelProviderId, AnyView>,
+    context_server_manager: Entity<ContextServerManager>,
+    expanded_context_server_tools: HashMap<Arc<str>, bool>,
+    tools: Arc<ToolWorkingSet>,
+    _registry_subscription: Subscription,
+}
+
+impl AssistantConfiguration {
+    pub fn new(
+        context_server_manager: Entity<ContextServerManager>,
+        tools: Arc<ToolWorkingSet>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let focus_handle = cx.focus_handle();
+
+        let registry_subscription = cx.subscribe_in(
+            &LanguageModelRegistry::global(cx),
+            window,
+            |this, _, event: &language_model::Event, window, cx| match event {
+                language_model::Event::AddedProvider(provider_id) => {
+                    let provider = LanguageModelRegistry::read_global(cx).provider(provider_id);
+                    if let Some(provider) = provider {
+                        this.add_provider_configuration_view(&provider, window, cx);
+                    }
+                }
+                language_model::Event::RemovedProvider(provider_id) => {
+                    this.remove_provider_configuration_view(provider_id);
+                }
+                _ => {}
+            },
+        );
+
+        let mut this = Self {
+            focus_handle,
+            configuration_views_by_provider: HashMap::default(),
+            context_server_manager,
+            expanded_context_server_tools: HashMap::default(),
+            tools,
+            _registry_subscription: registry_subscription,
+        };
+        this.build_provider_configuration_views(window, cx);
+        this
+    }
+
+    fn build_provider_configuration_views(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let providers = LanguageModelRegistry::read_global(cx).providers();
+        for provider in providers {
+            self.add_provider_configuration_view(&provider, window, cx);
+        }
+    }
+
+    fn remove_provider_configuration_view(&mut self, provider_id: &LanguageModelProviderId) {
+        self.configuration_views_by_provider.remove(provider_id);
+    }
+
+    fn add_provider_configuration_view(
+        &mut self,
+        provider: &Arc<dyn LanguageModelProvider>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let configuration_view = provider.configuration_view(window, cx);
+        self.configuration_views_by_provider
+            .insert(provider.id(), configuration_view);
+    }
+}
+
+impl Focusable for AssistantConfiguration {
+    fn focus_handle(&self, _: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+pub enum AssistantConfigurationEvent {
+    NewThread(Arc<dyn LanguageModelProvider>),
+}
+
+impl EventEmitter<AssistantConfigurationEvent> for AssistantConfiguration {}
+
+impl AssistantConfiguration {
+    fn render_provider_configuration(
+        &mut self,
+        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 configuration_view = self
+            .configuration_views_by_provider
+            .get(&provider.id())
+            .cloned();
+
+        v_flex()
+            .gap_1p5()
+            .child(
+                h_flex()
+                    .justify_between()
+                    .child(
+                        h_flex()
+                            .gap_2()
+                            .child(
+                                Icon::new(provider.icon())
+                                    .size(IconSize::Small)
+                                    .color(Color::Muted),
+                            )
+                            .child(Label::new(provider_name.clone())),
+                    )
+                    .when(provider.is_authenticated(cx), |parent| {
+                        parent.child(
+                            Button::new(
+                                SharedString::from(format!("new-thread-{provider_id}")),
+                                "Start New Thread",
+                            )
+                            .icon_position(IconPosition::Start)
+                            .icon(IconName::Plus)
+                            .icon_size(IconSize::Small)
+                            .style(ButtonStyle::Filled)
+                            .layer(ElevationIndex::ModalSurface)
+                            .label_size(LabelSize::Small)
+                            .on_click(cx.listener({
+                                let provider = provider.clone();
+                                move |_this, _event, _window, cx| {
+                                    cx.emit(AssistantConfigurationEvent::NewThread(
+                                        provider.clone(),
+                                    ))
+                                }
+                            })),
+                        )
+                    }),
+            )
+            .child(
+                div()
+                    .p(DynamicSpacing::Base08.rems(cx))
+                    .bg(cx.theme().colors().editor_background)
+                    .border_1()
+                    .border_color(cx.theme().colors().border_variant)
+                    .rounded_sm()
+                    .map(|parent| match configuration_view {
+                        Some(configuration_view) => parent.child(configuration_view),
+                        None => parent.child(div().child(Label::new(format!(
+                            "No configuration view for {provider_name}",
+                        )))),
+                    }),
+            )
+    }
+
+    fn render_context_servers_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
+        let context_servers = self.context_server_manager.read(cx).all_servers().clone();
+        let tools_by_source = self.tools.tools_by_source(cx);
+        let empty = Vec::new();
+
+        const SUBHEADING: &str = "Connect to context servers via the Model Context Protocol either via Zed extensions or directly.";
+
+        v_flex()
+            .p(DynamicSpacing::Base16.rems(cx))
+            .gap_2()
+            .flex_1()
+            .child(
+                v_flex()
+                    .gap_0p5()
+                    .child(Headline::new("Context Servers (MCP)").size(HeadlineSize::Small))
+                    .child(Label::new(SUBHEADING).color(Color::Muted)),
+            )
+            .children(context_servers.into_iter().map(|context_server| {
+                let is_running = context_server.client().is_some();
+                let are_tools_expanded = self
+                    .expanded_context_server_tools
+                    .get(&context_server.id())
+                    .copied()
+                    .unwrap_or_default();
+
+                let tools = tools_by_source
+                    .get(&ToolSource::ContextServer {
+                        id: context_server.id().into(),
+                    })
+                    .unwrap_or_else(|| &empty);
+                let tool_count = tools.len();
+
+                v_flex()
+                    .id(SharedString::from(context_server.id()))
+                    .border_1()
+                    .rounded_sm()
+                    .border_color(cx.theme().colors().border)
+                    .bg(cx.theme().colors().editor_background)
+                    .child(
+                        h_flex()
+                            .justify_between()
+                            .px_2()
+                            .py_1()
+                            .when(are_tools_expanded, |element| {
+                                element
+                                    .border_b_1()
+                                    .border_color(cx.theme().colors().border)
+                            })
+                            .child(
+                                h_flex()
+                                    .gap_2()
+                                    .child(
+                                        Disclosure::new("tool-list-disclosure", are_tools_expanded)
+                                            .on_click(cx.listener({
+                                                let context_server_id = context_server.id();
+                                                move |this, _event, _window, _cx| {
+                                                    let is_open = this
+                                                        .expanded_context_server_tools
+                                                        .entry(context_server_id.clone())
+                                                        .or_insert(false);
+
+                                                    *is_open = !*is_open;
+                                                }
+                                            })),
+                                    )
+                                    .child(Indicator::dot().color(if is_running {
+                                        Color::Success
+                                    } else {
+                                        Color::Error
+                                    }))
+                                    .child(Label::new(context_server.id()))
+                                    .child(
+                                        Label::new(format!("{tool_count} tools"))
+                                            .color(Color::Muted),
+                                    ),
+                            )
+                            .child(h_flex().child(
+                                Switch::new("context-server-switch", is_running.into()).on_click({
+                                    let context_server_manager =
+                                        self.context_server_manager.clone();
+                                    let context_server = context_server.clone();
+                                    move |state, _window, cx| match state {
+                                        ToggleState::Unselected | ToggleState::Indeterminate => {
+                                            context_server_manager.update(cx, |this, cx| {
+                                                this.stop_server(context_server.clone(), cx)
+                                                    .log_err();
+                                            });
+                                        }
+                                        ToggleState::Selected => {
+                                            cx.spawn({
+                                                let context_server_manager =
+                                                    context_server_manager.clone();
+                                                let context_server = context_server.clone();
+                                                async move |cx| {
+                                                    if let Some(start_server_task) =
+                                                        context_server_manager
+                                                            .update(cx, |this, cx| {
+                                                                this.start_server(
+                                                                    context_server,
+                                                                    cx,
+                                                                )
+                                                            })
+                                                            .log_err()
+                                                    {
+                                                        start_server_task.await.log_err();
+                                                    }
+                                                }
+                                            })
+                                            .detach();
+                                        }
+                                    }
+                                }),
+                            )),
+                    )
+                    .map(|parent| {
+                        if !are_tools_expanded {
+                            return parent;
+                        }
+
+                        parent.child(v_flex().children(tools.into_iter().enumerate().map(
+                            |(ix, tool)| {
+                                h_flex()
+                                    .px_2()
+                                    .py_1()
+                                    .when(ix < tool_count - 1, |element| {
+                                        element
+                                            .border_b_1()
+                                            .border_color(cx.theme().colors().border)
+                                    })
+                                    .child(Label::new(tool.name()))
+                            },
+                        )))
+                    })
+            }))
+            .child(
+                h_flex()
+                    .justify_between()
+                    .gap_2()
+                    .child(
+                        h_flex().w_full().child(
+                            Button::new("add-context-server", "Add Context Server")
+                                .style(ButtonStyle::Filled)
+                                .layer(ElevationIndex::ModalSurface)
+                                .full_width()
+                                .icon(IconName::Plus)
+                                .icon_size(IconSize::Small)
+                                .icon_position(IconPosition::Start)
+                                .on_click(|_event, window, cx| {
+                                    window.dispatch_action(AddContextServer.boxed_clone(), cx)
+                                }),
+                        ),
+                    )
+                    .child(
+                        h_flex().w_full().child(
+                            Button::new(
+                                "install-context-server-extensions",
+                                "Install Context Server Extensions",
+                            )
+                            .style(ButtonStyle::Filled)
+                            .layer(ElevationIndex::ModalSurface)
+                            .full_width()
+                            .icon(IconName::DatabaseZap)
+                            .icon_size(IconSize::Small)
+                            .icon_position(IconPosition::Start)
+                            .on_click(|_event, window, cx| {
+                                window.dispatch_action(
+                                    zed_actions::Extensions {
+                                        category_filter: Some(
+                                            ExtensionCategoryFilter::ContextServers,
+                                        ),
+                                    }
+                                    .boxed_clone(),
+                                    cx,
+                                )
+                            }),
+                        ),
+                    ),
+            )
+    }
+}
+
+impl Render for AssistantConfiguration {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let providers = LanguageModelRegistry::read_global(cx).providers();
+
+        v_flex()
+            .id("assistant-configuration")
+            .track_focus(&self.focus_handle(cx))
+            .bg(cx.theme().colors().panel_background)
+            .size_full()
+            .overflow_y_scroll()
+            .child(self.render_context_servers_section(cx))
+            .child(Divider::horizontal().color(DividerColor::Border))
+            .child(
+                v_flex()
+                    .p(DynamicSpacing::Base16.rems(cx))
+                    .mt_1()
+                    .gap_6()
+                    .flex_1()
+                    .child(
+                        v_flex()
+                            .gap_0p5()
+                            .child(Headline::new("LLM Providers").size(HeadlineSize::Small))
+                            .child(
+                                Label::new("Add at least one provider to use AI-powered features.")
+                                    .color(Color::Muted),
+                            ),
+                    )
+                    .children(
+                        providers
+                            .into_iter()
+                            .map(|provider| self.render_provider_configuration(&provider, cx)),
+                    ),
+            )
+    }
+}

crates/agent/src/assistant_configuration/add_context_server_modal.rs

@@ -0,0 +1,164 @@
+use context_server::{ContextServerSettings, ServerCommand, ServerConfig};
+use editor::Editor;
+use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, WeakEntity, prelude::*};
+use serde_json::json;
+use settings::update_settings_file;
+use ui::{Modal, ModalFooter, ModalHeader, Section, Tooltip, prelude::*};
+use workspace::{ModalView, Workspace};
+
+use crate::AddContextServer;
+
+pub struct AddContextServerModal {
+    workspace: WeakEntity<Workspace>,
+    name_editor: Entity<Editor>,
+    command_editor: Entity<Editor>,
+}
+
+impl AddContextServerModal {
+    pub fn register(
+        workspace: &mut Workspace,
+        _window: Option<&mut Window>,
+        _cx: &mut Context<Workspace>,
+    ) {
+        workspace.register_action(|workspace, _: &AddContextServer, window, cx| {
+            let workspace_handle = cx.entity().downgrade();
+            workspace.toggle_modal(window, cx, |window, cx| {
+                Self::new(workspace_handle, window, cx)
+            })
+        });
+    }
+
+    pub fn new(
+        workspace: WeakEntity<Workspace>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let name_editor = cx.new(|cx| Editor::single_line(window, cx));
+        let command_editor = cx.new(|cx| Editor::single_line(window, cx));
+
+        name_editor.update(cx, |editor, cx| {
+            editor.set_placeholder_text("Context server name", cx);
+        });
+
+        command_editor.update(cx, |editor, cx| {
+            editor.set_placeholder_text("Command to run the context server", cx);
+        });
+
+        Self {
+            name_editor,
+            command_editor,
+            workspace,
+        }
+    }
+
+    fn confirm(&mut self, cx: &mut Context<Self>) {
+        let name = self.name_editor.read(cx).text(cx).trim().to_string();
+        let command = self.command_editor.read(cx).text(cx).trim().to_string();
+
+        if name.is_empty() || command.is_empty() {
+            return;
+        }
+
+        let mut command_parts = command.split(' ').map(|part| part.trim().to_string());
+        let Some(path) = command_parts.next() else {
+            return;
+        };
+        let args = command_parts.collect::<Vec<_>>();
+
+        if let Some(workspace) = self.workspace.upgrade() {
+            workspace.update(cx, |workspace, cx| {
+                let fs = workspace.app_state().fs.clone();
+                update_settings_file::<ContextServerSettings>(fs.clone(), cx, |settings, _| {
+                    settings.context_servers.insert(
+                        name.into(),
+                        ServerConfig {
+                            command: Some(ServerCommand {
+                                path,
+                                args,
+                                env: None,
+                            }),
+                            settings: Some(json!({})),
+                        },
+                    );
+                });
+            });
+        }
+
+        cx.emit(DismissEvent);
+    }
+
+    fn cancel(&mut self, cx: &mut Context<Self>) {
+        cx.emit(DismissEvent);
+    }
+}
+
+impl ModalView for AddContextServerModal {}
+
+impl Focusable for AddContextServerModal {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.name_editor.focus_handle(cx).clone()
+    }
+}
+
+impl EventEmitter<DismissEvent> for AddContextServerModal {}
+
+impl Render for AddContextServerModal {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let is_name_empty = self.name_editor.read(cx).text(cx).trim().is_empty();
+        let is_command_empty = self.command_editor.read(cx).text(cx).trim().is_empty();
+
+        div()
+            .elevation_3(cx)
+            .w(rems(34.))
+            .key_context("AddContextServerModal")
+            .on_action(cx.listener(|this, _: &menu::Cancel, _window, cx| this.cancel(cx)))
+            .on_action(cx.listener(|this, _: &menu::Confirm, _window, cx| this.confirm(cx)))
+            .capture_any_mouse_down(cx.listener(|this, _, window, cx| {
+                this.focus_handle(cx).focus(window);
+            }))
+            .on_mouse_down_out(cx.listener(|_this, _, _, cx| cx.emit(DismissEvent)))
+            .child(
+                Modal::new("add-context-server", None)
+                    .header(ModalHeader::new().headline("Add Context Server"))
+                    .section(
+                        Section::new()
+                            .child(
+                                v_flex()
+                                    .gap_1()
+                                    .child(Label::new("Name"))
+                                    .child(self.name_editor.clone()),
+                            )
+                            .child(
+                                v_flex()
+                                    .gap_1()
+                                    .child(Label::new("Command"))
+                                    .child(self.command_editor.clone()),
+                            ),
+                    )
+                    .footer(
+                        ModalFooter::new()
+                            .start_slot(
+                                Button::new("cancel", "Cancel").on_click(
+                                    cx.listener(|this, _event, _window, cx| this.cancel(cx)),
+                                ),
+                            )
+                            .end_slot(
+                                Button::new("add-server", "Add Server")
+                                    .disabled(is_name_empty || is_command_empty)
+                                    .map(|button| {
+                                        if is_name_empty {
+                                            button.tooltip(Tooltip::text("Name is required"))
+                                        } else if is_command_empty {
+                                            button.tooltip(Tooltip::text("Command is required"))
+                                        } else {
+                                            button
+                                        }
+                                    })
+                                    .on_click(
+                                        cx.listener(|this, _event, _window, cx| this.confirm(cx)),
+                                    ),
+                            ),
+                    ),
+            )
+    }
+}

crates/agent/src/assistant_configuration/manage_profiles_modal.rs

@@ -0,0 +1,565 @@
+mod profile_modal_header;
+
+use std::sync::Arc;
+
+use assistant_settings::{AgentProfile, AssistantSettings};
+use assistant_tool::ToolWorkingSet;
+use convert_case::{Case, Casing as _};
+use editor::Editor;
+use fs::Fs;
+use gpui::{
+    DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription, WeakEntity,
+    prelude::*,
+};
+use settings::{Settings as _, update_settings_file};
+use ui::{
+    KeyBinding, ListItem, ListItemSpacing, ListSeparator, Navigable, NavigableEntry, prelude::*,
+};
+use util::ResultExt as _;
+use workspace::{ModalView, Workspace};
+
+use crate::assistant_configuration::manage_profiles_modal::profile_modal_header::ProfileModalHeader;
+use crate::assistant_configuration::tool_picker::{ToolPicker, ToolPickerDelegate};
+use crate::{AssistantPanel, ManageProfiles, ThreadStore};
+
+enum Mode {
+    ChooseProfile(ChooseProfileMode),
+    NewProfile(NewProfileMode),
+    ViewProfile(ViewProfileMode),
+    ConfigureTools {
+        profile_id: Arc<str>,
+        tool_picker: Entity<ToolPicker>,
+        _subscription: Subscription,
+    },
+}
+
+impl Mode {
+    pub fn choose_profile(_window: &mut Window, cx: &mut Context<ManageProfilesModal>) -> Self {
+        let settings = AssistantSettings::get_global(cx);
+
+        let mut profiles = settings.profiles.clone();
+        profiles.sort_unstable_by(|_, a, _, b| a.name.cmp(&b.name));
+
+        let profiles = profiles
+            .into_iter()
+            .map(|(id, profile)| ProfileEntry {
+                id,
+                name: profile.name,
+                navigation: NavigableEntry::focusable(cx),
+            })
+            .collect::<Vec<_>>();
+
+        Self::ChooseProfile(ChooseProfileMode {
+            profiles,
+            add_new_profile: NavigableEntry::focusable(cx),
+        })
+    }
+}
+
+#[derive(Clone)]
+struct ProfileEntry {
+    pub id: Arc<str>,
+    pub name: SharedString,
+    pub navigation: NavigableEntry,
+}
+
+#[derive(Clone)]
+pub struct ChooseProfileMode {
+    profiles: Vec<ProfileEntry>,
+    add_new_profile: NavigableEntry,
+}
+
+#[derive(Clone)]
+pub struct ViewProfileMode {
+    profile_id: Arc<str>,
+    fork_profile: NavigableEntry,
+    configure_tools: NavigableEntry,
+}
+
+#[derive(Clone)]
+pub struct NewProfileMode {
+    name_editor: Entity<Editor>,
+    base_profile_id: Option<Arc<str>>,
+}
+
+pub struct ManageProfilesModal {
+    fs: Arc<dyn Fs>,
+    tools: Arc<ToolWorkingSet>,
+    thread_store: WeakEntity<ThreadStore>,
+    focus_handle: FocusHandle,
+    mode: Mode,
+}
+
+impl ManageProfilesModal {
+    pub fn register(
+        workspace: &mut Workspace,
+        _window: Option<&mut Window>,
+        _cx: &mut Context<Workspace>,
+    ) {
+        workspace.register_action(|workspace, action: &ManageProfiles, window, cx| {
+            if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
+                let fs = workspace.app_state().fs.clone();
+                let thread_store = panel.read(cx).thread_store();
+                let tools = thread_store.read(cx).tools();
+                let thread_store = thread_store.downgrade();
+                workspace.toggle_modal(window, cx, |window, cx| {
+                    let mut this = Self::new(fs, tools, thread_store, window, cx);
+
+                    if let Some(profile_id) = action.customize_tools.clone() {
+                        this.configure_tools(profile_id, window, cx);
+                    }
+
+                    this
+                })
+            }
+        });
+    }
+
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        tools: Arc<ToolWorkingSet>,
+        thread_store: WeakEntity<ThreadStore>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let focus_handle = cx.focus_handle();
+
+        Self {
+            fs,
+            tools,
+            thread_store,
+            focus_handle,
+            mode: Mode::choose_profile(window, cx),
+        }
+    }
+
+    fn choose_profile(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.mode = Mode::choose_profile(window, cx);
+        self.focus_handle(cx).focus(window);
+    }
+
+    fn new_profile(
+        &mut self,
+        base_profile_id: Option<Arc<str>>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let name_editor = cx.new(|cx| Editor::single_line(window, cx));
+        name_editor.update(cx, |editor, cx| {
+            editor.set_placeholder_text("Profile name", cx);
+        });
+
+        self.mode = Mode::NewProfile(NewProfileMode {
+            name_editor,
+            base_profile_id,
+        });
+        self.focus_handle(cx).focus(window);
+    }
+
+    pub fn view_profile(
+        &mut self,
+        profile_id: Arc<str>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.mode = Mode::ViewProfile(ViewProfileMode {
+            profile_id,
+            fork_profile: NavigableEntry::focusable(cx),
+            configure_tools: NavigableEntry::focusable(cx),
+        });
+        self.focus_handle(cx).focus(window);
+    }
+
+    fn configure_tools(
+        &mut self,
+        profile_id: Arc<str>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let settings = AssistantSettings::get_global(cx);
+        let Some(profile) = settings.profiles.get(&profile_id).cloned() else {
+            return;
+        };
+
+        let tool_picker = cx.new(|cx| {
+            let delegate = ToolPickerDelegate::new(
+                self.fs.clone(),
+                self.tools.clone(),
+                self.thread_store.clone(),
+                profile_id.clone(),
+                profile,
+                cx,
+            );
+            ToolPicker::new(delegate, window, cx)
+        });
+        let dismiss_subscription = cx.subscribe_in(&tool_picker, window, {
+            let profile_id = profile_id.clone();
+            move |this, _tool_picker, _: &DismissEvent, window, cx| {
+                this.view_profile(profile_id.clone(), window, cx);
+            }
+        });
+
+        self.mode = Mode::ConfigureTools {
+            profile_id,
+            tool_picker,
+            _subscription: dismiss_subscription,
+        };
+        self.focus_handle(cx).focus(window);
+    }
+
+    fn confirm(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        match &self.mode {
+            Mode::ChooseProfile { .. } => {}
+            Mode::NewProfile(mode) => {
+                let settings = AssistantSettings::get_global(cx);
+
+                let base_profile = mode
+                    .base_profile_id
+                    .as_ref()
+                    .and_then(|profile_id| settings.profiles.get(profile_id).cloned());
+
+                let name = mode.name_editor.read(cx).text(cx);
+                let profile_id: Arc<str> = name.to_case(Case::Kebab).into();
+
+                let profile = AgentProfile {
+                    name: name.into(),
+                    tools: base_profile
+                        .as_ref()
+                        .map(|profile| profile.tools.clone())
+                        .unwrap_or_default(),
+                    enable_all_context_servers: base_profile
+                        .as_ref()
+                        .map(|profile| profile.enable_all_context_servers)
+                        .unwrap_or_default(),
+                    context_servers: base_profile
+                        .map(|profile| profile.context_servers)
+                        .unwrap_or_default(),
+                };
+
+                self.create_profile(profile_id.clone(), profile, cx);
+                self.view_profile(profile_id, window, cx);
+            }
+            Mode::ViewProfile(_) => {}
+            Mode::ConfigureTools { .. } => {}
+        }
+    }
+
+    fn cancel(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        match &self.mode {
+            Mode::ChooseProfile { .. } => {
+                cx.emit(DismissEvent);
+            }
+            Mode::NewProfile(mode) => {
+                if let Some(profile_id) = mode.base_profile_id.clone() {
+                    self.view_profile(profile_id, window, cx);
+                } else {
+                    self.choose_profile(window, cx);
+                }
+            }
+            Mode::ViewProfile(_) => self.choose_profile(window, cx),
+            Mode::ConfigureTools { .. } => {}
+        }
+    }
+
+    fn create_profile(&self, profile_id: Arc<str>, profile: AgentProfile, cx: &mut Context<Self>) {
+        update_settings_file::<AssistantSettings>(self.fs.clone(), cx, {
+            move |settings, _cx| {
+                settings.create_profile(profile_id, profile).log_err();
+            }
+        });
+    }
+}
+
+impl ModalView for ManageProfilesModal {}
+
+impl Focusable for ManageProfilesModal {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        match &self.mode {
+            Mode::ChooseProfile(_) => self.focus_handle.clone(),
+            Mode::NewProfile(mode) => mode.name_editor.focus_handle(cx),
+            Mode::ViewProfile(_) => self.focus_handle.clone(),
+            Mode::ConfigureTools { tool_picker, .. } => tool_picker.focus_handle(cx),
+        }
+    }
+}
+
+impl EventEmitter<DismissEvent> for ManageProfilesModal {}
+
+impl ManageProfilesModal {
+    fn render_choose_profile(
+        &mut self,
+        mode: ChooseProfileMode,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        Navigable::new(
+            div()
+                .track_focus(&self.focus_handle(cx))
+                .size_full()
+                .child(ProfileModalHeader::new(
+                    "Agent Profiles",
+                    IconName::ZedAssistant,
+                ))
+                .child(
+                    v_flex()
+                        .pb_1()
+                        .child(ListSeparator)
+                        .children(mode.profiles.iter().map(|profile| {
+                            div()
+                                .id(SharedString::from(format!("profile-{}", profile.id)))
+                                .track_focus(&profile.navigation.focus_handle)
+                                .on_action({
+                                    let profile_id = profile.id.clone();
+                                    cx.listener(move |this, _: &menu::Confirm, window, cx| {
+                                        this.view_profile(profile_id.clone(), window, cx);
+                                    })
+                                })
+                                .child(
+                                    ListItem::new(SharedString::from(format!(
+                                        "profile-{}",
+                                        profile.id
+                                    )))
+                                    .toggle_state(
+                                        profile
+                                            .navigation
+                                            .focus_handle
+                                            .contains_focused(window, cx),
+                                    )
+                                    .inset(true)
+                                    .spacing(ListItemSpacing::Sparse)
+                                    .child(Label::new(profile.name.clone()))
+                                    .end_slot(
+                                        h_flex()
+                                            .gap_1()
+                                            .child(Label::new("Customize").size(LabelSize::Small))
+                                            .children(KeyBinding::for_action_in(
+                                                &menu::Confirm,
+                                                &self.focus_handle,
+                                                window,
+                                                cx,
+                                            )),
+                                    )
+                                    .on_click({
+                                        let profile_id = profile.id.clone();
+                                        cx.listener(move |this, _, window, cx| {
+                                            this.view_profile(profile_id.clone(), window, cx);
+                                        })
+                                    }),
+                                )
+                        }))
+                        .child(ListSeparator)
+                        .child(
+                            div()
+                                .id("new-profile")
+                                .track_focus(&mode.add_new_profile.focus_handle)
+                                .on_action(cx.listener(|this, _: &menu::Confirm, window, cx| {
+                                    this.new_profile(None, window, cx);
+                                }))
+                                .child(
+                                    ListItem::new("new-profile")
+                                        .toggle_state(
+                                            mode.add_new_profile
+                                                .focus_handle
+                                                .contains_focused(window, cx),
+                                        )
+                                        .inset(true)
+                                        .spacing(ListItemSpacing::Sparse)
+                                        .start_slot(Icon::new(IconName::Plus))
+                                        .child(Label::new("Add New Profile"))
+                                        .on_click({
+                                            cx.listener(move |this, _, window, cx| {
+                                                this.new_profile(None, window, cx);
+                                            })
+                                        }),
+                                ),
+                        ),
+                )
+                .into_any_element(),
+        )
+        .map(|mut navigable| {
+            for profile in mode.profiles {
+                navigable = navigable.entry(profile.navigation);
+            }
+
+            navigable
+        })
+        .entry(mode.add_new_profile)
+    }
+
+    fn render_new_profile(
+        &mut self,
+        mode: NewProfileMode,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let settings = AssistantSettings::get_global(cx);
+
+        let base_profile_name = mode.base_profile_id.as_ref().map(|base_profile_id| {
+            settings
+                .profiles
+                .get(base_profile_id)
+                .map(|profile| profile.name.clone())
+                .unwrap_or_else(|| "Unknown".into())
+        });
+
+        v_flex()
+            .id("new-profile")
+            .track_focus(&self.focus_handle(cx))
+            .child(ProfileModalHeader::new(
+                match base_profile_name {
+                    Some(base_profile) => format!("Fork {base_profile}"),
+                    None => "New Profile".into(),
+                },
+                IconName::Plus,
+            ))
+            .child(ListSeparator)
+            .child(h_flex().p_2().child(mode.name_editor.clone()))
+    }
+
+    fn render_view_profile(
+        &mut self,
+        mode: ViewProfileMode,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let settings = AssistantSettings::get_global(cx);
+
+        let profile_name = settings
+            .profiles
+            .get(&mode.profile_id)
+            .map(|profile| profile.name.clone())
+            .unwrap_or_else(|| "Unknown".into());
+
+        Navigable::new(
+            div()
+                .track_focus(&self.focus_handle(cx))
+                .size_full()
+                .child(ProfileModalHeader::new(
+                    profile_name,
+                    IconName::ZedAssistant,
+                ))
+                .child(
+                    v_flex()
+                        .pb_1()
+                        .child(ListSeparator)
+                        .child(
+                            div()
+                                .id("fork-profile")
+                                .track_focus(&mode.fork_profile.focus_handle)
+                                .on_action({
+                                    let profile_id = mode.profile_id.clone();
+                                    cx.listener(move |this, _: &menu::Confirm, window, cx| {
+                                        this.new_profile(Some(profile_id.clone()), window, cx);
+                                    })
+                                })
+                                .child(
+                                    ListItem::new("fork-profile")
+                                        .toggle_state(
+                                            mode.fork_profile
+                                                .focus_handle
+                                                .contains_focused(window, cx),
+                                        )
+                                        .inset(true)
+                                        .spacing(ListItemSpacing::Sparse)
+                                        .start_slot(Icon::new(IconName::GitBranch))
+                                        .child(Label::new("Fork Profile"))
+                                        .on_click({
+                                            let profile_id = mode.profile_id.clone();
+                                            cx.listener(move |this, _, window, cx| {
+                                                this.new_profile(
+                                                    Some(profile_id.clone()),
+                                                    window,
+                                                    cx,
+                                                );
+                                            })
+                                        }),
+                                ),
+                        )
+                        .child(
+                            div()
+                                .id("configure-tools")
+                                .track_focus(&mode.configure_tools.focus_handle)
+                                .on_action({
+                                    let profile_id = mode.profile_id.clone();
+                                    cx.listener(move |this, _: &menu::Confirm, window, cx| {
+                                        this.configure_tools(profile_id.clone(), window, cx);
+                                    })
+                                })
+                                .child(
+                                    ListItem::new("configure-tools")
+                                        .toggle_state(
+                                            mode.configure_tools
+                                                .focus_handle
+                                                .contains_focused(window, cx),
+                                        )
+                                        .inset(true)
+                                        .spacing(ListItemSpacing::Sparse)
+                                        .start_slot(Icon::new(IconName::Cog))
+                                        .child(Label::new("Configure Tools"))
+                                        .on_click({
+                                            let profile_id = mode.profile_id.clone();
+                                            cx.listener(move |this, _, window, cx| {
+                                                this.configure_tools(
+                                                    profile_id.clone(),
+                                                    window,
+                                                    cx,
+                                                );
+                                            })
+                                        }),
+                                ),
+                        ),
+                )
+                .into_any_element(),
+        )
+        .entry(mode.fork_profile)
+        .entry(mode.configure_tools)
+    }
+}
+
+impl Render for ManageProfilesModal {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let settings = AssistantSettings::get_global(cx);
+
+        div()
+            .elevation_3(cx)
+            .w(rems(34.))
+            .key_context("ManageProfilesModal")
+            .on_action(cx.listener(|this, _: &menu::Cancel, window, cx| this.cancel(window, cx)))
+            .on_action(cx.listener(|this, _: &menu::Confirm, window, cx| this.confirm(window, cx)))
+            .capture_any_mouse_down(cx.listener(|this, _, window, cx| {
+                this.focus_handle(cx).focus(window);
+            }))
+            .on_mouse_down_out(cx.listener(|_this, _, _, cx| cx.emit(DismissEvent)))
+            .child(match &self.mode {
+                Mode::ChooseProfile(mode) => self
+                    .render_choose_profile(mode.clone(), window, cx)
+                    .into_any_element(),
+                Mode::NewProfile(mode) => self
+                    .render_new_profile(mode.clone(), window, cx)
+                    .into_any_element(),
+                Mode::ViewProfile(mode) => self
+                    .render_view_profile(mode.clone(), window, cx)
+                    .into_any_element(),
+                Mode::ConfigureTools {
+                    profile_id,
+                    tool_picker,
+                    ..
+                } => {
+                    let profile_name = settings
+                        .profiles
+                        .get(profile_id)
+                        .map(|profile| profile.name.clone())
+                        .unwrap_or_else(|| "Unknown".into());
+
+                    div()
+                        .child(ProfileModalHeader::new(
+                            format!("{profile_name}: Configure Tools"),
+                            IconName::Cog,
+                        ))
+                        .child(ListSeparator)
+                        .child(tool_picker.clone())
+                        .into_any_element()
+                }
+            })
+    }
+}

crates/agent/src/assistant_configuration/manage_profiles_modal/profile_modal_header.rs

@@ -0,0 +1,38 @@
+use ui::prelude::*;
+
+#[derive(IntoElement)]
+pub struct ProfileModalHeader {
+    label: SharedString,
+    icon: IconName,
+}
+
+impl ProfileModalHeader {
+    pub fn new(label: impl Into<SharedString>, icon: IconName) -> Self {
+        Self {
+            label: label.into(),
+            icon,
+        }
+    }
+}
+
+impl RenderOnce for ProfileModalHeader {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        h_flex()
+            .w_full()
+            .px(DynamicSpacing::Base12.rems(cx))
+            .pt(DynamicSpacing::Base08.rems(cx))
+            .pb(DynamicSpacing::Base04.rems(cx))
+            .rounded_t_sm()
+            .gap_1p5()
+            .child(Icon::new(self.icon).size(IconSize::XSmall))
+            .child(
+                h_flex().gap_1().overflow_x_hidden().child(
+                    div()
+                        .max_w_96()
+                        .overflow_x_hidden()
+                        .text_ellipsis()
+                        .child(Headline::new(self.label).size(HeadlineSize::XSmall)),
+                ),
+            )
+    }
+}

crates/agent/src/assistant_configuration/tool_picker.rs

@@ -0,0 +1,302 @@
+use std::sync::Arc;
+
+use assistant_settings::{
+    AgentProfile, AgentProfileContent, AssistantSettings, AssistantSettingsContent,
+    ContextServerPresetContent, VersionedAssistantSettingsContent,
+};
+use assistant_tool::{ToolSource, ToolWorkingSet};
+use fs::Fs;
+use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
+use gpui::{App, Context, DismissEvent, Entity, EventEmitter, Focusable, Task, WeakEntity, Window};
+use picker::{Picker, PickerDelegate};
+use settings::{Settings as _, update_settings_file};
+use ui::{HighlightedLabel, ListItem, ListItemSpacing, prelude::*};
+use util::ResultExt as _;
+
+use crate::ThreadStore;
+
+pub struct ToolPicker {
+    picker: Entity<Picker<ToolPickerDelegate>>,
+}
+
+impl ToolPicker {
+    pub fn new(delegate: ToolPickerDelegate, window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx).modal(false));
+        Self { picker }
+    }
+}
+
+impl EventEmitter<DismissEvent> for ToolPicker {}
+
+impl Focusable for ToolPicker {
+    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for ToolPicker {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex().w(rems(34.)).child(self.picker.clone())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ToolEntry {
+    pub name: Arc<str>,
+    pub source: ToolSource,
+}
+
+pub struct ToolPickerDelegate {
+    tool_picker: WeakEntity<ToolPicker>,
+    thread_store: WeakEntity<ThreadStore>,
+    fs: Arc<dyn Fs>,
+    tools: Vec<ToolEntry>,
+    profile_id: Arc<str>,
+    profile: AgentProfile,
+    matches: Vec<StringMatch>,
+    selected_index: usize,
+}
+
+impl ToolPickerDelegate {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        tool_set: Arc<ToolWorkingSet>,
+        thread_store: WeakEntity<ThreadStore>,
+        profile_id: Arc<str>,
+        profile: AgentProfile,
+        cx: &mut Context<ToolPicker>,
+    ) -> Self {
+        let mut tool_entries = Vec::new();
+
+        for (source, tools) in tool_set.tools_by_source(cx) {
+            tool_entries.extend(tools.into_iter().map(|tool| ToolEntry {
+                name: tool.name().into(),
+                source: source.clone(),
+            }));
+        }
+
+        Self {
+            tool_picker: cx.entity().downgrade(),
+            thread_store,
+            fs,
+            tools: tool_entries,
+            profile_id,
+            profile,
+            matches: Vec::new(),
+            selected_index: 0,
+        }
+    }
+}
+
+impl PickerDelegate for ToolPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Search tools…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        let background = cx.background_executor().clone();
+        let candidates = self
+            .tools
+            .iter()
+            .enumerate()
+            .map(|(id, profile)| StringMatchCandidate::new(id, profile.name.as_ref()))
+            .collect::<Vec<_>>();
+
+        cx.spawn_in(window, async move |this, cx| {
+            let matches = if query.is_empty() {
+                candidates
+                    .into_iter()
+                    .enumerate()
+                    .map(|(index, candidate)| StringMatch {
+                        candidate_id: index,
+                        string: candidate.string,
+                        positions: Vec::new(),
+                        score: 0.,
+                    })
+                    .collect()
+            } else {
+                match_strings(
+                    &candidates,
+                    &query,
+                    false,
+                    100,
+                    &Default::default(),
+                    background,
+                )
+                .await
+            };
+
+            this.update(cx, |this, _cx| {
+                this.delegate.matches = matches;
+                this.delegate.selected_index = this
+                    .delegate
+                    .selected_index
+                    .min(this.delegate.matches.len().saturating_sub(1));
+            })
+            .log_err();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        if self.matches.is_empty() {
+            self.dismissed(window, cx);
+            return;
+        }
+
+        let candidate_id = self.matches[self.selected_index].candidate_id;
+        let tool = &self.tools[candidate_id];
+
+        let is_enabled = match &tool.source {
+            ToolSource::Native => {
+                let is_enabled = self.profile.tools.entry(tool.name.clone()).or_default();
+                *is_enabled = !*is_enabled;
+                *is_enabled
+            }
+            ToolSource::ContextServer { id } => {
+                let preset = self
+                    .profile
+                    .context_servers
+                    .entry(id.clone().into())
+                    .or_default();
+                let is_enabled = preset.tools.entry(tool.name.clone()).or_default();
+                *is_enabled = !*is_enabled;
+                *is_enabled
+            }
+        };
+
+        let active_profile_id = &AssistantSettings::get_global(cx).default_profile;
+        if active_profile_id == &self.profile_id {
+            self.thread_store
+                .update(cx, |this, cx| {
+                    this.load_profile(&self.profile, cx);
+                })
+                .log_err();
+        }
+
+        update_settings_file::<AssistantSettings>(self.fs.clone(), cx, {
+            let profile_id = self.profile_id.clone();
+            let default_profile = self.profile.clone();
+            let tool = tool.clone();
+            move |settings, _cx| match settings {
+                AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(
+                    settings,
+                )) => {
+                    let profiles = settings.profiles.get_or_insert_default();
+                    let profile =
+                        profiles
+                            .entry(profile_id)
+                            .or_insert_with(|| AgentProfileContent {
+                                name: default_profile.name.into(),
+                                tools: default_profile.tools,
+                                enable_all_context_servers: Some(
+                                    default_profile.enable_all_context_servers,
+                                ),
+                                context_servers: default_profile
+                                    .context_servers
+                                    .into_iter()
+                                    .map(|(server_id, preset)| {
+                                        (
+                                            server_id,
+                                            ContextServerPresetContent {
+                                                tools: preset.tools,
+                                            },
+                                        )
+                                    })
+                                    .collect(),
+                            });
+
+                    match tool.source {
+                        ToolSource::Native => {
+                            *profile.tools.entry(tool.name).or_default() = is_enabled;
+                        }
+                        ToolSource::ContextServer { id } => {
+                            let preset = profile
+                                .context_servers
+                                .entry(id.clone().into())
+                                .or_default();
+                            *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
+                        }
+                    }
+                }
+                _ => {}
+            }
+        });
+    }
+
+    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.tool_picker
+            .update(cx, |_this, cx| cx.emit(DismissEvent))
+            .log_err();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let tool_match = &self.matches[ix];
+        let tool = &self.tools[tool_match.candidate_id];
+
+        let is_enabled = match &tool.source {
+            ToolSource::Native => self.profile.tools.get(&tool.name).copied().unwrap_or(false),
+            ToolSource::ContextServer { id } => self
+                .profile
+                .context_servers
+                .get(id.as_ref())
+                .and_then(|preset| preset.tools.get(&tool.name))
+                .copied()
+                .unwrap_or(false),
+        };
+
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .child(
+                    h_flex()
+                        .gap_2()
+                        .child(HighlightedLabel::new(
+                            tool_match.string.clone(),
+                            tool_match.positions.clone(),
+                        ))
+                        .map(|parent| match &tool.source {
+                            ToolSource::Native => parent,
+                            ToolSource::ContextServer { id } => parent
+                                .child(Label::new(id).size(LabelSize::XSmall).color(Color::Muted)),
+                        }),
+                )
+                .end_slot::<Icon>(is_enabled.then(|| {
+                    Icon::new(IconName::Check)
+                        .size(IconSize::Small)
+                        .color(Color::Success)
+                })),
+        )
+    }
+}

crates/agent/src/assistant_diff.rs

@@ -0,0 +1,743 @@
+use crate::{Thread, ThreadEvent};
+use anyhow::Result;
+use buffer_diff::DiffHunkStatus;
+use collections::HashSet;
+use editor::{
+    Direction, Editor, EditorEvent, MultiBuffer, ToPoint,
+    actions::{GoToHunk, GoToPreviousHunk},
+};
+use gpui::{
+    Action, AnyElement, AnyView, App, Entity, EventEmitter, FocusHandle, Focusable, SharedString,
+    Subscription, Task, WeakEntity, Window, prelude::*,
+};
+use language::{Capability, DiskState, OffsetRangeExt, Point};
+use multi_buffer::PathKey;
+use project::{Project, ProjectPath};
+use std::{
+    any::{Any, TypeId},
+    ops::Range,
+    sync::Arc,
+};
+use ui::{IconButtonShape, KeyBinding, Tooltip, prelude::*};
+use workspace::{
+    Item, ItemHandle, ItemNavHistory, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView,
+    Workspace,
+    item::{BreadcrumbText, ItemEvent, TabContentParams},
+    searchable::SearchableItemHandle,
+};
+
+pub struct AssistantDiff {
+    multibuffer: Entity<MultiBuffer>,
+    editor: Entity<Editor>,
+    thread: Entity<Thread>,
+    focus_handle: FocusHandle,
+    workspace: WeakEntity<Workspace>,
+    title: SharedString,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl AssistantDiff {
+    pub fn deploy(
+        thread: Entity<Thread>,
+        workspace: WeakEntity<Workspace>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Result<()> {
+        let existing_diff = workspace.update(cx, |workspace, cx| {
+            workspace
+                .items_of_type::<AssistantDiff>(cx)
+                .find(|diff| diff.read(cx).thread == thread)
+        })?;
+        if let Some(existing_diff) = existing_diff {
+            workspace.update(cx, |workspace, cx| {
+                workspace.activate_item(&existing_diff, true, true, window, cx);
+            })
+        } else {
+            let assistant_diff =
+                cx.new(|cx| AssistantDiff::new(thread.clone(), workspace.clone(), window, cx));
+            workspace.update(cx, |workspace, cx| {
+                workspace.add_item_to_center(Box::new(assistant_diff), window, cx);
+            })
+        }
+    }
+
+    pub fn new(
+        thread: Entity<Thread>,
+        workspace: WeakEntity<Workspace>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let focus_handle = cx.focus_handle();
+        let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+
+        let project = thread.read(cx).project().clone();
+        let render_diff_hunk_controls = Arc::new({
+            let assistant_diff = cx.entity();
+            move |row,
+                  status: &DiffHunkStatus,
+                  hunk_range,
+                  is_created_file,
+                  line_height,
+                  editor: &Entity<Editor>,
+                  window: &mut Window,
+                  cx: &mut App| {
+                render_diff_hunk_controls(
+                    row,
+                    status,
+                    hunk_range,
+                    is_created_file,
+                    line_height,
+                    &assistant_diff,
+                    editor,
+                    window,
+                    cx,
+                )
+            }
+        });
+        let editor = cx.new(|cx| {
+            let mut editor =
+                Editor::for_multibuffer(multibuffer.clone(), Some(project.clone()), window, cx);
+            editor.disable_inline_diagnostics();
+            editor.set_expand_all_diff_hunks(cx);
+            editor.set_render_diff_hunk_controls(render_diff_hunk_controls, cx);
+            editor.register_addon(AssistantDiffAddon);
+            editor
+        });
+
+        let action_log = thread.read(cx).action_log().clone();
+        let mut this = Self {
+            _subscriptions: vec![
+                cx.observe_in(&action_log, window, |this, _action_log, window, cx| {
+                    this.update_excerpts(window, cx)
+                }),
+                cx.subscribe(&thread, |this, _thread, event, cx| {
+                    this.handle_thread_event(event, cx)
+                }),
+            ],
+            title: SharedString::default(),
+            multibuffer,
+            editor,
+            thread,
+            focus_handle,
+            workspace,
+        };
+        this.update_excerpts(window, cx);
+        this.update_title(cx);
+        this
+    }
+
+    fn update_excerpts(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let thread = self.thread.read(cx);
+        let changed_buffers = thread.action_log().read(cx).changed_buffers(cx);
+        let mut paths_to_delete = self.multibuffer.read(cx).paths().collect::<HashSet<_>>();
+
+        for (buffer, diff_handle) in changed_buffers {
+            let Some(file) = buffer.read(cx).file().cloned() else {
+                continue;
+            };
+
+            let path_key = PathKey::namespaced(0, file.full_path(cx).into());
+            paths_to_delete.remove(&path_key);
+
+            let snapshot = buffer.read(cx).snapshot();
+            let diff = diff_handle.read(cx);
+            let diff_hunk_ranges = diff
+                .hunks_intersecting_range(
+                    language::Anchor::MIN..language::Anchor::MAX,
+                    &snapshot,
+                    cx,
+                )
+                .map(|diff_hunk| diff_hunk.buffer_range.to_point(&snapshot))
+                .collect::<Vec<_>>();
+
+            let (was_empty, is_excerpt_newly_added) =
+                self.multibuffer.update(cx, |multibuffer, cx| {
+                    let was_empty = multibuffer.is_empty();
+                    let (_, is_excerpt_newly_added) = multibuffer.set_excerpts_for_path(
+                        path_key.clone(),
+                        buffer.clone(),
+                        diff_hunk_ranges,
+                        editor::DEFAULT_MULTIBUFFER_CONTEXT,
+                        cx,
+                    );
+                    multibuffer.add_diff(diff_handle, cx);
+                    (was_empty, is_excerpt_newly_added)
+                });
+
+            self.editor.update(cx, |editor, cx| {
+                if was_empty {
+                    editor.change_selections(None, window, cx, |selections| {
+                        selections.select_ranges([0..0])
+                    });
+                }
+
+                if is_excerpt_newly_added
+                    && buffer
+                        .read(cx)
+                        .file()
+                        .map_or(false, |file| file.disk_state() == DiskState::Deleted)
+                {
+                    editor.fold_buffer(snapshot.text.remote_id(), cx)
+                }
+            });
+        }
+
+        self.multibuffer.update(cx, |multibuffer, cx| {
+            for path in paths_to_delete {
+                multibuffer.remove_excerpts_for_path(path, cx);
+            }
+        });
+
+        if self.multibuffer.read(cx).is_empty()
+            && self
+                .editor
+                .read(cx)
+                .focus_handle(cx)
+                .contains_focused(window, cx)
+        {
+            self.focus_handle.focus(window);
+        } else if self.focus_handle.is_focused(window) && !self.multibuffer.read(cx).is_empty() {
+            self.editor.update(cx, |editor, cx| {
+                editor.focus_handle(cx).focus(window);
+            });
+        }
+    }
+
+    fn update_title(&mut self, cx: &mut Context<Self>) {
+        let new_title = self
+            .thread
+            .read(cx)
+            .summary()
+            .unwrap_or("Assistant Changes".into());
+        if new_title != self.title {
+            self.title = new_title;
+            cx.emit(EditorEvent::TitleChanged);
+        }
+    }
+
+    fn handle_thread_event(&mut self, event: &ThreadEvent, cx: &mut Context<Self>) {
+        match event {
+            ThreadEvent::SummaryChanged => self.update_title(cx),
+            _ => {}
+        }
+    }
+
+    fn keep(&mut self, _: &crate::Keep, _window: &mut Window, cx: &mut Context<Self>) {
+        let ranges = self
+            .editor
+            .read(cx)
+            .selections
+            .disjoint_anchor_ranges()
+            .collect::<Vec<_>>();
+
+        let snapshot = self.multibuffer.read(cx).snapshot(cx);
+        let diff_hunks_in_ranges = self
+            .editor
+            .read(cx)
+            .diff_hunks_in_ranges(&ranges, &snapshot)
+            .collect::<Vec<_>>();
+
+        for hunk in diff_hunks_in_ranges {
+            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
+            if let Some(buffer) = buffer {
+                self.thread.update(cx, |thread, cx| {
+                    thread.keep_edits_in_range(buffer, hunk.buffer_range, cx)
+                });
+            }
+        }
+    }
+
+    fn reject(&mut self, _: &crate::Reject, window: &mut Window, cx: &mut Context<Self>) {
+        let ranges = self
+            .editor
+            .update(cx, |editor, cx| editor.selections.ranges(cx));
+        self.editor.update(cx, |editor, cx| {
+            editor.restore_hunks_in_ranges(ranges, window, cx)
+        })
+    }
+
+    fn reject_all(&mut self, _: &crate::RejectAll, window: &mut Window, cx: &mut Context<Self>) {
+        self.editor.update(cx, |editor, cx| {
+            let max_point = editor.buffer().read(cx).read(cx).max_point();
+            editor.restore_hunks_in_ranges(vec![Point::zero()..max_point], window, cx)
+        })
+    }
+
+    fn keep_all(&mut self, _: &crate::KeepAll, _window: &mut Window, cx: &mut Context<Self>) {
+        self.thread
+            .update(cx, |thread, cx| thread.keep_all_edits(cx));
+    }
+
+    fn keep_edits_in_ranges(
+        &mut self,
+        hunk_ranges: Vec<Range<editor::Anchor>>,
+        cx: &mut Context<Self>,
+    ) {
+        let snapshot = self.multibuffer.read(cx).snapshot(cx);
+        let diff_hunks_in_ranges = self
+            .editor
+            .read(cx)
+            .diff_hunks_in_ranges(&hunk_ranges, &snapshot)
+            .collect::<Vec<_>>();
+
+        for hunk in diff_hunks_in_ranges {
+            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
+            if let Some(buffer) = buffer {
+                self.thread.update(cx, |thread, cx| {
+                    thread.keep_edits_in_range(buffer, hunk.buffer_range, cx)
+                });
+            }
+        }
+    }
+}
+
+impl EventEmitter<EditorEvent> for AssistantDiff {}
+
+impl Focusable for AssistantDiff {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        if self.multibuffer.read(cx).is_empty() {
+            self.focus_handle.clone()
+        } else {
+            self.editor.focus_handle(cx)
+        }
+    }
+}
+
+impl Item for AssistantDiff {
+    type Event = EditorEvent;
+
+    fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
+        Some(Icon::new(IconName::ZedAssistant).color(Color::Muted))
+    }
+
+    fn to_item_events(event: &EditorEvent, f: impl FnMut(ItemEvent)) {
+        Editor::to_item_events(event, f)
+    }
+
+    fn deactivated(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.editor
+            .update(cx, |editor, cx| editor.deactivated(window, cx));
+    }
+
+    fn navigate(
+        &mut self,
+        data: Box<dyn Any>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        self.editor
+            .update(cx, |editor, cx| editor.navigate(data, window, cx))
+    }
+
+    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
+        Some("Assistant Diff".into())
+    }
+
+    fn tab_content(&self, params: TabContentParams, _window: &Window, cx: &App) -> AnyElement {
+        let summary = self
+            .thread
+            .read(cx)
+            .summary()
+            .unwrap_or("Assistant Changes".into());
+        Label::new(format!("Review: {}", summary))
+            .color(if params.selected {
+                Color::Default
+            } else {
+                Color::Muted
+            })
+            .into_any_element()
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        Some("Assistant Diff Opened")
+    }
+
+    fn as_searchable(&self, _: &Entity<Self>) -> Option<Box<dyn SearchableItemHandle>> {
+        Some(Box::new(self.editor.clone()))
+    }
+
+    fn for_each_project_item(
+        &self,
+        cx: &App,
+        f: &mut dyn FnMut(gpui::EntityId, &dyn project::ProjectItem),
+    ) {
+        self.editor.for_each_project_item(cx, f)
+    }
+
+    fn is_singleton(&self, _: &App) -> bool {
+        false
+    }
+
+    fn set_nav_history(
+        &mut self,
+        nav_history: ItemNavHistory,
+        _: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor.update(cx, |editor, _| {
+            editor.set_nav_history(Some(nav_history));
+        });
+    }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<workspace::WorkspaceId>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<Entity<Self>>
+    where
+        Self: Sized,
+    {
+        Some(cx.new(|cx| Self::new(self.thread.clone(), self.workspace.clone(), window, cx)))
+    }
+
+    fn is_dirty(&self, cx: &App) -> bool {
+        self.multibuffer.read(cx).is_dirty(cx)
+    }
+
+    fn has_conflict(&self, cx: &App) -> bool {
+        self.multibuffer.read(cx).has_conflict(cx)
+    }
+
+    fn can_save(&self, _: &App) -> bool {
+        true
+    }
+
+    fn save(
+        &mut self,
+        format: bool,
+        project: Entity<Project>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.editor.save(format, project, window, cx)
+    }
+
+    fn save_as(
+        &mut self,
+        _: Entity<Project>,
+        _: ProjectPath,
+        _window: &mut Window,
+        _: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        unreachable!()
+    }
+
+    fn reload(
+        &mut self,
+        project: Entity<Project>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.editor.reload(project, window, cx)
+    }
+
+    fn act_as_type<'a>(
+        &'a self,
+        type_id: TypeId,
+        self_handle: &'a Entity<Self>,
+        _: &'a App,
+    ) -> Option<AnyView> {
+        if type_id == TypeId::of::<Self>() {
+            Some(self_handle.to_any())
+        } else if type_id == TypeId::of::<Editor>() {
+            Some(self.editor.to_any())
+        } else {
+            None
+        }
+    }
+
+    fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation {
+        ToolbarItemLocation::PrimaryLeft
+    }
+
+    fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option<Vec<BreadcrumbText>> {
+        self.editor.breadcrumbs(theme, cx)
+    }
+
+    fn added_to_workspace(
+        &mut self,
+        workspace: &mut Workspace,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor.update(cx, |editor, cx| {
+            editor.added_to_workspace(workspace, window, cx)
+        });
+    }
+}
+
+impl Render for AssistantDiff {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let is_empty = self.multibuffer.read(cx).is_empty();
+
+        div()
+            .track_focus(&self.focus_handle)
+            .key_context(if is_empty {
+                "EmptyPane"
+            } else {
+                "AssistantDiff"
+            })
+            .on_action(cx.listener(Self::keep))
+            .on_action(cx.listener(Self::reject))
+            .on_action(cx.listener(Self::reject_all))
+            .on_action(cx.listener(Self::keep_all))
+            .bg(cx.theme().colors().editor_background)
+            .flex()
+            .items_center()
+            .justify_center()
+            .size_full()
+            .when(is_empty, |el| el.child("No changes to review"))
+            .when(!is_empty, |el| el.child(self.editor.clone()))
+    }
+}
+
+fn render_diff_hunk_controls(
+    row: u32,
+    _status: &DiffHunkStatus,
+    hunk_range: Range<editor::Anchor>,
+    is_created_file: bool,
+    line_height: Pixels,
+    assistant_diff: &Entity<AssistantDiff>,
+    editor: &Entity<Editor>,
+    window: &mut Window,
+    cx: &mut App,
+) -> AnyElement {
+    let editor = editor.clone();
+    h_flex()
+        .h(line_height)
+        .mr_0p5()
+        .gap_1()
+        .px_0p5()
+        .pb_1()
+        .border_x_1()
+        .border_b_1()
+        .border_color(cx.theme().colors().border)
+        .rounded_b_md()
+        .bg(cx.theme().colors().editor_background)
+        .gap_1()
+        .occlude()
+        .shadow_md()
+        .children(vec![
+            Button::new("reject", "Reject")
+                .disabled(is_created_file)
+                .key_binding(
+                    KeyBinding::for_action_in(
+                        &crate::Reject,
+                        &editor.read(cx).focus_handle(cx),
+                        window,
+                        cx,
+                    )
+                    .map(|kb| kb.size(rems_from_px(12.))),
+                )
+                .on_click({
+                    let editor = editor.clone();
+                    move |_event, window, cx| {
+                        editor.update(cx, |editor, cx| {
+                            let snapshot = editor.snapshot(window, cx);
+                            let point = hunk_range.start.to_point(&snapshot.buffer_snapshot);
+                            editor.restore_hunks_in_ranges(vec![point..point], window, cx);
+                        });
+                    }
+                }),
+            Button::new(("keep", row as u64), "Keep")
+                .key_binding(
+                    KeyBinding::for_action_in(
+                        &crate::Keep,
+                        &editor.read(cx).focus_handle(cx),
+                        window,
+                        cx,
+                    )
+                    .map(|kb| kb.size(rems_from_px(12.))),
+                )
+                .on_click({
+                    let assistant_diff = assistant_diff.clone();
+                    move |_event, _window, cx| {
+                        assistant_diff.update(cx, |diff, cx| {
+                            diff.keep_edits_in_ranges(vec![hunk_range.start..hunk_range.start], cx);
+                        });
+                    }
+                }),
+        ])
+        .when(
+            !editor.read(cx).buffer().read(cx).all_diff_hunks_expanded(),
+            |el| {
+                el.child(
+                    IconButton::new(("next-hunk", row as u64), IconName::ArrowDown)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::Small)
+                        // .disabled(!has_multiple_hunks)
+                        .tooltip({
+                            let focus_handle = editor.focus_handle(cx);
+                            move |window, cx| {
+                                Tooltip::for_action_in(
+                                    "Next Hunk",
+                                    &GoToHunk,
+                                    &focus_handle,
+                                    window,
+                                    cx,
+                                )
+                            }
+                        })
+                        .on_click({
+                            let editor = editor.clone();
+                            move |_event, window, cx| {
+                                editor.update(cx, |editor, cx| {
+                                    let snapshot = editor.snapshot(window, cx);
+                                    let position =
+                                        hunk_range.end.to_point(&snapshot.buffer_snapshot);
+                                    editor.go_to_hunk_before_or_after_position(
+                                        &snapshot,
+                                        position,
+                                        Direction::Next,
+                                        window,
+                                        cx,
+                                    );
+                                    editor.expand_selected_diff_hunks(cx);
+                                });
+                            }
+                        }),
+                )
+                .child(
+                    IconButton::new(("prev-hunk", row as u64), IconName::ArrowUp)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::Small)
+                        // .disabled(!has_multiple_hunks)
+                        .tooltip({
+                            let focus_handle = editor.focus_handle(cx);
+                            move |window, cx| {
+                                Tooltip::for_action_in(
+                                    "Previous Hunk",
+                                    &GoToPreviousHunk,
+                                    &focus_handle,
+                                    window,
+                                    cx,
+                                )
+                            }
+                        })
+                        .on_click({
+                            let editor = editor.clone();
+                            move |_event, window, cx| {
+                                editor.update(cx, |editor, cx| {
+                                    let snapshot = editor.snapshot(window, cx);
+                                    let point =
+                                        hunk_range.start.to_point(&snapshot.buffer_snapshot);
+                                    editor.go_to_hunk_before_or_after_position(
+                                        &snapshot,
+                                        point,
+                                        Direction::Prev,
+                                        window,
+                                        cx,
+                                    );
+                                    editor.expand_selected_diff_hunks(cx);
+                                });
+                            }
+                        }),
+                )
+            },
+        )
+        .into_any_element()
+}
+
+struct AssistantDiffAddon;
+
+impl editor::Addon for AssistantDiffAddon {
+    fn to_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn extend_key_context(&self, key_context: &mut gpui::KeyContext, _: &App) {
+        key_context.add("assistant_diff");
+    }
+}
+
+pub struct AssistantDiffToolbar {
+    assistant_diff: Option<WeakEntity<AssistantDiff>>,
+    _workspace: WeakEntity<Workspace>,
+}
+
+impl AssistantDiffToolbar {
+    pub fn new(workspace: &Workspace, _: &mut Context<Self>) -> Self {
+        Self {
+            assistant_diff: None,
+            _workspace: workspace.weak_handle(),
+        }
+    }
+
+    fn assistant_diff(&self, _: &App) -> Option<Entity<AssistantDiff>> {
+        self.assistant_diff.as_ref()?.upgrade()
+    }
+
+    fn dispatch_action(&self, action: &dyn Action, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(assistant_diff) = self.assistant_diff(cx) {
+            assistant_diff.focus_handle(cx).focus(window);
+        }
+        let action = action.boxed_clone();
+        cx.defer(move |cx| {
+            cx.dispatch_action(action.as_ref());
+        })
+    }
+}
+
+impl EventEmitter<ToolbarItemEvent> for AssistantDiffToolbar {}
+
+impl ToolbarItemView for AssistantDiffToolbar {
+    fn set_active_pane_item(
+        &mut self,
+        active_pane_item: Option<&dyn ItemHandle>,
+        _: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> ToolbarItemLocation {
+        self.assistant_diff = active_pane_item
+            .and_then(|item| item.act_as::<AssistantDiff>(cx))
+            .map(|entity| entity.downgrade());
+        if self.assistant_diff.is_some() {
+            ToolbarItemLocation::PrimaryRight
+        } else {
+            ToolbarItemLocation::Hidden
+        }
+    }
+
+    fn pane_focus_update(
+        &mut self,
+        _pane_focused: bool,
+        _window: &mut Window,
+        _cx: &mut Context<Self>,
+    ) {
+    }
+}
+
+impl Render for AssistantDiffToolbar {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let assistant_diff = match self.assistant_diff(cx) {
+            Some(ad) => ad,
+            None => return div(),
+        };
+
+        let is_empty = assistant_diff.read(cx).multibuffer.read(cx).is_empty();
+
+        if is_empty {
+            return div();
+        }
+
+        h_group_xl()
+            .my_neg_1()
+            .items_center()
+            .p_1()
+            .flex_wrap()
+            .justify_between()
+            .child(
+                h_group_sm()
+                    .child(
+                        Button::new("reject-all", "Reject All").on_click(cx.listener(
+                            |this, _, window, cx| {
+                                this.dispatch_action(&crate::RejectAll, window, cx)
+                            },
+                        )),
+                    )
+                    .child(Button::new("keep-all", "Keep All").on_click(cx.listener(
+                        |this, _, window, cx| this.dispatch_action(&crate::KeepAll, window, cx),
+                    ))),
+            )
+    }
+}

crates/agent/src/assistant_model_selector.rs

@@ -0,0 +1,91 @@
+use assistant_settings::AssistantSettings;
+use fs::Fs;
+use gpui::{Entity, FocusHandle, SharedString};
+use language_model::LanguageModelRegistry;
+use language_model_selector::{
+    LanguageModelSelector, LanguageModelSelectorPopoverMenu, ToggleModelSelector,
+};
+use settings::update_settings_file;
+use std::sync::Arc;
+use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*};
+
+pub struct AssistantModelSelector {
+    selector: Entity<LanguageModelSelector>,
+    menu_handle: PopoverMenuHandle<LanguageModelSelector>,
+    focus_handle: FocusHandle,
+}
+
+impl AssistantModelSelector {
+    pub(crate) fn new(
+        fs: Arc<dyn Fs>,
+        menu_handle: PopoverMenuHandle<LanguageModelSelector>,
+        focus_handle: FocusHandle,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Self {
+        Self {
+            selector: cx.new(|cx| {
+                let fs = fs.clone();
+                LanguageModelSelector::new(
+                    move |model, cx| {
+                        update_settings_file::<AssistantSettings>(
+                            fs.clone(),
+                            cx,
+                            move |settings, _cx| settings.set_model(model.clone()),
+                        );
+                    },
+                    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 AssistantModelSelector {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let active_model = LanguageModelRegistry::read_global(cx).active_model();
+        let focus_handle = self.focus_handle.clone();
+        let model_name = match active_model {
+            Some(model) => model.name().0,
+            _ => SharedString::from("No model selected"),
+        };
+
+        LanguageModelSelectorPopoverMenu::new(
+            self.selector.clone(),
+            ButtonLike::new("active-model")
+                .style(ButtonStyle::Subtle)
+                .child(
+                    h_flex()
+                        .gap_0p5()
+                        .child(
+                            Label::new(model_name)
+                                .size(LabelSize::Small)
+                                .color(Color::Muted),
+                        )
+                        .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,
+        )
+        .with_handle(self.menu_handle.clone())
+    }
+}

crates/agent/src/context.rs

@@ -0,0 +1,221 @@
+use std::{ops::Range, sync::Arc};
+
+use gpui::{App, Entity, SharedString};
+use language::{Buffer, File};
+use language_model::{LanguageModelRequestMessage, MessageContent};
+use project::ProjectPath;
+use serde::{Deserialize, Serialize};
+use text::{Anchor, BufferId};
+use ui::IconName;
+use util::post_inc;
+
+use crate::thread::Thread;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
+pub struct ContextId(pub(crate) usize);
+
+impl ContextId {
+    pub fn post_inc(&mut self) -> Self {
+        Self(post_inc(&mut self.0))
+    }
+}
+pub enum ContextKind {
+    File,
+    Directory,
+    Symbol,
+    FetchedUrl,
+    Thread,
+}
+
+impl ContextKind {
+    pub fn icon(&self) -> IconName {
+        match self {
+            ContextKind::File => IconName::File,
+            ContextKind::Directory => IconName::Folder,
+            ContextKind::Symbol => IconName::Code,
+            ContextKind::FetchedUrl => IconName::Globe,
+            ContextKind::Thread => IconName::MessageBubbles,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum AssistantContext {
+    File(FileContext),
+    Directory(DirectoryContext),
+    Symbol(SymbolContext),
+    FetchedUrl(FetchedUrlContext),
+    Thread(ThreadContext),
+}
+
+impl AssistantContext {
+    pub fn id(&self) -> ContextId {
+        match self {
+            Self::File(file) => file.id,
+            Self::Directory(directory) => directory.id,
+            Self::Symbol(symbol) => symbol.id,
+            Self::FetchedUrl(url) => url.id,
+            Self::Thread(thread) => thread.id,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FileContext {
+    pub id: ContextId,
+    pub context_buffer: ContextBuffer,
+}
+
+#[derive(Debug, Clone)]
+pub struct DirectoryContext {
+    pub id: ContextId,
+    pub project_path: ProjectPath,
+    pub context_buffers: Vec<ContextBuffer>,
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolContext {
+    pub id: ContextId,
+    pub context_symbol: ContextSymbol,
+}
+
+#[derive(Debug, Clone)]
+pub struct FetchedUrlContext {
+    pub id: ContextId,
+    pub url: SharedString,
+    pub text: SharedString,
+}
+
+// TODO: Model<Thread> holds onto the thread even if the thread is deleted. Can either handle this
+// explicitly or have a WeakModel<Thread> and remove during snapshot.
+
+#[derive(Debug, Clone)]
+pub struct ThreadContext {
+    pub id: ContextId,
+    pub thread: Entity<Thread>,
+    pub text: SharedString,
+}
+
+impl ThreadContext {
+    pub fn summary(&self, cx: &App) -> SharedString {
+        self.thread
+            .read(cx)
+            .summary()
+            .unwrap_or("New thread".into())
+    }
+}
+
+// TODO: Model<Buffer> holds onto the buffer even if the file is deleted and closed. Should remove
+// the context from the message editor in this case.
+
+#[derive(Clone)]
+pub struct ContextBuffer {
+    pub id: BufferId,
+    pub buffer: Entity<Buffer>,
+    pub file: Arc<dyn File>,
+    pub version: clock::Global,
+    pub text: SharedString,
+}
+
+impl std::fmt::Debug for ContextBuffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ContextBuffer")
+            .field("id", &self.id)
+            .field("buffer", &self.buffer)
+            .field("version", &self.version)
+            .field("text", &self.text)
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ContextSymbol {
+    pub id: ContextSymbolId,
+    pub buffer: Entity<Buffer>,
+    pub buffer_version: clock::Global,
+    /// The range that the symbol encloses, e.g. for function symbol, this will
+    /// include not only the signature, but also the body
+    pub enclosing_range: Range<Anchor>,
+    pub text: SharedString,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ContextSymbolId {
+    pub path: ProjectPath,
+    pub name: SharedString,
+    pub range: Range<Anchor>,
+}
+
+pub fn attach_context_to_message<'a>(
+    message: &mut LanguageModelRequestMessage,
+    contexts: impl Iterator<Item = &'a AssistantContext>,
+    cx: &App,
+) {
+    let mut file_context = Vec::new();
+    let mut directory_context = Vec::new();
+    let mut symbol_context = Vec::new();
+    let mut fetch_context = Vec::new();
+    let mut thread_context = Vec::new();
+
+    for context in contexts {
+        match context {
+            AssistantContext::File(context) => file_context.push(context),
+            AssistantContext::Directory(context) => directory_context.push(context),
+            AssistantContext::Symbol(context) => symbol_context.push(context),
+            AssistantContext::FetchedUrl(context) => fetch_context.push(context),
+            AssistantContext::Thread(context) => thread_context.push(context),
+        }
+    }
+
+    let mut context_chunks = Vec::new();
+
+    if !file_context.is_empty() {
+        context_chunks.push("The following files are available:\n");
+        for context in file_context {
+            context_chunks.push(&context.context_buffer.text);
+        }
+    }
+
+    if !directory_context.is_empty() {
+        context_chunks.push("The following directories are available:\n");
+        for context in directory_context {
+            for context_buffer in &context.context_buffers {
+                context_chunks.push(&context_buffer.text);
+            }
+        }
+    }
+
+    if !symbol_context.is_empty() {
+        context_chunks.push("The following symbols are available:\n");
+        for context in symbol_context {
+            context_chunks.push(&context.context_symbol.text);
+        }
+    }
+
+    if !fetch_context.is_empty() {
+        context_chunks.push("The following fetched results are available:\n");
+        for context in &fetch_context {
+            context_chunks.push(&context.url);
+            context_chunks.push(&context.text);
+        }
+    }
+
+    // Need to own the SharedString for summary so that it can be referenced.
+    let mut thread_context_chunks = Vec::new();
+    if !thread_context.is_empty() {
+        context_chunks.push("The following previous conversation threads are available:\n");
+        for context in &thread_context {
+            thread_context_chunks.push(context.summary(cx));
+            thread_context_chunks.push(context.text.clone());
+        }
+    }
+    for chunk in &thread_context_chunks {
+        context_chunks.push(chunk);
+    }
+
+    if !context_chunks.is_empty() {
+        message
+            .content
+            .push(MessageContent::Text(context_chunks.join("\n")));
+    }
+}

crates/agent/src/context_picker.rs

@@ -0,0 +1,755 @@
+mod completion_provider;
+mod fetch_context_picker;
+mod file_context_picker;
+mod symbol_context_picker;
+mod thread_context_picker;
+
+use std::ops::Range;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use anyhow::{Result, anyhow};
+use editor::display_map::{Crease, FoldId};
+use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
+use file_context_picker::render_file_context_entry;
+use gpui::{
+    App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
+};
+use multi_buffer::MultiBufferRow;
+use project::{Entry, ProjectPath};
+use symbol_context_picker::SymbolContextPicker;
+use thread_context_picker::{ThreadContextEntry, render_thread_context_entry};
+use ui::{
+    ButtonLike, ContextMenu, ContextMenuEntry, ContextMenuItem, Disclosure, TintColor, prelude::*,
+};
+use workspace::{Workspace, notifications::NotifyResultExt};
+
+use crate::AssistantPanel;
+pub use crate::context_picker::completion_provider::ContextPickerCompletionProvider;
+use crate::context_picker::fetch_context_picker::FetchContextPicker;
+use crate::context_picker::file_context_picker::FileContextPicker;
+use crate::context_picker::thread_context_picker::ThreadContextPicker;
+use crate::context_store::ContextStore;
+use crate::thread::ThreadId;
+use crate::thread_store::ThreadStore;
+
+#[derive(Debug, Clone, Copy)]
+pub enum ConfirmBehavior {
+    KeepOpen,
+    Close,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ContextPickerMode {
+    File,
+    Symbol,
+    Fetch,
+    Thread,
+}
+
+impl TryFrom<&str> for ContextPickerMode {
+    type Error = String;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+            "file" => Ok(Self::File),
+            "symbol" => Ok(Self::Symbol),
+            "fetch" => Ok(Self::Fetch),
+            "thread" => Ok(Self::Thread),
+            _ => Err(format!("Invalid context picker mode: {}", value)),
+        }
+    }
+}
+
+impl ContextPickerMode {
+    pub fn mention_prefix(&self) -> &'static str {
+        match self {
+            Self::File => "file",
+            Self::Symbol => "symbol",
+            Self::Fetch => "fetch",
+            Self::Thread => "thread",
+        }
+    }
+
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::File => "Files & Directories",
+            Self::Symbol => "Symbols",
+            Self::Fetch => "Fetch",
+            Self::Thread => "Thread",
+        }
+    }
+
+    pub fn icon(&self) -> IconName {
+        match self {
+            Self::File => IconName::File,
+            Self::Symbol => IconName::Code,
+            Self::Fetch => IconName::Globe,
+            Self::Thread => IconName::MessageBubbles,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+enum ContextPickerState {
+    Default(Entity<ContextMenu>),
+    File(Entity<FileContextPicker>),
+    Symbol(Entity<SymbolContextPicker>),
+    Fetch(Entity<FetchContextPicker>),
+    Thread(Entity<ThreadContextPicker>),
+}
+
+pub(super) struct ContextPicker {
+    mode: ContextPickerState,
+    workspace: WeakEntity<Workspace>,
+    context_store: WeakEntity<ContextStore>,
+    thread_store: Option<WeakEntity<ThreadStore>>,
+    confirm_behavior: ConfirmBehavior,
+}
+
+impl ContextPicker {
+    pub fn new(
+        workspace: WeakEntity<Workspace>,
+        thread_store: Option<WeakEntity<ThreadStore>>,
+        context_store: WeakEntity<ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        ContextPicker {
+            mode: ContextPickerState::Default(ContextMenu::build(
+                window,
+                cx,
+                |menu, _window, _cx| menu,
+            )),
+            workspace,
+            context_store,
+            thread_store,
+            confirm_behavior,
+        }
+    }
+
+    pub fn init(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.mode = ContextPickerState::Default(self.build_menu(window, cx));
+        cx.notify();
+    }
+
+    fn build_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Entity<ContextMenu> {
+        let context_picker = cx.entity().clone();
+
+        let menu = ContextMenu::build(window, cx, move |menu, _window, cx| {
+            let recent = self.recent_entries(cx);
+            let has_recent = !recent.is_empty();
+            let recent_entries = recent
+                .into_iter()
+                .enumerate()
+                .map(|(ix, entry)| self.recent_menu_item(context_picker.clone(), ix, entry));
+
+            let modes = supported_context_picker_modes(&self.thread_store);
+
+            let menu = menu
+                .when(has_recent, |menu| {
+                    menu.custom_row(|_, _| {
+                        div()
+                            .mb_1()
+                            .child(
+                                Label::new("Recent")
+                                    .color(Color::Muted)
+                                    .size(LabelSize::Small),
+                            )
+                            .into_any_element()
+                    })
+                })
+                .extend(recent_entries)
+                .when(has_recent, |menu| menu.separator())
+                .extend(modes.into_iter().map(|mode| {
+                    let context_picker = context_picker.clone();
+
+                    ContextMenuEntry::new(mode.label())
+                        .icon(mode.icon())
+                        .icon_size(IconSize::XSmall)
+                        .icon_color(Color::Muted)
+                        .handler(move |window, cx| {
+                            context_picker.update(cx, |this, cx| this.select_mode(mode, window, cx))
+                        })
+                }));
+
+            match self.confirm_behavior {
+                ConfirmBehavior::KeepOpen => menu.keep_open_on_confirm(),
+                ConfirmBehavior::Close => menu,
+            }
+        });
+
+        cx.subscribe(&menu, move |_, _, _: &DismissEvent, cx| {
+            cx.emit(DismissEvent);
+        })
+        .detach();
+
+        menu
+    }
+
+    /// Whether threads are allowed as context.
+    pub fn allow_threads(&self) -> bool {
+        self.thread_store.is_some()
+    }
+
+    fn select_mode(
+        &mut self,
+        mode: ContextPickerMode,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let context_picker = cx.entity().downgrade();
+
+        match mode {
+            ContextPickerMode::File => {
+                self.mode = ContextPickerState::File(cx.new(|cx| {
+                    FileContextPicker::new(
+                        context_picker.clone(),
+                        self.workspace.clone(),
+                        self.context_store.clone(),
+                        self.confirm_behavior,
+                        window,
+                        cx,
+                    )
+                }));
+            }
+            ContextPickerMode::Symbol => {
+                self.mode = ContextPickerState::Symbol(cx.new(|cx| {
+                    SymbolContextPicker::new(
+                        context_picker.clone(),
+                        self.workspace.clone(),
+                        self.context_store.clone(),
+                        self.confirm_behavior,
+                        window,
+                        cx,
+                    )
+                }));
+            }
+            ContextPickerMode::Fetch => {
+                self.mode = ContextPickerState::Fetch(cx.new(|cx| {
+                    FetchContextPicker::new(
+                        context_picker.clone(),
+                        self.workspace.clone(),
+                        self.context_store.clone(),
+                        self.confirm_behavior,
+                        window,
+                        cx,
+                    )
+                }));
+            }
+            ContextPickerMode::Thread => {
+                if let Some(thread_store) = self.thread_store.as_ref() {
+                    self.mode = ContextPickerState::Thread(cx.new(|cx| {
+                        ThreadContextPicker::new(
+                            thread_store.clone(),
+                            context_picker.clone(),
+                            self.context_store.clone(),
+                            self.confirm_behavior,
+                            window,
+                            cx,
+                        )
+                    }));
+                }
+            }
+        }
+
+        cx.notify();
+        cx.focus_self(window);
+    }
+
+    fn recent_menu_item(
+        &self,
+        context_picker: Entity<ContextPicker>,
+        ix: usize,
+        entry: RecentEntry,
+    ) -> ContextMenuItem {
+        match entry {
+            RecentEntry::File {
+                project_path,
+                path_prefix,
+            } => {
+                let context_store = self.context_store.clone();
+                let path = project_path.path.clone();
+
+                ContextMenuItem::custom_entry(
+                    move |_window, cx| {
+                        render_file_context_entry(
+                            ElementId::NamedInteger("ctx-recent".into(), ix),
+                            &path,
+                            &path_prefix,
+                            false,
+                            context_store.clone(),
+                            cx,
+                        )
+                        .into_any()
+                    },
+                    move |window, cx| {
+                        context_picker.update(cx, |this, cx| {
+                            this.add_recent_file(project_path.clone(), window, cx);
+                        })
+                    },
+                )
+            }
+            RecentEntry::Thread(thread) => {
+                let context_store = self.context_store.clone();
+                let view_thread = thread.clone();
+
+                ContextMenuItem::custom_entry(
+                    move |_window, cx| {
+                        render_thread_context_entry(&view_thread, context_store.clone(), cx)
+                            .into_any()
+                    },
+                    move |_window, cx| {
+                        context_picker.update(cx, |this, cx| {
+                            this.add_recent_thread(thread.clone(), cx)
+                                .detach_and_log_err(cx);
+                        })
+                    },
+                )
+            }
+        }
+    }
+
+    fn add_recent_file(
+        &self,
+        project_path: ProjectPath,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(context_store) = self.context_store.upgrade() else {
+            return;
+        };
+
+        let task = context_store.update(cx, |context_store, cx| {
+            context_store.add_file_from_path(project_path.clone(), true, cx)
+        });
+
+        cx.spawn_in(window, async move |_, cx| task.await.notify_async_err(cx))
+            .detach();
+
+        cx.notify();
+    }
+
+    fn add_recent_thread(
+        &self,
+        thread: ThreadContextEntry,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let Some(context_store) = self.context_store.upgrade() else {
+            return Task::ready(Err(anyhow!("context store not available")));
+        };
+
+        let Some(thread_store) = self
+            .thread_store
+            .as_ref()
+            .and_then(|thread_store| thread_store.upgrade())
+        else {
+            return Task::ready(Err(anyhow!("thread store not available")));
+        };
+
+        let open_thread_task = thread_store.update(cx, |this, cx| this.open_thread(&thread.id, cx));
+        cx.spawn(async move |this, cx| {
+            let thread = open_thread_task.await?;
+            context_store.update(cx, |context_store, cx| {
+                context_store.add_thread(thread, true, cx);
+            })?;
+
+            this.update(cx, |_this, cx| cx.notify())
+        })
+    }
+
+    fn recent_entries(&self, cx: &mut App) -> Vec<RecentEntry> {
+        let Some(workspace) = self.workspace.upgrade().map(|w| w.read(cx)) else {
+            return vec![];
+        };
+
+        let Some(context_store) = self.context_store.upgrade().map(|cs| cs.read(cx)) else {
+            return vec![];
+        };
+
+        let mut recent = Vec::with_capacity(6);
+
+        let mut current_files = context_store.file_paths(cx);
+
+        if let Some(active_path) = active_singleton_buffer_path(&workspace, cx) {
+            current_files.insert(active_path);
+        }
+
+        let project = workspace.project().read(cx);
+
+        recent.extend(
+            workspace
+                .recent_navigation_history_iter(cx)
+                .filter(|(path, _)| !current_files.contains(&path.path.to_path_buf()))
+                .take(4)
+                .filter_map(|(project_path, _)| {
+                    project
+                        .worktree_for_id(project_path.worktree_id, cx)
+                        .map(|worktree| RecentEntry::File {
+                            project_path,
+                            path_prefix: worktree.read(cx).root_name().into(),
+                        })
+                }),
+        );
+
+        let mut current_threads = context_store.thread_ids();
+
+        if let Some(active_thread) = workspace
+            .panel::<AssistantPanel>(cx)
+            .map(|panel| panel.read(cx).active_thread(cx))
+        {
+            current_threads.insert(active_thread.read(cx).id().clone());
+        }
+
+        let Some(thread_store) = self
+            .thread_store
+            .as_ref()
+            .and_then(|thread_store| thread_store.upgrade())
+        else {
+            return recent;
+        };
+
+        thread_store.update(cx, |thread_store, _cx| {
+            recent.extend(
+                thread_store
+                    .threads()
+                    .into_iter()
+                    .filter(|thread| !current_threads.contains(&thread.id))
+                    .take(2)
+                    .map(|thread| {
+                        RecentEntry::Thread(ThreadContextEntry {
+                            id: thread.id,
+                            summary: thread.summary,
+                        })
+                    }),
+            )
+        });
+
+        recent
+    }
+}
+
+impl EventEmitter<DismissEvent> for ContextPicker {}
+
+impl Focusable for ContextPicker {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        match &self.mode {
+            ContextPickerState::Default(menu) => menu.focus_handle(cx),
+            ContextPickerState::File(file_picker) => file_picker.focus_handle(cx),
+            ContextPickerState::Symbol(symbol_picker) => symbol_picker.focus_handle(cx),
+            ContextPickerState::Fetch(fetch_picker) => fetch_picker.focus_handle(cx),
+            ContextPickerState::Thread(thread_picker) => thread_picker.focus_handle(cx),
+        }
+    }
+}
+
+impl Render for ContextPicker {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .w(px(400.))
+            .min_w(px(400.))
+            .map(|parent| match &self.mode {
+                ContextPickerState::Default(menu) => parent.child(menu.clone()),
+                ContextPickerState::File(file_picker) => parent.child(file_picker.clone()),
+                ContextPickerState::Symbol(symbol_picker) => parent.child(symbol_picker.clone()),
+                ContextPickerState::Fetch(fetch_picker) => parent.child(fetch_picker.clone()),
+                ContextPickerState::Thread(thread_picker) => parent.child(thread_picker.clone()),
+            })
+    }
+}
+enum RecentEntry {
+    File {
+        project_path: ProjectPath,
+        path_prefix: Arc<str>,
+    },
+    Thread(ThreadContextEntry),
+}
+
+fn supported_context_picker_modes(
+    thread_store: &Option<WeakEntity<ThreadStore>>,
+) -> Vec<ContextPickerMode> {
+    let mut modes = vec![
+        ContextPickerMode::File,
+        ContextPickerMode::Symbol,
+        ContextPickerMode::Fetch,
+    ];
+    if thread_store.is_some() {
+        modes.push(ContextPickerMode::Thread);
+    }
+    modes
+}
+
+fn active_singleton_buffer_path(workspace: &Workspace, cx: &App) -> Option<PathBuf> {
+    let active_item = workspace.active_item(cx)?;
+
+    let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
+    let buffer = editor.buffer().read(cx).as_singleton()?;
+
+    let path = buffer.read(cx).file()?.path().to_path_buf();
+    Some(path)
+}
+
+fn recent_context_picker_entries(
+    context_store: Entity<ContextStore>,
+    thread_store: Option<WeakEntity<ThreadStore>>,
+    workspace: Entity<Workspace>,
+    cx: &App,
+) -> Vec<RecentEntry> {
+    let mut recent = Vec::with_capacity(6);
+
+    let mut current_files = context_store.read(cx).file_paths(cx);
+
+    let workspace = workspace.read(cx);
+
+    if let Some(active_path) = active_singleton_buffer_path(workspace, cx) {
+        current_files.insert(active_path);
+    }
+
+    let project = workspace.project().read(cx);
+
+    recent.extend(
+        workspace
+            .recent_navigation_history_iter(cx)
+            .filter(|(path, _)| !current_files.contains(&path.path.to_path_buf()))
+            .take(4)
+            .filter_map(|(project_path, _)| {
+                project
+                    .worktree_for_id(project_path.worktree_id, cx)
+                    .map(|worktree| RecentEntry::File {
+                        project_path,
+                        path_prefix: worktree.read(cx).root_name().into(),
+                    })
+            }),
+    );
+
+    let mut current_threads = context_store.read(cx).thread_ids();
+
+    if let Some(active_thread) = workspace
+        .panel::<AssistantPanel>(cx)
+        .map(|panel| panel.read(cx).active_thread(cx))
+    {
+        current_threads.insert(active_thread.read(cx).id().clone());
+    }
+
+    if let Some(thread_store) = thread_store.and_then(|thread_store| thread_store.upgrade()) {
+        recent.extend(
+            thread_store
+                .read(cx)
+                .threads()
+                .into_iter()
+                .filter(|thread| !current_threads.contains(&thread.id))
+                .take(2)
+                .map(|thread| {
+                    RecentEntry::Thread(ThreadContextEntry {
+                        id: thread.id,
+                        summary: thread.summary,
+                    })
+                }),
+        );
+    }
+
+    recent
+}
+
+pub(crate) fn insert_crease_for_mention(
+    excerpt_id: ExcerptId,
+    crease_start: text::Anchor,
+    content_len: usize,
+    crease_label: SharedString,
+    crease_icon_path: SharedString,
+    editor_entity: Entity<Editor>,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    editor_entity.update(cx, |editor, cx| {
+        let snapshot = editor.buffer().read(cx).snapshot(cx);
+
+        let Some(start) = snapshot.anchor_in_excerpt(excerpt_id, crease_start) else {
+            return;
+        };
+
+        let start = start.bias_right(&snapshot);
+        let end = snapshot.anchor_before(start.to_offset(&snapshot) + content_len);
+
+        let placeholder = FoldPlaceholder {
+            render: render_fold_icon_button(
+                crease_icon_path,
+                crease_label,
+                editor_entity.downgrade(),
+            ),
+            ..Default::default()
+        };
+
+        let render_trailer =
+            move |_row, _unfold, _window: &mut Window, _cx: &mut App| Empty.into_any();
+
+        let crease = Crease::inline(
+            start..end,
+            placeholder.clone(),
+            fold_toggle("mention"),
+            render_trailer,
+        );
+
+        editor.insert_creases(vec![crease.clone()], cx);
+        editor.fold_creases(vec![crease], false, window, cx);
+    });
+}
+
+fn render_fold_icon_button(
+    icon_path: SharedString,
+    label: SharedString,
+    editor: WeakEntity<Editor>,
+) -> 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()
+                })
+            });
+
+            ButtonLike::new(fold_id)
+                .style(ButtonStyle::Filled)
+                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
+                .toggle_state(is_in_text_selection)
+                .child(
+                    h_flex()
+                        .gap_1()
+                        .child(
+                            Icon::from_path(icon_path.clone())
+                                .size(IconSize::Small)
+                                .color(Color::Muted),
+                        )
+                        .child(
+                            Label::new(label.clone())
+                                .size(LabelSize::Small)
+                                .single_line(),
+                        ),
+                )
+                .into_any_element()
+        }
+    })
+}
+
+fn fold_toggle(
+    name: &'static str,
+) -> impl Fn(
+    MultiBufferRow,
+    bool,
+    Arc<dyn Fn(bool, &mut Window, &mut App) + Send + Sync>,
+    &mut Window,
+    &mut App,
+) -> AnyElement {
+    move |row, is_folded, fold, _window, _cx| {
+        Disclosure::new((name, row.0 as u64), !is_folded)
+            .toggle_state(is_folded)
+            .on_click(move |_e, window, cx| fold(!is_folded, window, cx))
+            .into_any_element()
+    }
+}
+
+pub enum MentionLink {
+    File(ProjectPath, Entry),
+    Symbol(ProjectPath, String),
+    Thread(ThreadId),
+}
+
+impl MentionLink {
+    pub fn for_file(file_name: &str, full_path: &str) -> String {
+        format!("[@{}](file:{})", file_name, full_path)
+    }
+
+    pub fn for_symbol(symbol_name: &str, full_path: &str) -> String {
+        format!("[@{}](symbol:{}:{})", symbol_name, full_path, symbol_name)
+    }
+
+    pub fn for_fetch(url: &str) -> String {
+        format!("[@{}]({})", url, url)
+    }
+
+    pub fn for_thread(thread: &ThreadContextEntry) -> String {
+        format!("[@{}](thread:{})", thread.summary, thread.id)
+    }
+
+    pub fn try_parse(link: &str, workspace: &Entity<Workspace>, cx: &App) -> Option<Self> {
+        fn extract_project_path_from_link(
+            path: &str,
+            workspace: &Entity<Workspace>,
+            cx: &App,
+        ) -> Option<ProjectPath> {
+            let path = PathBuf::from(path);
+            let worktree_name = path.iter().next()?;
+            let path: PathBuf = path.iter().skip(1).collect();
+            let worktree_id = workspace
+                .read(cx)
+                .visible_worktrees(cx)
+                .find(|worktree| worktree.read(cx).root_name() == worktree_name)
+                .map(|worktree| worktree.read(cx).id())?;
+            Some(ProjectPath {
+                worktree_id,
+                path: path.into(),
+            })
+        }
+
+        let (prefix, link, target) = {
+            let mut parts = link.splitn(3, ':');
+            let prefix = parts.next();
+            let link = parts.next();
+            let target = parts.next();
+            (prefix, link, target)
+        };
+
+        match (prefix, link, target) {
+            (Some("file"), Some(path), _) => {
+                let project_path = extract_project_path_from_link(path, workspace, cx)?;
+                let entry = workspace
+                    .read(cx)
+                    .project()
+                    .read(cx)
+                    .entry_for_path(&project_path, cx)?;
+                Some(MentionLink::File(project_path, entry))
+            }
+            (Some("symbol"), Some(path), Some(symbol_name)) => {
+                let project_path = extract_project_path_from_link(path, workspace, cx)?;
+                Some(MentionLink::Symbol(project_path, symbol_name.to_string()))
+            }
+            (Some("thread"), Some(thread_id), _) => {
+                let thread_id = ThreadId::from(thread_id);
+                Some(MentionLink::Thread(thread_id))
+            }
+            _ => None,
+        }
+    }
+}

crates/agent/src/context_picker/fetch_context_picker.rs

@@ -0,0 +1,271 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use anyhow::{Context as _, Result, bail};
+use futures::AsyncReadExt as _;
+use gpui::{App, DismissEvent, Entity, FocusHandle, Focusable, Task, WeakEntity};
+use html_to_markdown::{TagHandler, convert_html_to_markdown, markdown};
+use http_client::{AsyncBody, HttpClientWithUrl};
+use picker::{Picker, PickerDelegate};
+use ui::{Context, ListItem, Window, prelude::*};
+use workspace::Workspace;
+
+use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_store::ContextStore;
+
+pub struct FetchContextPicker {
+    picker: Entity<Picker<FetchContextPickerDelegate>>,
+}
+
+impl FetchContextPicker {
+    pub fn new(
+        context_picker: WeakEntity<ContextPicker>,
+        workspace: WeakEntity<Workspace>,
+        context_store: WeakEntity<ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let delegate = FetchContextPickerDelegate::new(
+            context_picker,
+            workspace,
+            context_store,
+            confirm_behavior,
+        );
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
+
+        Self { picker }
+    }
+}
+
+impl Focusable for FetchContextPicker {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for FetchContextPicker {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        self.picker.clone()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+enum ContentType {
+    Html,
+    Plaintext,
+    Json,
+}
+
+pub struct FetchContextPickerDelegate {
+    context_picker: WeakEntity<ContextPicker>,
+    workspace: WeakEntity<Workspace>,
+    context_store: WeakEntity<ContextStore>,
+    confirm_behavior: ConfirmBehavior,
+    url: String,
+}
+
+impl FetchContextPickerDelegate {
+    pub fn new(
+        context_picker: WeakEntity<ContextPicker>,
+        workspace: WeakEntity<Workspace>,
+        context_store: WeakEntity<ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+    ) -> Self {
+        FetchContextPickerDelegate {
+            context_picker,
+            workspace,
+            context_store,
+            confirm_behavior,
+            url: String::new(),
+        }
+    }
+}
+
+pub(crate) async fn fetch_url_content(
+    http_client: Arc<HttpClientWithUrl>,
+    url: String,
+) -> Result<String> {
+    let url = if !url.starts_with("https://") && !url.starts_with("http://") {
+        format!("https://{url}")
+    } else {
+        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 = match content_type {
+        "text/html" => ContentType::Html,
+        "text/plain" => ContentType::Plaintext,
+        "application/json" => ContentType::Json,
+        _ => 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 PickerDelegate for FetchContextPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        if self.url.is_empty() { 0 } else { 1 }
+    }
+
+    fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> Option<SharedString> {
+        Some("Enter the URL that you would like to fetch".into())
+    }
+
+    fn selected_index(&self) -> usize {
+        0
+    }
+
+    fn set_selected_index(
+        &mut self,
+        _ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) {
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Enter a URL…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        self.url = query;
+
+        Task::ready(())
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return;
+        };
+
+        let http_client = workspace.read(cx).client().http_client().clone();
+        let url = self.url.clone();
+        let confirm_behavior = self.confirm_behavior;
+        cx.spawn_in(window, async move |this, cx| {
+            let text = cx
+                .background_spawn(fetch_url_content(http_client, url.clone()))
+                .await?;
+
+            this.update_in(cx, |this, window, cx| {
+                this.delegate
+                    .context_store
+                    .update(cx, |context_store, _cx| {
+                        context_store.add_fetched_url(url, text);
+                    })?;
+
+                match confirm_behavior {
+                    ConfirmBehavior::KeepOpen => {}
+                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
+                }
+
+                anyhow::Ok(())
+            })??;
+
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.context_picker
+            .update(cx, |_, cx| {
+                cx.emit(DismissEvent);
+            })
+            .ok();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _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).is_some()
+        });
+
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .toggle_state(selected)
+                .child(Label::new(self.url.clone()))
+                .when(added, |child| {
+                    child.disabled(true).end_slot(
+                        h_flex()
+                            .gap_1()
+                            .child(
+                                Icon::new(IconName::Check)
+                                    .size(IconSize::Small)
+                                    .color(Color::Success),
+                            )
+                            .child(Label::new("Added").size(LabelSize::Small)),
+                    )
+                }),
+        )
+    }
+}

crates/agent/src/context_picker/file_context_picker.rs

@@ -0,0 +1,384 @@
+use std::path::Path;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+
+use file_icons::FileIcons;
+use fuzzy::PathMatch;
+use gpui::{
+    App, AppContext, DismissEvent, Entity, FocusHandle, Focusable, Stateful, Task, WeakEntity,
+};
+use picker::{Picker, PickerDelegate};
+use project::{PathMatchCandidateSet, ProjectPath, WorktreeId};
+use ui::{ListItem, Tooltip, prelude::*};
+use util::ResultExt as _;
+use workspace::{Workspace, notifications::NotifyResultExt};
+
+use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_store::{ContextStore, FileInclusion};
+
+pub struct FileContextPicker {
+    picker: Entity<Picker<FileContextPickerDelegate>>,
+}
+
+impl FileContextPicker {
+    pub fn new(
+        context_picker: WeakEntity<ContextPicker>,
+        workspace: WeakEntity<Workspace>,
+        context_store: WeakEntity<ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let delegate = FileContextPickerDelegate::new(
+            context_picker,
+            workspace,
+            context_store,
+            confirm_behavior,
+        );
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
+
+        Self { picker }
+    }
+}
+
+impl Focusable for FileContextPicker {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for FileContextPicker {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        self.picker.clone()
+    }
+}
+
+pub struct FileContextPickerDelegate {
+    context_picker: WeakEntity<ContextPicker>,
+    workspace: WeakEntity<Workspace>,
+    context_store: WeakEntity<ContextStore>,
+    confirm_behavior: ConfirmBehavior,
+    matches: Vec<PathMatch>,
+    selected_index: usize,
+}
+
+impl FileContextPickerDelegate {
+    pub fn new(
+        context_picker: WeakEntity<ContextPicker>,
+        workspace: WeakEntity<Workspace>,
+        context_store: WeakEntity<ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+    ) -> Self {
+        Self {
+            context_picker,
+            workspace,
+            context_store,
+            confirm_behavior,
+            matches: Vec::new(),
+            selected_index: 0,
+        }
+    }
+}
+
+impl PickerDelegate for FileContextPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Search files & directories…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return Task::ready(());
+        };
+
+        let search_task = search_paths(query, Arc::<AtomicBool>::default(), &workspace, cx);
+
+        cx.spawn_in(window, async move |this, cx| {
+            // TODO: This should be probably be run in the background.
+            let paths = search_task.await;
+
+            this.update(cx, |this, _cx| {
+                this.delegate.matches = paths;
+            })
+            .log_err();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        let Some(mat) = self.matches.get(self.selected_index) else {
+            return;
+        };
+
+        let project_path = ProjectPath {
+            worktree_id: WorktreeId::from_usize(mat.worktree_id),
+            path: mat.path.clone(),
+        };
+
+        let is_directory = mat.is_dir;
+
+        let Some(task) = self
+            .context_store
+            .update(cx, |context_store, cx| {
+                if is_directory {
+                    context_store.add_directory(project_path, true, cx)
+                } else {
+                    context_store.add_file_from_path(project_path, true, cx)
+                }
+            })
+            .ok()
+        else {
+            return;
+        };
+
+        let confirm_behavior = self.confirm_behavior;
+        cx.spawn_in(window, async move |this, cx| {
+            match task.await.notify_async_err(cx) {
+                None => anyhow::Ok(()),
+                Some(()) => this.update_in(cx, |this, window, cx| match confirm_behavior {
+                    ConfirmBehavior::KeepOpen => {}
+                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
+                }),
+            }
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.context_picker
+            .update(cx, |_, cx| {
+                cx.emit(DismissEvent);
+            })
+            .ok();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let path_match = &self.matches[ix];
+
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .toggle_state(selected)
+                .child(render_file_context_entry(
+                    ElementId::NamedInteger("file-ctx-picker".into(), ix),
+                    &path_match.path,
+                    &path_match.path_prefix,
+                    path_match.is_dir,
+                    self.context_store.clone(),
+                    cx,
+                )),
+        )
+    }
+}
+
+pub(crate) fn search_paths(
+    query: String,
+    cancellation_flag: Arc<AtomicBool>,
+    workspace: &Entity<Workspace>,
+    cx: &App,
+) -> Task<Vec<PathMatch>> {
+    if query.is_empty() {
+        let workspace = workspace.read(cx);
+        let project = workspace.project().read(cx);
+        let recent_matches = workspace
+            .recent_navigation_history(Some(10), cx)
+            .into_iter()
+            .filter_map(|(project_path, _)| {
+                let worktree = project.worktree_for_id(project_path.worktree_id, cx)?;
+                Some(PathMatch {
+                    score: 0.,
+                    positions: Vec::new(),
+                    worktree_id: project_path.worktree_id.to_usize(),
+                    path: project_path.path,
+                    path_prefix: worktree.read(cx).root_name().into(),
+                    distance_to_relative_ancestor: 0,
+                    is_dir: false,
+                })
+            });
+
+        let file_matches = project.worktrees(cx).flat_map(|worktree| {
+            let worktree = worktree.read(cx);
+            let path_prefix: Arc<str> = worktree.root_name().into();
+            worktree.entries(false, 0).map(move |entry| PathMatch {
+                score: 0.,
+                positions: Vec::new(),
+                worktree_id: worktree.id().to_usize(),
+                path: entry.path.clone(),
+                path_prefix: path_prefix.clone(),
+                distance_to_relative_ancestor: 0,
+                is_dir: entry.is_dir(),
+            })
+        });
+
+        Task::ready(recent_matches.chain(file_matches).collect())
+    } else {
+        let worktrees = workspace.read(cx).visible_worktrees(cx).collect::<Vec<_>>();
+        let candidate_sets = worktrees
+            .into_iter()
+            .map(|worktree| {
+                let worktree = worktree.read(cx);
+
+                PathMatchCandidateSet {
+                    snapshot: worktree.snapshot(),
+                    include_ignored: worktree
+                        .root_entry()
+                        .map_or(false, |entry| entry.is_ignored),
+                    include_root_name: true,
+                    candidates: project::Candidates::Entries,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let executor = cx.background_executor().clone();
+        cx.foreground_executor().spawn(async move {
+            fuzzy::match_path_sets(
+                candidate_sets.as_slice(),
+                query.as_str(),
+                None,
+                false,
+                100,
+                &cancellation_flag,
+                executor,
+            )
+            .await
+        })
+    }
+}
+
+pub fn extract_file_name_and_directory(
+    path: &Path,
+    path_prefix: &str,
+) -> (SharedString, Option<SharedString>) {
+    if path == Path::new("") {
+        (
+            SharedString::from(
+                path_prefix
+                    .trim_end_matches(std::path::MAIN_SEPARATOR)
+                    .to_string(),
+            ),
+            None,
+        )
+    } else {
+        let file_name = path
+            .file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string()
+            .into();
+
+        let mut directory = path_prefix
+            .trim_end_matches(std::path::MAIN_SEPARATOR)
+            .to_string();
+        if !directory.ends_with('/') {
+            directory.push('/');
+        }
+        if let Some(parent) = path.parent().filter(|parent| parent != &Path::new("")) {
+            directory.push_str(&parent.to_string_lossy());
+            directory.push('/');
+        }
+
+        (file_name, Some(directory.into()))
+    }
+}
+
+pub fn render_file_context_entry(
+    id: ElementId,
+    path: &Path,
+    path_prefix: &Arc<str>,
+    is_directory: bool,
+    context_store: WeakEntity<ContextStore>,
+    cx: &App,
+) -> Stateful<Div> {
+    let (file_name, directory) = extract_file_name_and_directory(path, path_prefix);
+
+    let added = context_store.upgrade().and_then(|context_store| {
+        if is_directory {
+            context_store.read(cx).includes_directory(path)
+        } else {
+            context_store.read(cx).will_include_file_path(path, cx)
+        }
+    });
+
+    let file_icon = if is_directory {
+        FileIcons::get_folder_icon(false, cx)
+    } else {
+        FileIcons::get_icon(&path, cx)
+    }
+    .map(Icon::from_path)
+    .unwrap_or_else(|| Icon::new(IconName::File));
+
+    h_flex()
+        .id(id)
+        .gap_1p5()
+        .w_full()
+        .child(file_icon.size(IconSize::Small).color(Color::Muted))
+        .child(
+            h_flex()
+                .gap_1()
+                .child(Label::new(file_name))
+                .children(directory.map(|directory| {
+                    Label::new(directory)
+                        .size(LabelSize::Small)
+                        .color(Color::Muted)
+                })),
+        )
+        .when_some(added, |el, added| match added {
+            FileInclusion::Direct(_) => el.child(
+                h_flex()
+                    .w_full()
+                    .justify_end()
+                    .gap_0p5()
+                    .child(
+                        Icon::new(IconName::Check)
+                            .size(IconSize::Small)
+                            .color(Color::Success),
+                    )
+                    .child(Label::new("Added").size(LabelSize::Small)),
+            ),
+            FileInclusion::InDirectory(dir_name) => {
+                let dir_name = dir_name.to_string_lossy().into_owned();
+
+                el.child(
+                    h_flex()
+                        .w_full()
+                        .justify_end()
+                        .gap_0p5()
+                        .child(
+                            Icon::new(IconName::Check)
+                                .size(IconSize::Small)
+                                .color(Color::Success),
+                        )
+                        .child(Label::new("Included").size(LabelSize::Small)),
+                )
+                .tooltip(Tooltip::text(format!("in {dir_name}")))
+            }
+        })
+}

crates/agent/src/context_picker/symbol_context_picker.rs

@@ -0,0 +1,438 @@
+use std::cmp::Reverse;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+
+use anyhow::{Context as _, Result};
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::{
+    App, AppContext, DismissEvent, Entity, FocusHandle, Focusable, Stateful, Task, WeakEntity,
+};
+use ordered_float::OrderedFloat;
+use picker::{Picker, PickerDelegate};
+use project::{DocumentSymbol, Symbol};
+use text::OffsetRangeExt;
+use ui::{ListItem, prelude::*};
+use util::ResultExt as _;
+use workspace::Workspace;
+
+use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_store::ContextStore;
+
+pub struct SymbolContextPicker {
+    picker: Entity<Picker<SymbolContextPickerDelegate>>,
+}
+
+impl SymbolContextPicker {
+    pub fn new(
+        context_picker: WeakEntity<ContextPicker>,
+        workspace: WeakEntity<Workspace>,
+        context_store: WeakEntity<ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let delegate = SymbolContextPickerDelegate::new(
+            context_picker,
+            workspace,
+            context_store,
+            confirm_behavior,
+        );
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
+
+        Self { picker }
+    }
+}
+
+impl Focusable for SymbolContextPicker {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for SymbolContextPicker {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        self.picker.clone()
+    }
+}
+
+pub struct SymbolContextPickerDelegate {
+    context_picker: WeakEntity<ContextPicker>,
+    workspace: WeakEntity<Workspace>,
+    context_store: WeakEntity<ContextStore>,
+    confirm_behavior: ConfirmBehavior,
+    matches: Vec<SymbolEntry>,
+    selected_index: usize,
+}
+
+impl SymbolContextPickerDelegate {
+    pub fn new(
+        context_picker: WeakEntity<ContextPicker>,
+        workspace: WeakEntity<Workspace>,
+        context_store: WeakEntity<ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+    ) -> Self {
+        Self {
+            context_picker,
+            workspace,
+            context_store,
+            confirm_behavior,
+            matches: Vec::new(),
+            selected_index: 0,
+        }
+    }
+}
+
+impl PickerDelegate for SymbolContextPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Search symbols…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return Task::ready(());
+        };
+
+        let search_task = search_symbols(query, Arc::<AtomicBool>::default(), &workspace, cx);
+        let context_store = self.context_store.clone();
+        cx.spawn_in(window, async move |this, cx| {
+            let symbols = search_task
+                .await
+                .context("Failed to load symbols")
+                .log_err()
+                .unwrap_or_default();
+
+            let symbol_entries = context_store
+                .read_with(cx, |context_store, cx| {
+                    compute_symbol_entries(symbols, context_store, cx)
+                })
+                .log_err()
+                .unwrap_or_default();
+
+            this.update(cx, |this, _cx| {
+                this.delegate.matches = symbol_entries;
+            })
+            .log_err();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        let Some(mat) = self.matches.get(self.selected_index) else {
+            return;
+        };
+        let Some(workspace) = self.workspace.upgrade() else {
+            return;
+        };
+
+        let confirm_behavior = self.confirm_behavior;
+        let add_symbol_task = add_symbol(
+            mat.symbol.clone(),
+            true,
+            workspace,
+            self.context_store.clone(),
+            cx,
+        );
+
+        let selected_index = self.selected_index;
+        cx.spawn_in(window, async move |this, cx| {
+            let included = add_symbol_task.await?;
+            this.update_in(cx, |this, window, cx| {
+                if let Some(mat) = this.delegate.matches.get_mut(selected_index) {
+                    mat.is_included = included;
+                }
+                match confirm_behavior {
+                    ConfirmBehavior::KeepOpen => {}
+                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
+                }
+            })
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.context_picker
+            .update(cx, |_, cx| {
+                cx.emit(DismissEvent);
+            })
+            .ok();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _window: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let mat = &self.matches[ix];
+
+        Some(ListItem::new(ix).inset(true).toggle_state(selected).child(
+            render_symbol_context_entry(
+                ElementId::NamedInteger("symbol-ctx-picker".into(), ix),
+                mat,
+            ),
+        ))
+    }
+}
+
+pub(crate) struct SymbolEntry {
+    pub symbol: Symbol,
+    pub is_included: bool,
+}
+
+pub(crate) fn add_symbol(
+    symbol: Symbol,
+    remove_if_exists: bool,
+    workspace: Entity<Workspace>,
+    context_store: WeakEntity<ContextStore>,
+    cx: &mut App,
+) -> Task<Result<bool>> {
+    let project = workspace.read(cx).project().clone();
+    let open_buffer_task = project.update(cx, |project, cx| {
+        project.open_buffer(symbol.path.clone(), cx)
+    });
+    cx.spawn(async move |cx| {
+        let buffer = open_buffer_task.await?;
+        let document_symbols = project
+            .update(cx, |project, cx| project.document_symbols(&buffer, cx))?
+            .await?;
+
+        // Try to find a matching document symbol. Document symbols include
+        // not only the symbol itself (e.g. function name), but they also
+        // include the context that they contain (e.g. function body).
+        let (name, range, enclosing_range) = if let Some(DocumentSymbol {
+            name,
+            range,
+            selection_range,
+            ..
+        }) =
+            find_matching_symbol(&symbol, document_symbols.as_slice())
+        {
+            (name, selection_range, range)
+        } else {
+            // If we do not find a matching document symbol, fall back to
+            // just the symbol itself
+            (symbol.name, symbol.range.clone(), symbol.range)
+        };
+
+        let (range, enclosing_range) = buffer.read_with(cx, |buffer, _| {
+            (
+                buffer.anchor_after(range.start)..buffer.anchor_before(range.end),
+                buffer.anchor_after(enclosing_range.start)
+                    ..buffer.anchor_before(enclosing_range.end),
+            )
+        })?;
+
+        context_store
+            .update(cx, move |context_store, cx| {
+                context_store.add_symbol(
+                    buffer,
+                    name.into(),
+                    range,
+                    enclosing_range,
+                    remove_if_exists,
+                    cx,
+                )
+            })?
+            .await
+    })
+}
+
+fn find_matching_symbol(symbol: &Symbol, candidates: &[DocumentSymbol]) -> Option<DocumentSymbol> {
+    let mut candidates = candidates.iter();
+    let mut candidate = candidates.next()?;
+
+    loop {
+        if candidate.range.start > symbol.range.end {
+            return None;
+        }
+        if candidate.range.end < symbol.range.start {
+            candidate = candidates.next()?;
+            continue;
+        }
+        if candidate.selection_range == symbol.range {
+            return Some(candidate.clone());
+        }
+        if candidate.range.start <= symbol.range.start && symbol.range.end <= candidate.range.end {
+            candidates = candidate.children.iter();
+            candidate = candidates.next()?;
+            continue;
+        }
+        return None;
+    }
+}
+
+pub(crate) fn search_symbols(
+    query: String,
+    cancellation_flag: Arc<AtomicBool>,
+    workspace: &Entity<Workspace>,
+    cx: &mut App,
+) -> Task<Result<Vec<(StringMatch, Symbol)>>> {
+    let symbols_task = workspace.update(cx, |workspace, cx| {
+        workspace
+            .project()
+            .update(cx, |project, cx| project.symbols(&query, cx))
+    });
+    let project = workspace.read(cx).project().clone();
+    cx.spawn(async move |cx| {
+        let symbols = symbols_task.await?;
+        let (visible_match_candidates, external_match_candidates): (Vec<_>, Vec<_>) = project
+            .update(cx, |project, cx| {
+                symbols
+                    .iter()
+                    .enumerate()
+                    .map(|(id, symbol)| 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)
+                    })
+            })?;
+
+        const MAX_MATCHES: usize = 100;
+        let mut visible_matches = cx.background_executor().block(fuzzy::match_strings(
+            &visible_match_candidates,
+            &query,
+            false,
+            MAX_MATCHES,
+            &cancellation_flag,
+            cx.background_executor().clone(),
+        ));
+        let mut external_matches = cx.background_executor().block(fuzzy::match_strings(
+            &external_match_candidates,
+            &query,
+            false,
+            MAX_MATCHES - visible_matches.len().min(MAX_MATCHES),
+            &cancellation_flag,
+            cx.background_executor().clone(),
+        ));
+        let sort_key_for_match = |mat: &StringMatch| {
+            let symbol = &symbols[mat.candidate_id];
+            (Reverse(OrderedFloat(mat.score)), symbol.label.filter_text())
+        };
+
+        visible_matches.sort_unstable_by_key(sort_key_for_match);
+        external_matches.sort_unstable_by_key(sort_key_for_match);
+        let mut matches = visible_matches;
+        matches.append(&mut external_matches);
+
+        Ok(matches
+            .into_iter()
+            .map(|mut mat| {
+                let symbol = symbols[mat.candidate_id].clone();
+                let filter_start = symbol.label.filter_range.start;
+                for position in &mut mat.positions {
+                    *position += filter_start;
+                }
+                (mat, symbol)
+            })
+            .collect())
+    })
+}
+
+fn compute_symbol_entries(
+    symbols: Vec<(StringMatch, Symbol)>,
+    context_store: &ContextStore,
+    cx: &App,
+) -> Vec<SymbolEntry> {
+    let mut symbol_entries = Vec::with_capacity(symbols.len());
+    for (_, symbol) in symbols {
+        let symbols_for_path = context_store.included_symbols_by_path().get(&symbol.path);
+        let is_included = if let Some(symbols_for_path) = symbols_for_path {
+            let mut is_included = false;
+            for included_symbol_id in symbols_for_path {
+                if included_symbol_id.name.as_ref() == symbol.name.as_str() {
+                    if let Some(buffer) = context_store.buffer_for_symbol(included_symbol_id) {
+                        let snapshot = buffer.read(cx).snapshot();
+                        let included_symbol_range =
+                            included_symbol_id.range.to_point_utf16(&snapshot);
+
+                        if included_symbol_range.start == symbol.range.start.0
+                            && included_symbol_range.end == symbol.range.end.0
+                        {
+                            is_included = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            is_included
+        } else {
+            false
+        };
+
+        symbol_entries.push(SymbolEntry {
+            symbol,
+            is_included,
+        })
+    }
+    symbol_entries
+}
+
+pub fn render_symbol_context_entry(id: ElementId, entry: &SymbolEntry) -> Stateful<Div> {
+    let path = entry
+        .symbol
+        .path
+        .path
+        .file_name()
+        .map(|s| s.to_string_lossy())
+        .unwrap_or_default();
+    let symbol_location = format!("{} L{}", path, entry.symbol.range.start.0.row + 1);
+
+    h_flex()
+        .id(id)
+        .gap_1p5()
+        .w_full()
+        .child(
+            Icon::new(IconName::Code)
+                .size(IconSize::Small)
+                .color(Color::Muted),
+        )
+        .child(
+            h_flex()
+                .gap_1()
+                .child(Label::new(&entry.symbol.name))
+                .child(
+                    Label::new(symbol_location)
+                        .size(LabelSize::Small)
+                        .color(Color::Muted),
+                ),
+        )
+        .when(entry.is_included, |el| {
+            el.child(
+                h_flex()
+                    .w_full()
+                    .justify_end()
+                    .gap_0p5()
+                    .child(
+                        Icon::new(IconName::Check)
+                            .size(IconSize::Small)
+                            .color(Color::Success),
+                    )
+                    .child(Label::new("Added").size(LabelSize::Small)),
+            )
+        })
+}

crates/agent/src/context_picker/thread_context_picker.rs

@@ -0,0 +1,261 @@
+use std::sync::Arc;
+
+use fuzzy::StringMatchCandidate;
+use gpui::{App, DismissEvent, Entity, FocusHandle, Focusable, Task, WeakEntity};
+use picker::{Picker, PickerDelegate};
+use ui::{ListItem, prelude::*};
+
+use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_store::{self, ContextStore};
+use crate::thread::ThreadId;
+use crate::thread_store::ThreadStore;
+
+pub struct ThreadContextPicker {
+    picker: Entity<Picker<ThreadContextPickerDelegate>>,
+}
+
+impl ThreadContextPicker {
+    pub fn new(
+        thread_store: WeakEntity<ThreadStore>,
+        context_picker: WeakEntity<ContextPicker>,
+        context_store: WeakEntity<context_store::ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let delegate = ThreadContextPickerDelegate::new(
+            thread_store,
+            context_picker,
+            context_store,
+            confirm_behavior,
+        );
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
+
+        ThreadContextPicker { picker }
+    }
+}
+
+impl Focusable for ThreadContextPicker {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for ThreadContextPicker {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        self.picker.clone()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ThreadContextEntry {
+    pub id: ThreadId,
+    pub summary: SharedString,
+}
+
+pub struct ThreadContextPickerDelegate {
+    thread_store: WeakEntity<ThreadStore>,
+    context_picker: WeakEntity<ContextPicker>,
+    context_store: WeakEntity<context_store::ContextStore>,
+    confirm_behavior: ConfirmBehavior,
+    matches: Vec<ThreadContextEntry>,
+    selected_index: usize,
+}
+
+impl ThreadContextPickerDelegate {
+    pub fn new(
+        thread_store: WeakEntity<ThreadStore>,
+        context_picker: WeakEntity<ContextPicker>,
+        context_store: WeakEntity<context_store::ContextStore>,
+        confirm_behavior: ConfirmBehavior,
+    ) -> Self {
+        ThreadContextPickerDelegate {
+            thread_store,
+            context_picker,
+            context_store,
+            confirm_behavior,
+            matches: Vec::new(),
+            selected_index: 0,
+        }
+    }
+}
+
+impl PickerDelegate for ThreadContextPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Search threads…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        let Some(threads) = self.thread_store.upgrade() else {
+            return Task::ready(());
+        };
+
+        let search_task = search_threads(query, threads, cx);
+        cx.spawn_in(window, async move |this, cx| {
+            let matches = search_task.await;
+            this.update(cx, |this, cx| {
+                this.delegate.matches = matches;
+                this.delegate.selected_index = 0;
+                cx.notify();
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        let Some(entry) = self.matches.get(self.selected_index) else {
+            return;
+        };
+
+        let Some(thread_store) = self.thread_store.upgrade() else {
+            return;
+        };
+
+        let open_thread_task = thread_store.update(cx, |this, cx| this.open_thread(&entry.id, cx));
+
+        cx.spawn_in(window, async move |this, cx| {
+            let thread = open_thread_task.await?;
+            this.update_in(cx, |this, window, cx| {
+                this.delegate
+                    .context_store
+                    .update(cx, |context_store, cx| {
+                        context_store.add_thread(thread, true, cx)
+                    })
+                    .ok();
+
+                match this.delegate.confirm_behavior {
+                    ConfirmBehavior::KeepOpen => {}
+                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
+                }
+            })
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.context_picker
+            .update(cx, |_, cx| {
+                cx.emit(DismissEvent);
+            })
+            .ok();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let thread = &self.matches[ix];
+
+        Some(ListItem::new(ix).inset(true).toggle_state(selected).child(
+            render_thread_context_entry(thread, self.context_store.clone(), cx),
+        ))
+    }
+}
+
+pub fn render_thread_context_entry(
+    thread: &ThreadContextEntry,
+    context_store: WeakEntity<ContextStore>,
+    cx: &mut App,
+) -> Div {
+    let added = context_store.upgrade().map_or(false, |ctx_store| {
+        ctx_store.read(cx).includes_thread(&thread.id).is_some()
+    });
+
+    h_flex()
+        .gap_1p5()
+        .w_full()
+        .justify_between()
+        .child(
+            h_flex()
+                .gap_1p5()
+                .max_w_72()
+                .child(
+                    Icon::new(IconName::MessageBubbles)
+                        .size(IconSize::XSmall)
+                        .color(Color::Muted),
+                )
+                .child(Label::new(thread.summary.clone()).truncate()),
+        )
+        .when(added, |el| {
+            el.child(
+                h_flex()
+                    .gap_1()
+                    .child(
+                        Icon::new(IconName::Check)
+                            .size(IconSize::Small)
+                            .color(Color::Success),
+                    )
+                    .child(Label::new("Added").size(LabelSize::Small)),
+            )
+        })
+}
+
+pub(crate) fn search_threads(
+    query: String,
+    thread_store: Entity<ThreadStore>,
+    cx: &mut App,
+) -> Task<Vec<ThreadContextEntry>> {
+    let threads = thread_store.update(cx, |this, _cx| {
+        this.threads()
+            .into_iter()
+            .map(|thread| ThreadContextEntry {
+                id: thread.id,
+                summary: thread.summary,
+            })
+            .collect::<Vec<_>>()
+    });
+
+    let executor = cx.background_executor().clone();
+    cx.background_spawn(async move {
+        if query.is_empty() {
+            threads
+        } else {
+            let candidates = threads
+                .iter()
+                .enumerate()
+                .map(|(id, thread)| StringMatchCandidate::new(id, &thread.summary))
+                .collect::<Vec<_>>();
+            let matches = fuzzy::match_strings(
+                &candidates,
+                &query,
+                false,
+                100,
+                &Default::default(),
+                executor,
+            )
+            .await;
+
+            matches
+                .into_iter()
+                .map(|mat| threads[mat.candidate_id].clone())
+                .collect()
+        }
+    })
+}

crates/agent/src/context_store.rs

@@ -0,0 +1,971 @@
+use std::ops::Range;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::{Context as _, Result, anyhow};
+use collections::{BTreeMap, HashMap, HashSet};
+use futures::future::join_all;
+use futures::{self, Future, FutureExt, future};
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};
+use language::{Buffer, File};
+use project::{ProjectItem, ProjectPath, Worktree};
+use rope::Rope;
+use text::{Anchor, BufferId, OffsetRangeExt};
+use util::{ResultExt as _, maybe};
+use workspace::Workspace;
+
+use crate::ThreadStore;
+use crate::context::{
+    AssistantContext, ContextBuffer, ContextId, ContextSymbol, ContextSymbolId, DirectoryContext,
+    FetchedUrlContext, FileContext, SymbolContext, ThreadContext,
+};
+use crate::context_strip::SuggestedContext;
+use crate::thread::{Thread, ThreadId};
+
+pub struct ContextStore {
+    workspace: WeakEntity<Workspace>,
+    context: Vec<AssistantContext>,
+    thread_store: Option<WeakEntity<ThreadStore>>,
+    // TODO: If an EntityId is used for all context types (like BufferId), can remove ContextId.
+    next_context_id: ContextId,
+    files: BTreeMap<BufferId, ContextId>,
+    directories: HashMap<PathBuf, ContextId>,
+    symbols: HashMap<ContextSymbolId, ContextId>,
+    symbol_buffers: HashMap<ContextSymbolId, Entity<Buffer>>,
+    symbols_by_path: HashMap<ProjectPath, Vec<ContextSymbolId>>,
+    threads: HashMap<ThreadId, ContextId>,
+    thread_summary_tasks: Vec<Task<()>>,
+    fetched_urls: HashMap<String, ContextId>,
+}
+
+impl ContextStore {
+    pub fn new(
+        workspace: WeakEntity<Workspace>,
+        thread_store: Option<WeakEntity<ThreadStore>>,
+    ) -> Self {
+        Self {
+            workspace,
+            thread_store,
+            context: Vec::new(),
+            next_context_id: ContextId(0),
+            files: BTreeMap::default(),
+            directories: HashMap::default(),
+            symbols: HashMap::default(),
+            symbol_buffers: HashMap::default(),
+            symbols_by_path: HashMap::default(),
+            threads: HashMap::default(),
+            thread_summary_tasks: Vec::new(),
+            fetched_urls: HashMap::default(),
+        }
+    }
+
+    pub fn context(&self) -> &Vec<AssistantContext> {
+        &self.context
+    }
+
+    pub fn context_for_id(&self, id: ContextId) -> Option<&AssistantContext> {
+        self.context().iter().find(|context| context.id() == id)
+    }
+
+    pub fn clear(&mut self) {
+        self.context.clear();
+        self.files.clear();
+        self.directories.clear();
+        self.threads.clear();
+        self.fetched_urls.clear();
+    }
+
+    pub fn add_file_from_path(
+        &mut self,
+        project_path: ProjectPath,
+        remove_if_exists: bool,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let workspace = self.workspace.clone();
+
+        let Some(project) = workspace
+            .upgrade()
+            .map(|workspace| workspace.read(cx).project().clone())
+        else {
+            return Task::ready(Err(anyhow!("failed to read project")));
+        };
+
+        cx.spawn(async move |this, cx| {
+            let open_buffer_task = project.update(cx, |project, cx| {
+                project.open_buffer(project_path.clone(), cx)
+            })?;
+
+            let buffer_entity = open_buffer_task.await?;
+            let buffer_id = this.update(cx, |_, cx| buffer_entity.read(cx).remote_id())?;
+
+            let already_included = this.update(cx, |this, _cx| {
+                match this.will_include_buffer(buffer_id, &project_path.path) {
+                    Some(FileInclusion::Direct(context_id)) => {
+                        if remove_if_exists {
+                            this.remove_context(context_id);
+                        }
+                        true
+                    }
+                    Some(FileInclusion::InDirectory(_)) => true,
+                    None => false,
+                }
+            })?;
+
+            if already_included {
+                return anyhow::Ok(());
+            }
+
+            let (buffer_info, text_task) = this.update(cx, |_, cx| {
+                let buffer = buffer_entity.read(cx);
+                collect_buffer_info_and_text(
+                    project_path.path.clone(),
+                    buffer_entity,
+                    buffer,
+                    None,
+                    cx.to_async(),
+                )
+            })??;
+
+            let text = text_task.await;
+
+            this.update(cx, |this, _cx| {
+                this.insert_file(make_context_buffer(buffer_info, text));
+            })?;
+
+            anyhow::Ok(())
+        })
+    }
+
+    pub fn add_file_from_buffer(
+        &mut self,
+        buffer_entity: Entity<Buffer>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        cx.spawn(async move |this, cx| {
+            let (buffer_info, text_task) = this.update(cx, |_, cx| {
+                let buffer = buffer_entity.read(cx);
+                let Some(file) = buffer.file() else {
+                    return Err(anyhow!("Buffer has no path."));
+                };
+                collect_buffer_info_and_text(
+                    file.path().clone(),
+                    buffer_entity,
+                    buffer,
+                    None,
+                    cx.to_async(),
+                )
+            })??;
+
+            let text = text_task.await;
+
+            this.update(cx, |this, _cx| {
+                this.insert_file(make_context_buffer(buffer_info, text))
+            })?;
+
+            anyhow::Ok(())
+        })
+    }
+
+    fn insert_file(&mut self, context_buffer: ContextBuffer) {
+        let id = self.next_context_id.post_inc();
+        self.files.insert(context_buffer.id, id);
+        self.context.push(AssistantContext::File(FileContext {
+            id,
+            context_buffer: context_buffer,
+        }));
+    }
+
+    pub fn add_directory(
+        &mut self,
+        project_path: ProjectPath,
+        remove_if_exists: bool,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let workspace = self.workspace.clone();
+        let Some(project) = workspace
+            .upgrade()
+            .map(|workspace| workspace.read(cx).project().clone())
+        else {
+            return Task::ready(Err(anyhow!("failed to read project")));
+        };
+
+        let already_included = match self.includes_directory(&project_path.path) {
+            Some(FileInclusion::Direct(context_id)) => {
+                if remove_if_exists {
+                    self.remove_context(context_id);
+                }
+                true
+            }
+            Some(FileInclusion::InDirectory(_)) => true,
+            None => false,
+        };
+        if already_included {
+            return Task::ready(Ok(()));
+        }
+
+        let worktree_id = project_path.worktree_id;
+        cx.spawn(async move |this, cx| {
+            let worktree = project.update(cx, |project, cx| {
+                project
+                    .worktree_for_id(worktree_id, cx)
+                    .ok_or_else(|| anyhow!("no worktree found for {worktree_id:?}"))
+            })??;
+
+            let files = worktree.update(cx, |worktree, _cx| {
+                collect_files_in_path(worktree, &project_path.path)
+            })?;
+
+            let open_buffers_task = project.update(cx, |project, cx| {
+                let tasks = files.iter().map(|file_path| {
+                    project.open_buffer(
+                        ProjectPath {
+                            worktree_id,
+                            path: file_path.clone(),
+                        },
+                        cx,
+                    )
+                });
+                future::join_all(tasks)
+            })?;
+
+            let buffers = open_buffers_task.await;
+
+            let mut buffer_infos = Vec::new();
+            let mut text_tasks = Vec::new();
+            this.update(cx, |_, cx| {
+                for (path, buffer_entity) in files.into_iter().zip(buffers) {
+                    // Skip all binary files and other non-UTF8 files
+                    if let Ok(buffer_entity) = buffer_entity {
+                        let buffer = buffer_entity.read(cx);
+                        if let Some((buffer_info, text_task)) = collect_buffer_info_and_text(
+                            path,
+                            buffer_entity,
+                            buffer,
+                            None,
+                            cx.to_async(),
+                        )
+                        .log_err()
+                        {
+                            buffer_infos.push(buffer_info);
+                            text_tasks.push(text_task);
+                        }
+                    }
+                }
+                anyhow::Ok(())
+            })??;
+
+            let buffer_texts = future::join_all(text_tasks).await;
+            let context_buffers = buffer_infos
+                .into_iter()
+                .zip(buffer_texts)
+                .map(|(info, text)| make_context_buffer(info, text))
+                .collect::<Vec<_>>();
+
+            if context_buffers.is_empty() {
+                return Err(anyhow!(
+                    "No text files found in {}",
+                    &project_path.path.display()
+                ));
+            }
+
+            this.update(cx, |this, _| {
+                this.insert_directory(project_path, context_buffers);
+            })?;
+
+            anyhow::Ok(())
+        })
+    }
+
+    fn insert_directory(&mut self, project_path: ProjectPath, context_buffers: Vec<ContextBuffer>) {
+        let id = self.next_context_id.post_inc();
+        self.directories.insert(project_path.path.to_path_buf(), id);
+
+        self.context
+            .push(AssistantContext::Directory(DirectoryContext {
+                id,
+                project_path,
+                context_buffers,
+            }));
+    }
+
+    pub fn add_symbol(
+        &mut self,
+        buffer: Entity<Buffer>,
+        symbol_name: SharedString,
+        symbol_range: Range<Anchor>,
+        symbol_enclosing_range: Range<Anchor>,
+        remove_if_exists: bool,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<bool>> {
+        let buffer_ref = buffer.read(cx);
+        let Some(file) = buffer_ref.file() else {
+            return Task::ready(Err(anyhow!("Buffer has no path.")));
+        };
+
+        let Some(project_path) = buffer_ref.project_path(cx) else {
+            return Task::ready(Err(anyhow!("Buffer has no project path.")));
+        };
+
+        if let Some(symbols_for_path) = self.symbols_by_path.get(&project_path) {
+            let mut matching_symbol_id = None;
+            for symbol in symbols_for_path {
+                if &symbol.name == &symbol_name {
+                    let snapshot = buffer_ref.snapshot();
+                    if symbol.range.to_offset(&snapshot) == symbol_range.to_offset(&snapshot) {
+                        matching_symbol_id = self.symbols.get(symbol).cloned();
+                        break;
+                    }
+                }
+            }
+
+            if let Some(id) = matching_symbol_id {
+                if remove_if_exists {
+                    self.remove_context(id);
+                }
+                return Task::ready(Ok(false));
+            }
+        }
+
+        let (buffer_info, collect_content_task) = match collect_buffer_info_and_text(
+            file.path().clone(),
+            buffer,
+            buffer_ref,
+            Some(symbol_enclosing_range.clone()),
+            cx.to_async(),
+        ) {
+            Ok((buffer_info, collect_context_task)) => (buffer_info, collect_context_task),
+            Err(err) => return Task::ready(Err(err)),
+        };
+
+        cx.spawn(async move |this, cx| {
+            let content = collect_content_task.await;
+
+            this.update(cx, |this, _cx| {
+                this.insert_symbol(make_context_symbol(
+                    buffer_info,
+                    project_path,
+                    symbol_name,
+                    symbol_range,
+                    symbol_enclosing_range,
+                    content,
+                ))
+            })?;
+            anyhow::Ok(true)
+        })
+    }
+
+    fn insert_symbol(&mut self, context_symbol: ContextSymbol) {
+        let id = self.next_context_id.post_inc();
+        self.symbols.insert(context_symbol.id.clone(), id);
+        self.symbols_by_path
+            .entry(context_symbol.id.path.clone())
+            .or_insert_with(Vec::new)
+            .push(context_symbol.id.clone());
+        self.symbol_buffers
+            .insert(context_symbol.id.clone(), context_symbol.buffer.clone());
+        self.context.push(AssistantContext::Symbol(SymbolContext {
+            id,
+            context_symbol,
+        }));
+    }
+
+    pub fn add_thread(
+        &mut self,
+        thread: Entity<Thread>,
+        remove_if_exists: bool,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(context_id) = self.includes_thread(&thread.read(cx).id()) {
+            if remove_if_exists {
+                self.remove_context(context_id);
+            }
+        } else {
+            self.insert_thread(thread, cx);
+        }
+    }
+
+    pub fn wait_for_summaries(&mut self, cx: &App) -> Task<()> {
+        let tasks = std::mem::take(&mut self.thread_summary_tasks);
+
+        cx.spawn(async move |_cx| {
+            join_all(tasks).await;
+        })
+    }
+
+    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &mut App) {
+        if let Some(summary_task) =
+            thread.update(cx, |thread, cx| thread.generate_detailed_summary(cx))
+        {
+            let thread = thread.clone();
+            let thread_store = self.thread_store.clone();
+
+            self.thread_summary_tasks.push(cx.spawn(async move |cx| {
+                summary_task.await;
+
+                if let Some(thread_store) = thread_store {
+                    // Save thread so its summary can be reused later
+                    let save_task = thread_store
+                        .update(cx, |thread_store, cx| thread_store.save_thread(&thread, cx));
+
+                    if let Some(save_task) = save_task.ok() {
+                        save_task.await.log_err();
+                    }
+                }
+            }));
+        }
+
+        let id = self.next_context_id.post_inc();
+
+        let text = thread.read(cx).latest_detailed_summary_or_text();
+
+        self.threads.insert(thread.read(cx).id().clone(), id);
+        self.context
+            .push(AssistantContext::Thread(ThreadContext { id, thread, text }));
+    }
+
+    pub fn add_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
+        if self.includes_url(&url).is_none() {
+            self.insert_fetched_url(url, text);
+        }
+    }
+
+    fn insert_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
+        let id = self.next_context_id.post_inc();
+
+        self.fetched_urls.insert(url.clone(), id);
+        self.context
+            .push(AssistantContext::FetchedUrl(FetchedUrlContext {
+                id,
+                url: url.into(),
+                text: text.into(),
+            }));
+    }
+
+    pub fn accept_suggested_context(
+        &mut self,
+        suggested: &SuggestedContext,
+        cx: &mut Context<ContextStore>,
+    ) -> Task<Result<()>> {
+        match suggested {
+            SuggestedContext::File {
+                buffer,
+                icon_path: _,
+                name: _,
+            } => {
+                if let Some(buffer) = buffer.upgrade() {
+                    return self.add_file_from_buffer(buffer, cx);
+                };
+            }
+            SuggestedContext::Thread { thread, name: _ } => {
+                if let Some(thread) = thread.upgrade() {
+                    self.insert_thread(thread, cx);
+                };
+            }
+        }
+        Task::ready(Ok(()))
+    }
+
+    pub fn remove_context(&mut self, id: ContextId) {
+        let Some(ix) = self.context.iter().position(|context| context.id() == id) else {
+            return;
+        };
+
+        match self.context.remove(ix) {
+            AssistantContext::File(_) => {
+                self.files.retain(|_, context_id| *context_id != id);
+            }
+            AssistantContext::Directory(_) => {
+                self.directories.retain(|_, context_id| *context_id != id);
+            }
+            AssistantContext::Symbol(symbol) => {
+                if let Some(symbols_in_path) =
+                    self.symbols_by_path.get_mut(&symbol.context_symbol.id.path)
+                {
+                    symbols_in_path.retain(|s| {
+                        self.symbols
+                            .get(s)
+                            .map_or(false, |context_id| *context_id != id)
+                    });
+                }
+                self.symbol_buffers.remove(&symbol.context_symbol.id);
+                self.symbols.retain(|_, context_id| *context_id != id);
+            }
+            AssistantContext::FetchedUrl(_) => {
+                self.fetched_urls.retain(|_, context_id| *context_id != id);
+            }
+            AssistantContext::Thread(_) => {
+                self.threads.retain(|_, context_id| *context_id != id);
+            }
+        }
+    }
+
+    /// Returns whether the buffer is already included directly in the context, or if it will be
+    /// included in the context via a directory. Directory inclusion is based on paths rather than
+    /// buffer IDs as the directory will be re-scanned.
+    pub fn will_include_buffer(&self, buffer_id: BufferId, path: &Path) -> Option<FileInclusion> {
+        if let Some(context_id) = self.files.get(&buffer_id) {
+            return Some(FileInclusion::Direct(*context_id));
+        }
+
+        self.will_include_file_path_via_directory(path)
+    }
+
+    /// Returns whether this file path is already included directly in the context, or if it will be
+    /// included in the context via a directory.
+    pub fn will_include_file_path(&self, path: &Path, cx: &App) -> Option<FileInclusion> {
+        if !self.files.is_empty() {
+            let found_file_context = self.context.iter().find(|context| match &context {
+                AssistantContext::File(file_context) => {
+                    let buffer = file_context.context_buffer.buffer.read(cx);
+                    if let Some(file_path) = buffer_path_log_err(buffer, cx) {
+                        *file_path == *path
+                    } else {
+                        false
+                    }
+                }
+                _ => false,
+            });
+            if let Some(context) = found_file_context {
+                return Some(FileInclusion::Direct(context.id()));
+            }
+        }
+
+        self.will_include_file_path_via_directory(path)
+    }
+
+    fn will_include_file_path_via_directory(&self, path: &Path) -> Option<FileInclusion> {
+        if self.directories.is_empty() {
+            return None;
+        }
+
+        let mut buf = path.to_path_buf();
+
+        while buf.pop() {
+            if let Some(_) = self.directories.get(&buf) {
+                return Some(FileInclusion::InDirectory(buf));
+            }
+        }
+
+        None
+    }
+
+    pub fn includes_directory(&self, path: &Path) -> Option<FileInclusion> {
+        if let Some(context_id) = self.directories.get(path) {
+            return Some(FileInclusion::Direct(*context_id));
+        }
+
+        self.will_include_file_path_via_directory(path)
+    }
+
+    pub fn included_symbol(&self, symbol_id: &ContextSymbolId) -> Option<ContextId> {
+        self.symbols.get(symbol_id).copied()
+    }
+
+    pub fn included_symbols_by_path(&self) -> &HashMap<ProjectPath, Vec<ContextSymbolId>> {
+        &self.symbols_by_path
+    }
+
+    pub fn buffer_for_symbol(&self, symbol_id: &ContextSymbolId) -> Option<Entity<Buffer>> {
+        self.symbol_buffers.get(symbol_id).cloned()
+    }
+
+    pub fn includes_thread(&self, thread_id: &ThreadId) -> Option<ContextId> {
+        self.threads.get(thread_id).copied()
+    }
+
+    pub fn includes_url(&self, url: &str) -> Option<ContextId> {
+        self.fetched_urls.get(url).copied()
+    }
+
+    /// Replaces the context that matches the ID of the new context, if any match.
+    fn replace_context(&mut self, new_context: AssistantContext) {
+        let id = new_context.id();
+        for context in self.context.iter_mut() {
+            if context.id() == id {
+                *context = new_context;
+                break;
+            }
+        }
+    }
+
+    pub fn file_paths(&self, cx: &App) -> HashSet<PathBuf> {
+        self.context
+            .iter()
+            .filter_map(|context| match context {
+                AssistantContext::File(file) => {
+                    let buffer = file.context_buffer.buffer.read(cx);
+                    buffer_path_log_err(buffer, cx).map(|p| p.to_path_buf())
+                }
+                AssistantContext::Directory(_)
+                | AssistantContext::Symbol(_)
+                | AssistantContext::FetchedUrl(_)
+                | AssistantContext::Thread(_) => None,
+            })
+            .collect()
+    }
+
+    pub fn thread_ids(&self) -> HashSet<ThreadId> {
+        self.threads.keys().cloned().collect()
+    }
+}
+
+pub enum FileInclusion {
+    Direct(ContextId),
+    InDirectory(PathBuf),
+}
+
+// ContextBuffer without text.
+struct BufferInfo {
+    buffer_entity: Entity<Buffer>,
+    file: Arc<dyn File>,
+    id: BufferId,
+    version: clock::Global,
+}
+
+fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {
+    ContextBuffer {
+        id: info.id,
+        buffer: info.buffer_entity,
+        file: info.file,
+        version: info.version,
+        text,
+    }
+}
+
+fn make_context_symbol(
+    info: BufferInfo,
+    path: ProjectPath,
+    name: SharedString,
+    range: Range<Anchor>,
+    enclosing_range: Range<Anchor>,
+    text: SharedString,
+) -> ContextSymbol {
+    ContextSymbol {
+        id: ContextSymbolId { name, range, path },
+        buffer_version: info.version,
+        enclosing_range,
+        buffer: info.buffer_entity,
+        text,
+    }
+}
+
+fn collect_buffer_info_and_text(
+    path: Arc<Path>,
+    buffer_entity: Entity<Buffer>,
+    buffer: &Buffer,
+    range: Option<Range<Anchor>>,
+    cx: AsyncApp,
+) -> Result<(BufferInfo, Task<SharedString>)> {
+    let buffer_info = BufferInfo {
+        id: buffer.remote_id(),
+        buffer_entity,
+        file: buffer
+            .file()
+            .context("buffer context must have a file")?
+            .clone(),
+        version: buffer.version(),
+    };
+    // Important to collect version at the same time as content so that staleness logic is correct.
+    let content = if let Some(range) = range {
+        buffer.text_for_range(range).collect::<Rope>()
+    } else {
+        buffer.as_rope().clone()
+    };
+    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&path, content) });
+    Ok((buffer_info, text_task))
+}
+
+pub fn buffer_path_log_err(buffer: &Buffer, cx: &App) -> Option<Arc<Path>> {
+    if let Some(file) = buffer.file() {
+        let mut path = file.path().clone();
+        if path.as_os_str().is_empty() {
+            path = file.full_path(cx).into();
+        }
+        Some(path)
+    } else {
+        log::error!("Buffer that had a path unexpectedly no longer has a path.");
+        None
+    }
+}
+
+fn to_fenced_codeblock(path: &Path, content: Rope) -> SharedString {
+    let path_extension = path.extension().and_then(|ext| ext.to_str());
+    let path_string = path.to_string_lossy();
+    let capacity = 3
+        + path_extension.map_or(0, |extension| extension.len() + 1)
+        + path_string.len()
+        + 1
+        + content.len()
+        + 5;
+    let mut buffer = String::with_capacity(capacity);
+
+    buffer.push_str("```");
+
+    if let Some(extension) = path_extension {
+        buffer.push_str(extension);
+        buffer.push(' ');
+    }
+    buffer.push_str(&path_string);
+
+    buffer.push('\n');
+    for chunk in content.chunks() {
+        buffer.push_str(&chunk);
+    }
+
+    if !buffer.ends_with('\n') {
+        buffer.push('\n');
+    }
+
+    buffer.push_str("```\n");
+
+    debug_assert!(
+        buffer.len() == capacity - 1 || buffer.len() == capacity,
+        "to_fenced_codeblock calculated capacity of {}, but length was {}",
+        capacity,
+        buffer.len(),
+    );
+
+    buffer.into()
+}
+
+fn collect_files_in_path(worktree: &Worktree, path: &Path) -> Vec<Arc<Path>> {
+    let mut files = Vec::new();
+
+    for entry in worktree.child_entries(path) {
+        if entry.is_dir() {
+            files.extend(collect_files_in_path(worktree, &entry.path));
+        } else if entry.is_file() {
+            files.push(entry.path.clone());
+        }
+    }
+
+    files
+}
+
+pub fn refresh_context_store_text(
+    context_store: Entity<ContextStore>,
+    changed_buffers: &HashSet<Entity<Buffer>>,
+    cx: &App,
+) -> impl Future<Output = Vec<ContextId>> + use<> {
+    let mut tasks = Vec::new();
+
+    for context in &context_store.read(cx).context {
+        let id = context.id();
+
+        let task = maybe!({
+            match context {
+                AssistantContext::File(file_context) => {
+                    if changed_buffers.is_empty()
+                        || changed_buffers.contains(&file_context.context_buffer.buffer)
+                    {
+                        let context_store = context_store.clone();
+                        return refresh_file_text(context_store, file_context, cx);
+                    }
+                }
+                AssistantContext::Directory(directory_context) => {
+                    let should_refresh = changed_buffers.is_empty()
+                        || changed_buffers.iter().any(|buffer| {
+                            let buffer = buffer.read(cx);
+
+                            buffer_path_log_err(&buffer, cx).map_or(false, |path| {
+                                path.starts_with(&directory_context.project_path.path)
+                            })
+                        });
+
+                    if should_refresh {
+                        let context_store = context_store.clone();
+                        return refresh_directory_text(context_store, directory_context, cx);
+                    }
+                }
+                AssistantContext::Symbol(symbol_context) => {
+                    if changed_buffers.is_empty()
+                        || changed_buffers.contains(&symbol_context.context_symbol.buffer)
+                    {
+                        let context_store = context_store.clone();
+                        return refresh_symbol_text(context_store, symbol_context, cx);
+                    }
+                }
+                AssistantContext::Thread(thread_context) => {
+                    if changed_buffers.is_empty() {
+                        let context_store = context_store.clone();
+                        return Some(refresh_thread_text(context_store, thread_context, cx));
+                    }
+                }
+                // Intentionally omit refreshing fetched URLs as it doesn't seem all that useful,
+                // and doing the caching properly could be tricky (unless it's already handled by
+                // the HttpClient?).
+                AssistantContext::FetchedUrl(_) => {}
+            }
+
+            None
+        });
+
+        if let Some(task) = task {
+            tasks.push(task.map(move |_| id));
+        }
+    }
+
+    future::join_all(tasks)
+}
+
+fn refresh_file_text(
+    context_store: Entity<ContextStore>,
+    file_context: &FileContext,
+    cx: &App,
+) -> Option<Task<()>> {
+    let id = file_context.id;
+    let task = refresh_context_buffer(&file_context.context_buffer, cx);
+    if let Some(task) = task {
+        Some(cx.spawn(async move |cx| {
+            let context_buffer = task.await;
+            context_store
+                .update(cx, |context_store, _| {
+                    let new_file_context = FileContext { id, context_buffer };
+                    context_store.replace_context(AssistantContext::File(new_file_context));
+                })
+                .ok();
+        }))
+    } else {
+        None
+    }
+}
+
+fn refresh_directory_text(
+    context_store: Entity<ContextStore>,
+    directory_context: &DirectoryContext,
+    cx: &App,
+) -> Option<Task<()>> {
+    let mut stale = false;
+    let futures = directory_context
+        .context_buffers
+        .iter()
+        .map(|context_buffer| {
+            if let Some(refresh_task) = refresh_context_buffer(context_buffer, cx) {
+                stale = true;
+                future::Either::Left(refresh_task)
+            } else {
+                future::Either::Right(future::ready((*context_buffer).clone()))
+            }
+        })
+        .collect::<Vec<_>>();
+
+    if !stale {
+        return None;
+    }
+
+    let context_buffers = future::join_all(futures);
+
+    let id = directory_context.id;
+    let project_path = directory_context.project_path.clone();
+    Some(cx.spawn(async move |cx| {
+        let context_buffers = context_buffers.await;
+        context_store
+            .update(cx, |context_store, _| {
+                let new_directory_context = DirectoryContext {
+                    id,
+                    project_path,
+                    context_buffers,
+                };
+                context_store.replace_context(AssistantContext::Directory(new_directory_context));
+            })
+            .ok();
+    }))
+}
+
+fn refresh_symbol_text(
+    context_store: Entity<ContextStore>,
+    symbol_context: &SymbolContext,
+    cx: &App,
+) -> Option<Task<()>> {
+    let id = symbol_context.id;
+    let task = refresh_context_symbol(&symbol_context.context_symbol, cx);
+    if let Some(task) = task {
+        Some(cx.spawn(async move |cx| {
+            let context_symbol = task.await;
+            context_store
+                .update(cx, |context_store, _| {
+                    let new_symbol_context = SymbolContext { id, context_symbol };
+                    context_store.replace_context(AssistantContext::Symbol(new_symbol_context));
+                })
+                .ok();
+        }))
+    } else {
+        None
+    }
+}
+
+fn refresh_thread_text(
+    context_store: Entity<ContextStore>,
+    thread_context: &ThreadContext,
+    cx: &App,
+) -> Task<()> {
+    let id = thread_context.id;
+    let thread = thread_context.thread.clone();
+    cx.spawn(async move |cx| {
+        context_store
+            .update(cx, |context_store, cx| {
+                let text = thread.read(cx).latest_detailed_summary_or_text();
+                context_store.replace_context(AssistantContext::Thread(ThreadContext {
+                    id,
+                    thread,
+                    text,
+                }));
+            })
+            .ok();
+    })
+}
+
+fn refresh_context_buffer(
+    context_buffer: &ContextBuffer,
+    cx: &App,
+) -> Option<impl Future<Output = ContextBuffer> + use<>> {
+    let buffer = context_buffer.buffer.read(cx);
+    let path = buffer_path_log_err(buffer, cx)?;
+    if buffer.version.changed_since(&context_buffer.version) {
+        let (buffer_info, text_task) = collect_buffer_info_and_text(
+            path,
+            context_buffer.buffer.clone(),
+            buffer,
+            None,
+            cx.to_async(),
+        )
+        .log_err()?;
+        Some(text_task.map(move |text| make_context_buffer(buffer_info, text)))
+    } else {
+        None
+    }
+}
+
+fn refresh_context_symbol(
+    context_symbol: &ContextSymbol,
+    cx: &App,
+) -> Option<impl Future<Output = ContextSymbol> + use<>> {
+    let buffer = context_symbol.buffer.read(cx);
+    let path = buffer_path_log_err(buffer, cx)?;
+    let project_path = buffer.project_path(cx)?;
+    if buffer.version.changed_since(&context_symbol.buffer_version) {
+        let (buffer_info, text_task) = collect_buffer_info_and_text(
+            path,
+            context_symbol.buffer.clone(),
+            buffer,
+            Some(context_symbol.enclosing_range.clone()),
+            cx.to_async(),
+        )
+        .log_err()?;
+        let name = context_symbol.id.name.clone();
+        let range = context_symbol.id.range.clone();
+        let enclosing_range = context_symbol.enclosing_range.clone();
+        Some(text_task.map(move |text| {
+            make_context_symbol(
+                buffer_info,
+                project_path,
+                name,
+                range,
+                enclosing_range,
+                text,
+            )
+        }))
+    } else {
+        None
+    }
+}

crates/agent/src/context_strip.rs

@@ -0,0 +1,589 @@
+use std::rc::Rc;
+
+use collections::HashSet;
+use editor::Editor;
+use file_icons::FileIcons;
+use gpui::{
+    App, Bounds, ClickEvent, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,
+    Subscription, WeakEntity,
+};
+use itertools::Itertools;
+use language::Buffer;
+use ui::{KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
+use workspace::{Workspace, notifications::NotifyResultExt};
+
+use crate::context::{ContextId, ContextKind};
+use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_store::ContextStore;
+use crate::thread::Thread;
+use crate::thread_store::ThreadStore;
+use crate::ui::{AddedContext, ContextPill};
+use crate::{
+    AcceptSuggestedContext, AssistantPanel, FocusDown, FocusLeft, FocusRight, FocusUp,
+    RemoveAllContext, RemoveFocusedContext, ToggleContextPicker,
+};
+
+pub struct ContextStrip {
+    context_store: Entity<ContextStore>,
+    context_picker: Entity<ContextPicker>,
+    context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
+    focus_handle: FocusHandle,
+    suggest_context_kind: SuggestContextKind,
+    workspace: WeakEntity<Workspace>,
+    _subscriptions: Vec<Subscription>,
+    focused_index: Option<usize>,
+    children_bounds: Option<Vec<Bounds<Pixels>>>,
+}
+
+impl ContextStrip {
+    pub fn new(
+        context_store: Entity<ContextStore>,
+        workspace: WeakEntity<Workspace>,
+        thread_store: Option<WeakEntity<ThreadStore>>,
+        context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
+        suggest_context_kind: SuggestContextKind,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let context_picker = cx.new(|cx| {
+            ContextPicker::new(
+                workspace.clone(),
+                thread_store.clone(),
+                context_store.downgrade(),
+                ConfirmBehavior::KeepOpen,
+                window,
+                cx,
+            )
+        });
+
+        let focus_handle = cx.focus_handle();
+
+        let subscriptions = vec![
+            cx.subscribe_in(&context_picker, window, Self::handle_context_picker_event),
+            cx.on_focus(&focus_handle, window, Self::handle_focus),
+            cx.on_blur(&focus_handle, window, Self::handle_blur),
+        ];
+
+        Self {
+            context_store: context_store.clone(),
+            context_picker,
+            context_picker_menu_handle,
+            focus_handle,
+            suggest_context_kind,
+            workspace,
+            _subscriptions: subscriptions,
+            focused_index: None,
+            children_bounds: None,
+        }
+    }
+
+    fn suggested_context(&self, cx: &Context<Self>) -> Option<SuggestedContext> {
+        match self.suggest_context_kind {
+            SuggestContextKind::File => self.suggested_file(cx),
+            SuggestContextKind::Thread => self.suggested_thread(cx),
+        }
+    }
+
+    fn suggested_file(&self, cx: &Context<Self>) -> Option<SuggestedContext> {
+        let workspace = self.workspace.upgrade()?;
+        let active_item = workspace.read(cx).active_item(cx)?;
+
+        let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
+        let active_buffer_entity = editor.buffer().read(cx).as_singleton()?;
+        let active_buffer = active_buffer_entity.read(cx);
+
+        let path = active_buffer.file()?.full_path(cx);
+
+        if self
+            .context_store
+            .read(cx)
+            .will_include_buffer(active_buffer.remote_id(), &path)
+            .is_some()
+        {
+            return None;
+        }
+
+        let name = match path.file_name() {
+            Some(name) => name.to_string_lossy().into_owned().into(),
+            None => path.to_string_lossy().into_owned().into(),
+        };
+
+        let icon_path = FileIcons::get_icon(&path, cx);
+
+        Some(SuggestedContext::File {
+            name,
+            buffer: active_buffer_entity.downgrade(),
+            icon_path,
+        })
+    }
+
+    fn suggested_thread(&self, cx: &Context<Self>) -> Option<SuggestedContext> {
+        if !self.context_picker.read(cx).allow_threads() {
+            return None;
+        }
+
+        let workspace = self.workspace.upgrade()?;
+        let active_thread = workspace
+            .read(cx)
+            .panel::<AssistantPanel>(cx)?
+            .read(cx)
+            .active_thread(cx);
+        let weak_active_thread = active_thread.downgrade();
+
+        let active_thread = active_thread.read(cx);
+
+        if self
+            .context_store
+            .read(cx)
+            .includes_thread(active_thread.id())
+            .is_some()
+        {
+            return None;
+        }
+
+        Some(SuggestedContext::Thread {
+            name: active_thread.summary_or_default(),
+            thread: weak_active_thread,
+        })
+    }
+
+    fn handle_context_picker_event(
+        &mut self,
+        _picker: &Entity<ContextPicker>,
+        _event: &DismissEvent,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        cx.emit(ContextStripEvent::PickerDismissed);
+    }
+
+    fn handle_focus(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
+        self.focused_index = self.last_pill_index();
+        cx.notify();
+    }
+
+    fn handle_blur(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
+        self.focused_index = None;
+        cx.notify();
+    }
+
+    fn focus_left(&mut self, _: &FocusLeft, _window: &mut Window, cx: &mut Context<Self>) {
+        self.focused_index = match self.focused_index {
+            Some(index) if index > 0 => Some(index - 1),
+            _ => self.last_pill_index(),
+        };
+
+        cx.notify();
+    }
+
+    fn focus_right(&mut self, _: &FocusRight, _window: &mut Window, cx: &mut Context<Self>) {
+        let Some(last_index) = self.last_pill_index() else {
+            return;
+        };
+
+        self.focused_index = match self.focused_index {
+            Some(index) if index < last_index => Some(index + 1),
+            _ => Some(0),
+        };
+
+        cx.notify();
+    }
+
+    fn focus_up(&mut self, _: &FocusUp, _window: &mut Window, cx: &mut Context<Self>) {
+        let Some(focused_index) = self.focused_index else {
+            return;
+        };
+
+        if focused_index == 0 {
+            return cx.emit(ContextStripEvent::BlurredUp);
+        }
+
+        let Some((focused, pills)) = self.focused_bounds(focused_index) else {
+            return;
+        };
+
+        let iter = pills[..focused_index].iter().enumerate().rev();
+        self.focused_index = Self::find_best_horizontal_match(focused, iter).or(Some(0));
+        cx.notify();
+    }
+
+    fn focus_down(&mut self, _: &FocusDown, _window: &mut Window, cx: &mut Context<Self>) {
+        let Some(focused_index) = self.focused_index else {
+            return;
+        };
+
+        let last_index = self.last_pill_index();
+
+        if self.focused_index == last_index {
+            return cx.emit(ContextStripEvent::BlurredDown);
+        }
+
+        let Some((focused, pills)) = self.focused_bounds(focused_index) else {
+            return;
+        };
+
+        let iter = pills.iter().enumerate().skip(focused_index + 1);
+        self.focused_index = Self::find_best_horizontal_match(focused, iter).or(last_index);
+        cx.notify();
+    }
+
+    fn focused_bounds(&self, focused: usize) -> Option<(&Bounds<Pixels>, &[Bounds<Pixels>])> {
+        let pill_bounds = self.pill_bounds()?;
+        let focused = pill_bounds.get(focused)?;
+
+        Some((focused, pill_bounds))
+    }
+
+    fn pill_bounds(&self) -> Option<&[Bounds<Pixels>]> {
+        let bounds = self.children_bounds.as_ref()?;
+        let eraser = if bounds.len() < 3 { 0 } else { 1 };
+        let pills = &bounds[1..bounds.len() - eraser];
+
+        if pills.is_empty() { None } else { Some(pills) }
+    }
+
+    fn last_pill_index(&self) -> Option<usize> {
+        Some(self.pill_bounds()?.len() - 1)
+    }
+
+    fn find_best_horizontal_match<'a>(
+        focused: &'a Bounds<Pixels>,
+        iter: impl Iterator<Item = (usize, &'a Bounds<Pixels>)>,
+    ) -> Option<usize> {
+        let mut best = None;
+
+        let focused_left = focused.left();
+        let focused_right = focused.right();
+
+        for (index, probe) in iter {
+            if probe.origin.y == focused.origin.y {
+                continue;
+            }
+
+            let overlap = probe.right().min(focused_right) - probe.left().max(focused_left);
+
+            best = match best {
+                Some((_, prev_overlap, y)) if probe.origin.y != y || prev_overlap > overlap => {
+                    break;
+                }
+                Some(_) | None => Some((index, overlap, probe.origin.y)),
+            };
+        }
+
+        best.map(|(index, _, _)| index)
+    }
+
+    fn open_context(&mut self, id: ContextId, window: &mut Window, cx: &mut App) {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return;
+        };
+
+        crate::active_thread::open_context(id, self.context_store.clone(), workspace, window, cx);
+    }
+
+    fn remove_focused_context(
+        &mut self,
+        _: &RemoveFocusedContext,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(index) = self.focused_index {
+            let mut is_empty = false;
+
+            self.context_store.update(cx, |this, _cx| {
+                if let Some(item) = this.context().get(index) {
+                    this.remove_context(item.id());
+                }
+
+                is_empty = this.context().is_empty();
+            });
+
+            if is_empty {
+                cx.emit(ContextStripEvent::BlurredEmpty);
+            } else {
+                self.focused_index = Some(index.saturating_sub(1));
+                cx.notify();
+            }
+        }
+    }
+
+    fn is_suggested_focused<T>(&self, context: &Vec<T>) -> bool {
+        // We only suggest one item after the actual context
+        self.focused_index == Some(context.len())
+    }
+
+    fn accept_suggested_context(
+        &mut self,
+        _: &AcceptSuggestedContext,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(suggested) = self.suggested_context(cx) {
+            let context_store = self.context_store.read(cx);
+
+            if self.is_suggested_focused(context_store.context()) {
+                self.add_suggested_context(&suggested, window, cx);
+            }
+        }
+    }
+
+    fn add_suggested_context(
+        &mut self,
+        suggested: &SuggestedContext,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let task = self.context_store.update(cx, |context_store, cx| {
+            context_store.accept_suggested_context(&suggested, cx)
+        });
+
+        cx.spawn_in(window, async move |this, cx| {
+            match task.await.notify_async_err(cx) {
+                None => {}
+                Some(()) => {
+                    if let Some(this) = this.upgrade() {
+                        this.update(cx, |_, cx| cx.notify())?;
+                    }
+                }
+            }
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+
+        cx.notify();
+    }
+}
+
+impl Focusable for ContextStrip {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for ContextStrip {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let context_store = self.context_store.read(cx);
+        let context = context_store.context();
+        let context_picker = self.context_picker.clone();
+        let focus_handle = self.focus_handle.clone();
+
+        let suggested_context = self.suggested_context(cx);
+
+        let added_contexts = context
+            .iter()
+            .map(|c| AddedContext::new(c, cx))
+            .collect::<Vec<_>>();
+        let dupe_names = added_contexts
+            .iter()
+            .map(|c| c.name.clone())
+            .sorted()
+            .tuple_windows()
+            .filter(|(a, b)| a == b)
+            .map(|(a, _)| a)
+            .collect::<HashSet<SharedString>>();
+
+        h_flex()
+            .flex_wrap()
+            .gap_1()
+            .track_focus(&focus_handle)
+            .key_context("ContextStrip")
+            .on_action(cx.listener(Self::focus_up))
+            .on_action(cx.listener(Self::focus_right))
+            .on_action(cx.listener(Self::focus_down))
+            .on_action(cx.listener(Self::focus_left))
+            .on_action(cx.listener(Self::remove_focused_context))
+            .on_action(cx.listener(Self::accept_suggested_context))
+            .on_children_prepainted({
+                let entity = cx.entity().downgrade();
+                move |children_bounds, _window, cx| {
+                    entity
+                        .update(cx, |this, _| {
+                            this.children_bounds = Some(children_bounds);
+                        })
+                        .ok();
+                }
+            })
+            .child(
+                PopoverMenu::new("context-picker")
+                    .menu(move |window, cx| {
+                        context_picker.update(cx, |this, cx| {
+                            this.init(window, cx);
+                        });
+
+                        Some(context_picker.clone())
+                    })
+                    .trigger_with_tooltip(
+                        IconButton::new("add-context", IconName::Plus)
+                            .icon_size(IconSize::Small)
+                            .style(ui::ButtonStyle::Filled),
+                        {
+                            let focus_handle = focus_handle.clone();
+                            move |window, cx| {
+                                Tooltip::for_action_in(
+                                    "Add Context",
+                                    &ToggleContextPicker,
+                                    &focus_handle,
+                                    window,
+                                    cx,
+                                )
+                            }
+                        },
+                    )
+                    .attach(gpui::Corner::TopLeft)
+                    .anchor(gpui::Corner::BottomLeft)
+                    .offset(gpui::Point {
+                        x: px(0.0),
+                        y: px(-2.0),
+                    })
+                    .with_handle(self.context_picker_menu_handle.clone()),
+            )
+            .when(context.is_empty() && suggested_context.is_none(), {
+                |parent| {
+                    parent.child(
+                        h_flex()
+                            .ml_1p5()
+                            .gap_2()
+                            .child(
+                                Label::new("Add Context")
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
+                            )
+                            .opacity(0.5)
+                            .children(
+                                KeyBinding::for_action_in(
+                                    &ToggleContextPicker,
+                                    &focus_handle,
+                                    window,
+                                    cx,
+                                )
+                                .map(|binding| binding.into_any_element()),
+                            ),
+                    )
+                }
+            })
+            .children(
+                added_contexts
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, added_context)| {
+                        let name = added_context.name.clone();
+                        let id = added_context.id;
+                        ContextPill::added(
+                            added_context,
+                            dupe_names.contains(&name),
+                            self.focused_index == Some(i),
+                            Some({
+                                let context_store = self.context_store.clone();
+                                Rc::new(cx.listener(move |_this, _event, _window, cx| {
+                                    context_store.update(cx, |this, _cx| {
+                                        this.remove_context(id);
+                                    });
+                                    cx.notify();
+                                }))
+                            }),
+                        )
+                        .on_click({
+                            Rc::new(cx.listener(move |this, event: &ClickEvent, window, cx| {
+                                if event.down.click_count > 1 {
+                                    this.open_context(id, window, cx);
+                                } else {
+                                    this.focused_index = Some(i);
+                                }
+                                cx.notify();
+                            }))
+                        })
+                    }),
+            )
+            .when_some(suggested_context, |el, suggested| {
+                el.child(
+                    ContextPill::suggested(
+                        suggested.name().clone(),
+                        suggested.icon_path(),
+                        suggested.kind(),
+                        self.is_suggested_focused(&context),
+                    )
+                    .on_click(Rc::new(cx.listener(
+                        move |this, _event, window, cx| {
+                            this.add_suggested_context(&suggested, window, cx);
+                        },
+                    ))),
+                )
+            })
+            .when(!context.is_empty(), {
+                move |parent| {
+                    parent.child(
+                        IconButton::new("remove-all-context", IconName::Eraser)
+                            .icon_size(IconSize::Small)
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+                                move |window, cx| {
+                                    Tooltip::for_action_in(
+                                        "Remove All Context",
+                                        &RemoveAllContext,
+                                        &focus_handle,
+                                        window,
+                                        cx,
+                                    )
+                                }
+                            })
+                            .on_click(cx.listener({
+                                let focus_handle = focus_handle.clone();
+                                move |_this, _event, window, cx| {
+                                    focus_handle.dispatch_action(&RemoveAllContext, window, cx);
+                                }
+                            })),
+                    )
+                }
+            })
+    }
+}
+
+pub enum ContextStripEvent {
+    PickerDismissed,
+    BlurredEmpty,
+    BlurredDown,
+    BlurredUp,
+}
+
+impl EventEmitter<ContextStripEvent> for ContextStrip {}
+
+pub enum SuggestContextKind {
+    File,
+    Thread,
+}
+
+#[derive(Clone)]
+pub enum SuggestedContext {
+    File {
+        name: SharedString,
+        icon_path: Option<SharedString>,
+        buffer: WeakEntity<Buffer>,
+    },
+    Thread {
+        name: SharedString,
+        thread: WeakEntity<Thread>,
+    },
+}
+
+impl SuggestedContext {
+    pub fn name(&self) -> &SharedString {
+        match self {
+            Self::File { name, .. } => name,
+            Self::Thread { name, .. } => name,
+        }
+    }
+
+    pub fn icon_path(&self) -> Option<SharedString> {
+        match self {
+            Self::File { icon_path, .. } => icon_path.clone(),
+            Self::Thread { .. } => None,
+        }
+    }
+
+    pub fn kind(&self) -> ContextKind {
+        match self {
+            Self::File { .. } => ContextKind::File,
+            Self::Thread { .. } => ContextKind::Thread,
+        }
+    }
+}

crates/agent/src/history_store.rs

@@ -0,0 +1,66 @@
+use assistant_context_editor::SavedContextMetadata;
+use chrono::{DateTime, Utc};
+use gpui::{Entity, prelude::*};
+
+use crate::thread_store::{SerializedThreadMetadata, ThreadStore};
+
+pub enum HistoryEntry {
+    Thread(SerializedThreadMetadata),
+    Context(SavedContextMetadata),
+}
+
+impl HistoryEntry {
+    pub fn updated_at(&self) -> DateTime<Utc> {
+        match self {
+            HistoryEntry::Thread(thread) => thread.updated_at,
+            HistoryEntry::Context(context) => context.mtime.to_utc(),
+        }
+    }
+}
+
+pub struct HistoryStore {
+    thread_store: Entity<ThreadStore>,
+    context_store: Entity<assistant_context_editor::ContextStore>,
+}
+
+impl HistoryStore {
+    pub fn new(
+        thread_store: Entity<ThreadStore>,
+        context_store: Entity<assistant_context_editor::ContextStore>,
+        _cx: &mut Context<Self>,
+    ) -> Self {
+        Self {
+            thread_store,
+            context_store,
+        }
+    }
+
+    /// Returns the number of history entries.
+    pub fn entry_count(&self, cx: &mut Context<Self>) -> usize {
+        self.entries(cx).len()
+    }
+
+    pub fn entries(&self, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
+        let mut history_entries = Vec::new();
+
+        #[cfg(debug_assertions)]
+        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
+            return history_entries;
+        }
+
+        for thread in self.thread_store.update(cx, |this, _cx| this.threads()) {
+            history_entries.push(HistoryEntry::Thread(thread));
+        }
+
+        for context in self.context_store.update(cx, |this, _cx| this.contexts()) {
+            history_entries.push(HistoryEntry::Context(context));
+        }
+
+        history_entries.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.updated_at()));
+        history_entries
+    }
+
+    pub fn recent_entries(&self, limit: usize, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
+        self.entries(cx).into_iter().take(limit).collect()
+    }
+}

crates/agent/src/message_editor.rs

@@ -0,0 +1,837 @@
+use std::sync::Arc;
+
+use collections::HashSet;
+use editor::actions::MoveUp;
+use editor::{ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorStyle};
+use file_icons::FileIcons;
+use fs::Fs;
+use gpui::{
+    Animation, AnimationExt, App, DismissEvent, Entity, Focusable, Subscription, TextStyle,
+    WeakEntity, linear_color_stop, linear_gradient, point,
+};
+use language_model::LanguageModelRegistry;
+use language_model_selector::ToggleModelSelector;
+use project::Project;
+use settings::Settings;
+use std::time::Duration;
+use theme::ThemeSettings;
+use ui::{
+    ButtonLike, Disclosure, KeyBinding, PlatformStyle, PopoverMenu, PopoverMenuHandle, Tooltip,
+    prelude::*,
+};
+use util::ResultExt as _;
+use vim_mode_setting::VimModeSetting;
+use workspace::Workspace;
+
+use crate::assistant_model_selector::AssistantModelSelector;
+use crate::context_picker::{ConfirmBehavior, ContextPicker, ContextPickerCompletionProvider};
+use crate::context_store::{ContextStore, refresh_context_store_text};
+use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
+use crate::profile_selector::ProfileSelector;
+use crate::thread::{RequestKind, Thread};
+use crate::thread_store::ThreadStore;
+use crate::{
+    AssistantDiff, Chat, ChatMode, NewThread, OpenAssistantDiff, RemoveAllContext, ThreadEvent,
+    ToggleContextPicker, ToggleProfileSelector,
+};
+
+pub struct MessageEditor {
+    thread: Entity<Thread>,
+    editor: Entity<Editor>,
+    #[allow(dead_code)]
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    context_store: Entity<ContextStore>,
+    context_strip: Entity<ContextStrip>,
+    context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
+    inline_context_picker: Entity<ContextPicker>,
+    inline_context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
+    model_selector: Entity<AssistantModelSelector>,
+    profile_selector: Entity<ProfileSelector>,
+    edits_expanded: bool,
+    waiting_for_summaries_to_send: bool,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl MessageEditor {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        workspace: WeakEntity<Workspace>,
+        context_store: Entity<ContextStore>,
+        thread_store: WeakEntity<ThreadStore>,
+        thread: Entity<Thread>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let context_picker_menu_handle = PopoverMenuHandle::default();
+        let inline_context_picker_menu_handle = PopoverMenuHandle::default();
+        let model_selector_menu_handle = PopoverMenuHandle::default();
+
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::auto_height(10, window, cx);
+            editor.set_placeholder_text("Ask anything, @ to mention, ↑ to select", cx);
+            editor.set_show_indent_guides(false, cx);
+            editor.set_context_menu_options(ContextMenuOptions {
+                min_entries_visible: 12,
+                max_entries_visible: 12,
+                placement: Some(ContextMenuPlacement::Above),
+            });
+
+            editor
+        });
+
+        let editor_entity = editor.downgrade();
+        editor.update(cx, |editor, _| {
+            editor.set_completion_provider(Some(Box::new(ContextPickerCompletionProvider::new(
+                workspace.clone(),
+                context_store.downgrade(),
+                Some(thread_store.clone()),
+                editor_entity,
+            ))));
+        });
+
+        let inline_context_picker = cx.new(|cx| {
+            ContextPicker::new(
+                workspace.clone(),
+                Some(thread_store.clone()),
+                context_store.downgrade(),
+                ConfirmBehavior::Close,
+                window,
+                cx,
+            )
+        });
+
+        let context_strip = cx.new(|cx| {
+            ContextStrip::new(
+                context_store.clone(),
+                workspace.clone(),
+                Some(thread_store.clone()),
+                context_picker_menu_handle.clone(),
+                SuggestContextKind::File,
+                window,
+                cx,
+            )
+        });
+
+        let subscriptions = vec![
+            cx.subscribe_in(
+                &inline_context_picker,
+                window,
+                Self::handle_inline_context_picker_event,
+            ),
+            cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
+        ];
+
+        Self {
+            editor: editor.clone(),
+            project: thread.read(cx).project().clone(),
+            thread,
+            workspace,
+            context_store,
+            context_strip,
+            context_picker_menu_handle,
+            inline_context_picker,
+            inline_context_picker_menu_handle,
+            model_selector: cx.new(|cx| {
+                AssistantModelSelector::new(
+                    fs.clone(),
+                    model_selector_menu_handle,
+                    editor.focus_handle(cx),
+                    window,
+                    cx,
+                )
+            }),
+            edits_expanded: false,
+            waiting_for_summaries_to_send: false,
+            profile_selector: cx
+                .new(|cx| ProfileSelector::new(fs, thread_store, editor.focus_handle(cx), cx)),
+            _subscriptions: subscriptions,
+        }
+    }
+
+    fn toggle_chat_mode(&mut self, _: &ChatMode, _window: &mut Window, cx: &mut Context<Self>) {
+        cx.notify();
+    }
+
+    fn toggle_context_picker(
+        &mut self,
+        _: &ToggleContextPicker,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.context_picker_menu_handle.toggle(window, cx);
+    }
+    pub fn remove_all_context(
+        &mut self,
+        _: &RemoveAllContext,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.context_store.update(cx, |store, _cx| store.clear());
+        cx.notify();
+    }
+
+    fn chat(&mut self, _: &Chat, window: &mut Window, cx: &mut Context<Self>) {
+        if self.is_editor_empty(cx) {
+            return;
+        }
+
+        if self.thread.read(cx).is_generating() {
+            return;
+        }
+
+        self.send_to_model(RequestKind::Chat, window, cx);
+    }
+
+    fn is_editor_empty(&self, cx: &App) -> bool {
+        self.editor.read(cx).text(cx).is_empty()
+    }
+
+    fn is_model_selected(&self, cx: &App) -> bool {
+        LanguageModelRegistry::read_global(cx)
+            .active_model()
+            .is_some()
+    }
+
+    fn send_to_model(
+        &mut self,
+        request_kind: RequestKind,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        if provider
+            .as_ref()
+            .map_or(false, |provider| provider.must_accept_terms(cx))
+        {
+            cx.notify();
+            return;
+        }
+
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let Some(model) = model_registry.active_model() else {
+            return;
+        };
+
+        let user_message = self.editor.update(cx, |editor, cx| {
+            let text = editor.text(cx);
+            editor.clear(window, cx);
+            text
+        });
+
+        let refresh_task =
+            refresh_context_store_text(self.context_store.clone(), &HashSet::default(), cx);
+
+        let system_prompt_context_task = self.thread.read(cx).load_system_prompt_context(cx);
+
+        let thread = self.thread.clone();
+        let context_store = self.context_store.clone();
+        let checkpoint = self.project.read(cx).git_store().read(cx).checkpoint(cx);
+
+        cx.spawn(async move |this, cx| {
+            let checkpoint = checkpoint.await.ok();
+            refresh_task.await;
+            let (system_prompt_context, load_error) = system_prompt_context_task.await;
+
+            thread
+                .update(cx, |thread, cx| {
+                    thread.set_system_prompt_context(system_prompt_context);
+                    if let Some(load_error) = load_error {
+                        cx.emit(ThreadEvent::ShowError(load_error));
+                    }
+                })
+                .ok();
+
+            thread
+                .update(cx, |thread, cx| {
+                    let context = context_store.read(cx).context().clone();
+                    thread.insert_user_message(user_message, context, checkpoint, cx);
+                })
+                .ok();
+
+            if let Some(wait_for_summaries) = context_store
+                .update(cx, |context_store, cx| context_store.wait_for_summaries(cx))
+                .log_err()
+            {
+                this.update(cx, |this, cx| {
+                    this.waiting_for_summaries_to_send = true;
+                    cx.notify();
+                })
+                .ok();
+
+                wait_for_summaries.await;
+
+                this.update(cx, |this, cx| {
+                    this.waiting_for_summaries_to_send = false;
+                    cx.notify();
+                })
+                .ok();
+            }
+
+            // Send to model after summaries are done
+            thread
+                .update(cx, |thread, cx| {
+                    thread.send_to_model(model, request_kind, cx);
+                })
+                .ok();
+        })
+        .detach();
+    }
+
+    fn handle_inline_context_picker_event(
+        &mut self,
+        _inline_context_picker: &Entity<ContextPicker>,
+        _event: &DismissEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let editor_focus_handle = self.editor.focus_handle(cx);
+        window.focus(&editor_focus_handle);
+    }
+
+    fn handle_context_strip_event(
+        &mut self,
+        _context_strip: &Entity<ContextStrip>,
+        event: &ContextStripEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            ContextStripEvent::PickerDismissed
+            | ContextStripEvent::BlurredEmpty
+            | ContextStripEvent::BlurredDown => {
+                let editor_focus_handle = self.editor.focus_handle(cx);
+                window.focus(&editor_focus_handle);
+            }
+            ContextStripEvent::BlurredUp => {}
+        }
+    }
+
+    fn move_up(&mut self, _: &MoveUp, window: &mut Window, cx: &mut Context<Self>) {
+        if self.context_picker_menu_handle.is_deployed()
+            || self.inline_context_picker_menu_handle.is_deployed()
+        {
+            cx.propagate();
+        } else {
+            self.context_strip.focus_handle(cx).focus(window);
+        }
+    }
+
+    fn handle_review_click(&self, window: &mut Window, cx: &mut Context<Self>) {
+        AssistantDiff::deploy(self.thread.clone(), self.workspace.clone(), window, cx).log_err();
+    }
+}
+
+impl Focusable for MessageEditor {
+    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
+        self.editor.focus_handle(cx)
+    }
+}
+
+impl Render for MessageEditor {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let font_size = TextSize::Default.rems(cx);
+        let line_height = font_size.to_pixels(window.rem_size()) * 1.5;
+
+        let focus_handle = self.editor.focus_handle(cx);
+        let inline_context_picker = self.inline_context_picker.clone();
+
+        let thread = self.thread.read(cx);
+        let is_generating = thread.is_generating();
+        let is_too_long = thread.is_getting_too_long(cx);
+        let is_model_selected = self.is_model_selected(cx);
+        let is_editor_empty = self.is_editor_empty(cx);
+        let submit_label_color = if is_editor_empty {
+            Color::Muted
+        } else {
+            Color::Default
+        };
+
+        let vim_mode_enabled = VimModeSetting::get_global(cx).0;
+        let platform = PlatformStyle::platform();
+        let linux = platform == PlatformStyle::Linux;
+        let windows = platform == PlatformStyle::Windows;
+        let button_width = if linux || windows || vim_mode_enabled {
+            px(82.)
+        } else {
+            px(64.)
+        };
+
+        let action_log = self.thread.read(cx).action_log();
+        let changed_buffers = action_log.read(cx).changed_buffers(cx);
+        let changed_buffers_count = changed_buffers.len();
+
+        let editor_bg_color = cx.theme().colors().editor_background;
+        let border_color = cx.theme().colors().border;
+        let active_color = cx.theme().colors().element_selected;
+        let bg_edit_files_disclosure = editor_bg_color.blend(active_color.opacity(0.3));
+
+        v_flex()
+            .size_full()
+            .when(self.waiting_for_summaries_to_send, |parent| {
+                parent.child(
+                    h_flex().py_3().w_full().justify_center().child(
+                        h_flex()
+                            .flex_none()
+                            .px_2()
+                            .py_2()
+                            .bg(editor_bg_color)
+                            .border_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .rounded_lg()
+                            .shadow_md()
+                            .gap_1()
+                            .child(
+                                Icon::new(IconName::ArrowCircle)
+                                    .size(IconSize::XSmall)
+                                    .color(Color::Muted)
+                                    .with_animation(
+                                        "arrow-circle",
+                                        Animation::new(Duration::from_secs(2)).repeat(),
+                                        |icon, delta| {
+                                            icon.transform(gpui::Transformation::rotate(
+                                                gpui::percentage(delta),
+                                            ))
+                                        },
+                                    ),
+                            )
+                            .child(
+                                Label::new("Summarizing context…")
+                                    .size(LabelSize::XSmall)
+                                    .color(Color::Muted),
+                            ),
+                    ),
+                )
+            })
+            .when(is_generating, |parent| {
+                let focus_handle = self.editor.focus_handle(cx).clone();
+                parent.child(
+                    h_flex().py_3().w_full().justify_center().child(
+                        h_flex()
+                            .flex_none()
+                            .pl_2()
+                            .pr_1()
+                            .py_1()
+                            .bg(editor_bg_color)
+                            .border_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .rounded_lg()
+                            .shadow_md()
+                            .gap_1()
+                            .child(
+                                Icon::new(IconName::ArrowCircle)
+                                    .size(IconSize::XSmall)
+                                    .color(Color::Muted)
+                                    .with_animation(
+                                        "arrow-circle",
+                                        Animation::new(Duration::from_secs(2)).repeat(),
+                                        |icon, delta| {
+                                            icon.transform(gpui::Transformation::rotate(
+                                                gpui::percentage(delta),
+                                            ))
+                                        },
+                                    ),
+                            )
+                            .child(
+                                Label::new("Generating…")
+                                    .size(LabelSize::XSmall)
+                                    .color(Color::Muted),
+                            )
+                            .child(ui::Divider::vertical())
+                            .child(
+                                Button::new("cancel-generation", "Cancel")
+                                    .label_size(LabelSize::XSmall)
+                                    .key_binding(
+                                        KeyBinding::for_action_in(
+                                            &editor::actions::Cancel,
+                                            &focus_handle,
+                                            window,
+                                            cx,
+                                        )
+                                        .map(|kb| kb.size(rems_from_px(10.))),
+                                    )
+                                    .on_click(move |_event, window, cx| {
+                                        focus_handle.dispatch_action(
+                                            &editor::actions::Cancel,
+                                            window,
+                                            cx,
+                                        );
+                                    }),
+                            ),
+                    ),
+                )
+            })
+            .when(changed_buffers_count > 0, |parent| {
+                parent.child(
+                    v_flex()
+                        .mx_2()
+                        .bg(bg_edit_files_disclosure)
+                        .border_1()
+                        .border_b_0()
+                        .border_color(border_color)
+                        .rounded_t_md()
+                        .shadow(smallvec::smallvec![gpui::BoxShadow {
+                            color: gpui::black().opacity(0.15),
+                            offset: point(px(1.), px(-1.)),
+                            blur_radius: px(3.),
+                            spread_radius: px(0.),
+                        }])
+                        .child(
+                            h_flex()
+                                .p_1p5()
+                                .justify_between()
+                                .when(self.edits_expanded, |this| {
+                                    this.border_b_1().border_color(border_color)
+                                })
+                                .child(
+                                    h_flex()
+                                        .gap_1()
+                                        .child(
+                                            Disclosure::new(
+                                                "edits-disclosure",
+                                                self.edits_expanded,
+                                            )
+                                            .on_click(
+                                                cx.listener(|this, _ev, _window, cx| {
+                                                    this.edits_expanded = !this.edits_expanded;
+                                                    cx.notify();
+                                                }),
+                                            ),
+                                        )
+                                        .child(
+                                            Label::new("Edits")
+                                                .size(LabelSize::Small)
+                                                .color(Color::Muted),
+                                        )
+                                        .child(
+                                            Label::new("•")
+                                                .size(LabelSize::XSmall)
+                                                .color(Color::Muted),
+                                        )
+                                        .child(
+                                            Label::new(format!(
+                                                "{} {}",
+                                                changed_buffers_count,
+                                                if changed_buffers_count == 1 {
+                                                    "file"
+                                                } else {
+                                                    "files"
+                                                }
+                                            ))
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted),
+                                        ),
+                                )
+                                .child(
+                                    Button::new("review", "Review Changes")
+                                        .label_size(LabelSize::Small)
+                                        .key_binding(
+                                            KeyBinding::for_action_in(
+                                                &OpenAssistantDiff,
+                                                &focus_handle,
+                                                window,
+                                                cx,
+                                            )
+                                            .map(|kb| kb.size(rems_from_px(12.))),
+                                        )
+                                        .on_click(cx.listener(|this, _, window, cx| {
+                                            this.handle_review_click(window, cx)
+                                        })),
+                                ),
+                        )
+                        .when(self.edits_expanded, |parent| {
+                            parent.child(
+                                v_flex().bg(cx.theme().colors().editor_background).children(
+                                    changed_buffers.into_iter().enumerate().flat_map(
+                                        |(index, (buffer, _diff))| {
+                                            let file = buffer.read(cx).file()?;
+                                            let path = file.path();
+
+                                            let parent_label = path.parent().and_then(|parent| {
+                                                let parent_str = parent.to_string_lossy();
+
+                                                if parent_str.is_empty() {
+                                                    None
+                                                } else {
+                                                    Some(
+                                                        Label::new(format!(
+                                                            "{}{}",
+                                                            parent_str,
+                                                            std::path::MAIN_SEPARATOR_STR
+                                                        ))
+                                                        .color(Color::Muted)
+                                                        .size(LabelSize::XSmall)
+                                                        .buffer_font(cx),
+                                                    )
+                                                }
+                                            });
+
+                                            let name_label = path.file_name().map(|name| {
+                                                Label::new(name.to_string_lossy().to_string())
+                                                    .size(LabelSize::XSmall)
+                                                    .buffer_font(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(|| {
+                                                    Icon::new(IconName::File)
+                                                        .color(Color::Muted)
+                                                        .size(IconSize::Small)
+                                                });
+
+                                            let element = div()
+                                                .relative()
+                                                .py_1()
+                                                .px_2()
+                                                .when(index + 1 < changed_buffers_count, |parent| {
+                                                    parent.border_color(border_color).border_b_1()
+                                                })
+                                                .child(
+                                                    h_flex()
+                                                        .gap_2()
+                                                        .justify_between()
+                                                        .child(
+                                                            h_flex()
+                                                                .id("file-container")
+                                                                .pr_8()
+                                                                .gap_1p5()
+                                                                .max_w_full()
+                                                                .overflow_x_scroll()
+                                                                .child(file_icon)
+                                                                .child(
+                                                                    h_flex()
+                                                                        .children(parent_label)
+                                                                        .children(name_label),
+                                                                ) // TODO: show lines changed
+                                                                .child(
+                                                                    Label::new("+")
+                                                                        .color(Color::Created),
+                                                                )
+                                                                .child(
+                                                                    Label::new("-")
+                                                                        .color(Color::Deleted),
+                                                                ),
+                                                        )
+                                                        .child(
+                                                            div()
+                                                                .h_full()
+                                                                .absolute()
+                                                                .w_8()
+                                                                .bottom_0()
+                                                                .right_0()
+                                                                .bg(linear_gradient(
+                                                                    90.,
+                                                                    linear_color_stop(
+                                                                        editor_bg_color,
+                                                                        1.,
+                                                                    ),
+                                                                    linear_color_stop(
+                                                                        editor_bg_color
+                                                                            .opacity(0.2),
+                                                                        0.,
+                                                                    ),
+                                                                )),
+                                                        ),
+                                                );
+
+                                            Some(element)
+                                        },
+                                    ),
+                                ),
+                            )
+                        }),
+                )
+            })
+            .child(
+                v_flex()
+                    .key_context("MessageEditor")
+                    .on_action(cx.listener(Self::chat))
+                    .on_action(cx.listener(|this, _: &ToggleProfileSelector, window, cx| {
+                        this.profile_selector
+                            .read(cx)
+                            .menu_handle()
+                            .toggle(window, cx);
+                    }))
+                    .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
+                        this.model_selector
+                            .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
+                    }))
+                    .on_action(cx.listener(Self::toggle_context_picker))
+                    .on_action(cx.listener(Self::remove_all_context))
+                    .on_action(cx.listener(Self::move_up))
+                    .on_action(cx.listener(Self::toggle_chat_mode))
+                    .gap_2()
+                    .p_2()
+                    .bg(editor_bg_color)
+                    .border_t_1()
+                    .border_color(cx.theme().colors().border)
+                    .child(h_flex().justify_between().child(self.context_strip.clone()))
+                    .child(
+                        v_flex()
+                            .gap_5()
+                            .child({
+                                    let settings = ThemeSettings::get_global(cx);
+                                    let text_style = TextStyle {
+                                        color: cx.theme().colors().text,
+                                        font_family: settings.ui_font.family.clone(),
+                                        font_fallbacks: settings.ui_font.fallbacks.clone(),
+                                        font_features: settings.ui_font.features.clone(),
+                                        font_size: font_size.into(),
+                                        font_weight: settings.ui_font.weight,
+                                        line_height: line_height.into(),
+                                        ..Default::default()
+                                    };
+
+                                    EditorElement::new(
+                                        &self.editor,
+                                        EditorStyle {
+                                            background: editor_bg_color,
+                                            local_player: cx.theme().players().local(),
+                                            text: text_style,
+                                            syntax: cx.theme().syntax().clone(),
+                                            ..Default::default()
+                                        },
+                                    ).into_any()
+
+                            })
+                            .child(
+                                PopoverMenu::new("inline-context-picker")
+                                    .menu(move |window, cx| {
+                                        inline_context_picker.update(cx, |this, cx| {
+                                            this.init(window, cx);
+                                        });
+
+                                        Some(inline_context_picker.clone())
+                                    })
+                                    .attach(gpui::Corner::TopLeft)
+                                    .anchor(gpui::Corner::BottomLeft)
+                                    .offset(gpui::Point {
+                                        x: px(0.0),
+                                        y: (-ThemeSettings::get_global(cx).ui_font_size(cx) * 2)
+                                            - px(4.0),
+                                    })
+                                    .with_handle(self.inline_context_picker_menu_handle.clone()),
+                            )
+                            .child(
+                                h_flex()
+                                    .justify_between()
+                                    .child(h_flex().gap_2().child(self.profile_selector.clone()))
+                                    .child(
+                                        h_flex().gap_1().child(self.model_selector.clone()).child(
+                                            ButtonLike::new("submit-message")
+                                                .width(button_width.into())
+                                                .style(ButtonStyle::Filled)
+                                                .disabled(
+                                                    is_editor_empty
+                                                        || !is_model_selected
+                                                        || is_generating
+                                                        || self.waiting_for_summaries_to_send
+                                                )
+                                                .child(
+                                                    h_flex()
+                                                        .w_full()
+                                                        .justify_between()
+                                                        .child(
+                                                            Label::new("Submit")
+                                                                .size(LabelSize::Small)
+                                                                .color(submit_label_color),
+                                                        )
+                                                        .children(
+                                                            KeyBinding::for_action_in(
+                                                                &Chat,
+                                                                &focus_handle,
+                                                                window,
+                                                                cx,
+                                                            )
+                                                            .map(|binding| {
+                                                                binding
+                                                                    .when(vim_mode_enabled, |kb| {
+                                                                        kb.size(rems_from_px(12.))
+                                                                    })
+                                                                    .into_any_element()
+                                                            }),
+                                                        ),
+                                                )
+                                                .on_click(move |_event, window, cx| {
+                                                    focus_handle.dispatch_action(&Chat, window, cx);
+                                                })
+                                                .when(is_editor_empty, |button| {
+                                                    button.tooltip(Tooltip::text(
+                                                        "Type a message to submit",
+                                                    ))
+                                                })
+                                                .when(is_generating, |button| {
+                                                    button.tooltip(Tooltip::text(
+                                                        "Cancel to submit a new message",
+                                                    ))
+                                                })
+                                                .when(!is_model_selected, |button| {
+                                                    button.tooltip(Tooltip::text(
+                                                        "Select a model to continue",
+                                                    ))
+                                                }),
+                                        ),
+                                    ),
+                            ),
+                    )
+            )
+            .when(is_too_long, |parent| {
+                parent.child(
+                    h_flex()
+                        .p_2()
+                        .gap_2()
+                        .flex_wrap()
+                        .justify_between()
+                        .bg(cx.theme().status().warning_background.opacity(0.1))
+                        .border_t_1()
+                        .border_color(cx.theme().colors().border)
+                        .child(
+                            h_flex()
+                                .gap_2()
+                                .items_start()
+                                .child(
+                                    h_flex()
+                                        .h(line_height)
+                                        .justify_center()
+                                        .child(
+                                            Icon::new(IconName::Warning)
+                                                .color(Color::Warning)
+                                                .size(IconSize::XSmall),
+                                        ),
+                                )
+                                .child(
+                                    v_flex()
+                                        .mr_auto()
+                                        .child(Label::new("Thread reaching the token limit soon").size(LabelSize::Small))
+                                        .child(
+                                            Label::new(
+                                                "Start a new thread from a summary to continue the conversation.",
+                                            )
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted),
+                                        ),
+                                ),
+                        )
+                        .child(
+                            Button::new("new-thread", "Start New Thread")
+                                .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);
+                                }))
+                                .icon(IconName::Plus)
+                                .icon_position(IconPosition::Start)
+                                .icon_size(IconSize::Small)
+                                .style(ButtonStyle::Tinted(ui::TintColor::Accent))
+                                .label_size(LabelSize::Small),
+                        ),
+                )
+            })
+    }
+}

crates/agent/src/profile_selector.rs

@@ -0,0 +1,189 @@
+use std::sync::Arc;
+
+use assistant_settings::{AgentProfile, AssistantSettings};
+use fs::Fs;
+use gpui::{Action, Entity, FocusHandle, Subscription, WeakEntity, prelude::*};
+use indexmap::IndexMap;
+use language_model::LanguageModelRegistry;
+use settings::{Settings as _, SettingsStore, update_settings_file};
+use ui::{
+    ButtonLike, ContextMenu, ContextMenuEntry, KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip,
+    prelude::*,
+};
+use util::ResultExt as _;
+
+use crate::{ManageProfiles, ThreadStore, ToggleProfileSelector};
+
+pub struct ProfileSelector {
+    profiles: IndexMap<Arc<str>, AgentProfile>,
+    fs: Arc<dyn Fs>,
+    thread_store: WeakEntity<ThreadStore>,
+    focus_handle: FocusHandle,
+    menu_handle: PopoverMenuHandle<ContextMenu>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl ProfileSelector {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        thread_store: WeakEntity<ThreadStore>,
+        focus_handle: FocusHandle,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let settings_subscription = cx.observe_global::<SettingsStore>(move |this, cx| {
+            this.refresh_profiles(cx);
+        });
+
+        let mut this = Self {
+            profiles: IndexMap::default(),
+            fs,
+            thread_store,
+            focus_handle,
+            menu_handle: PopoverMenuHandle::default(),
+            _subscriptions: vec![settings_subscription],
+        };
+        this.refresh_profiles(cx);
+
+        this
+    }
+
+    pub fn menu_handle(&self) -> PopoverMenuHandle<ContextMenu> {
+        self.menu_handle.clone()
+    }
+
+    fn refresh_profiles(&mut self, cx: &mut Context<Self>) {
+        let settings = AssistantSettings::get_global(cx);
+
+        self.profiles = settings.profiles.clone();
+    }
+
+    fn build_context_menu(
+        &self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Entity<ContextMenu> {
+        ContextMenu::build(window, cx, |mut menu, _window, cx| {
+            let settings = AssistantSettings::get_global(cx);
+            let icon_position = IconPosition::End;
+
+            menu = menu.header("Profiles");
+            for (profile_id, profile) in self.profiles.clone() {
+                menu = menu.toggleable_entry(
+                    profile.name.clone(),
+                    profile_id == settings.default_profile,
+                    icon_position,
+                    None,
+                    {
+                        let fs = self.fs.clone();
+                        let thread_store = self.thread_store.clone();
+                        move |_window, cx| {
+                            update_settings_file::<AssistantSettings>(fs.clone(), cx, {
+                                let profile_id = profile_id.clone();
+                                move |settings, _cx| {
+                                    settings.set_profile(profile_id.clone());
+                                }
+                            });
+
+                            thread_store
+                                .update(cx, |this, cx| {
+                                    this.load_profile_by_id(&profile_id, cx);
+                                })
+                                .log_err();
+                        }
+                    },
+                );
+            }
+
+            menu = menu.separator();
+            menu = menu.header("Customize Current Profile");
+            menu = menu.item(ContextMenuEntry::new("Tools…").handler({
+                let profile_id = settings.default_profile.clone();
+                move |window, cx| {
+                    window.dispatch_action(
+                        ManageProfiles::customize_tools(profile_id.clone()).boxed_clone(),
+                        cx,
+                    );
+                }
+            }));
+
+            menu = menu.separator();
+            menu = menu.item(ContextMenuEntry::new("Configure Profiles…").handler(
+                move |window, cx| {
+                    window.dispatch_action(ManageProfiles::default().boxed_clone(), cx);
+                },
+            ));
+
+            menu
+        })
+    }
+}
+
+impl Render for ProfileSelector {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let settings = AssistantSettings::get_global(cx);
+        let profile_id = &settings.default_profile;
+        let profile = settings.profiles.get(profile_id);
+
+        let selected_profile = profile
+            .map(|profile| profile.name.clone())
+            .unwrap_or_else(|| "Unknown".into());
+
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let supports_tools = model_registry
+            .active_model()
+            .map_or(false, |model| model.supports_tools());
+
+        let icon = match profile_id.as_ref() {
+            "write" => IconName::Pencil,
+            "ask" => IconName::MessageBubbles,
+            _ => IconName::UserRoundPen,
+        };
+
+        let this = cx.entity().clone();
+        let focus_handle = self.focus_handle.clone();
+        PopoverMenu::new("profile-selector")
+            .menu(move |window, cx| {
+                Some(this.update(cx, |this, cx| this.build_context_menu(window, cx)))
+            })
+            .trigger(if supports_tools {
+                ButtonLike::new("profile-selector-button").child(
+                    h_flex()
+                        .gap_1()
+                        .child(Icon::new(icon).size(IconSize::XSmall).color(Color::Muted))
+                        .child(
+                            Label::new(selected_profile)
+                                .size(LabelSize::Small)
+                                .color(Color::Muted),
+                        )
+                        .child(
+                            Icon::new(IconName::ChevronDown)
+                                .size(IconSize::XSmall)
+                                .color(Color::Muted),
+                        )
+                        .child(div().opacity(0.5).children({
+                            let focus_handle = focus_handle.clone();
+                            KeyBinding::for_action_in(
+                                &ToggleProfileSelector,
+                                &focus_handle,
+                                window,
+                                cx,
+                            )
+                            .map(|kb| kb.size(rems_from_px(10.)))
+                        })),
+                )
+            } else {
+                ButtonLike::new("tools-not-supported-button")
+                    .disabled(true)
+                    .child(
+                        h_flex().gap_1().child(
+                            Label::new("No Tools")
+                                .size(LabelSize::Small)
+                                .color(Color::Muted),
+                        ),
+                    )
+                    .tooltip(Tooltip::text("The current model does not support tools."))
+            })
+            .anchor(gpui::Corner::BottomLeft)
+            .with_handle(self.menu_handle.clone())
+    }
+}

crates/agent/src/terminal_codegen.rs

@@ -0,0 +1,194 @@
+use crate::inline_prompt_editor::CodegenStatus;
+use client::telemetry::Telemetry;
+use futures::{SinkExt, StreamExt, channel::mpsc};
+use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
+use language_model::{LanguageModelRegistry, LanguageModelRequest, report_assistant_event};
+use std::{sync::Arc, time::Instant};
+use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use terminal::Terminal;
+
+pub struct TerminalCodegen {
+    pub status: CodegenStatus,
+    pub telemetry: Option<Arc<Telemetry>>,
+    terminal: Entity<Terminal>,
+    generation: Task<()>,
+    pub message_id: Option<String>,
+    transaction: Option<TerminalTransaction>,
+}
+
+impl EventEmitter<CodegenEvent> for TerminalCodegen {}
+
+impl TerminalCodegen {
+    pub fn new(terminal: Entity<Terminal>, telemetry: Option<Arc<Telemetry>>) -> Self {
+        Self {
+            terminal,
+            telemetry,
+            status: CodegenStatus::Idle,
+            generation: Task::ready(()),
+            message_id: None,
+            transaction: None,
+        }
+    }
+
+    pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+            return;
+        };
+
+        let model_api_key = model.api_key(cx);
+        let http_client = cx.http_client();
+        let telemetry = self.telemetry.clone();
+        self.status = CodegenStatus::Pending;
+        self.transaction = Some(TerminalTransaction::start(self.terminal.clone()));
+        self.generation = cx.spawn(async move |this, cx| {
+            let model_telemetry_id = model.telemetry_id();
+            let model_provider_id = model.provider_id();
+            let response = model.stream_completion_text(prompt, &cx).await;
+            let generate = async {
+                let message_id = response
+                    .as_ref()
+                    .ok()
+                    .and_then(|response| response.message_id.clone());
+
+                let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);
+
+                let task = cx.background_spawn({
+                    let message_id = message_id.clone();
+                    let executor = cx.background_executor().clone();
+                    async move {
+                        let mut response_latency = None;
+                        let request_start = Instant::now();
+                        let task = async {
+                            let mut chunks = response?.stream;
+                            while let Some(chunk) = chunks.next().await {
+                                if response_latency.is_none() {
+                                    response_latency = Some(request_start.elapsed());
+                                }
+                                let chunk = chunk?;
+                                hunks_tx.send(chunk).await?;
+                            }
+
+                            anyhow::Ok(())
+                        };
+
+                        let result = task.await;
+
+                        let error_message = result.as_ref().err().map(|error| error.to_string());
+                        report_assistant_event(
+                            AssistantEvent {
+                                conversation_id: None,
+                                kind: AssistantKind::InlineTerminal,
+                                message_id,
+                                phase: AssistantPhase::Response,
+                                model: model_telemetry_id,
+                                model_provider: model_provider_id.to_string(),
+                                response_latency,
+                                error_message,
+                                language_name: None,
+                            },
+                            telemetry,
+                            http_client,
+                            model_api_key,
+                            &executor,
+                        );
+
+                        result?;
+                        anyhow::Ok(())
+                    }
+                });
+
+                this.update(cx, |this, _| {
+                    this.message_id = message_id;
+                })?;
+
+                while let Some(hunk) = hunks_rx.next().await {
+                    this.update(cx, |this, cx| {
+                        if let Some(transaction) = &mut this.transaction {
+                            transaction.push(hunk, cx);
+                            cx.notify();
+                        }
+                    })?;
+                }
+
+                task.await?;
+                anyhow::Ok(())
+            };
+
+            let result = generate.await;
+
+            this.update(cx, |this, cx| {
+                if let Err(error) = result {
+                    this.status = CodegenStatus::Error(error);
+                } else {
+                    this.status = CodegenStatus::Done;
+                }
+                cx.emit(CodegenEvent::Finished);
+                cx.notify();
+            })
+            .ok();
+        });
+        cx.notify();
+    }
+
+    pub fn stop(&mut self, cx: &mut Context<Self>) {
+        self.status = CodegenStatus::Done;
+        self.generation = Task::ready(());
+        cx.emit(CodegenEvent::Finished);
+        cx.notify();
+    }
+
+    pub fn complete(&mut self, cx: &mut Context<Self>) {
+        if let Some(transaction) = self.transaction.take() {
+            transaction.complete(cx);
+        }
+    }
+
+    pub fn undo(&mut self, cx: &mut Context<Self>) {
+        if let Some(transaction) = self.transaction.take() {
+            transaction.undo(cx);
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum CodegenEvent {
+    Finished,
+}
+
+#[cfg(not(target_os = "windows"))]
+pub const CLEAR_INPUT: &str = "\x15";
+#[cfg(target_os = "windows")]
+pub const CLEAR_INPUT: &str = "\x03";
+const CARRIAGE_RETURN: &str = "\x0d";
+
+struct TerminalTransaction {
+    terminal: Entity<Terminal>,
+}
+
+impl TerminalTransaction {
+    pub fn start(terminal: Entity<Terminal>) -> Self {
+        Self { terminal }
+    }
+
+    pub fn push(&mut self, hunk: String, cx: &mut App) {
+        // Ensure that the assistant cannot accidentally execute commands that are streamed into the terminal
+        let input = Self::sanitize_input(hunk);
+        self.terminal
+            .update(cx, |terminal, _| terminal.input(input));
+    }
+
+    pub fn undo(&self, cx: &mut App) {
+        self.terminal
+            .update(cx, |terminal, _| terminal.input(CLEAR_INPUT.to_string()));
+    }
+
+    pub fn complete(&self, cx: &mut App) {
+        self.terminal.update(cx, |terminal, _| {
+            terminal.input(CARRIAGE_RETURN.to_string())
+        });
+    }
+
+    fn sanitize_input(input: String) -> String {
+        input.replace(['\r', '\n'], "")
+    }
+}

crates/agent/src/terminal_inline_assistant.rs

@@ -0,0 +1,441 @@
+use crate::context::attach_context_to_message;
+use crate::context_store::ContextStore;
+use crate::inline_prompt_editor::{
+    CodegenStatus, PromptEditor, PromptEditorEvent, TerminalInlineAssistId,
+};
+use crate::terminal_codegen::{CLEAR_INPUT, CodegenEvent, TerminalCodegen};
+use crate::thread_store::ThreadStore;
+use anyhow::{Context as _, Result};
+use client::telemetry::Telemetry;
+use collections::{HashMap, VecDeque};
+use editor::{MultiBuffer, actions::SelectAll};
+use fs::Fs;
+use gpui::{App, Entity, Focusable, Global, Subscription, UpdateGlobal, WeakEntity};
+use language::Buffer;
+use language_model::{
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    report_assistant_event,
+};
+use prompt_store::PromptBuilder;
+use std::sync::Arc;
+use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use terminal_view::TerminalView;
+use ui::prelude::*;
+use util::ResultExt;
+use workspace::{Toast, Workspace, notifications::NotificationId};
+
+pub fn init(
+    fs: Arc<dyn Fs>,
+    prompt_builder: Arc<PromptBuilder>,
+    telemetry: Arc<Telemetry>,
+    cx: &mut App,
+) {
+    cx.set_global(TerminalInlineAssistant::new(fs, prompt_builder, telemetry));
+}
+
+const DEFAULT_CONTEXT_LINES: usize = 50;
+const PROMPT_HISTORY_MAX_LEN: usize = 20;
+
+pub struct TerminalInlineAssistant {
+    next_assist_id: TerminalInlineAssistId,
+    assists: HashMap<TerminalInlineAssistId, TerminalInlineAssist>,
+    prompt_history: VecDeque<String>,
+    telemetry: Option<Arc<Telemetry>>,
+    fs: Arc<dyn Fs>,
+    prompt_builder: Arc<PromptBuilder>,
+}
+
+impl Global for TerminalInlineAssistant {}
+
+impl TerminalInlineAssistant {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        prompt_builder: Arc<PromptBuilder>,
+        telemetry: Arc<Telemetry>,
+    ) -> Self {
+        Self {
+            next_assist_id: TerminalInlineAssistId::default(),
+            assists: HashMap::default(),
+            prompt_history: VecDeque::default(),
+            telemetry: Some(telemetry),
+            fs,
+            prompt_builder,
+        }
+    }
+
+    pub fn assist(
+        &mut self,
+        terminal_view: &Entity<TerminalView>,
+        workspace: WeakEntity<Workspace>,
+        thread_store: Option<WeakEntity<ThreadStore>>,
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        let terminal = terminal_view.read(cx).terminal().clone();
+        let assist_id = self.next_assist_id.post_inc();
+        let prompt_buffer =
+            cx.new(|cx| MultiBuffer::singleton(cx.new(|cx| Buffer::local(String::new(), cx)), cx));
+        let context_store =
+            cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+        let codegen = cx.new(|_| TerminalCodegen::new(terminal, self.telemetry.clone()));
+
+        let prompt_editor = cx.new(|cx| {
+            PromptEditor::new_terminal(
+                assist_id,
+                self.prompt_history.clone(),
+                prompt_buffer.clone(),
+                codegen,
+                self.fs.clone(),
+                context_store.clone(),
+                workspace.clone(),
+                thread_store.clone(),
+                window,
+                cx,
+            )
+        });
+        let prompt_editor_render = prompt_editor.clone();
+        let block = terminal_view::BlockProperties {
+            height: 2,
+            render: Box::new(move |_| prompt_editor_render.clone().into_any_element()),
+        };
+        terminal_view.update(cx, |terminal_view, cx| {
+            terminal_view.set_block_below_cursor(block, window, cx);
+        });
+
+        let terminal_assistant = TerminalInlineAssist::new(
+            assist_id,
+            terminal_view,
+            prompt_editor,
+            workspace.clone(),
+            context_store,
+            window,
+            cx,
+        );
+
+        self.assists.insert(assist_id, terminal_assistant);
+
+        self.focus_assist(assist_id, window, cx);
+    }
+
+    fn focus_assist(
+        &mut self,
+        assist_id: TerminalInlineAssistId,
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        let assist = &self.assists[&assist_id];
+        if let Some(prompt_editor) = assist.prompt_editor.as_ref() {
+            prompt_editor.update(cx, |this, cx| {
+                this.editor.update(cx, |editor, cx| {
+                    window.focus(&editor.focus_handle(cx));
+                    editor.select_all(&SelectAll, window, cx);
+                });
+            });
+        }
+    }
+
+    fn handle_prompt_editor_event(
+        &mut self,
+        prompt_editor: Entity<PromptEditor<TerminalCodegen>>,
+        event: &PromptEditorEvent,
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        let assist_id = prompt_editor.read(cx).id();
+        match event {
+            PromptEditorEvent::StartRequested => {
+                self.start_assist(assist_id, cx);
+            }
+            PromptEditorEvent::StopRequested => {
+                self.stop_assist(assist_id, cx);
+            }
+            PromptEditorEvent::ConfirmRequested { execute } => {
+                self.finish_assist(assist_id, false, *execute, window, cx);
+            }
+            PromptEditorEvent::CancelRequested => {
+                self.finish_assist(assist_id, true, false, window, cx);
+            }
+            PromptEditorEvent::DismissRequested => {
+                self.dismiss_assist(assist_id, window, cx);
+            }
+            PromptEditorEvent::Resized { height_in_lines } => {
+                self.insert_prompt_editor_into_terminal(assist_id, *height_in_lines, window, cx);
+            }
+        }
+    }
+
+    fn start_assist(&mut self, assist_id: TerminalInlineAssistId, cx: &mut App) {
+        let assist = if let Some(assist) = self.assists.get_mut(&assist_id) {
+            assist
+        } else {
+            return;
+        };
+
+        let Some(user_prompt) = assist
+            .prompt_editor
+            .as_ref()
+            .map(|editor| editor.read(cx).prompt(cx))
+        else {
+            return;
+        };
+
+        self.prompt_history.retain(|prompt| *prompt != user_prompt);
+        self.prompt_history.push_back(user_prompt.clone());
+        if self.prompt_history.len() > PROMPT_HISTORY_MAX_LEN {
+            self.prompt_history.pop_front();
+        }
+
+        assist
+            .terminal
+            .update(cx, |terminal, cx| {
+                terminal
+                    .terminal()
+                    .update(cx, |terminal, _| terminal.input(CLEAR_INPUT.to_string()));
+            })
+            .log_err();
+
+        let codegen = assist.codegen.clone();
+        let Some(request) = self.request_for_inline_assist(assist_id, cx).log_err() else {
+            return;
+        };
+
+        codegen.update(cx, |codegen, cx| codegen.start(request, cx));
+    }
+
+    fn stop_assist(&mut self, assist_id: TerminalInlineAssistId, cx: &mut App) {
+        let assist = if let Some(assist) = self.assists.get_mut(&assist_id) {
+            assist
+        } else {
+            return;
+        };
+
+        assist.codegen.update(cx, |codegen, cx| codegen.stop(cx));
+    }
+
+    fn request_for_inline_assist(
+        &self,
+        assist_id: TerminalInlineAssistId,
+        cx: &mut App,
+    ) -> Result<LanguageModelRequest> {
+        let assist = self.assists.get(&assist_id).context("invalid assist")?;
+
+        let shell = std::env::var("SHELL").ok();
+        let (latest_output, working_directory) = assist
+            .terminal
+            .update(cx, |terminal, cx| {
+                let terminal = terminal.entity().read(cx);
+                let latest_output = terminal.last_n_non_empty_lines(DEFAULT_CONTEXT_LINES);
+                let working_directory = terminal
+                    .working_directory()
+                    .map(|path| path.to_string_lossy().to_string());
+                (latest_output, working_directory)
+            })
+            .ok()
+            .unwrap_or_default();
+
+        let prompt = self.prompt_builder.generate_terminal_assistant_prompt(
+            &assist
+                .prompt_editor
+                .clone()
+                .context("invalid assist")?
+                .read(cx)
+                .prompt(cx),
+            shell.as_deref(),
+            working_directory.as_deref(),
+            &latest_output,
+        )?;
+
+        let mut request_message = LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec![],
+            cache: false,
+        };
+
+        attach_context_to_message(
+            &mut request_message,
+            assist.context_store.read(cx).context().iter(),
+            cx,
+        );
+
+        request_message.content.push(prompt.into());
+
+        Ok(LanguageModelRequest {
+            messages: vec![request_message],
+            tools: Vec::new(),
+            stop: Vec::new(),
+            temperature: None,
+        })
+    }
+
+    fn finish_assist(
+        &mut self,
+        assist_id: TerminalInlineAssistId,
+        undo: bool,
+        execute: bool,
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        self.dismiss_assist(assist_id, window, cx);
+
+        if let Some(assist) = self.assists.remove(&assist_id) {
+            assist
+                .terminal
+                .update(cx, |this, cx| {
+                    this.clear_block_below_cursor(cx);
+                    this.focus_handle(cx).focus(window);
+                })
+                .log_err();
+
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                let codegen = assist.codegen.read(cx);
+                let executor = cx.background_executor().clone();
+                report_assistant_event(
+                    AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::InlineTerminal,
+                        message_id: codegen.message_id.clone(),
+                        phase: if undo {
+                            AssistantPhase::Rejected
+                        } else {
+                            AssistantPhase::Accepted
+                        },
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
+                        response_latency: None,
+                        error_message: None,
+                        language_name: None,
+                    },
+                    codegen.telemetry.clone(),
+                    cx.http_client(),
+                    model.api_key(cx),
+                    &executor,
+                );
+            }
+
+            assist.codegen.update(cx, |codegen, cx| {
+                if undo {
+                    codegen.undo(cx);
+                } else if execute {
+                    codegen.complete(cx);
+                }
+            });
+        }
+    }
+
+    fn dismiss_assist(
+        &mut self,
+        assist_id: TerminalInlineAssistId,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> bool {
+        let Some(assist) = self.assists.get_mut(&assist_id) else {
+            return false;
+        };
+        if assist.prompt_editor.is_none() {
+            return false;
+        }
+        assist.prompt_editor = None;
+        assist
+            .terminal
+            .update(cx, |this, cx| {
+                this.clear_block_below_cursor(cx);
+                this.focus_handle(cx).focus(window);
+            })
+            .is_ok()
+    }
+
+    fn insert_prompt_editor_into_terminal(
+        &mut self,
+        assist_id: TerminalInlineAssistId,
+        height: u8,
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        if let Some(assist) = self.assists.get_mut(&assist_id) {
+            if let Some(prompt_editor) = assist.prompt_editor.as_ref().cloned() {
+                assist
+                    .terminal
+                    .update(cx, |terminal, cx| {
+                        terminal.clear_block_below_cursor(cx);
+                        let block = terminal_view::BlockProperties {
+                            height,
+                            render: Box::new(move |_| prompt_editor.clone().into_any_element()),
+                        };
+                        terminal.set_block_below_cursor(block, window, cx);
+                    })
+                    .log_err();
+            }
+        }
+    }
+}
+
+struct TerminalInlineAssist {
+    terminal: WeakEntity<TerminalView>,
+    prompt_editor: Option<Entity<PromptEditor<TerminalCodegen>>>,
+    codegen: Entity<TerminalCodegen>,
+    workspace: WeakEntity<Workspace>,
+    context_store: Entity<ContextStore>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl TerminalInlineAssist {
+    pub fn new(
+        assist_id: TerminalInlineAssistId,
+        terminal: &Entity<TerminalView>,
+        prompt_editor: Entity<PromptEditor<TerminalCodegen>>,
+        workspace: WeakEntity<Workspace>,
+        context_store: Entity<ContextStore>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Self {
+        let codegen = prompt_editor.read(cx).codegen().clone();
+        Self {
+            terminal: terminal.downgrade(),
+            prompt_editor: Some(prompt_editor.clone()),
+            codegen: codegen.clone(),
+            workspace: workspace.clone(),
+            context_store,
+            _subscriptions: vec![
+                window.subscribe(&prompt_editor, cx, |prompt_editor, event, window, cx| {
+                    TerminalInlineAssistant::update_global(cx, |this, cx| {
+                        this.handle_prompt_editor_event(prompt_editor, event, window, cx)
+                    })
+                }),
+                window.subscribe(&codegen, cx, move |codegen, event, window, cx| {
+                    TerminalInlineAssistant::update_global(cx, |this, cx| match event {
+                        CodegenEvent::Finished => {
+                            let assist = if let Some(assist) = this.assists.get(&assist_id) {
+                                assist
+                            } else {
+                                return;
+                            };
+
+                            if let CodegenStatus::Error(error) = &codegen.read(cx).status {
+                                if assist.prompt_editor.is_none() {
+                                    if let Some(workspace) = assist.workspace.upgrade() {
+                                        let error =
+                                            format!("Terminal inline assistant error: {}", error);
+                                        workspace.update(cx, |workspace, cx| {
+                                            struct InlineAssistantError;
+
+                                            let id =
+                                                NotificationId::composite::<InlineAssistantError>(
+                                                    assist_id.0,
+                                                );
+
+                                            workspace.show_toast(Toast::new(id, error), cx);
+                                        })
+                                    }
+                                }
+                            }
+
+                            if assist.prompt_editor.is_none() {
+                                this.finish_assist(assist_id, false, false, window, cx);
+                            }
+                        }
+                    })
+                }),
+            ],
+        }
+    }
+}

crates/agent/src/thread_history.rs

@@ -0,0 +1,411 @@
+use assistant_context_editor::SavedContextMetadata;
+use gpui::{
+    App, Entity, FocusHandle, Focusable, ScrollStrategy, UniformListScrollHandle, WeakEntity,
+    uniform_list,
+};
+use time::{OffsetDateTime, UtcOffset};
+use ui::{IconButtonShape, ListItem, ListItemSpacing, Tooltip, prelude::*};
+
+use crate::history_store::{HistoryEntry, HistoryStore};
+use crate::thread_store::SerializedThreadMetadata;
+use crate::{AssistantPanel, RemoveSelectedThread};
+
+pub struct ThreadHistory {
+    focus_handle: FocusHandle,
+    assistant_panel: WeakEntity<AssistantPanel>,
+    history_store: Entity<HistoryStore>,
+    scroll_handle: UniformListScrollHandle,
+    selected_index: usize,
+}
+
+impl ThreadHistory {
+    pub(crate) fn new(
+        assistant_panel: WeakEntity<AssistantPanel>,
+        history_store: Entity<HistoryStore>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+            assistant_panel,
+            history_store,
+            scroll_handle: UniformListScrollHandle::default(),
+            selected_index: 0,
+        }
+    }
+
+    pub fn select_previous(
+        &mut self,
+        _: &menu::SelectPrevious,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            if self.selected_index == 0 {
+                self.set_selected_index(count - 1, window, cx);
+            } else {
+                self.set_selected_index(self.selected_index - 1, window, cx);
+            }
+        }
+    }
+
+    pub fn select_next(
+        &mut self,
+        _: &menu::SelectNext,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            if self.selected_index == count - 1 {
+                self.set_selected_index(0, window, cx);
+            } else {
+                self.set_selected_index(self.selected_index + 1, window, cx);
+            }
+        }
+    }
+
+    fn select_first(&mut self, _: &menu::SelectFirst, window: &mut Window, cx: &mut Context<Self>) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            self.set_selected_index(0, window, cx);
+        }
+    }
+
+    fn select_last(&mut self, _: &menu::SelectLast, window: &mut Window, cx: &mut Context<Self>) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            self.set_selected_index(count - 1, window, cx);
+        }
+    }
+
+    fn set_selected_index(&mut self, index: usize, _window: &mut Window, cx: &mut Context<Self>) {
+        self.selected_index = index;
+        self.scroll_handle
+            .scroll_to_item(index, ScrollStrategy::Top);
+        cx.notify();
+    }
+
+    fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
+        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+
+        if let Some(entry) = entries.get(self.selected_index) {
+            match entry {
+                HistoryEntry::Thread(thread) => {
+                    self.assistant_panel
+                        .update(cx, move |this, cx| this.open_thread(&thread.id, window, cx))
+                        .ok();
+                }
+                HistoryEntry::Context(context) => {
+                    self.assistant_panel
+                        .update(cx, move |this, cx| {
+                            this.open_saved_prompt_editor(context.path.clone(), window, cx)
+                        })
+                        .ok();
+                }
+            }
+
+            cx.notify();
+        }
+    }
+
+    fn remove_selected_thread(
+        &mut self,
+        _: &RemoveSelectedThread,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+
+        if let Some(entry) = entries.get(self.selected_index) {
+            match entry {
+                HistoryEntry::Thread(thread) => {
+                    self.assistant_panel
+                        .update(cx, |this, cx| {
+                            this.delete_thread(&thread.id, cx);
+                        })
+                        .ok();
+                }
+                HistoryEntry::Context(context) => {
+                    self.assistant_panel
+                        .update(cx, |this, cx| {
+                            this.delete_context(context.path.clone(), cx);
+                        })
+                        .ok();
+                }
+            }
+
+            cx.notify();
+        }
+    }
+}
+
+impl Focusable for ThreadHistory {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for ThreadHistory {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let history_entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+        let selected_index = self.selected_index;
+
+        v_flex()
+            .id("thread-history-container")
+            .key_context("ThreadHistory")
+            .track_focus(&self.focus_handle)
+            .overflow_y_scroll()
+            .size_full()
+            .p_1()
+            .on_action(cx.listener(Self::select_previous))
+            .on_action(cx.listener(Self::select_next))
+            .on_action(cx.listener(Self::select_first))
+            .on_action(cx.listener(Self::select_last))
+            .on_action(cx.listener(Self::confirm))
+            .on_action(cx.listener(Self::remove_selected_thread))
+            .map(|history| {
+                if history_entries.is_empty() {
+                    history
+                        .justify_center()
+                        .child(
+                            h_flex().w_full().justify_center().child(
+                                Label::new("You don't have any past threads yet.")
+                                    .size(LabelSize::Small),
+                            ),
+                        )
+                } else {
+                    history.child(
+                        uniform_list(
+                            cx.entity().clone(),
+                            "thread-history",
+                            history_entries.len(),
+                            move |history, range, _window, _cx| {
+                                history_entries[range]
+                                    .iter()
+                                    .enumerate()
+                                    .map(|(index, entry)| {
+                                        h_flex().w_full().pb_1().child(match entry {
+                                            HistoryEntry::Thread(thread) => PastThread::new(
+                                                thread.clone(),
+                                                history.assistant_panel.clone(),
+                                                selected_index == index,
+                                            )
+                                            .into_any_element(),
+                                            HistoryEntry::Context(context) => PastContext::new(
+                                                context.clone(),
+                                                history.assistant_panel.clone(),
+                                                selected_index == index,
+                                            )
+                                            .into_any_element(),
+                                        })
+                                    })
+                                    .collect()
+                            },
+                        )
+                        .track_scroll(self.scroll_handle.clone())
+                        .flex_grow(),
+                    )
+                }
+            })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct PastThread {
+    thread: SerializedThreadMetadata,
+    assistant_panel: WeakEntity<AssistantPanel>,
+    selected: bool,
+}
+
+impl PastThread {
+    pub fn new(
+        thread: SerializedThreadMetadata,
+        assistant_panel: WeakEntity<AssistantPanel>,
+        selected: bool,
+    ) -> Self {
+        Self {
+            thread,
+            assistant_panel,
+            selected,
+        }
+    }
+}
+
+impl RenderOnce for PastThread {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let summary = self.thread.summary;
+
+        let thread_timestamp = time_format::format_localized_timestamp(
+            OffsetDateTime::from_unix_timestamp(self.thread.updated_at.timestamp()).unwrap(),
+            OffsetDateTime::now_utc(),
+            self.assistant_panel
+                .update(cx, |this, _cx| this.local_timezone())
+                .unwrap_or(UtcOffset::UTC),
+            time_format::TimestampFormat::EnhancedAbsolute,
+        );
+
+        ListItem::new(SharedString::from(self.thread.id.to_string()))
+            .rounded()
+            .toggle_state(self.selected)
+            .spacing(ListItemSpacing::Sparse)
+            .start_slot(
+                div()
+                    .max_w_4_5()
+                    .child(Label::new(summary).size(LabelSize::Small).truncate()),
+            )
+            .end_slot(
+                h_flex()
+                    .gap_1p5()
+                    .child(
+                        Label::new("Thread")
+                            .color(Color::Muted)
+                            .size(LabelSize::XSmall),
+                    )
+                    .child(
+                        div()
+                            .size(px(3.))
+                            .rounded_full()
+                            .bg(cx.theme().colors().text_disabled),
+                    )
+                    .child(
+                        Label::new(thread_timestamp)
+                            .color(Color::Muted)
+                            .size(LabelSize::XSmall),
+                    )
+                    .child(
+                        IconButton::new("delete", IconName::TrashAlt)
+                            .shape(IconButtonShape::Square)
+                            .icon_size(IconSize::XSmall)
+                            .tooltip(Tooltip::text("Delete Thread"))
+                            .on_click({
+                                let assistant_panel = self.assistant_panel.clone();
+                                let id = self.thread.id.clone();
+                                move |_event, _window, cx| {
+                                    assistant_panel
+                                        .update(cx, |this, cx| {
+                                            this.delete_thread(&id, cx);
+                                        })
+                                        .ok();
+                                }
+                            }),
+                    ),
+            )
+            .on_click({
+                let assistant_panel = self.assistant_panel.clone();
+                let id = self.thread.id.clone();
+                move |_event, window, cx| {
+                    assistant_panel
+                        .update(cx, |this, cx| {
+                            this.open_thread(&id, window, cx).detach_and_log_err(cx);
+                        })
+                        .ok();
+                }
+            })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct PastContext {
+    context: SavedContextMetadata,
+    assistant_panel: WeakEntity<AssistantPanel>,
+    selected: bool,
+}
+
+impl PastContext {
+    pub fn new(
+        context: SavedContextMetadata,
+        assistant_panel: WeakEntity<AssistantPanel>,
+        selected: bool,
+    ) -> Self {
+        Self {
+            context,
+            assistant_panel,
+            selected,
+        }
+    }
+}
+
+impl RenderOnce for PastContext {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let summary = self.context.title;
+
+        let context_timestamp = time_format::format_localized_timestamp(
+            OffsetDateTime::from_unix_timestamp(self.context.mtime.timestamp()).unwrap(),
+            OffsetDateTime::now_utc(),
+            self.assistant_panel
+                .update(cx, |this, _cx| this.local_timezone())
+                .unwrap_or(UtcOffset::UTC),
+            time_format::TimestampFormat::EnhancedAbsolute,
+        );
+
+        ListItem::new(SharedString::from(
+            self.context.path.to_string_lossy().to_string(),
+        ))
+        .rounded()
+        .toggle_state(self.selected)
+        .spacing(ListItemSpacing::Sparse)
+        .start_slot(
+            div()
+                .max_w_4_5()
+                .child(Label::new(summary).size(LabelSize::Small).truncate()),
+        )
+        .end_slot(
+            h_flex()
+                .gap_1p5()
+                .child(
+                    Label::new("Prompt Editor")
+                        .color(Color::Muted)
+                        .size(LabelSize::XSmall),
+                )
+                .child(
+                    div()
+                        .size(px(3.))
+                        .rounded_full()
+                        .bg(cx.theme().colors().text_disabled),
+                )
+                .child(
+                    Label::new(context_timestamp)
+                        .color(Color::Muted)
+                        .size(LabelSize::XSmall),
+                )
+                .child(
+                    IconButton::new("delete", IconName::TrashAlt)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::XSmall)
+                        .tooltip(Tooltip::text("Delete Prompt Editor"))
+                        .on_click({
+                            let assistant_panel = self.assistant_panel.clone();
+                            let path = self.context.path.clone();
+                            move |_event, _window, cx| {
+                                assistant_panel
+                                    .update(cx, |this, cx| {
+                                        this.delete_context(path.clone(), cx);
+                                    })
+                                    .ok();
+                            }
+                        }),
+                ),
+        )
+        .on_click({
+            let assistant_panel = self.assistant_panel.clone();
+            let path = self.context.path.clone();
+            move |_event, window, cx| {
+                assistant_panel
+                    .update(cx, |this, cx| {
+                        this.open_saved_prompt_editor(path.clone(), window, cx)
+                            .detach_and_log_err(cx);
+                    })
+                    .ok();
+            }
+        })
+    }
+}

crates/agent/src/thread_store.rs

@@ -0,0 +1,576 @@
+use std::borrow::Cow;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use anyhow::{Result, anyhow};
+use assistant_settings::{AgentProfile, AssistantSettings};
+use assistant_tool::{ToolId, ToolSource, ToolWorkingSet};
+use chrono::{DateTime, Utc};
+use collections::HashMap;
+use context_server::manager::ContextServerManager;
+use context_server::{ContextServerFactoryRegistry, ContextServerTool};
+use futures::FutureExt as _;
+use futures::future::{self, BoxFuture, Shared};
+use gpui::{
+    App, BackgroundExecutor, Context, Entity, Global, ReadGlobal, SharedString, Subscription, Task,
+    prelude::*,
+};
+use heed::Database;
+use heed::types::SerdeBincode;
+use language_model::{LanguageModelToolUseId, Role, TokenUsage};
+use project::Project;
+use prompt_store::PromptBuilder;
+use serde::{Deserialize, Serialize};
+use settings::{Settings as _, SettingsStore};
+use util::ResultExt as _;
+
+use crate::thread::{
+    DetailedSummaryState, MessageId, ProjectSnapshot, Thread, ThreadEvent, ThreadId,
+};
+
+pub fn init(cx: &mut App) {
+    ThreadsDatabase::init(cx);
+}
+
+pub struct ThreadStore {
+    project: Entity<Project>,
+    tools: Arc<ToolWorkingSet>,
+    prompt_builder: Arc<PromptBuilder>,
+    context_server_manager: Entity<ContextServerManager>,
+    context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
+    threads: Vec<SerializedThreadMetadata>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl ThreadStore {
+    pub fn new(
+        project: Entity<Project>,
+        tools: Arc<ToolWorkingSet>,
+        prompt_builder: Arc<PromptBuilder>,
+        cx: &mut App,
+    ) -> Result<Entity<Self>> {
+        let this = cx.new(|cx| {
+            let context_server_factory_registry = ContextServerFactoryRegistry::default_global(cx);
+            let context_server_manager = cx.new(|cx| {
+                ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
+            });
+            let settings_subscription =
+                cx.observe_global::<SettingsStore>(move |this: &mut Self, cx| {
+                    this.load_default_profile(cx);
+                });
+
+            let this = Self {
+                project,
+                tools,
+                prompt_builder,
+                context_server_manager,
+                context_server_tool_ids: HashMap::default(),
+                threads: Vec::new(),
+                _subscriptions: vec![settings_subscription],
+            };
+            this.load_default_profile(cx);
+            this.register_context_server_handlers(cx);
+            this.reload(cx).detach_and_log_err(cx);
+
+            this
+        });
+
+        Ok(this)
+    }
+
+    pub fn context_server_manager(&self) -> Entity<ContextServerManager> {
+        self.context_server_manager.clone()
+    }
+
+    pub fn tools(&self) -> Arc<ToolWorkingSet> {
+        self.tools.clone()
+    }
+
+    /// Returns the number of threads.
+    pub fn thread_count(&self) -> usize {
+        self.threads.len()
+    }
+
+    pub fn threads(&self) -> Vec<SerializedThreadMetadata> {
+        let mut threads = self.threads.iter().cloned().collect::<Vec<_>>();
+        threads.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.updated_at));
+        threads
+    }
+
+    pub fn recent_threads(&self, limit: usize) -> Vec<SerializedThreadMetadata> {
+        self.threads().into_iter().take(limit).collect()
+    }
+
+    pub fn create_thread(&mut self, cx: &mut Context<Self>) -> Entity<Thread> {
+        cx.new(|cx| {
+            Thread::new(
+                self.project.clone(),
+                self.tools.clone(),
+                self.prompt_builder.clone(),
+                cx,
+            )
+        })
+    }
+
+    pub fn open_thread(
+        &self,
+        id: &ThreadId,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Entity<Thread>>> {
+        let id = id.clone();
+        let database_future = ThreadsDatabase::global_future(cx);
+        cx.spawn(async move |this, cx| {
+            let database = database_future.await.map_err(|err| anyhow!(err))?;
+            let thread = database
+                .try_find_thread(id.clone())
+                .await?
+                .ok_or_else(|| anyhow!("no thread found with ID: {id:?}"))?;
+
+            let thread = this.update(cx, |this, cx| {
+                cx.new(|cx| {
+                    Thread::deserialize(
+                        id.clone(),
+                        thread,
+                        this.project.clone(),
+                        this.tools.clone(),
+                        this.prompt_builder.clone(),
+                        cx,
+                    )
+                })
+            })?;
+
+            let (system_prompt_context, load_error) = thread
+                .update(cx, |thread, cx| thread.load_system_prompt_context(cx))?
+                .await;
+            thread.update(cx, |thread, cx| {
+                thread.set_system_prompt_context(system_prompt_context);
+                if let Some(load_error) = load_error {
+                    cx.emit(ThreadEvent::ShowError(load_error));
+                }
+            })?;
+
+            Ok(thread)
+        })
+    }
+
+    pub fn save_thread(&self, thread: &Entity<Thread>, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let (metadata, serialized_thread) =
+            thread.update(cx, |thread, cx| (thread.id().clone(), thread.serialize(cx)));
+
+        let database_future = ThreadsDatabase::global_future(cx);
+        cx.spawn(async move |this, cx| {
+            let serialized_thread = serialized_thread.await?;
+            let database = database_future.await.map_err(|err| anyhow!(err))?;
+            database.save_thread(metadata, serialized_thread).await?;
+
+            this.update(cx, |this, cx| this.reload(cx))?.await
+        })
+    }
+
+    pub fn delete_thread(&mut self, id: &ThreadId, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let id = id.clone();
+        let database_future = ThreadsDatabase::global_future(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.threads.retain(|thread| thread.id != id)
+            })
+        })
+    }
+
+    pub fn reload(&self, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let database_future = ThreadsDatabase::global_future(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| {
+                this.threads = threads;
+                cx.notify();
+            })
+        })
+    }
+
+    fn load_default_profile(&self, cx: &Context<Self>) {
+        let assistant_settings = AssistantSettings::get_global(cx);
+
+        self.load_profile_by_id(&assistant_settings.default_profile, cx);
+    }
+
+    pub fn load_profile_by_id(&self, profile_id: &Arc<str>, cx: &Context<Self>) {
+        let assistant_settings = AssistantSettings::get_global(cx);
+
+        if let Some(profile) = assistant_settings.profiles.get(profile_id) {
+            self.load_profile(profile, cx);
+        }
+    }
+
+    pub fn load_profile(&self, profile: &AgentProfile, cx: &Context<Self>) {
+        self.tools.disable_all_tools();
+        self.tools.enable(
+            ToolSource::Native,
+            &profile
+                .tools
+                .iter()
+                .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
+                .collect::<Vec<_>>(),
+        );
+
+        if profile.enable_all_context_servers {
+            for context_server in self.context_server_manager.read(cx).all_servers() {
+                self.tools.enable_source(
+                    ToolSource::ContextServer {
+                        id: context_server.id().into(),
+                    },
+                    cx,
+                );
+            }
+        } else {
+            for (context_server_id, preset) in &profile.context_servers {
+                self.tools.enable(
+                    ToolSource::ContextServer {
+                        id: context_server_id.clone().into(),
+                    },
+                    &preset
+                        .tools
+                        .iter()
+                        .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
+                        .collect::<Vec<_>>(),
+                )
+            }
+        }
+    }
+
+    fn register_context_server_handlers(&self, cx: &mut Context<Self>) {
+        cx.subscribe(
+            &self.context_server_manager.clone(),
+            Self::handle_context_server_event,
+        )
+        .detach();
+    }
+
+    fn handle_context_server_event(
+        &mut self,
+        context_server_manager: Entity<ContextServerManager>,
+        event: &context_server::manager::Event,
+        cx: &mut Context<Self>,
+    ) {
+        let tool_working_set = self.tools.clone();
+        match event {
+            context_server::manager::Event::ServerStarted { server_id } => {
+                if let Some(server) = context_server_manager.read(cx).get_server(server_id) {
+                    let context_server_manager = context_server_manager.clone();
+                    cx.spawn({
+                        let server = server.clone();
+                        let server_id = server_id.clone();
+                        async move |this, cx| {
+                            let Some(protocol) = server.client() else {
+                                return;
+                            };
+
+                            if protocol.capable(context_server::protocol::ServerCapability::Tools) {
+                                if let Some(tools) = protocol.list_tools().await.log_err() {
+                                    let tool_ids = tools
+                                        .tools
+                                        .into_iter()
+                                        .map(|tool| {
+                                            log::info!(
+                                                "registering context server tool: {:?}",
+                                                tool.name
+                                            );
+                                            tool_working_set.insert(Arc::new(
+                                                ContextServerTool::new(
+                                                    context_server_manager.clone(),
+                                                    server.id(),
+                                                    tool,
+                                                ),
+                                            ))
+                                        })
+                                        .collect::<Vec<_>>();
+
+                                    this.update(cx, |this, cx| {
+                                        this.context_server_tool_ids.insert(server_id, tool_ids);
+                                        this.load_default_profile(cx);
+                                    })
+                                    .log_err();
+                                }
+                            }
+                        }
+                    })
+                    .detach();
+                }
+            }
+            context_server::manager::Event::ServerStopped { server_id } => {
+                if let Some(tool_ids) = self.context_server_tool_ids.remove(server_id) {
+                    tool_working_set.remove(&tool_ids);
+                    self.load_default_profile(cx);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SerializedThreadMetadata {
+    pub id: ThreadId,
+    pub summary: SharedString,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct SerializedThread {
+    pub version: String,
+    pub summary: SharedString,
+    pub updated_at: DateTime<Utc>,
+    pub messages: Vec<SerializedMessage>,
+    #[serde(default)]
+    pub initial_project_snapshot: Option<Arc<ProjectSnapshot>>,
+    #[serde(default)]
+    pub cumulative_token_usage: TokenUsage,
+    #[serde(default)]
+    pub detailed_summary_state: DetailedSummaryState,
+}
+
+impl SerializedThread {
+    pub const VERSION: &'static str = "0.1.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() {
+                SerializedThread::VERSION => Ok(serde_json::from_value::<SerializedThread>(
+                    saved_thread_json,
+                )?),
+                _ => Err(anyhow!(
+                    "unrecognized serialized thread version: {}",
+                    version
+                )),
+            },
+            None => {
+                let saved_thread =
+                    serde_json::from_value::<LegacySerializedThread>(saved_thread_json)?;
+                Ok(saved_thread.upgrade())
+            }
+            version => Err(anyhow!(
+                "unrecognized serialized thread version: {:?}",
+                version
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SerializedMessage {
+    pub id: MessageId,
+    pub role: Role,
+    #[serde(default)]
+    pub segments: Vec<SerializedMessageSegment>,
+    #[serde(default)]
+    pub tool_uses: Vec<SerializedToolUse>,
+    #[serde(default)]
+    pub tool_results: Vec<SerializedToolResult>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum SerializedMessageSegment {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "thinking")]
+    Thinking { text: String },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SerializedToolUse {
+    pub id: LanguageModelToolUseId,
+    pub name: SharedString,
+    pub input: serde_json::Value,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SerializedToolResult {
+    pub tool_use_id: LanguageModelToolUseId,
+    pub is_error: bool,
+    pub content: Arc<str>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct LegacySerializedThread {
+    pub summary: SharedString,
+    pub updated_at: DateTime<Utc>,
+    pub messages: Vec<LegacySerializedMessage>,
+    #[serde(default)]
+    pub initial_project_snapshot: Option<Arc<ProjectSnapshot>>,
+}
+
+impl LegacySerializedThread {
+    pub fn upgrade(self) -> SerializedThread {
+        SerializedThread {
+            version: SerializedThread::VERSION.to_string(),
+            summary: self.summary,
+            updated_at: self.updated_at,
+            messages: self.messages.into_iter().map(|msg| msg.upgrade()).collect(),
+            initial_project_snapshot: self.initial_project_snapshot,
+            cumulative_token_usage: TokenUsage::default(),
+            detailed_summary_state: DetailedSummaryState::default(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct LegacySerializedMessage {
+    pub id: MessageId,
+    pub role: Role,
+    pub text: String,
+    #[serde(default)]
+    pub tool_uses: Vec<SerializedToolUse>,
+    #[serde(default)]
+    pub tool_results: Vec<SerializedToolResult>,
+}
+
+impl LegacySerializedMessage {
+    fn upgrade(self) -> SerializedMessage {
+        SerializedMessage {
+            id: self.id,
+            role: self.role,
+            segments: vec![SerializedMessageSegment::Text { text: self.text }],
+            tool_uses: self.tool_uses,
+            tool_results: self.tool_results,
+        }
+    }
+}
+
+struct GlobalThreadsDatabase(
+    Shared<BoxFuture<'static, Result<Arc<ThreadsDatabase>, Arc<anyhow::Error>>>>,
+);
+
+impl Global for GlobalThreadsDatabase {}
+
+pub(crate) struct ThreadsDatabase {
+    executor: BackgroundExecutor,
+    env: heed::Env,
+    threads: Database<SerdeBincode<ThreadId>, SerializedThread>,
+}
+
+impl heed::BytesEncode<'_> for SerializedThread {
+    type EItem = SerializedThread;
+
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, heed::BoxedError> {
+        serde_json::to_vec(item).map(Cow::Owned).map_err(Into::into)
+    }
+}
+
+impl<'a> heed::BytesDecode<'a> for SerializedThread {
+    type DItem = SerializedThread;
+
+    fn bytes_decode(bytes: &'a [u8]) -> Result<Self::DItem, heed::BoxedError> {
+        // We implement this type manually because we want to call `SerializedThread::from_json`,
+        // instead of the Deserialize trait implementation for `SerializedThread`.
+        SerializedThread::from_json(bytes).map_err(Into::into)
+    }
+}
+
+impl ThreadsDatabase {
+    fn global_future(
+        cx: &mut App,
+    ) -> Shared<BoxFuture<'static, Result<Arc<ThreadsDatabase>, Arc<anyhow::Error>>>> {
+        GlobalThreadsDatabase::global(cx).0.clone()
+    }
+
+    fn init(cx: &mut App) {
+        let executor = cx.background_executor().clone();
+        let database_future = executor
+            .spawn({
+                let executor = executor.clone();
+                let database_path = paths::support_dir().join("threads/threads-db.1.mdb");
+                async move { ThreadsDatabase::new(database_path, executor) }
+            })
+            .then(|result| future::ready(result.map(Arc::new).map_err(Arc::new)))
+            .boxed()
+            .shared();
+
+        cx.set_global(GlobalThreadsDatabase(database_future));
+    }
+
+    pub fn new(path: PathBuf, executor: BackgroundExecutor) -> Result<Self> {
+        std::fs::create_dir_all(&path)?;
+
+        const ONE_GB_IN_BYTES: usize = 1024 * 1024 * 1024;
+        let env = unsafe {
+            heed::EnvOpenOptions::new()
+                .map_size(ONE_GB_IN_BYTES)
+                .max_dbs(1)
+                .open(path)?
+        };
+
+        let mut txn = env.write_txn()?;
+        let threads = env.create_database(&mut txn, Some("threads"))?;
+        txn.commit()?;
+
+        Ok(Self {
+            executor,
+            env,
+            threads,
+        })
+    }
+
+    pub fn list_threads(&self) -> Task<Result<Vec<SerializedThreadMetadata>>> {
+        let env = self.env.clone();
+        let threads = self.threads;
+
+        self.executor.spawn(async move {
+            let txn = env.read_txn()?;
+            let mut iter = threads.iter(&txn)?;
+            let mut threads = Vec::new();
+            while let Some((key, value)) = iter.next().transpose()? {
+                threads.push(SerializedThreadMetadata {
+                    id: key,
+                    summary: value.summary,
+                    updated_at: value.updated_at,
+                });
+            }
+
+            Ok(threads)
+        })
+    }
+
+    pub fn try_find_thread(&self, id: ThreadId) -> Task<Result<Option<SerializedThread>>> {
+        let env = self.env.clone();
+        let threads = self.threads;
+
+        self.executor.spawn(async move {
+            let txn = env.read_txn()?;
+            let thread = threads.get(&txn, &id)?;
+            Ok(thread)
+        })
+    }
+
+    pub fn save_thread(&self, id: ThreadId, thread: SerializedThread) -> Task<Result<()>> {
+        let env = self.env.clone();
+        let threads = self.threads;
+
+        self.executor.spawn(async move {
+            let mut txn = env.write_txn()?;
+            threads.put(&mut txn, &id, &thread)?;
+            txn.commit()?;
+            Ok(())
+        })
+    }
+
+    pub fn delete_thread(&self, id: ThreadId) -> Task<Result<()>> {
+        let env = self.env.clone();
+        let threads = self.threads;
+
+        self.executor.spawn(async move {
+            let mut txn = env.write_txn()?;
+            threads.delete(&mut txn, &id)?;
+            txn.commit()?;
+            Ok(())
+        })
+    }
+}

crates/agent/src/tool_use.rs

@@ -0,0 +1,445 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use assistant_tool::{Tool, ToolWorkingSet};
+use collections::HashMap;
+use futures::FutureExt as _;
+use futures::future::Shared;
+use gpui::{App, SharedString, Task};
+use language_model::{
+    LanguageModelRequestMessage, LanguageModelToolResult, LanguageModelToolUse,
+    LanguageModelToolUseId, MessageContent, Role,
+};
+use ui::IconName;
+
+use crate::thread::MessageId;
+use crate::thread_store::SerializedMessage;
+
+#[derive(Debug)]
+pub struct ToolUse {
+    pub id: LanguageModelToolUseId,
+    pub name: SharedString,
+    pub ui_text: SharedString,
+    pub status: ToolUseStatus,
+    pub input: serde_json::Value,
+    pub icon: ui::IconName,
+    pub needs_confirmation: bool,
+}
+
+#[derive(Debug, Clone)]
+pub enum ToolUseStatus {
+    NeedsConfirmation,
+    Pending,
+    Running,
+    Finished(SharedString),
+    Error(SharedString),
+}
+
+pub struct ToolUseState {
+    tools: Arc<ToolWorkingSet>,
+    tool_uses_by_assistant_message: HashMap<MessageId, Vec<LanguageModelToolUse>>,
+    tool_uses_by_user_message: HashMap<MessageId, Vec<LanguageModelToolUseId>>,
+    tool_results: HashMap<LanguageModelToolUseId, LanguageModelToolResult>,
+    pending_tool_uses_by_id: HashMap<LanguageModelToolUseId, PendingToolUse>,
+}
+
+impl ToolUseState {
+    pub fn new(tools: Arc<ToolWorkingSet>) -> Self {
+        Self {
+            tools,
+            tool_uses_by_assistant_message: HashMap::default(),
+            tool_uses_by_user_message: HashMap::default(),
+            tool_results: HashMap::default(),
+            pending_tool_uses_by_id: HashMap::default(),
+        }
+    }
+
+    /// Constructs a [`ToolUseState`] from the given list of [`SerializedMessage`]s.
+    ///
+    /// Accepts a function to filter the tools that should be used to populate the state.
+    pub fn from_serialized_messages(
+        tools: Arc<ToolWorkingSet>,
+        messages: &[SerializedMessage],
+        mut filter_by_tool_name: impl FnMut(&str) -> bool,
+    ) -> Self {
+        let mut this = Self::new(tools);
+        let mut tool_names_by_id = HashMap::default();
+
+        for message in messages {
+            match message.role {
+                Role::Assistant => {
+                    if !message.tool_uses.is_empty() {
+                        let tool_uses = message
+                            .tool_uses
+                            .iter()
+                            .filter(|tool_use| (filter_by_tool_name)(tool_use.name.as_ref()))
+                            .map(|tool_use| LanguageModelToolUse {
+                                id: tool_use.id.clone(),
+                                name: tool_use.name.clone().into(),
+                                input: tool_use.input.clone(),
+                            })
+                            .collect::<Vec<_>>();
+
+                        tool_names_by_id.extend(
+                            tool_uses
+                                .iter()
+                                .map(|tool_use| (tool_use.id.clone(), tool_use.name.clone())),
+                        );
+
+                        this.tool_uses_by_assistant_message
+                            .insert(message.id, tool_uses);
+                    }
+                }
+                Role::User => {
+                    if !message.tool_results.is_empty() {
+                        let tool_uses_by_user_message = this
+                            .tool_uses_by_user_message
+                            .entry(message.id)
+                            .or_default();
+
+                        for tool_result in &message.tool_results {
+                            let tool_use_id = tool_result.tool_use_id.clone();
+                            let Some(tool_use) = tool_names_by_id.get(&tool_use_id) else {
+                                log::warn!("no tool name found for tool use: {tool_use_id:?}");
+                                continue;
+                            };
+
+                            if !(filter_by_tool_name)(tool_use.as_ref()) {
+                                continue;
+                            }
+
+                            tool_uses_by_user_message.push(tool_use_id.clone());
+                            this.tool_results.insert(
+                                tool_use_id.clone(),
+                                LanguageModelToolResult {
+                                    tool_use_id,
+                                    tool_name: tool_use.clone(),
+                                    is_error: tool_result.is_error,
+                                    content: tool_result.content.clone(),
+                                },
+                            );
+                        }
+                    }
+                }
+                Role::System => {}
+            }
+        }
+
+        this
+    }
+
+    pub fn cancel_pending(&mut self) -> Vec<PendingToolUse> {
+        let mut pending_tools = Vec::new();
+        for (tool_use_id, tool_use) in self.pending_tool_uses_by_id.drain() {
+            self.tool_results.insert(
+                tool_use_id.clone(),
+                LanguageModelToolResult {
+                    tool_use_id,
+                    tool_name: tool_use.name.clone(),
+                    content: "Tool canceled by user".into(),
+                    is_error: true,
+                },
+            );
+            pending_tools.push(tool_use.clone());
+        }
+        pending_tools
+    }
+
+    pub fn pending_tool_uses(&self) -> Vec<&PendingToolUse> {
+        self.pending_tool_uses_by_id.values().collect()
+    }
+
+    pub fn tool_uses_for_message(&self, id: MessageId, cx: &App) -> Vec<ToolUse> {
+        let Some(tool_uses_for_message) = &self.tool_uses_by_assistant_message.get(&id) else {
+            return Vec::new();
+        };
+
+        let mut tool_uses = Vec::new();
+
+        for tool_use in tool_uses_for_message.iter() {
+            let tool_result = self.tool_results.get(&tool_use.id);
+
+            let status = (|| {
+                if let Some(tool_result) = tool_result {
+                    return if tool_result.is_error {
+                        ToolUseStatus::Error(tool_result.content.clone().into())
+                    } else {
+                        ToolUseStatus::Finished(tool_result.content.clone().into())
+                    };
+                }
+
+                if let Some(pending_tool_use) = self.pending_tool_uses_by_id.get(&tool_use.id) {
+                    match pending_tool_use.status {
+                        PendingToolUseStatus::Idle => ToolUseStatus::Pending,
+                        PendingToolUseStatus::NeedsConfirmation { .. } => {
+                            ToolUseStatus::NeedsConfirmation
+                        }
+                        PendingToolUseStatus::Running { .. } => ToolUseStatus::Running,
+                        PendingToolUseStatus::Error(ref err) => {
+                            ToolUseStatus::Error(err.clone().into())
+                        }
+                    }
+                } else {
+                    ToolUseStatus::Pending
+                }
+            })();
+
+            let (icon, needs_confirmation) = if let Some(tool) = self.tools.tool(&tool_use.name, cx)
+            {
+                (tool.icon(), tool.needs_confirmation())
+            } else {
+                (IconName::Cog, false)
+            };
+
+            tool_uses.push(ToolUse {
+                id: tool_use.id.clone(),
+                name: tool_use.name.clone().into(),
+                ui_text: self.tool_ui_label(&tool_use.name, &tool_use.input, cx),
+                input: tool_use.input.clone(),
+                status,
+                icon,
+                needs_confirmation,
+            })
+        }
+
+        tool_uses
+    }
+
+    pub fn tool_ui_label(
+        &self,
+        tool_name: &str,
+        input: &serde_json::Value,
+        cx: &App,
+    ) -> SharedString {
+        if let Some(tool) = self.tools.tool(tool_name, cx) {
+            tool.ui_text(input).into()
+        } else {
+            format!("Unknown tool {tool_name:?}").into()
+        }
+    }
+
+    pub fn tool_results_for_message(&self, message_id: MessageId) -> Vec<&LanguageModelToolResult> {
+        let empty = Vec::new();
+
+        self.tool_uses_by_user_message
+            .get(&message_id)
+            .unwrap_or(&empty)
+            .iter()
+            .filter_map(|tool_use_id| self.tool_results.get(&tool_use_id))
+            .collect()
+    }
+
+    pub fn message_has_tool_results(&self, message_id: MessageId) -> bool {
+        self.tool_uses_by_user_message
+            .get(&message_id)
+            .map_or(false, |results| !results.is_empty())
+    }
+
+    pub fn tool_result(
+        &self,
+        tool_use_id: &LanguageModelToolUseId,
+    ) -> Option<&LanguageModelToolResult> {
+        self.tool_results.get(tool_use_id)
+    }
+
+    pub fn request_tool_use(
+        &mut self,
+        assistant_message_id: MessageId,
+        tool_use: LanguageModelToolUse,
+        cx: &App,
+    ) {
+        self.tool_uses_by_assistant_message
+            .entry(assistant_message_id)
+            .or_default()
+            .push(tool_use.clone());
+
+        // The tool use is being requested by the Assistant, so we want to
+        // attach the tool results to the next user message.
+        let next_user_message_id = MessageId(assistant_message_id.0 + 1);
+        self.tool_uses_by_user_message
+            .entry(next_user_message_id)
+            .or_default()
+            .push(tool_use.id.clone());
+
+        self.pending_tool_uses_by_id.insert(
+            tool_use.id.clone(),
+            PendingToolUse {
+                assistant_message_id,
+                id: tool_use.id,
+                name: tool_use.name.clone(),
+                ui_text: self
+                    .tool_ui_label(&tool_use.name, &tool_use.input, cx)
+                    .into(),
+                input: tool_use.input,
+                status: PendingToolUseStatus::Idle,
+            },
+        );
+    }
+
+    pub fn run_pending_tool(
+        &mut self,
+        tool_use_id: LanguageModelToolUseId,
+        ui_text: SharedString,
+        task: Task<()>,
+    ) {
+        if let Some(tool_use) = self.pending_tool_uses_by_id.get_mut(&tool_use_id) {
+            tool_use.ui_text = ui_text.into();
+            tool_use.status = PendingToolUseStatus::Running {
+                _task: task.shared(),
+            };
+        }
+    }
+
+    pub fn confirm_tool_use(
+        &mut self,
+        tool_use_id: LanguageModelToolUseId,
+        ui_text: impl Into<Arc<str>>,
+        input: serde_json::Value,
+        messages: Arc<Vec<LanguageModelRequestMessage>>,
+        tool: Arc<dyn Tool>,
+    ) {
+        if let Some(tool_use) = self.pending_tool_uses_by_id.get_mut(&tool_use_id) {
+            let ui_text = ui_text.into();
+            tool_use.ui_text = ui_text.clone();
+            let confirmation = Confirmation {
+                tool_use_id,
+                input,
+                messages,
+                tool,
+                ui_text,
+            };
+            tool_use.status = PendingToolUseStatus::NeedsConfirmation(Arc::new(confirmation));
+        }
+    }
+
+    pub fn insert_tool_output(
+        &mut self,
+        tool_use_id: LanguageModelToolUseId,
+        tool_name: Arc<str>,
+        output: Result<String>,
+    ) -> Option<PendingToolUse> {
+        match output {
+            Ok(tool_result) => {
+                self.tool_results.insert(
+                    tool_use_id.clone(),
+                    LanguageModelToolResult {
+                        tool_use_id: tool_use_id.clone(),
+                        tool_name,
+                        content: tool_result.into(),
+                        is_error: false,
+                    },
+                );
+                self.pending_tool_uses_by_id.remove(&tool_use_id)
+            }
+            Err(err) => {
+                self.tool_results.insert(
+                    tool_use_id.clone(),
+                    LanguageModelToolResult {
+                        tool_use_id: tool_use_id.clone(),
+                        tool_name,
+                        content: err.to_string().into(),
+                        is_error: true,
+                    },
+                );
+
+                if let Some(tool_use) = self.pending_tool_uses_by_id.get_mut(&tool_use_id) {
+                    tool_use.status = PendingToolUseStatus::Error(err.to_string().into());
+                }
+
+                self.pending_tool_uses_by_id.get(&tool_use_id).cloned()
+            }
+        }
+    }
+
+    pub fn attach_tool_uses(
+        &self,
+        message_id: MessageId,
+        request_message: &mut LanguageModelRequestMessage,
+    ) {
+        if let Some(tool_uses) = self.tool_uses_by_assistant_message.get(&message_id) {
+            for tool_use in tool_uses {
+                if self.tool_results.contains_key(&tool_use.id) {
+                    // Do not send tool uses until they are completed
+                    request_message
+                        .content
+                        .push(MessageContent::ToolUse(tool_use.clone()));
+                } else {
+                    log::debug!(
+                        "skipped tool use {:?} because it is still pending",
+                        tool_use
+                    );
+                }
+            }
+        }
+    }
+
+    pub fn attach_tool_results(
+        &self,
+        message_id: MessageId,
+        request_message: &mut LanguageModelRequestMessage,
+    ) {
+        if let Some(tool_uses) = self.tool_uses_by_user_message.get(&message_id) {
+            for tool_use_id in tool_uses {
+                if let Some(tool_result) = self.tool_results.get(tool_use_id) {
+                    request_message.content.push(MessageContent::ToolResult(
+                        LanguageModelToolResult {
+                            tool_use_id: tool_use_id.clone(),
+                            tool_name: tool_result.tool_name.clone(),
+                            is_error: tool_result.is_error,
+                            content: if tool_result.content.is_empty() {
+                                // Surprisingly, the API fails if we return an empty string here.
+                                // It thinks we are sending a tool use without a tool result.
+                                "<Tool returned an empty string>".into()
+                            } else {
+                                tool_result.content.clone()
+                            },
+                        },
+                    ));
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct PendingToolUse {
+    pub id: LanguageModelToolUseId,
+    /// The ID of the Assistant message in which the tool use was requested.
+    #[allow(unused)]
+    pub assistant_message_id: MessageId,
+    pub name: Arc<str>,
+    pub ui_text: Arc<str>,
+    pub input: serde_json::Value,
+    pub status: PendingToolUseStatus,
+}
+
+#[derive(Debug, Clone)]
+pub struct Confirmation {
+    pub tool_use_id: LanguageModelToolUseId,
+    pub input: serde_json::Value,
+    pub ui_text: Arc<str>,
+    pub messages: Arc<Vec<LanguageModelRequestMessage>>,
+    pub tool: Arc<dyn Tool>,
+}
+
+#[derive(Debug, Clone)]
+pub enum PendingToolUseStatus {
+    Idle,
+    NeedsConfirmation(Arc<Confirmation>),
+    Running { _task: Shared<Task<()>> },
+    Error(#[allow(unused)] Arc<str>),
+}
+
+impl PendingToolUseStatus {
+    pub fn is_idle(&self) -> bool {
+        matches!(self, PendingToolUseStatus::Idle)
+    }
+
+    pub fn is_error(&self) -> bool {
+        matches!(self, PendingToolUseStatus::Error(_))
+    }
+
+    pub fn needs_confirmation(&self) -> bool {
+        matches!(self, PendingToolUseStatus::NeedsConfirmation { .. })
+    }
+}

crates/agent/src/ui.rs

@@ -0,0 +1,5 @@
+mod agent_notification;
+mod context_pill;
+
+pub use agent_notification::*;
+pub use context_pill::*;

crates/agent/src/ui/agent_notification.rs

@@ -0,0 +1,164 @@
+use gpui::{
+    App, Context, EventEmitter, IntoElement, PlatformDisplay, Size, Window,
+    WindowBackgroundAppearance, WindowBounds, WindowDecorations, WindowKind, WindowOptions,
+    linear_color_stop, linear_gradient, point,
+};
+use release_channel::ReleaseChannel;
+use std::rc::Rc;
+use theme;
+use ui::{Render, prelude::*};
+
+pub struct AgentNotification {
+    title: SharedString,
+    caption: SharedString,
+    icon: IconName,
+}
+
+impl AgentNotification {
+    pub fn new(
+        title: impl Into<SharedString>,
+        caption: impl Into<SharedString>,
+        icon: IconName,
+    ) -> Self {
+        Self {
+            title: title.into(),
+            caption: caption.into(),
+            icon,
+        }
+    }
+
+    pub fn window_options(screen: Rc<dyn PlatformDisplay>, cx: &App) -> WindowOptions {
+        let size = Size {
+            width: px(450.),
+            height: px(72.),
+        };
+
+        let notification_margin_width = px(16.);
+        let notification_margin_height = px(-48.);
+
+        let bounds = gpui::Bounds::<Pixels> {
+            origin: screen.bounds().top_right()
+                - point(
+                    size.width + notification_margin_width,
+                    notification_margin_height,
+                ),
+            size,
+        };
+
+        let app_id = ReleaseChannel::global(cx).app_id();
+
+        WindowOptions {
+            window_bounds: Some(WindowBounds::Windowed(bounds)),
+            titlebar: None,
+            focus: false,
+            show: true,
+            kind: WindowKind::PopUp,
+            is_movable: false,
+            display_id: Some(screen.id()),
+            window_background: WindowBackgroundAppearance::Transparent,
+            app_id: Some(app_id.to_owned()),
+            window_min_size: None,
+            window_decorations: Some(WindowDecorations::Client),
+        }
+    }
+}
+
+pub enum AgentNotificationEvent {
+    Accepted,
+    Dismissed,
+}
+
+impl EventEmitter<AgentNotificationEvent> for AgentNotification {}
+
+impl Render for AgentNotification {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let ui_font = theme::setup_ui_font(window, cx);
+        let line_height = window.line_height();
+
+        let bg = cx.theme().colors().elevated_surface_background;
+        let gradient_overflow = || {
+            div()
+                .h_full()
+                .absolute()
+                .w_8()
+                .bottom_0()
+                .right_0()
+                .bg(linear_gradient(
+                    90.,
+                    linear_color_stop(bg, 1.),
+                    linear_color_stop(bg.opacity(0.2), 0.),
+                ))
+        };
+
+        h_flex()
+            .id("agent-notification")
+            .size_full()
+            .p_3()
+            .gap_4()
+            .justify_between()
+            .elevation_3(cx)
+            .text_ui(cx)
+            .font(ui_font)
+            .border_color(cx.theme().colors().border)
+            .rounded_xl()
+            .on_click(cx.listener(|_, _, _, cx| {
+                cx.emit(AgentNotificationEvent::Accepted);
+            }))
+            .child(
+                h_flex()
+                    .items_start()
+                    .gap_2()
+                    .flex_1()
+                    .child(
+                        h_flex().h(line_height).justify_center().child(
+                            Icon::new(self.icon)
+                                .color(Color::Muted)
+                                .size(IconSize::Small),
+                        ),
+                    )
+                    .child(
+                        v_flex()
+                            .flex_1()
+                            .max_w(px(300.))
+                            .child(
+                                div()
+                                    .relative()
+                                    .text_size(px(14.))
+                                    .text_color(cx.theme().colors().text)
+                                    .truncate()
+                                    .child(self.title.clone())
+                                    .child(gradient_overflow()),
+                            )
+                            .child(
+                                div()
+                                    .relative()
+                                    .text_size(px(12.))
+                                    .text_color(cx.theme().colors().text_muted)
+                                    .truncate()
+                                    .child(self.caption.clone())
+                                    .child(gradient_overflow()),
+                            ),
+                    ),
+            )
+            .child(
+                v_flex()
+                    .gap_1()
+                    .items_center()
+                    .child(
+                        Button::new("open", "View Panel")
+                            .style(ButtonStyle::Tinted(ui::TintColor::Accent))
+                            .full_width()
+                            .on_click({
+                                cx.listener(move |_this, _event, _, cx| {
+                                    cx.emit(AgentNotificationEvent::Accepted);
+                                })
+                            }),
+                    )
+                    .child(Button::new("dismiss", "Dismiss").full_width().on_click({
+                        cx.listener(move |_, _event, _, cx| {
+                            cx.emit(AgentNotificationEvent::Dismissed);
+                        })
+                    })),
+            )
+    }
+}

crates/agent/src/ui/context_pill.rs

@@ -0,0 +1,341 @@
+use std::{rc::Rc, time::Duration};
+
+use file_icons::FileIcons;
+use gpui::ClickEvent;
+use gpui::{Animation, AnimationExt as _, pulsating_between};
+use ui::{IconButtonShape, Tooltip, prelude::*};
+
+use crate::context::{AssistantContext, ContextId, ContextKind};
+
+#[derive(IntoElement)]
+pub enum ContextPill {
+    Added {
+        context: AddedContext,
+        dupe_name: bool,
+        focused: bool,
+        on_click: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>>,
+        on_remove: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>>,
+    },
+    Suggested {
+        name: SharedString,
+        icon_path: Option<SharedString>,
+        kind: ContextKind,
+        focused: bool,
+        on_click: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>>,
+    },
+}
+
+impl ContextPill {
+    pub fn added(
+        context: AddedContext,
+        dupe_name: bool,
+        focused: bool,
+        on_remove: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>>,
+    ) -> Self {
+        Self::Added {
+            context,
+            dupe_name,
+            on_remove,
+            focused,
+            on_click: None,
+        }
+    }
+
+    pub fn suggested(
+        name: SharedString,
+        icon_path: Option<SharedString>,
+        kind: ContextKind,
+        focused: bool,
+    ) -> Self {
+        Self::Suggested {
+            name,
+            icon_path,
+            kind,
+            focused,
+            on_click: None,
+        }
+    }
+
+    pub fn on_click(mut self, listener: Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>) -> Self {
+        match &mut self {
+            ContextPill::Added { on_click, .. } => {
+                *on_click = Some(listener);
+            }
+            ContextPill::Suggested { on_click, .. } => {
+                *on_click = Some(listener);
+            }
+        }
+        self
+    }
+
+    pub fn id(&self) -> ElementId {
+        match self {
+            Self::Added { context, .. } => {
+                ElementId::NamedInteger("context-pill".into(), context.id.0)
+            }
+            Self::Suggested { .. } => "suggested-context-pill".into(),
+        }
+    }
+
+    pub fn icon(&self) -> Icon {
+        match self {
+            Self::Suggested {
+                icon_path: Some(icon_path),
+                ..
+            }
+            | Self::Added {
+                context:
+                    AddedContext {
+                        icon_path: Some(icon_path),
+                        ..
+                    },
+                ..
+            } => Icon::from_path(icon_path),
+            Self::Suggested { kind, .. }
+            | Self::Added {
+                context: AddedContext { kind, .. },
+                ..
+            } => Icon::new(kind.icon()),
+        }
+    }
+}
+
+impl RenderOnce for ContextPill {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let color = cx.theme().colors();
+
+        let base_pill = h_flex()
+            .id(self.id())
+            .pl_1()
+            .pb(px(1.))
+            .border_1()
+            .rounded_sm()
+            .gap_1()
+            .child(self.icon().size(IconSize::XSmall).color(Color::Muted));
+
+        match &self {
+            ContextPill::Added {
+                context,
+                dupe_name,
+                on_remove,
+                focused,
+                on_click,
+            } => base_pill
+                .bg(color.element_background)
+                .border_color(if *focused {
+                    color.border_focused
+                } else {
+                    color.border.opacity(0.5)
+                })
+                .pr(if on_remove.is_some() { px(2.) } else { px(4.) })
+                .child(
+                    h_flex()
+                        .id("context-data")
+                        .gap_1()
+                        .child(
+                            div().max_w_64().child(
+                                Label::new(context.name.clone())
+                                    .size(LabelSize::Small)
+                                    .truncate(),
+                            ),
+                        )
+                        .when_some(context.parent.as_ref(), |element, parent_name| {
+                            if *dupe_name {
+                                element.child(
+                                    Label::new(parent_name.clone())
+                                        .size(LabelSize::XSmall)
+                                        .color(Color::Muted),
+                                )
+                            } else {
+                                element
+                            }
+                        })
+                        .when_some(context.tooltip.as_ref(), |element, tooltip| {
+                            element.tooltip(Tooltip::text(tooltip.clone()))
+                        }),
+                )
+                .when_some(on_remove.as_ref(), |element, on_remove| {
+                    element.child(
+                        IconButton::new(("remove", context.id.0), IconName::Close)
+                            .shape(IconButtonShape::Square)
+                            .icon_size(IconSize::XSmall)
+                            .tooltip(Tooltip::text("Remove Context"))
+                            .on_click({
+                                let on_remove = on_remove.clone();
+                                move |event, window, cx| on_remove(event, window, cx)
+                            }),
+                    )
+                })
+                .when_some(on_click.as_ref(), |element, on_click| {
+                    let on_click = on_click.clone();
+                    element
+                        .cursor_pointer()
+                        .on_click(move |event, window, cx| on_click(event, window, cx))
+                })
+                .map(|element| {
+                    if context.summarizing {
+                        element
+                            .tooltip(ui::Tooltip::text("Summarizing..."))
+                            .with_animation(
+                                "pulsating-ctx-pill",
+                                Animation::new(Duration::from_secs(2))
+                                    .repeat()
+                                    .with_easing(pulsating_between(0.4, 0.8)),
+                                |label, delta| label.opacity(delta),
+                            )
+                            .into_any_element()
+                    } else {
+                        element.into_any()
+                    }
+                }),
+            ContextPill::Suggested {
+                name,
+                icon_path: _,
+                kind,
+                focused,
+                on_click,
+            } => base_pill
+                .cursor_pointer()
+                .pr_1()
+                .when(*focused, |this| {
+                    this.bg(color.element_background.opacity(0.5))
+                })
+                .border_dashed()
+                .border_color(if *focused {
+                    color.border_focused
+                } else {
+                    color.border
+                })
+                .hover(|style| style.bg(color.element_hover.opacity(0.5)))
+                .child(
+                    div().px_0p5().max_w_64().child(
+                        Label::new(name.clone())
+                            .size(LabelSize::Small)
+                            .color(Color::Muted)
+                            .truncate(),
+                    ),
+                )
+                .child(
+                    Label::new(match kind {
+                        ContextKind::File => "Active Tab",
+                        ContextKind::Thread
+                        | ContextKind::Directory
+                        | ContextKind::FetchedUrl
+                        | ContextKind::Symbol => "Active",
+                    })
+                    .size(LabelSize::XSmall)
+                    .color(Color::Muted),
+                )
+                .child(
+                    Icon::new(IconName::Plus)
+                        .size(IconSize::XSmall)
+                        .into_any_element(),
+                )
+                .tooltip(|window, cx| {
+                    Tooltip::with_meta("Suggested Context", None, "Click to add it", window, cx)
+                })
+                .when_some(on_click.as_ref(), |element, on_click| {
+                    let on_click = on_click.clone();
+                    element.on_click(move |event, window, cx| on_click(event, window, cx))
+                })
+                .into_any(),
+        }
+    }
+}
+
+pub struct AddedContext {
+    pub id: ContextId,
+    pub kind: ContextKind,
+    pub name: SharedString,
+    pub parent: Option<SharedString>,
+    pub tooltip: Option<SharedString>,
+    pub icon_path: Option<SharedString>,
+    pub summarizing: bool,
+}
+
+impl AddedContext {
+    pub fn new(context: &AssistantContext, cx: &App) -> AddedContext {
+        match context {
+            AssistantContext::File(file_context) => {
+                let full_path = file_context.context_buffer.file.full_path(cx);
+                let full_path_string: SharedString =
+                    full_path.to_string_lossy().into_owned().into();
+                let name = full_path
+                    .file_name()
+                    .map(|n| n.to_string_lossy().into_owned().into())
+                    .unwrap_or_else(|| full_path_string.clone());
+                let parent = full_path
+                    .parent()
+                    .and_then(|p| p.file_name())
+                    .map(|n| n.to_string_lossy().into_owned().into());
+                AddedContext {
+                    id: file_context.id,
+                    kind: ContextKind::File,
+                    name,
+                    parent,
+                    tooltip: Some(full_path_string),
+                    icon_path: FileIcons::get_icon(&full_path, cx),
+                    summarizing: false,
+                }
+            }
+
+            AssistantContext::Directory(directory_context) => {
+                // TODO: handle worktree disambiguation. Maybe by storing an `Arc<dyn File>` to also
+                // handle renames?
+                let full_path = &directory_context.project_path.path;
+                let full_path_string: SharedString =
+                    full_path.to_string_lossy().into_owned().into();
+                let name = full_path
+                    .file_name()
+                    .map(|n| n.to_string_lossy().into_owned().into())
+                    .unwrap_or_else(|| full_path_string.clone());
+                let parent = full_path
+                    .parent()
+                    .and_then(|p| p.file_name())
+                    .map(|n| n.to_string_lossy().into_owned().into());
+                AddedContext {
+                    id: directory_context.id,
+                    kind: ContextKind::Directory,
+                    name,
+                    parent,
+                    tooltip: Some(full_path_string),
+                    icon_path: None,
+                    summarizing: false,
+                }
+            }
+
+            AssistantContext::Symbol(symbol_context) => AddedContext {
+                id: symbol_context.id,
+                kind: ContextKind::Symbol,
+                name: symbol_context.context_symbol.id.name.clone(),
+                parent: None,
+                tooltip: None,
+                icon_path: None,
+                summarizing: false,
+            },
+
+            AssistantContext::FetchedUrl(fetched_url_context) => AddedContext {
+                id: fetched_url_context.id,
+                kind: ContextKind::FetchedUrl,
+                name: fetched_url_context.url.clone(),
+                parent: None,
+                tooltip: None,
+                icon_path: None,
+                summarizing: false,
+            },
+
+            AssistantContext::Thread(thread_context) => AddedContext {
+                id: thread_context.id,
+                kind: ContextKind::Thread,
+                name: thread_context.summary(cx),
+                parent: None,
+                tooltip: None,
+                icon_path: None,
+                summarizing: thread_context
+                    .thread
+                    .read(cx)
+                    .is_generating_detailed_summary(),
+            },
+        }
+    }
+}