Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
sidebar: Add right-click menu to thread items (#58232)
Danilo Leal26e69b9d9e3d
diff --git a/Cargo.lock b/Cargo.lockindex 3542c4a1993..beb400cd093 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -16706,6 +16706,7 @@ dependencies = ["log","menu","node_runtime",+ "notifications","platform_title_bar","pretty_assertions","project",diff --git a/crates/agent/src/db.rs b/crates/agent/src/db.rsindex aeeca37c170..4a15b0920e6 100644--- a/crates/agent/src/db.rs+++ b/crates/agent/src/db.rs@@ -152,6 +152,10 @@ impl SharedThread {impl DbThread {pub const VERSION: &'static str = "0.3.0";+ pub fn to_markdown(&self) -> String {+ crate::messages_to_markdown(&self.messages)+ }+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") {diff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rsindex 45baa2cf69a..f82c4c7dddf 100644--- a/crates/agent/src/tests/mod.rs+++ b/crates/agent/src/tests/mod.rs@@ -3371,6 +3371,72 @@ async fn test_title_generation(cx: &mut TestAppContext) {});}+#[gpui::test]+async fn test_stream_thread_title_keeps_only_first_line(cx: &mut TestAppContext) {+ let model = Arc::new(FakeLanguageModel::default());+ let request = LanguageModelRequest::default();++ let title_task = cx.spawn({+ let model = model.clone();+ async move |cx| crate::stream_thread_title(model, request, &cx).await+ });++ cx.run_until_parked();++ model.send_last_completion_stream_text_chunk("Hello world\nGoodnight Moon");+ model.end_last_completion_stream();++ let title = title_task.await.unwrap();+ assert_eq!(title, "Hello world");+}++#[gpui::test]+async fn test_stream_thread_title_stops_when_newline_ends_chunk(cx: &mut TestAppContext) {+ let model = Arc::new(FakeLanguageModel::default());+ let request = LanguageModelRequest::default();++ let title_task = cx.spawn({+ let model = model.clone();+ async move |cx| crate::stream_thread_title(model, request, &cx).await+ });++ cx.run_until_parked();++ model.send_last_completion_stream_text_chunk("Hello world\n");+ model.send_last_completion_stream_text_chunk("Goodnight Moon");+ model.end_last_completion_stream();++ let title = title_task.await.unwrap();+ assert_eq!(title, "Hello world");+}++// `Thread::to_markdown` (live native) and `DbThread::to_markdown` (persisted+// native) must stay byte-for-byte identical for the same messages, since both+// back the sidebar's native "Open Thread as Markdown" action. This pins that+// they share a single rendering path.+#[gpui::test]+async fn test_db_thread_markdown_matches_live_thread(cx: &mut TestAppContext) {+ let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;+ let fake_model = model.as_fake();++ let send = thread+ .update(cx, |thread, cx| {+ thread.send(UserMessageId::new(), ["Hello"], cx)+ })+ .unwrap();+ cx.run_until_parked();+ fake_model.send_last_completion_stream_text_chunk("Hey there!");+ fake_model.end_last_completion_stream();+ send.collect::<Vec<_>>().await;+ cx.run_until_parked();++ let db_thread = thread.update(cx, |thread, cx| thread.to_db(cx)).await;+ let live_markdown = thread.read_with(cx, |thread, _| thread.to_markdown());++ assert!(!live_markdown.is_empty());+ assert_eq!(db_thread.to_markdown(), live_markdown);+}+#[gpui::test]async fn test_title_generation_failure_allows_retry(cx: &mut TestAppContext) {let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex 953bbe194e8..3f990345363 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -3173,64 +3173,63 @@ impl Thread {if !self.can_generate_title(cx) {return;}-- self.title_generation_failed = false;let Some(model) = self.summarization_model.clone() else {return;};+ self.spawn_title_generation(model, None, cx);+ }- log::debug!(- "Generating title with model: {:?}",- self.summarization_model.as_ref().map(|model| model.name())- );- let mut request = LanguageModelRequest {- intent: Some(CompletionIntent::ThreadSummarization),- temperature: AgentSettings::temperature_for_model(&model, cx),- ..Default::default()- };+ pub fn regenerate_title(&mut self, cx: &mut Context<Self>) -> bool {+ self.regenerate_title_with_callback(cx, |_title, _cx| {})+ }- for message in &self.messages {- request.messages.extend(message.to_request());+ pub fn regenerate_title_with_callback(+ &mut self,+ cx: &mut Context<Self>,+ on_generated_title: impl FnOnce(SharedString, &mut Context<Self>) + 'static,+ ) -> bool {+ if self.pending_title_generation.is_some() {+ return false;}- request.messages.push(LanguageModelRequestMessage {- role: Role::User,- content: vec![SUMMARIZE_THREAD_PROMPT.into()],- cache: false,- reasoning_details: None,- });- self.pending_title_generation = Some(cx.spawn(async move |this, cx| {- let mut title = String::new();+ let Some(model) = self.summarization_model.clone() else {+ return false;+ };- let generate = async {- let mut messages = model.stream_completion(request, cx).await?;- while let Some(event) = messages.next().await {- let event = event?;- let text = match event {- LanguageModelCompletionEvent::Text(text) => text,- _ => continue,- };+ self.spawn_title_generation(model, Some(Box::new(on_generated_title)), cx);- let mut lines = text.lines();- title.extend(lines.next());+ true+ }- // Stop if the LLM generated multiple lines.- if lines.next().is_some() {- break;- }- }- anyhow::Ok(())- };+ fn spawn_title_generation(+ &mut self,+ model: Arc<dyn LanguageModel>,+ on_generated_title: Option<Box<dyn FnOnce(SharedString, &mut Context<Self>)>>,+ cx: &mut Context<Self>,+ ) {+ self.title_generation_failed = false;+ log::debug!("Generating title with model: {:?}", model.name());- let succeeded = generate+ let temperature = AgentSettings::temperature_for_model(&model, cx);+ let request = build_thread_title_request(&self.messages, temperature);++ let title_generation = cx.spawn(async move |_this, cx| {+ stream_thread_title(model, request, cx).await.context("failed to generate thread title")+ .map(SharedString::from).log_err()- .is_some();+ });++ self.pending_title_generation = Some(cx.spawn(async move |this, cx| {+ let title = title_generation.await;_ = this.update(cx, |this, cx| {this.pending_title_generation = None;- if succeeded {- this.set_title(title.into(), cx);+ if let Some(title) = title {+ this.set_title(title.clone(), cx);+ if let Some(on_generated_title) = on_generated_title {+ on_generated_title(title, cx);+ }} else {this.title_generation_failed = true;cx.emit(TitleUpdated);@@ -3238,6 +3237,7 @@ impl Thread {}});}));+ cx.notify();}pub fn set_title(&mut self, title: SharedString, cx: &mut Context<Self>) {@@ -3737,18 +3737,7 @@ impl Thread {}pub fn to_markdown(&self) -> String {- let mut markdown = String::new();- for (ix, message) in self.messages.iter().enumerate() {- if ix > 0 {- markdown.push('\n');- }- match &**message {- Message::User(_) => markdown.push_str("## User\n\n"),- Message::Agent(_) => markdown.push_str("## Assistant\n\n"),- Message::Resume | Message::Compaction(_) => {}- }- markdown.push_str(&message.to_markdown());- }+ let mut markdown = messages_to_markdown(&self.messages);if let Some(message) = self.pending_message.as_ref() {markdown.push_str("\n## Assistant\n\n");@@ -3979,6 +3968,63 @@ impl RunningTurn {}}+pub(crate) fn messages_to_markdown(messages: &[Arc<Message>]) -> String {+ let mut markdown = String::new();+ for (ix, message) in messages.iter().enumerate() {+ if ix > 0 {+ markdown.push('\n');+ }+ match &**message {+ Message::User(_) => markdown.push_str("## User\n\n"),+ Message::Agent(_) => markdown.push_str("## Assistant\n\n"),+ Message::Resume | Message::Compaction(_) => {}+ }+ markdown.push_str(&message.to_markdown());+ }+ markdown+}++pub fn build_thread_title_request(+ messages: &[Arc<Message>],+ temperature: Option<f32>,+) -> LanguageModelRequest {+ let mut request = LanguageModelRequest {+ intent: Some(CompletionIntent::ThreadSummarization),+ temperature,+ ..Default::default()+ };+ for message in messages {+ request.messages.extend(message.to_request());+ }+ request.messages.push(LanguageModelRequestMessage {+ role: Role::User,+ content: vec![SUMMARIZE_THREAD_PROMPT.into()],+ cache: false,+ reasoning_details: None,+ });+ request+}++pub async fn stream_thread_title(+ model: Arc<dyn LanguageModel>,+ request: LanguageModelRequest,+ cx: &AsyncApp,+) -> Result<String> {+ let mut title = String::new();+ let mut events = model.stream_completion(request, cx).await?;+ while let Some(event) = events.next().await {+ let LanguageModelCompletionEvent::Text(text) = event? else {+ continue;+ };+ if let Some(newline_ix) = text.find(|ch| ch == '\n' || ch == '\r') {+ title.push_str(&text[..newline_ix]);+ break;+ }+ title.push_str(&text);+ }+ Ok(title)+}+pub struct TokenUsageUpdated(pub Option<acp_thread::TokenUsage>);impl EventEmitter<TokenUsageUpdated> for Thread {}diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rsindex 30161a7a9f9..ca6ac97b384 100644--- a/crates/agent_ui/src/agent_panel.rs+++ b/crates/agent_ui/src/agent_panel.rs@@ -18,7 +18,7 @@ use agent_settings::UserAgentsMd;use collections::HashSet;use db::kvp::{Dismissable, KeyValueStore};use itertools::Itertools;-use project::AgentId;+use project::{AgentId, ProjectItem};use serde::{Deserialize, Serialize};use settings::{LanguageModelProviderSetting, LanguageModelSelection};@@ -81,7 +81,8 @@ use gpui::{};use language::LanguageRegistry;use language_model::LanguageModelRegistry;-use project::{Project, ProjectItem, ProjectPath, Worktree};+use notifications::status_toast::StatusToast;+use project::{Project, ProjectPath, Worktree};use settings::TerminalDockPosition;use settings::{NotifyWhenAgentWaiting, Settings, update_settings_file};use skill_creator::{SkillCreatorOpenMode, is_supported_skill_url, open_skill_creator};@@ -321,6 +322,14 @@ fn read_legacy_serialized_panel(kvp: &KeyValueStore) -> Option<SerializedAgentPa.and_then(|json| serde_json::from_str::<SerializedAgentPanel>(&json).log_err())}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum ThreadTitleRegenerationResult {+ NotOpen,+ Started,+ NoModel,+ AlreadyGenerating,+}+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]enum AgentPanelEntryKind {#[default]@@ -3672,6 +3681,27 @@ impl AgentPanel {}}+ pub fn open_thread_as_markdown(+ &mut self,+ thread_id: ThreadId,+ workspace: Entity<Workspace>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) -> bool {+ let Some(conversation_view) = self.conversation_view_for_id(&thread_id, cx).cloned() else {+ return false;+ };+ let Some(thread_view) = conversation_view.read(cx).root_thread_view() else {+ return false;+ };+ thread_view.update(cx, |thread, cx| {+ thread+ .open_thread_as_markdown(workspace, window, cx)+ .detach_and_log_err(cx);+ });+ true+ }+fn copy_thread_to_clipboard(&mut self, window: &mut Window, cx: &mut Context<Self>) {let Some(thread) = self.active_native_agent_thread(cx) else {Self::show_deferred_toast(&self.workspace, "No active native thread to copy", cx);@@ -3998,6 +4028,42 @@ impl AgentPanel {})}+ pub fn regenerate_thread_title(+ &mut self,+ thread_id: ThreadId,+ cx: &mut Context<Self>,+ ) -> ThreadTitleRegenerationResult {+ let Some(conversation_view) = self.conversation_view_for_id(&thread_id, cx).cloned() else {+ return ThreadTitleRegenerationResult::NotOpen;+ };+ Self::regenerate_conversation_thread_title(conversation_view, cx)+ }++ fn regenerate_conversation_thread_title(+ conversation_view: Entity<ConversationView>,+ cx: &mut App,+ ) -> ThreadTitleRegenerationResult {+ let Some(thread) = conversation_view.read(cx).as_native_thread(cx) else {+ return ThreadTitleRegenerationResult::NotOpen;+ };+ let thread_id = conversation_view.read(cx).parent_id();+ thread.update(cx, |thread, cx| {+ if thread.is_generating_title() {+ ThreadTitleRegenerationResult::AlreadyGenerating+ } else if thread.summarization_model().is_none() {+ ThreadTitleRegenerationResult::NoModel+ } else if thread.regenerate_title_with_callback(cx, move |title, cx| {+ ThreadMetadataStore::global(cx).update(cx, |store, cx| {+ store.set_generated_title(thread_id, title, cx);+ });+ }) {+ ThreadTitleRegenerationResult::Started+ } else {+ ThreadTitleRegenerationResult::AlreadyGenerating+ }+ })+ }+pub fn conversation_views(&self) -> Vec<Entity<ConversationView>> {self.active_conversation_view().into_iter()@@ -5360,9 +5426,11 @@ impl AgentPanel {.tooltip(Tooltip::text("Title generation failed. Retry")).on_click({let conversation_view = conversation_view.clone();+ let workspace = self.workspace.clone();move |_event, _window, cx| {Self::handle_regenerate_thread_title(conversation_view.clone(),+ workspace.clone(),cx,);}@@ -5460,19 +5528,41 @@ impl AgentPanel {.into_any()}- fn handle_regenerate_thread_title(conversation_view: Entity<ConversationView>, cx: &mut App) {- conversation_view.update(cx, |conversation_view, cx| {- if let Some(thread) = conversation_view.as_native_thread(cx) {- thread.update(cx, |thread, cx| {- if thread.can_generate_title(cx) {- thread.generate_title(cx);- cx.notify();- }- });- }+ fn show_no_thread_summary_model_toast(workspace: Entity<Workspace>, cx: &mut App) {+ workspace.update(cx, |workspace, cx| {+ let toast = StatusToast::new(+ "No model is configured for summarizing thread titles.",+ cx,+ |this, _cx| {+ this.icon(+ Icon::new(IconName::Warning)+ .size(IconSize::Small)+ .color(Color::Warning),+ )+ .dismiss_button(true)+ },+ );+ workspace.toggle_status_toast(toast, cx);});}+ fn handle_regenerate_thread_title(+ conversation_view: Entity<ConversationView>,+ workspace: WeakEntity<Workspace>,+ cx: &mut App,+ ) {+ match Self::regenerate_conversation_thread_title(conversation_view, cx) {+ ThreadTitleRegenerationResult::NoModel => {+ if let Some(workspace) = workspace.upgrade() {+ Self::show_no_thread_summary_model_toast(workspace, cx);+ }+ }+ ThreadTitleRegenerationResult::NotOpen+ | ThreadTitleRegenerationResult::Started+ | ThreadTitleRegenerationResult::AlreadyGenerating => {}+ }+ }+fn render_panel_options_menu(&self,_window: &mut Window,@@ -5502,7 +5592,7 @@ impl AgentPanel {conversation_view.has_user_submitted_prompt(cx)&& conversation_view.as_native_thread(cx)- .is_some_and(|thread| thread.read(cx).can_generate_title(cx))+ .is_some_and(|thread| !thread.read(cx).is_generating_title())});let has_auth_methods = match &self.base_view {@@ -5550,9 +5640,11 @@ impl AgentPanel {menu = menu.entry("Regenerate Thread Title", None, {let conversation_view = conversation_view.clone();+ let workspace = workspace.clone();move |_, cx| {Self::handle_regenerate_thread_title(conversation_view.clone(),+ workspace.clone(),cx,);}diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rsindex bc2a8f4147e..ff62a60c254 100644--- a/crates/agent_ui/src/agent_ui.rs+++ b/crates/agent_ui/src/agent_ui.rs@@ -71,12 +71,14 @@ use crate::agent_configuration::{ConfigureContextServerModal, ManageProfilesModapub use crate::agent_connection_store::{ActiveAcpConnection, AgentConnectionStore};pub use crate::agent_panel::{AgentPanel, AgentPanelEvent, AgentPanelTerminalInfo, MaxIdleRetainedThreads, TerminalId,+ ThreadTitleRegenerationResult,};use crate::agent_registry_ui::AgentRegistryPage;pub use crate::inline_assistant::InlineAssistant;pub use crate::thread_metadata_store::ThreadId;pub use agent_diff::{AgentDiffPane, AgentDiffToolbar};pub use conversation_view::ConversationView;+pub use conversation_view::open_markdown_in_workspace;pub use external_source_prompt::ExternalSourcePrompt;pub(crate) use mode_selector::ModeSelector;pub(crate) use model_selector::ModelSelector;diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex 2670744711f..63998dea9bc 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -666,6 +666,55 @@ fn full_path_for_empty_project_path(file: &dyn language::File, cx: &App) -> Opti(!full_path.is_empty()).then_some(full_path)}+pub fn open_markdown_in_workspace(+ title: String,+ markdown: String,+ workspace: Entity<Workspace>,+ window: &mut Window,+ cx: &mut App,+) -> Task<Result<()>> {+ let markdown_language_task = workspace+ .read(cx)+ .app_state()+ .languages+ .language_for_name("Markdown");+ let project = workspace.read(cx).project().clone();++ window.spawn(cx, async move |cx| {+ let markdown_language = markdown_language_task.await?;++ let buffer = project+ .update(cx, |project, cx| {+ project.create_buffer(Some(markdown_language), false, cx)+ })+ .await?;++ buffer.update(cx, |buffer, cx| {+ buffer.set_text(markdown, cx);+ buffer.set_capability(language::Capability::ReadWrite, cx);+ });++ workspace.update_in(cx, |workspace, window, cx| {+ let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx).with_title(title.clone()));++ workspace.add_item_to_active_pane(+ Box::new(cx.new(|cx| {+ let mut editor =+ Editor::for_multibuffer(buffer, Some(project.clone()), window, cx);+ editor.set_breadcrumb_header(title);+ editor.disable_mouse_wheel_zoom();+ editor+ })),+ None,+ true,+ window,+ cx,+ );+ })?;+ anyhow::Ok(())+ })+}+impl ThreadView {pub(crate) fn new(root_thread_id: ThreadId,@@ -6014,12 +6063,6 @@ impl ThreadView {window: &mut Window,cx: &mut App,) -> Task<Result<()>> {- let markdown_language_task = workspace- .read(cx)- .app_state()- .languages- .language_for_name("Markdown");-let thread = self.thread.read(cx);let thread_title = thread.title()@@ -6027,41 +6070,7 @@ impl ThreadView {.to_string();let markdown = thread.to_markdown(cx);- let project = workspace.read(cx).project().clone();- window.spawn(cx, async move |cx| {- let markdown_language = markdown_language_task.await?;-- let buffer = project- .update(cx, |project, cx| {- project.create_buffer(Some(markdown_language), false, cx)- })- .await?;-- buffer.update(cx, |buffer, cx| {- buffer.set_text(markdown, cx);- buffer.set_capability(language::Capability::ReadWrite, cx);- });-- workspace.update_in(cx, |workspace, window, cx| {- let buffer = cx- .new(|cx| MultiBuffer::singleton(buffer, cx).with_title(thread_title.clone()));-- workspace.add_item_to_active_pane(- Box::new(cx.new(|cx| {- let mut editor =- Editor::for_multibuffer(buffer, Some(project.clone()), window, cx);- editor.set_breadcrumb_header(thread_title);- editor.disable_mouse_wheel_zoom();- editor- })),- None,- true,- window,- cx,- );- })?;- anyhow::Ok(())- })+ open_markdown_in_workspace(thread_title, markdown, workspace, window, cx)}pub(crate) fn sync_editor_mode_for_empty_state(&mut self, cx: &mut Context<Self>) {diff --git a/crates/agent_ui/src/thread_metadata_store.rs b/crates/agent_ui/src/thread_metadata_store.rsindex 5b4b90e4b70..49bfbec9c0e 100644--- a/crates/agent_ui/src/thread_metadata_store.rs+++ b/crates/agent_ui/src/thread_metadata_store.rs@@ -718,6 +718,26 @@ impl ThreadMetadataStore {self.save(metadata, cx);}+ pub fn set_generated_title(+ &mut self,+ thread_id: ThreadId,+ title: SharedString,+ cx: &mut Context<Self>,+ ) {+ let Some(existing) = self.entry(thread_id) else {+ return;+ };+ if existing.title.as_ref() == Some(&title) && existing.title_override.is_none() {+ return;+ }+ let metadata = ThreadMetadata {+ title: Some(title),+ title_override: None,+ ..existing.clone()+ };+ self.save(metadata, cx);+ }+fn save_internal(&mut self, metadata: ThreadMetadata) {if let Some(thread) = self.threads.get(&metadata.thread_id) {if thread.folder_paths() != metadata.folder_paths() {@@ -1985,6 +2005,39 @@ mod tests {});}+ #[gpui::test]+ async fn test_store_set_generated_title_clears_title_override(cx: &mut TestAppContext) {+ init_test(cx);++ let mut metadata = make_metadata(+ "session-1",+ "Old Generated Title",+ Utc::now(),+ PathList::default(),+ );+ metadata.title_override = Some("User Title".into());+ let thread_id = metadata.thread_id;++ cx.update(|cx| {+ let store = ThreadMetadataStore::global(cx);+ store.update(cx, |store, cx| {+ store.save(metadata, cx);+ store.set_generated_title(thread_id, "New Generated Title".into(), cx);+ });+ });++ cx.run_until_parked();++ cx.update(|cx| {+ let store = ThreadMetadataStore::global(cx);+ let store = store.read(cx);+ let metadata = store.entry(thread_id).expect("metadata should be cached");+ assert_eq!(metadata.title.as_deref(), Some("New Generated Title"));+ assert_eq!(metadata.title_override, None);+ assert_eq!(metadata.display_title().as_ref(), "New Generated Title");+ });+ }+#[gpui::test]async fn test_store_initializes_cache_from_database(cx: &mut TestAppContext) {let first_paths = PathList::new(&[Path::new("/project-a")]);diff --git a/crates/sidebar/Cargo.toml b/crates/sidebar/Cargo.tomlindex d479f21af4e..fc3b8108f65 100644--- a/crates/sidebar/Cargo.toml+++ b/crates/sidebar/Cargo.toml@@ -30,8 +30,10 @@ fs.workspace = truegit.workspace = truegpui.workspace = trueitertools.workspace = true+language_model.workspace = truelog.workspace = truemenu.workspace = true+notifications.workspace = trueplatform_title_bar.workspace = trueproject.workspace = truerecent_projects.workspace = truediff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rsindex e4359dc30d9..3da8efe0cdb 100644--- a/crates/sidebar/src/sidebar.rs+++ b/crates/sidebar/src/sidebar.rs@@ -2,6 +2,7 @@ mod thread_switcher;use acp_thread::ThreadStatus;use action_log::DiffStats;+use agent::{ThreadStore, ZED_AGENT_ID};use agent_client_protocol::schema as acp;use agent_settings::AgentSettings;use agent_ui::terminal_thread_metadata_store::{@@ -19,7 +20,7 @@ use agent_ui::{AcpThreadImportOnboarding, Agent, AgentPanel, AgentPanelEvent, AgentThreadSource,ArchiveSelectedThread, CrossChannelImportOnboarding, DEFAULT_THREAD_TITLE, NewTerminalThread,NewThread, RenameSelectedThread, TerminalId, ThreadId, ThreadImportModal,- channels_with_threads, import_threads_from_other_channels,+ ThreadTitleRegenerationResult, channels_with_threads, import_threads_from_other_channels,};use chrono::{DateTime, Utc};use editor::Editor;@@ -32,9 +33,11 @@ use gpui::{WeakEntity, Window, WindowHandle, linear_color_stop, linear_gradient, list, prelude::*, px,};use itertools::Itertools;+use language_model::LanguageModelRegistry;use menu::{Cancel, Confirm, SelectChild, SelectFirst, SelectLast, SelectNext, SelectParent, SelectPrevious,};+use notifications::status_toast::StatusToast;use project::{AgentId, AgentRegistryStore, Event as ProjectEvent, WorktreeId};use recent_projects::sidebar_recent_projects::SidebarRecentProjects;use remote::{RemoteConnectionOptions, same_remote_connection_identity};@@ -53,7 +56,7 @@ use ui::{AgentThreadStatus, CommonAnimationExt, ContextMenu, ContextMenuEntry, Divider, GradientFade,HighlightedLabel, KeyBinding, PopoverMenu, PopoverMenuHandle, ProjectEmptyState, ScrollAxes,Scrollbars, Tab, ThreadItem, ThreadItemWorktreeInfo, TintColor, Tooltip, WithScrollbar,- prelude::*, render_modifiers,+ prelude::*, render_modifiers, right_click_menu,};use unicode_segmentation::UnicodeSegmentation as _;use util::ResultExt as _;@@ -747,6 +750,9 @@ pub struct Sidebar {active_entry: Option<ActiveEntry>,hovered_thread_index: Option<usize>,renaming_thread_id: Option<ThreadId>,+ /// Threads in the database-backed regeneration path need their own loading+ /// state because they do not have a live `agent::Thread` to report it.+ regenerating_titles: HashSet<ThreadId>,/// start_renaming_thread must seed current title into the title editor/// so this prevents that BufferEdited event from being interpreted as user input.suppress_next_rename_edit: bool,@@ -895,6 +901,7 @@ impl Sidebar {active_entry: None,hovered_thread_index: None,renaming_thread_id: None,+ regenerating_titles: HashSet::new(),suppress_next_rename_edit: false,thread_last_accessed: HashMap::new(),@@ -3487,6 +3494,171 @@ impl Sidebar {.detach_and_log_err(cx);}+ fn open_closed_native_thread_as_markdown(+ session_id: &acp::SessionId,+ title: Option<SharedString>,+ workspace: &Entity<Workspace>,+ window: &mut Window,+ cx: &mut App,+ ) {+ let thread_store = ThreadStore::global(cx);+ let load_task =+ thread_store.update(cx, |store, cx| store.load_thread(session_id.clone(), cx));++ let thread_title = title+ .map(|t| t.to_string())+ .unwrap_or_else(|| DEFAULT_THREAD_TITLE.to_string());++ let workspace = workspace.clone();++ window+ .spawn(cx, async move |cx| {+ let db_thread = load_task.await?;+ let Some(db_thread) = db_thread else {+ anyhow::bail!("Thread not found in database");+ };++ let markdown = db_thread.to_markdown();++ cx.update(|window, cx| {+ agent_ui::open_markdown_in_workspace(+ thread_title,+ markdown,+ workspace,+ window,+ cx,+ )+ })?+ .await+ })+ .detach_and_log_err(cx);+ }++ fn show_thread_title_toast(workspace: Entity<Workspace>, message: &'static str, cx: &mut App) {+ workspace.update(cx, |workspace, cx| {+ let toast = StatusToast::new(message, cx, |this, _cx| {+ this.icon(+ Icon::new(IconName::Warning)+ .size(IconSize::Small)+ .color(Color::Warning),+ )+ .dismiss_button(true)+ });+ workspace.toggle_status_toast(toast, cx);+ });+ }++ fn show_no_thread_summary_model_toast(workspace: Entity<Workspace>, cx: &mut App) {+ Self::show_thread_title_toast(+ workspace,+ "No model is configured for summarizing thread titles.",+ cx,+ );+ }++ fn regenerate_thread_title(+ &mut self,+ session_id: &acp::SessionId,+ thread_id: ThreadId,+ folder_paths: PathList,+ thread_workspace: Option<Entity<Workspace>>,+ cx: &mut Context<Self>,+ ) {+ if let Some(panel) = thread_workspace+ .as_ref()+ .and_then(|w| w.read(cx).panel::<AgentPanel>(cx))+ {+ match panel.update(cx, |panel, cx| panel.regenerate_thread_title(thread_id, cx)) {+ ThreadTitleRegenerationResult::Started+ | ThreadTitleRegenerationResult::AlreadyGenerating => return,+ ThreadTitleRegenerationResult::NoModel => {+ if let Some(workspace) = self.active_workspace(cx) {+ Self::show_no_thread_summary_model_toast(workspace, cx);+ }+ return;+ }+ ThreadTitleRegenerationResult::NotOpen => {}+ }+ }++ let Some(configured_model) =+ LanguageModelRegistry::read_global(cx).thread_summary_model(cx)+ else {+ if let Some(workspace) = self.active_workspace(cx) {+ Self::show_no_thread_summary_model_toast(workspace, cx);+ }+ return;+ };++ if !self.regenerating_titles.insert(thread_id) {+ return;+ }++ let model = configured_model.model;+ let temperature = AgentSettings::temperature_for_model(&model, cx);++ let thread_store = ThreadStore::global(cx);+ let load_task =+ thread_store.update(cx, |store, cx| store.load_thread(session_id.clone(), cx));+ let session_id = session_id.clone();++ cx.notify();++ cx.spawn(async move |this, cx| {+ let result: anyhow::Result<SharedString> = async {+ let Some(db_thread) = load_task.await? else {+ anyhow::bail!("Thread not found in database");+ };++ let request = agent::build_thread_title_request(&db_thread.messages, temperature);+ let title =+ SharedString::from(agent::stream_thread_title(model, request, cx).await?);++ let Some(mut db_thread) = thread_store+ .update(cx, |store, cx| store.load_thread(session_id.clone(), cx))+ .await?+ else {+ anyhow::bail!("Thread not found in database");+ };+ db_thread.title = title.clone();++ thread_store+ .update(cx, |store, cx| {+ store.save_thread(session_id, db_thread, folder_paths, cx)+ })+ .await?;++ anyhow::Ok(title)+ }+ .await;++ this.update(cx, |this, cx| {+ this.regenerating_titles.remove(&thread_id);+ match &result {+ Ok(title) => {+ ThreadMetadataStore::global(cx).update(cx, |store, cx| {+ store.set_generated_title(thread_id, title.clone(), cx);+ });+ }+ Err(_) => {+ if let Some(workspace) = this.active_workspace(cx) {+ Self::show_thread_title_toast(+ workspace,+ "Failed to regenerate thread title.",+ cx,+ );+ }+ }+ }+ cx.notify();+ })+ .ok();++ result.map(|_| ())+ })+ .detach_and_log_err(cx);+ }+fn activate_thread_locally(&mut self,metadata: &ThreadMetadata,@@ -5931,7 +6103,12 @@ impl Sidebar {(thread.icon, thread.icon_from_external_svg.clone())};- ThreadItem::new(id, title.clone())+ let title_generating = thread.is_title_generating+ || self+ .regenerating_titles+ .contains(&thread.metadata.thread_id);++ let thread_item = ThreadItem::new(id, title.clone()).base_bg(sidebar_bg).icon(icon).when(is_draft, |this| {@@ -5945,7 +6122,7 @@ impl Sidebar {.worktrees(worktrees).timestamp(timestamp).highlight_positions(thread.highlight_positions.to_vec())- .title_generating(thread.is_title_generating)+ .title_generating(title_generating).notified(has_notification).when(thread.diff_stats.lines_added > 0, |this| {this.added(thread.diff_stats.lines_added as usize)@@ -6083,6 +6260,7 @@ impl Sidebar {)}).on_click({+ let thread_workspace = thread_workspace.clone();cx.listener(move |this, _, window, cx| {this.selection = None;match &thread_workspace {@@ -6103,6 +6281,134 @@ impl Sidebar {}}})+ });++ if is_draft || thread.metadata.session_id.is_none() {+ return thread_item.into_any_element();+ }++ let Some(session_id) = thread.metadata.session_id.clone() else {+ return thread_item.into_any_element();+ };++ let context_menu_id = SharedString::from(format!("thread-context-menu-{}", ix));+ let sidebar = cx.weak_entity();++ let active_workspace = self.active_workspace(cx);+ let thread_workspace = match &thread_workspace {+ ThreadEntryWorkspace::Open(workspace) => Some(workspace.clone()),+ ThreadEntryWorkspace::Closed { .. } => None,+ };++ let is_zed_thread = thread.metadata.agent_id.as_ref() == ZED_AGENT_ID.as_ref();+ let can_open_as_markdown = thread.is_live || is_zed_thread;+ let folder_paths = thread.metadata.folder_paths().clone();++ right_click_menu(context_menu_id)+ .trigger(move |_, _, _| thread_item)+ .menu({+ let thread_id = thread.metadata.thread_id;+ let markdown_title = Some(thread.metadata.display_title());+ let rename_title = title;+ move |_window, cx| {+ let session_id = session_id.clone();+ let sidebar = sidebar.clone();+ let active_workspace = active_workspace.clone();+ let thread_workspace = thread_workspace.clone();+ let markdown_title = markdown_title.clone();+ let rename_title = rename_title.clone();+ let folder_paths = folder_paths.clone();+ ContextMenu::build(_window, cx, move |mut menu, _window, _cx| {+ menu = menu.entry("Rename Title", None, {+ let sidebar = sidebar.clone();+ let rename_title = rename_title.clone();+ move |window, cx| {+ sidebar+ .update(cx, |sidebar, cx| {+ sidebar.start_renaming_thread(+ ix,+ thread_id,+ rename_title.clone(),+ window,+ cx,+ );+ })+ .ok();+ }+ });++ if is_zed_thread {+ menu = menu.entry("Regenerate Thread Title", None, {+ let session_id = session_id.clone();+ let sidebar = sidebar.clone();+ let thread_workspace = thread_workspace.clone();+ let folder_paths = folder_paths.clone();+ move |_window, cx| {+ sidebar+ .update(cx, |sidebar, cx| {+ sidebar.regenerate_thread_title(+ &session_id,+ thread_id,+ folder_paths.clone(),+ thread_workspace.clone(),+ cx,+ );+ })+ .ok();+ }+ });+ }++ if can_open_as_markdown {+ menu = menu.entry("Open Thread as Markdown", None, {+ let session_id = session_id.clone();+ let markdown_title = markdown_title.clone();+ let thread_workspace = thread_workspace.clone();+ move |window, cx| {+ if let Some(thread_workspace) = thread_workspace.as_ref()+ && let Some(panel) =+ thread_workspace.read(cx).panel::<AgentPanel>(cx)+ {+ let opened = panel.update(cx, |panel, cx| {+ panel.open_thread_as_markdown(+ thread_id,+ thread_workspace.clone(),+ window,+ cx,+ )+ });+ if opened {+ return;+ }+ }++ if is_zed_thread+ && let Some(active_workspace) = &active_workspace+ {+ Self::open_closed_native_thread_as_markdown(+ &session_id,+ markdown_title.clone(),+ active_workspace,+ window,+ cx,+ );+ }+ }+ });+ }++ menu.separator().entry("Archive Thread", None, {+ let session_id = session_id.clone();+ move |window, cx| {+ sidebar+ .update(cx, |sidebar, cx| {+ sidebar.archive_thread(&session_id, window, cx);+ })+ .ok();+ }+ })+ })+ }}).into_any_element()}