Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent_ui: Fix restoring uninstalled external agents (#62497)
Eli Stark0969b0dba3f3
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rsindex 5496df4a5a9..0cabb01f381 100644--- a/crates/agent_ui/src/agent_panel.rs+++ b/crates/agent_ui/src/agent_panel.rs@@ -18,6 +18,7 @@ use agent_settings::UserAgentsMd;use collections::HashSet;use db::kvp::{Dismissable, KeyValueStore};use itertools::Itertools;+use project::agent_server_store::AllAgentServersSettings;use project::{AgentId, ProjectItem};use serde::{Deserialize, Serialize};@@ -1433,14 +1434,23 @@ impl AgentPanel {// so the draft survives reload bound to the right// backend; otherwise fall back to the serialized// selection, then the global last-used agent.- let initial_agent = match &thread_to_restore {- Some((info, _)) => Some(clamp(info.agent_type.clone())),- None => serialized_panel+ // Keep a session's agent so users can resume it after reinstalling the agent.+ let restored_thread_agent = thread_to_restore.as_ref().and_then(|(info, _)| {+ let agent = clamp(info.agent_type.clone());+ (info.session_id.is_some() || panel.should_restore_agent(&agent, cx))+ .then_some(agent)+ });+ let initial_agent = restored_thread_agent.or_else(|| {+ serialized_panel.as_ref().and_then(|p| p.selected_agent.clone()).map(clamp)- .or(global_fallback),- };+ .filter(|agent| panel.should_restore_agent(agent, cx))+ .or_else(|| {+ global_fallback+ .filter(|agent| panel.should_restore_agent(agent, cx))+ })+ });if let Some(agent) = initial_agent {panel.selected_agent = agent;}@@ -1657,6 +1667,25 @@ impl AgentPanel {}}+ fn should_restore_agent(&self, agent: &Agent, cx: &App) -> bool {+ let Agent::Custom { id } = agent else {+ return true;+ };++ // Local settings do not list remote agents, and the remote list may not have loaded yet.+ self.project.read(cx).is_via_remote_server()+ || AllAgentServersSettings::get_global(cx).contains_key(id.0.as_ref())+ }++ fn restorable_agent_selection(&self, cx: &App) -> Agent {+ let agent = self.selected_agent(cx);+ if self.should_restore_agent(&agent, cx) {+ agent+ } else {+ Agent::NativeAgent+ }+ }+pub fn open_thread(&mut self,session_id: acp::SessionId,@@ -1885,7 +1914,13 @@ impl AgentPanel {let agent = if self.project.read(cx).is_via_collab() {Agent::NativeAgent} else {- Agent::from(metadata.agent_id.clone())+ // Draft text is stored locally, so use the selected agent if the original was uninstalled.+ let agent = Agent::from(metadata.agent_id.clone());+ if self.should_restore_agent(&agent, cx) {+ agent+ } else {+ self.restorable_agent_selection(cx)+ }};let initial_content = crate::draft_prompt_store::read(thread_id, cx).map(|blocks| {AgentInitialContent::ContentBlock {@@ -5239,7 +5274,7 @@ impl AgentPanel {let source_panel = source_workspace.read(cx).panel::<AgentPanel>(cx)?;let source_panel = source_panel.read(cx);Some(SourcePanelInitialization {- agent: source_panel.selected_agent(cx),+ agent: source_panel.restorable_agent_selection(cx),initial_content: source_panel.active_initial_content(cx),})}@@ -6849,6 +6884,34 @@ mod tests {use std::sync::Arc;use std::time::Instant;+ fn install_custom_agent(id: &str, cx: &mut App) {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |content| {+ content.agent_servers.get_or_insert_default().insert(+ id.to_string(),+ settings::CustomAgentServerSettings::Custom {+ path: PathBuf::from("/usr/bin/fake-agent"),+ args: Vec::new(),+ env: Default::default(),+ default_mode: None,+ default_config_options: Default::default(),+ favorite_config_option_values: Default::default(),+ },+ );+ });+ });+ }++ fn uninstall_custom_agent(id: &str, cx: &mut App) {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |content| {+ if let Some(agent_servers) = content.agent_servers.as_mut() {+ agent_servers.remove(id);+ }+ });+ });+ }+#[test]fn test_is_known_terminal_agent_command() {assert!(is_known_terminal_agent_command("claude"));@@ -7307,6 +7370,7 @@ mod tests {cx.new(|cx| AgentPanel::new(workspace, window, cx))});+ cx.update(|_window, cx| install_custom_agent("claude-acp", cx));panel_b.update(cx, |panel, _cx| {panel.selected_agent = Agent::Custom {id: "claude-acp".into(),@@ -11471,6 +11535,7 @@ mod tests {let custom_agent = Agent::Custom {id: "my-preferred-agent".into(),};+ cx.update(|cx| install_custom_agent("my-preferred-agent", cx));// Write a known agent to the global KVP to simulate a user who has// previously used this agent in another workspace.@@ -11511,6 +11576,329 @@ mod tests {});}+ #[gpui::test]+ async fn test_new_workspace_ignores_uninstalled_global_last_used_agent(+ cx: &mut TestAppContext,+ ) {+ init_test(cx);+ cx.update(|cx| {+ agent::ThreadStore::init_global(cx);+ language_model::LanguageModelRegistry::test(cx);+ // Use an isolated DB so parallel tests can't overwrite our global key.+ cx.set_global(db::AppDatabase::test_new());+ });++ let kvp = cx.update(|cx| KeyValueStore::global(cx));+ write_global_last_used_agent(+ kvp,+ Agent::Custom {+ id: "uninstalled-agent".into(),+ },+ )+ .await;++ let fs = FakeFs::new(cx.executor());+ let project = Project::test(fs.clone(), [], cx).await;++ let multi_workspace =+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));++ let workspace = multi_workspace+ .read_with(cx, |multi_workspace, _cx| {+ multi_workspace.workspace().clone()+ })+ .unwrap();++ workspace.update(cx, |workspace, _cx| {+ workspace.set_random_database_id();+ });++ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);++ let async_cx = cx.update(|window, cx| window.to_async(cx));+ let panel = AgentPanel::load(workspace.downgrade(), async_cx)+ .await+ .expect("panel load should succeed");+ cx.run_until_parked();++ panel.read_with(cx, |panel, _cx| {+ assert_eq!(+ panel.selected_agent,+ Agent::NativeAgent,+ "a workspace should not inherit a last-used agent that is no longer installed"+ );+ });+ }++ #[gpui::test]+ async fn test_reopened_workspace_uses_installed_global_agent_when_selected_agent_was_uninstalled(+ cx: &mut TestAppContext,+ ) {+ init_test(cx);+ cx.update(|cx| {+ agent::ThreadStore::init_global(cx);+ language_model::LanguageModelRegistry::test(cx);+ install_custom_agent("workspace-agent", cx);+ install_custom_agent("global-agent", cx);+ // Use an isolated DB so parallel tests can't overwrite our global key.+ cx.set_global(db::AppDatabase::test_new());+ });++ let global_agent = Agent::Custom {+ id: "global-agent".into(),+ };+ let kvp = cx.update(|cx| KeyValueStore::global(cx));+ write_global_last_used_agent(kvp, global_agent.clone()).await;++ let fs = FakeFs::new(cx.executor());+ let project = Project::test(fs.clone(), [], cx).await;+ let multi_workspace =+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = multi_workspace+ .read_with(cx, |multi_workspace, _cx| {+ multi_workspace.workspace().clone()+ })+ .unwrap();+ workspace.update(cx, |workspace, _cx| {+ workspace.set_random_database_id();+ });+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);++ let panel = workspace.update_in(cx, |workspace, window, cx| {+ cx.new(|cx| AgentPanel::new(workspace, window, cx))+ });+ panel.update(cx, |panel, cx| {+ panel.selected_agent = Agent::Custom {+ id: "workspace-agent".into(),+ };+ panel.serialize(cx);+ });+ cx.run_until_parked();++ cx.update(|_window, cx| uninstall_custom_agent("workspace-agent", cx));++ let async_cx = cx.update(|window, cx| window.to_async(cx));+ let reloaded_panel = AgentPanel::load(workspace.downgrade(), async_cx)+ .await+ .expect("panel load should succeed");+ cx.run_until_parked();++ reloaded_panel.read_with(cx, |panel, _cx| {+ assert_eq!(+ panel.selected_agent, global_agent,+ "an installed global agent should be used when the workspace agent was uninstalled"+ );+ });+ }++ #[gpui::test]+ async fn test_opened_workspace_does_not_inherit_uninstalled_agent_from_source(+ cx: &mut TestAppContext,+ ) {+ init_test(cx);+ cx.update(|cx| {+ agent::ThreadStore::init_global(cx);+ language_model::LanguageModelRegistry::test(cx);+ install_custom_agent("my-custom-agent", cx);+ });++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree("/project_a", json!({ "file.txt": "" }))+ .await;+ fs.insert_tree("/project_b", json!({ "file.txt": "" }))+ .await;+ let project_a = Project::test(fs.clone(), [Path::new("/project_a")], cx).await;+ let project_b = Project::test(fs.clone(), [Path::new("/project_b")], cx).await;++ let multi_workspace =+ cx.add_window(|window, cx| MultiWorkspace::test_new(project_a.clone(), window, cx));+ let workspace_a = multi_workspace+ .read_with(cx, |mw, _cx| mw.workspace().clone())+ .unwrap();+ let workspace_b = multi_workspace+ .update(cx, |multi_workspace, window, cx| {+ multi_workspace.test_add_workspace(project_b.clone(), window, cx)+ })+ .unwrap();+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);++ let panel_a = workspace_a.update_in(cx, |workspace, window, cx| {+ let panel = cx.new(|cx| AgentPanel::new(workspace, window, cx));+ workspace.add_panel(panel.clone(), window, cx);+ panel+ });+ panel_a.update(cx, |panel, _cx| {+ panel.selected_agent = Agent::Custom {+ id: "my-custom-agent".into(),+ };+ });++ cx.update(|_window, cx| uninstall_custom_agent("my-custom-agent", cx));++ let panel_b = workspace_b.update_in(cx, |workspace, window, cx| {+ let panel = cx.new(|cx| AgentPanel::new(workspace, window, cx));+ workspace.add_panel(panel.clone(), window, cx);+ panel+ });+ panel_b.update_in(cx, |panel, window, cx| {+ panel.initialize_from_source_workspace_if_needed(workspace_a.downgrade(), window, cx);+ });+ cx.run_until_parked();++ panel_b.read_with(cx, |panel, _cx| {+ assert_eq!(+ panel.selected_agent,+ Agent::NativeAgent,+ "a newly opened project should not inherit an uninstalled agent"+ );+ });+ }++ #[gpui::test]+ async fn test_restored_thread_keeps_uninstalled_agent(cx: &mut TestAppContext) {+ init_test(cx);+ cx.update(|cx| {+ agent::ThreadStore::init_global(cx);+ language_model::LanguageModelRegistry::test(cx);+ });++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree("/project", json!({ "file.txt": "" })).await;+ let project = Project::test(fs.clone(), [Path::new("/project")], cx).await;+ let multi_workspace =+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = multi_workspace+ .read_with(cx, |multi_workspace, _cx| {+ multi_workspace.workspace().clone()+ })+ .unwrap();+ workspace.update(cx, |workspace, _cx| {+ workspace.set_random_database_id();+ });+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);++ let external_agent_id = StubAgentServer::default_response().agent_id();+ cx.update(|_window, cx| install_custom_agent(external_agent_id.0.as_ref(), cx));++ let panel = workspace.update_in(cx, |workspace, window, cx| {+ let panel = cx.new(|cx| AgentPanel::new(workspace, window, cx));+ workspace.add_panel(panel.clone(), window, cx);+ panel+ });++ open_thread_with_connection(&panel, StubAgentConnection::new(), cx);+ send_message(&panel, cx);+ let thread_id = active_thread_id(&panel, cx);+ panel.update(cx, |panel, cx| panel.serialize(cx));+ cx.run_until_parked();++ cx.update(|_window, cx| uninstall_custom_agent(external_agent_id.0.as_ref(), cx));+ cx.run_until_parked();++ let async_cx = cx.update(|window, cx| window.to_async(cx));+ let reloaded_panel = AgentPanel::load(workspace.downgrade(), async_cx)+ .await+ .expect("panel load should succeed");+ cx.run_until_parked();++ reloaded_panel.read_with(cx, |panel, cx| {+ let conversation_view = panel+ .active_conversation_view()+ .expect("the last active thread should be restored");+ assert_eq!(+ conversation_view.read(cx).thread_id,+ thread_id,+ "the same thread should be restored"+ );+ assert_eq!(+ *conversation_view.read(cx).agent_key(),+ Agent::Custom {+ id: external_agent_id.clone()+ },+ "a restored thread should keep its original agent"+ );+ });+ }++ #[gpui::test]+ async fn test_restored_draft_drops_uninstalled_agent_but_keeps_text(cx: &mut TestAppContext) {+ init_test(cx);+ let fs = FakeFs::new(cx.executor());+ cx.update(|cx| {+ agent::ThreadStore::init_global(cx);+ language_model::LanguageModelRegistry::test(cx);+ // Building the native fallback requires a global `Fs`.+ <dyn fs::Fs>::set_global(fs.clone(), cx);+ });++ fs.insert_tree("/project", json!({ "file.txt": "" })).await;+ let project = Project::test(fs.clone(), [Path::new("/project")], cx).await;+ let multi_workspace =+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = multi_workspace+ .read_with(cx, |multi_workspace, _cx| {+ multi_workspace.workspace().clone()+ })+ .unwrap();+ workspace.update(cx, |workspace, _cx| {+ workspace.set_random_database_id();+ });+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);++ let external_agent_id = StubAgentServer::default_response().agent_id();+ cx.update(|_window, cx| install_custom_agent(external_agent_id.0.as_ref(), cx));++ let panel = workspace.update_in(cx, |workspace, window, cx| {+ let panel = cx.new(|cx| AgentPanel::new(workspace, window, cx));+ workspace.add_panel(panel.clone(), window, cx);+ panel+ });++ crate::test_support::open_draft_with_connection(&panel, StubAgentConnection::new(), cx);+ crate::test_support::type_draft_prompt(&panel, "Unsent draft", cx);+ let draft_thread_id = active_thread_id(&panel, cx);+ panel.update(cx, |panel, cx| panel.serialize(cx));+ cx.run_until_parked();++ cx.update(|_window, cx| uninstall_custom_agent(external_agent_id.0.as_ref(), cx));+ cx.run_until_parked();++ let async_cx = cx.update(|window, cx| window.to_async(cx));+ let reloaded_panel = AgentPanel::load(workspace.downgrade(), async_cx)+ .await+ .expect("panel load should succeed");+ cx.run_until_parked();++ reloaded_panel.read_with(cx, |panel, cx| {+ let draft = panel+ .draft_thread+ .as_ref()+ .expect("the draft should be restored");+ assert_eq!(+ draft.read(cx).thread_id,+ draft_thread_id,+ "the same draft should be restored"+ );+ assert_eq!(+ *draft.read(cx).agent_key(),+ Agent::NativeAgent,+ "a restored draft should drop an uninstalled agent"+ );+ assert_eq!(+ panel.selected_agent,+ Agent::NativeAgent,+ "the panel should not stay selected on the uninstalled agent"+ );+ });++ let persisted_prompt =+ cx.update(|_window, cx| crate::draft_prompt_store::read(draft_thread_id, cx));+ assert!(+ persisted_prompt.is_some_and(|blocks| !blocks.is_empty()),+ "a restored draft should keep the text the user had typed"+ );+ }+#[gpui::test(iterations = 25)]async fn test_select_agent_action_updates_visible_draft(cx: &mut TestAppContext) {init_test(cx);@@ -11607,6 +11995,10 @@ mod tests {let agent_b = Agent::Custom {id: "agent-beta".into(),};+ cx.update(|_window, cx| {+ install_custom_agent("agent-alpha", cx);+ install_custom_agent("agent-beta", cx);+ });// Set up workspace A with agent_alet panel_a = workspace_a.update_in(cx, |workspace, window, cx| {@@ -13184,6 +13576,13 @@ mod tests {let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);+ cx.update(|_window, cx| {+ install_custom_agent(+ StubAgentServer::default_response().agent_id().0.as_ref(),+ cx,+ )+ });+// Set up panel_a with an active thread and type draft text.let panel_a = workspace_a.update_in(cx, |workspace, window, cx| {let panel = cx.new(|cx| AgentPanel::new(workspace, window, cx));