Skip to content

armgit / zed

Public Imported from GitHub
0

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.lock
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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, ManageProfilesModa
pub 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.rs
index 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.rs
index 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.toml
index d479f21af4e..fc3b8108f65 100644
--- a/crates/sidebar/Cargo.toml
+++ b/crates/sidebar/Cargo.toml
@@ -30,8 +30,10 @@ fs.workspace = true
git.workspace = true
gpui.workspace = true
itertools.workspace = true
+language_model.workspace = true
log.workspace = true
menu.workspace = true
+notifications.workspace = true
platform_title_bar.workspace = true
project.workspace = true
recent_projects.workspace = true
diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index 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()
}