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.

agent_ui: Separate session close from view release (#65703)

Ben Brandt8c8ada0fbf15
diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs
index e64e9fc9800..86d0be54dfd 100644
--- a/crates/acp_thread/src/connection.rs
+++ b/crates/acp_thread/src/connection.rs
@@ -125,12 +125,20 @@ pub trait AgentConnection {
Task::ready(Err(anyhow::Error::msg("Loading sessions is not supported")))
}
- /// Whether this agent supports closing existing sessions.
+ /// Whether this agent supports explicitly closing existing sessions.
fn supports_close_session(&self) -> bool {
false
}
- /// Close an existing session. Allows the agent to free the session from memory.
+ /// Whether conversation teardown should invoke `close_session`.
+ /// The default preserves existing UI cleanup; backend-owned release hooks are separate.
+ /// Autonomous backends can opt out without disabling explicit close support.
+ fn should_close_sessions_on_release(&self) -> bool {
+ self.supports_close_session()
+ }
+
+ /// Close an existing session and free its resources. This may cancel remote work;
+ /// automatic cleanup must also respect `should_close_sessions_on_release`.
fn close_session(
self: Rc<Self>,
_session_id: &acp_v2::SessionId,
@@ -867,7 +875,7 @@ mod test_support {
use std::sync::atomic::{AtomicUsize, Ordering};
use action_log::ActionLog;
- use collections::HashMap;
+ use collections::{HashMap, VecDeque};
use futures::{channel::oneshot, future::try_join_all};
use gpui::{AppContext as _, WeakEntity};
use parking_lot::Mutex;
@@ -929,12 +937,16 @@ mod test_support {
Arc<Mutex<Option<oneshot::Receiver<Result<acp_v2::PromptResponse>>>>>,
receipt_prompt: Arc<Mutex<Option<Vec<acp_v2::ContentBlock>>>>,
next_truncate: Arc<Mutex<Option<oneshot::Receiver<()>>>>,
+ close_session_calls: Arc<Mutex<Vec<acp_v2::SessionId>>>,
+ next_close_responses: Arc<Mutex<VecDeque<oneshot::Receiver<Result<()>>>>>,
set_title_calls: Arc<Mutex<Vec<(acp_v2::SessionId, SharedString)>>>,
cancel_calls: Arc<Mutex<Vec<acp_v2::SessionId>>>,
next_cancel_error: Arc<Mutex<Option<anyhow::Error>>>,
supports_receipt_submissions: bool,
supports_retry: bool,
supports_load_session: bool,
+ supports_close_session: bool,
+ close_sessions_on_release: bool,
supports_session_additional_directories: bool,
supports_set_title: bool,
agent_id: AgentId,
@@ -968,6 +980,8 @@ mod test_support {
next_receipt_response: Default::default(),
receipt_prompt: Default::default(),
next_truncate: Default::default(),
+ close_session_calls: Default::default(),
+ next_close_responses: Default::default(),
set_title_calls: Default::default(),
cancel_calls: Default::default(),
next_cancel_error: Default::default(),
@@ -976,6 +990,8 @@ mod test_support {
supports_receipt_submissions: false,
supports_retry: false,
supports_load_session: false,
+ supports_close_session: false,
+ close_sessions_on_release: true,
supports_session_additional_directories: false,
supports_set_title: true,
agent_id: AgentId::new("stub"),
@@ -1035,6 +1051,16 @@ mod test_support {
std::mem::take(&mut *self.set_title_calls.lock())
}
+ pub fn take_close_session_calls(&self) -> Vec<acp_v2::SessionId> {
+ std::mem::take(&mut *self.close_session_calls.lock())
+ }
+
+ pub fn defer_next_close_response(&self) -> oneshot::Sender<Result<()>> {
+ let (sender, receiver) = oneshot::channel();
+ self.next_close_responses.lock().push_back(receiver);
+ sender
+ }
+
pub fn take_cancel_calls(&self) -> Vec<acp_v2::SessionId> {
std::mem::take(&mut *self.cancel_calls.lock())
}
@@ -1062,6 +1088,16 @@ mod test_support {
self
}
+ pub fn with_supports_close_session(mut self, supports_close_session: bool) -> Self {
+ self.supports_close_session = supports_close_session;
+ self
+ }
+
+ pub fn with_close_sessions_on_release(mut self, close_sessions_on_release: bool) -> Self {
+ self.close_sessions_on_release = close_sessions_on_release;
+ self
+ }
+
pub fn with_receipt_submissions(mut self, enabled: bool) -> Self {
self.supports_receipt_submissions = enabled;
self
@@ -1205,6 +1241,29 @@ mod test_support {
self.supports_load_session
}
+ fn supports_close_session(&self) -> bool {
+ self.supports_close_session
+ }
+
+ fn should_close_sessions_on_release(&self) -> bool {
+ self.supports_close_session && self.close_sessions_on_release
+ }
+
+ fn close_session(
+ self: Rc<Self>,
+ session_id: &acp_v2::SessionId,
+ cx: &mut App,
+ ) -> Task<Result<()>> {
+ if !self.supports_close_session {
+ return Task::ready(Err(anyhow::Error::msg("Closing sessions is not supported")));
+ }
+ self.close_session_calls.lock().push(session_id.clone());
+ match self.next_close_responses.lock().pop_front() {
+ Some(response) => cx.spawn(async move |_| response.await?),
+ None => Task::ready(Ok(())),
+ }
+ }
+
fn supports_session_additional_directories(&self) -> bool {
self.supports_session_additional_directories
}
diff --git a/crates/agent_servers/src/acp/v2.rs b/crates/agent_servers/src/acp/v2.rs
index 2f5c28fc8f6..7641fb2194c 100644
--- a/crates/agent_servers/src/acp/v2.rs
+++ b/crates/agent_servers/src/acp/v2.rs
@@ -1085,6 +1085,11 @@ impl AgentConnection for AcpV2Connection {
validate_prompt_content(&session.prompt.clone().unwrap_or_default(), content)
}
+ fn should_close_sessions_on_release(&self) -> bool {
+ // V2 close cancels agent-owned work; disposing a view must only detach.
+ false
+ }
+
fn supports_session_additional_directories(&self) -> bool {
self.initialize_response
.capabilities
@@ -2390,6 +2395,7 @@ done
&& harness.client.supports_resume_session()
&& !harness.client.supports_close_session()
);
+ assert!(!harness.client.should_close_sessions_on_release());
});
assert_eq!(thread.read_with(cx, |thread, _| thread.entries().len()), 1);
drop(thread);
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rs
index 791caca70b6..3f11b5439b4 100644
--- a/crates/agent_ui/src/conversation_view.rs
+++ b/crates/agent_ui/src/conversation_view.rs
@@ -964,6 +964,23 @@ struct LoadingView {
_load_task: Task<()>,
}
+#[derive(Debug)]
+struct SessionCloseErrors {
+ failures: Vec<(acp_v2::SessionId, anyhow::Error)>,
+}
+
+impl std::fmt::Display for SessionCloseErrors {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "Failed to close agent sessions")?;
+ for (session_id, error) in &self.failures {
+ write!(formatter, "\n{session_id}: {error:#}")?;
+ }
+ Ok(())
+ }
+}
+
+impl std::error::Error for SessionCloseErrors {}
+
impl ConnectedServerState {
pub fn active_view(&self) -> Option<&Entity<ThreadView>> {
self.active_id.as_ref().and_then(|id| self.threads.get(id))
@@ -980,20 +997,41 @@ impl ConnectedServerState {
}
}
- pub fn close_all_sessions(&self, cx: &mut App) -> Task<()> {
- let tasks = self.threads.values().filter_map(|view| {
- if self.connection.supports_close_session() {
+ pub fn close_all_sessions(&self, cx: &mut App) -> Task<Result<()>> {
+ if !self.connection.supports_close_session() {
+ return Task::ready(Ok(()));
+ }
+ // Initiate cleanup before a replacement can rebind the same session IDs.
+ let tasks = self
+ .threads
+ .values()
+ .map(|view| {
let session_id = view.read(cx).thread.read(cx).session_id().clone();
- Some(self.connection.clone().close_session(&session_id, cx))
+ let closing = self.connection.clone().close_session(&session_id, cx);
+ async move { (session_id, closing.await) }
+ })
+ .collect::<Vec<_>>();
+ cx.background_spawn(async move {
+ let failures = futures::future::join_all(tasks)
+ .await
+ .into_iter()
+ .filter_map(|(session_id, result)| result.err().map(|error| (session_id, error)))
+ .collect::<Vec<_>>();
+ if failures.is_empty() {
+ Ok(())
} else {
- None
+ Err(SessionCloseErrors { failures }.into())
}
- });
- let task = futures::future::join_all(tasks);
- cx.background_spawn(async move {
- task.await;
})
}
+
+ fn release_sessions(&self, cx: &mut App) -> Task<Result<()>> {
+ if self.connection.should_close_sessions_on_release() {
+ self.close_all_sessions(cx)
+ } else {
+ Task::ready(Ok(()))
+ }
+ }
}
impl ConversationView {
@@ -1044,7 +1082,7 @@ impl ConversationView {
cx.on_release(|this, cx| {
this.request_elicitation_form_states.clear();
if let Some(connected) = this.as_connected() {
- connected.close_all_sessions(cx).detach();
+ connected.release_sessions(cx).detach_and_log_err(cx);
}
for window in this.notifications.drain(..) {
window
@@ -1101,7 +1139,7 @@ impl ConversationView {
Self::request_elicitation_connection_for_state(&state);
if let Some(connected) = self.as_connected() {
- connected.close_all_sessions(cx).detach();
+ connected.release_sessions(cx).detach_and_log_err(cx);
}
if let Some(connection) = previous_request_elicitation_connection
@@ -18394,49 +18432,175 @@ pub(crate) mod tests {
.expect("Should be connected")
.close_all_sessions(cx)
})
- .await;
+ .await
+ .expect("unsupported batch close is a no-op");
}
#[gpui::test]
async fn test_close_all_sessions_calls_close_when_supported(cx: &mut TestAppContext) {
init_test(cx);
- let (conversation_view, cx) =
- setup_conversation_view(StubAgentServer::new(CloseCapableConnection::new()), cx).await;
-
- cx.run_until_parked();
-
- let close_capable = conversation_view.read_with(cx, |view, _cx| {
- let connected = view.as_connected().expect("Should be connected");
- assert!(
- !connected.threads.is_empty(),
- "There should be at least one thread"
+ for replace_state in [false, true] {
+ let connection = CloseCapableConnection::new();
+ assert!(connection.should_close_sessions_on_release());
+ let calls = connection.closed_sessions.clone();
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::new(connection), cx).await;
+ let expected = conversation_view.read_with(cx, |view, _| {
+ view.as_connected().expect("connected").threads.len()
+ });
+ assert!(expected > 0);
+ conversation_view
+ .update(cx, |view, cx| {
+ view.as_connected()
+ .expect("connected")
+ .close_all_sessions(cx)
+ })
+ .await
+ .expect("explicit close");
+ assert_eq!(calls.lock().len(), expected);
+ calls.lock().clear();
+ if replace_state {
+ conversation_view.update(cx, |view, cx| {
+ view.set_server_state(
+ ServerState::LoadError {
+ error: LoadError::Other("replacement".into()),
+ },
+ cx,
+ )
+ });
+ } else {
+ drop(conversation_view);
+ }
+ cx.update(|_, _| ());
+ cx.run_until_parked();
+ assert_eq!(
+ calls.lock().len(),
+ expected,
+ "default automatic cleanup is preserved"
);
+ }
+ }
+
+ #[gpui::test]
+ async fn test_release_policy_does_not_disable_explicit_close(cx: &mut TestAppContext) {
+ init_test(cx);
+ for replace_state in [false, true] {
+ let connection = StubAgentConnection::new()
+ .with_supports_close_session(true)
+ .with_close_sessions_on_release(false);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::new(connection.clone()), cx).await;
+ conversation_view.read_with(cx, |view, _| {
+ let connection = &view.as_connected().expect("connected").connection;
+ assert!(connection.supports_close_session());
+ assert!(!connection.should_close_sessions_on_release());
+ });
+ conversation_view
+ .update(cx, |view, cx| {
+ view.as_connected()
+ .expect("connected")
+ .close_all_sessions(cx)
+ })
+ .await
+ .expect("explicit close remains available");
+ assert_eq!(connection.take_close_session_calls().len(), 1);
+ if replace_state {
+ conversation_view.update(cx, |view, cx| {
+ view.set_server_state(
+ ServerState::LoadError {
+ error: LoadError::Other("replacement".into()),
+ },
+ cx,
+ )
+ });
+ } else {
+ drop(conversation_view);
+ }
+ cx.update(|_, _| ());
+ cx.run_until_parked();
assert!(
- connected.connection.supports_close_session(),
- "CloseCapableConnection should support close"
+ connection.take_close_session_calls().is_empty(),
+ "release must not terminate autonomous work"
);
- connected
- .connection
- .clone()
- .into_any()
- .downcast::<CloseCapableConnection>()
- .expect("Should be CloseCapableConnection")
- });
+ }
+ }
- conversation_view
+ #[gpui::test]
+ async fn test_close_all_sessions_waits_for_all_results_and_preserves_failures(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let connection = StubAgentConnection::new()
+ .with_supports_close_session(true)
+ .with_close_sessions_on_release(false);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::new(connection.clone()), cx).await;
+ let second = conversation_view
.update(cx, |view, cx| {
- view.as_connected()
- .expect("Should be connected")
- .close_all_sessions(cx)
+ Rc::new(connection.clone()).new_session(
+ view.project.clone(),
+ view.project.read(cx).default_path_list(cx),
+ cx,
+ )
})
- .await;
-
- let closed_count = close_capable.closed_sessions.lock().len();
+ .await
+ .expect("second session");
+ conversation_view.update_in(cx, |view, window, cx| {
+ let session_id = second.read(cx).session_id().clone();
+ let conversation = view.as_connected().expect("connected").conversation.clone();
+ conversation.update(cx, |conversation, cx| {
+ conversation.register_thread(second.clone(), cx)
+ });
+ let thread_view = view.new_thread_view(second, conversation, false, None, window, cx);
+ view.as_connected_mut()
+ .expect("connected")
+ .threads
+ .insert(session_id, thread_view);
+ });
+ let first_response = connection.defer_next_close_response();
+ let second_response = connection.defer_next_close_response();
+ let mut closing = conversation_view.update(cx, |view, cx| {
+ view.as_connected()
+ .expect("connected")
+ .close_all_sessions(cx)
+ });
+ let calls = connection.take_close_session_calls();
+ let [first_id, second_id] = calls.as_slice() else {
+ panic!("both closes must be initiated before a replacement can load")
+ };
+ drop(conversation_view);
+ cx.update(|_, _| ());
+ cx.run_until_parked();
+ let first_error = agent_client_protocol::Error::new(-32042, "First close failed")
+ .data(serde_json::json!({"retain": [null, 7]}));
+ first_response
+ .send(Err(first_error.clone().into()))
+ .expect("first response");
+ cx.run_until_parked();
assert!(
- closed_count > 0,
- "close_session should have been called for each thread"
+ (&mut closing).now_or_never().is_none(),
+ "one failure must not abandon the other close"
+ );
+ second_response
+ .send(Err(anyhow!("Second close failed")))
+ .expect("second response");
+ let error = closing.await.expect_err("all failures must be returned");
+ let failures = &error
+ .downcast_ref::<SessionCloseErrors>()
+ .expect("batch failures")
+ .failures;
+ assert_eq!(failures.len(), 2);
+ assert!(failures.iter().any(|(id, error)| id == first_id
+ && error.downcast_ref::<agent_client_protocol::Error>() == Some(&first_error)));
+ assert!(
+ failures
+ .iter()
+ .any(|(id, error)| id == second_id && error.to_string() == "Second close failed")
);
+ let message = error.to_string();
+ assert!(message.contains(first_id.0.as_ref()) && message.contains(second_id.0.as_ref()));
+ assert!(message.contains("First close failed") && message.contains("Second close failed"));
}
#[gpui::test]