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_servers: Preserve initial ACP session updates (#65339)

Ben Brandt9ab0715969e9
diff --git a/Cargo.lock b/Cargo.lock
index 7d4927114a0..bf7b2d1f2c5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -327,9 +327,9 @@ dependencies = [
[[package]]
name = "agent-client-protocol"
-version = "3.1.0"
+version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e582d0a6aed50feeea4d4ed3c57919db2f614a5cec42cd7acd1717231fa4f2f"
+checksum = "e0d09e5bd7214b0aa5f0fd3f2eefae4a8c0069fd6a4c1ae4e733d3691e36ec19"
dependencies = [
"agent-client-protocol-derive",
"agent-client-protocol-schema",
@@ -345,9 +345,9 @@ dependencies = [
[[package]]
name = "agent-client-protocol-derive"
-version = "3.1.0"
+version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "605b0063f9c1b05c28bb7d6242b156ffa1e81b9469c6279f9cc291c0df2855d2"
+checksum = "e8b4e3a708345c6c952bd0091abb58f3169e839ee9c7023285a7e22ab96ba4f3"
dependencies = [
"quote",
"syn 3.0.3",
diff --git a/Cargo.toml b/Cargo.toml
index 062c473f593..616a75fa126 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -527,7 +527,7 @@ accesskit = { version = "0.24.0", features = ["enumn"] }
accesskit_macos = "0.26.0"
accesskit_unix = "0.22"
accesskit_windows = "0.34"
-agent-client-protocol = { version = "=3.1.0", features = ["schemars", "unstable", "unstable_protocol_v2"] }
+agent-client-protocol = { version = "=3.2.0", features = ["schemars", "unstable", "unstable_protocol_v2"] }
aho-corasick = "1.1"
alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "4c129667ce56611becdc82de6e28218c80e2e88f" }
any_vec = "0.14"
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index 2319b3e1f9b..2aa0324dbb1 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -1656,12 +1656,61 @@ impl AgentConnection for AcpConnection {
let mcp_servers = mcp_servers_for_project(&project, cx);
cx.spawn(async move |cx| {
- let response = self
+ let (response_sender, response_received) = futures::channel::oneshot::channel();
+ let (registered, registration_finished) = futures::channel::oneshot::channel();
+ let request = self
.connection
- .send_request(directories.into_new_session_request(mcp_servers))
- .block_task()
- .await
- .map_err(map_acp_error)?;
+ .prepare_request(directories.into_new_session_request(mcp_servers));
+ let cancellation = request.cancellation_handle();
+ request
+ .on_receiving_result({
+ let connection = self.connection.clone();
+ let supports_close = self
+ .agent_capabilities
+ .session_capabilities
+ .close
+ .is_some();
+ async move |result: Result<acp::NewSessionResponse, acp::Error>| {
+ let session_id = result
+ .as_ref()
+ .ok()
+ .map(|response| response.session_id.clone());
+ let registered = response_sender.send(result).is_ok()
+ && registration_finished.await.is_ok();
+ if !registered && supports_close {
+ if let Some(session_id) = session_id {
+ connection
+ .prepare_request(acp::CloseSessionRequest::new(session_id))
+ .on_receiving_result(
+ async move |result: Result<
+ acp::CloseSessionResponse,
+ acp::Error,
+ >| {
+ if let Err(error) = result {
+ log::warn!(
+ "ACP abandoned-session close failed with code {}",
+ error.code
+ );
+ }
+ Ok(())
+ },
+ )
+ .log_err();
+ }
+ }
+ Ok(())
+ }
+ })
+ .map_err(map_acp_error)?;
+ // Early SDK cancellation is not latched, so arm caller-drop cleanup
+ // only after the prepared request's publishing call returns.
+ let _request_guard = util::defer(move || {
+ cancellation.cancel().log_err();
+ });
+ let response = response_received
+ .await
+ .context("ACP new-session response callback was cancelled")?
+ .map_err(map_acp_error)?;
let (modes, config_options) = config_state(response.modes, response.config_options)?;
@@ -1746,6 +1795,9 @@ impl AgentConnection for AcpConnection {
)
});
+ registered
+ .send(())
+ .map_err(|_| anyhow!("ACP new-session ordering callback ended before registration"))?;
Ok(thread)
})
}
@@ -5162,6 +5214,30 @@ exit 7
Arc<std::sync::Mutex<Vec<acp::SessionUpdate>>>,
Arc<std::sync::Mutex<Option<async_channel::Receiver<()>>>>,
Task<anyhow::Result<()>>,
+ ) {
+ connect_fake_agent_with_new_session_behavior(close_session_gate, agent_sender, None, cx)
+ .await
+ }
+
+ struct NewSessionTestBehavior {
+ received: async_channel::Sender<agent_client_protocol::RequestCancellation>,
+ respond: async_channel::Receiver<Result<acp::NewSessionResponse, acp::Error>>,
+ updates: Vec<acp::SessionUpdate>,
+ }
+
+ async fn connect_fake_agent_with_new_session_behavior(
+ close_session_gate: Option<async_channel::Receiver<()>>,
+ agent_sender: Option<futures::channel::oneshot::Sender<ConnectionTo<Client>>>,
+ new_session_behavior: Option<NewSessionTestBehavior>,
+ cx: &mut gpui::TestAppContext,
+ ) -> (
+ Rc<AcpConnection>,
+ Entity<project::Project>,
+ Arc<AtomicUsize>,
+ Arc<AtomicUsize>,
+ Arc<std::sync::Mutex<Vec<acp::SessionUpdate>>>,
+ Arc<std::sync::Mutex<Option<async_channel::Receiver<()>>>>,
+ Task<anyhow::Result<()>>,
) {
cx.update(|cx| {
let store = settings::SettingsStore::test(cx);
@@ -5179,6 +5255,7 @@ exit 7
let load_session_gate: Arc<std::sync::Mutex<Option<async_channel::Receiver<()>>>> =
Arc::new(std::sync::Mutex::new(None));
let close_session_gate = Arc::new(std::sync::Mutex::new(close_session_gate));
+ let new_session_behavior = Arc::new(Mutex::new(new_session_behavior));
let (client_transport, agent_transport) = agent_client_protocol::Channel::duplex();
@@ -5214,8 +5291,40 @@ exit 7
agent_client_protocol::on_receive_request!(),
)
.on_receive_request(
- async move |_req: acp::NewSessionRequest, responder, _cx| {
- responder.respond(acp::NewSessionResponse::new(acp::SessionId::new("unused")))
+ async move |_req: acp::NewSessionRequest, responder, cx| {
+ let behavior = new_session_behavior
+ .lock()
+ .expect("new session behavior")
+ .take();
+ if let Some(behavior) = behavior {
+ let connection = cx.clone();
+ cx.spawn(async move {
+ behavior
+ .received
+ .send(responder.cancellation())
+ .await
+ .expect("notify new request");
+ let response =
+ behavior.respond.recv().await.expect("release new response");
+ let session_id = response
+ .as_ref()
+ .ok()
+ .map(|response| response.session_id.clone());
+ responder.respond_with_result(response)?;
+ if let Some(session_id) = session_id {
+ for update in behavior.updates {
+ connection.send_notification(acp::SessionNotification::new(
+ session_id.clone(),
+ update,
+ ))?;
+ }
+ }
+ Ok(())
+ })
+ } else {
+ responder
+ .respond(acp::NewSessionResponse::new(acp::SessionId::new("unused")))
+ }
},
agent_client_protocol::on_receive_request!(),
)
@@ -5810,6 +5919,273 @@ exit 7
assert!(receiver.next().now_or_never().is_none());
}
+ #[gpui::test]
+ async fn new_session_registers_before_immediate_update(cx: &mut gpui::TestAppContext) {
+ let (received, request_received) = async_channel::bounded(1);
+ let (respond, response_released) = async_channel::bounded(1);
+ let (connection, project, _, _, _, _, _keep_agent_alive) =
+ connect_fake_agent_with_new_session_behavior(
+ None,
+ None,
+ Some(NewSessionTestBehavior {
+ received,
+ respond: response_released,
+ updates: vec![acp::SessionUpdate::AgentMessageChunk(
+ acp::ContentChunk::new("First update immediately after creation".into()),
+ )],
+ }),
+ cx,
+ )
+ .await;
+ let creation = cx.update(|cx| {
+ connection.clone().new_session(
+ project,
+ PathList::new(&[std::path::Path::new("/a")]),
+ cx,
+ )
+ });
+ request_received.recv().await.expect("new-session request");
+
+ let (acknowledgment, mut barrier_received) = futures::channel::oneshot::channel();
+ let barrier: ForegroundWork = Box::new(ForegroundBarrier { acknowledgment });
+ assert!(connection.dispatch_tx.unbounded_send(barrier).is_ok());
+ respond
+ .try_send(Ok(acp::NewSessionResponse::new(acp::SessionId::new(
+ "unused",
+ ))))
+ .expect("release response and first update");
+ let executor = cx.executor();
+ let dispatcher = executor
+ .dispatcher()
+ .as_test()
+ .expect("deterministic test dispatcher");
+ let mut background_drained = false;
+ for _ in 0..1000 {
+ if !dispatcher.tick(true) {
+ background_drained = true;
+ break;
+ }
+ }
+ assert!(background_drained, "SDK dispatch must quiesce");
+ assert!(connection.sessions.borrow().is_empty());
+ assert!(
+ barrier_received
+ .try_recv()
+ .expect("queued barrier")
+ .is_none()
+ );
+
+ cx.run_until_parked();
+ let thread = creation.await.expect("new session");
+ assert!(
+ thread
+ .read_with(cx, |thread, cx| thread.to_markdown(cx))
+ .contains("First update immediately after creation"),
+ "the first update must not be dropped before session registration"
+ );
+ }
+
+ #[gpui::test]
+ async fn abandoned_new_session_closes_late_response(cx: &mut gpui::TestAppContext) {
+ let (received, request_received) = async_channel::bounded(1);
+ let (respond, response_released) = async_channel::bounded(1);
+ let (connection, project, _, close_count, _, _, _keep_agent_alive) =
+ connect_fake_agent_with_new_session_behavior(
+ None,
+ None,
+ Some(NewSessionTestBehavior {
+ received,
+ respond: response_released,
+ updates: Vec::new(),
+ }),
+ cx,
+ )
+ .await;
+ let creation = cx.update(|cx| {
+ connection.clone().new_session(
+ project.clone(),
+ PathList::new(&[std::path::Path::new("/a")]),
+ cx,
+ )
+ });
+ let cancellation = request_received.recv().await.expect("new-session request");
+ drop(creation);
+ cx.run_until_parked();
+ assert!(
+ cancellation.is_cancelled(),
+ "caller drop must cancel the RPC"
+ );
+ assert!(connection.sessions.borrow().is_empty());
+ assert_eq!(close_count.load(Ordering::SeqCst), 0);
+
+ respond
+ .try_send(Ok(acp::NewSessionResponse::new(acp::SessionId::new(
+ "unused",
+ ))))
+ .expect("release late response");
+ cx.run_until_parked();
+ assert!(connection.sessions.borrow().is_empty());
+ assert_eq!(close_count.load(Ordering::SeqCst), 1);
+ let thread = cx
+ .update(|cx| {
+ connection.clone().load_session(
+ acp::SessionId::new("after-abandonment"),
+ project,
+ PathList::new(&[std::path::Path::new("/a")]),
+ None,
+ cx,
+ )
+ })
+ .await
+ .expect("abandonment must not end the connection");
+ assert_eq!(
+ thread.read_with(cx, |thread, _| thread.session_id().clone()),
+ acp::SessionId::new("after-abandonment")
+ );
+ }
+
+ #[gpui::test]
+ async fn abandoned_new_session_releases_registration_barrier(cx: &mut gpui::TestAppContext) {
+ let (received, request_received) = async_channel::bounded(1);
+ let (respond, response_released) = async_channel::bounded(1);
+ let (connection, project, _, close_count, _, _, _keep_agent_alive) =
+ connect_fake_agent_with_new_session_behavior(
+ None,
+ None,
+ Some(NewSessionTestBehavior {
+ received,
+ respond: response_released,
+ updates: Vec::new(),
+ }),
+ cx,
+ )
+ .await;
+ let creation = cx.update(|cx| {
+ connection.clone().new_session(
+ project,
+ PathList::new(&[std::path::Path::new("/a")]),
+ cx,
+ )
+ });
+ request_received.recv().await.expect("new-session request");
+ respond
+ .try_send(Ok(acp::NewSessionResponse::new(acp::SessionId::new(
+ "unused",
+ ))))
+ .expect("release response");
+ let executor = cx.executor();
+ let dispatcher = executor
+ .dispatcher()
+ .as_test()
+ .expect("deterministic test dispatcher");
+ let mut background_drained = false;
+ for _ in 0..1000 {
+ if !dispatcher.tick(true) {
+ background_drained = true;
+ break;
+ }
+ }
+ assert!(
+ background_drained,
+ "ordered response must await foreground setup"
+ );
+ assert!(connection.sessions.borrow().is_empty());
+ drop(creation);
+ cx.run_until_parked();
+ assert_eq!(close_count.load(Ordering::SeqCst), 1);
+ assert!(connection.sessions.borrow().is_empty());
+ }
+
+ #[gpui::test]
+ async fn new_session_rejection_releases_ordered_dispatch(cx: &mut gpui::TestAppContext) {
+ let (received, request_received) = async_channel::bounded(1);
+ let (respond, response_released) = async_channel::bounded(1);
+ let (connection, project, _, close_count, _, _, _keep_agent_alive) =
+ connect_fake_agent_with_new_session_behavior(
+ None,
+ None,
+ Some(NewSessionTestBehavior {
+ received,
+ respond: response_released,
+ updates: Vec::new(),
+ }),
+ cx,
+ )
+ .await;
+ let creation = cx.update(|cx| {
+ connection.clone().new_session(
+ project.clone(),
+ PathList::new(&[std::path::Path::new("/a")]),
+ cx,
+ )
+ });
+ request_received.recv().await.expect("new-session request");
+ let rejection = acp::Error::invalid_params();
+ respond
+ .try_send(Err(rejection.clone()))
+ .expect("reject session creation");
+ let error = creation.await.expect_err("creation must reject");
+ assert_eq!(error.downcast_ref::<acp::Error>(), Some(&rejection));
+ cx.run_until_parked();
+ assert!(connection.sessions.borrow().is_empty());
+ assert_eq!(close_count.load(Ordering::SeqCst), 0);
+ let thread = cx
+ .update(|cx| {
+ connection.clone().load_session(
+ acp::SessionId::new("after-rejection"),
+ project,
+ PathList::new(&[std::path::Path::new("/a")]),
+ None,
+ cx,
+ )
+ })
+ .await
+ .expect("rejection must not end or block the connection");
+ assert_eq!(
+ thread.read_with(cx, |thread, _| thread.session_id().clone()),
+ acp::SessionId::new("after-rejection")
+ );
+ }
+
+ #[gpui::test]
+ async fn new_session_eof_releases_ordered_dispatch(cx: &mut gpui::TestAppContext) {
+ let (received, request_received) = async_channel::bounded(1);
+ let (_respond, response_released) = async_channel::bounded(1);
+ let (connection, project, _, close_count, _, _, keep_agent_alive) =
+ connect_fake_agent_with_new_session_behavior(
+ None,
+ None,
+ Some(NewSessionTestBehavior {
+ received,
+ respond: response_released,
+ updates: Vec::new(),
+ }),
+ cx,
+ )
+ .await;
+ let creation = cx.update(|cx| {
+ connection.clone().new_session(
+ project,
+ PathList::new(&[std::path::Path::new("/a")]),
+ cx,
+ )
+ });
+ request_received.recv().await.expect("new-session request");
+ drop(keep_agent_alive);
+ cx.run_until_parked();
+ assert!(creation.await.is_err(), "EOF must fail session creation");
+ cx.run_until_parked();
+ assert!(connection.connection.is_incoming_closed());
+ assert!(connection.sessions.borrow().is_empty());
+ assert_eq!(close_count.load(Ordering::SeqCst), 0);
+ let (acknowledgment, barrier_received) = futures::channel::oneshot::channel();
+ let barrier: ForegroundWork = Box::new(ForegroundBarrier { acknowledgment });
+ assert!(connection.dispatch_tx.unbounded_send(barrier).is_ok());
+ barrier_received
+ .await
+ .expect("foreground dispatch after EOF");
+ }
+
#[gpui::test]
async fn test_permission_rpc_cancellation_does_not_cancel_successor(
cx: &mut gpui::TestAppContext,
diff --git a/crates/agent_servers/src/acp/debug_log.rs b/crates/agent_servers/src/acp/debug_log.rs
index beb3b4a6dd2..71e690d2c2f 100644
--- a/crates/agent_servers/src/acp/debug_log.rs
+++ b/crates/agent_servers/src/acp/debug_log.rs
@@ -183,6 +183,9 @@ impl AcpDebugLog {
.messages
.iter()
.rev()
+ // Client writes can race the agent's final stderr; only later
+ // traffic from the agent makes those diagnostics stale.
+ .filter(|message| message.direction != AcpDebugMessageDirection::Outgoing)
.take_while(|message| matches!(&message.message, AcpDebugMessageContent::Stderr { .. }))
.filter_map(|message| match &message.message {
AcpDebugMessageContent::Stderr { line } if !line.is_empty() => Some(line.as_ref()),
@@ -221,6 +224,42 @@ mod tests {
);
}
+ #[test]
+ fn trailing_stderr_is_not_hidden_by_client_traffic() {
+ let debug_log = AcpDebugLog::default();
+ debug_log.record_line(AcpDebugMessageDirection::Stderr, "startup error");
+ debug_log.record_line(
+ AcpDebugMessageDirection::Outgoing,
+ r#"{"jsonrpc":"2.0","id":"startup","method":"initialize","params":{}}"#,
+ );
+ debug_log.record_line(AcpDebugMessageDirection::Stderr, "error detail");
+ debug_log.record_line(
+ AcpDebugMessageDirection::Outgoing,
+ r#"{"jsonrpc":"2.0","method":"$/cancel_request","params":{"requestId":"startup"}}"#,
+ );
+ assert_eq!(
+ debug_log.trailing_stderr().as_deref(),
+ Some("startup error\nerror detail")
+ );
+
+ debug_log.record_line(
+ AcpDebugMessageDirection::Incoming,
+ r#"{"jsonrpc":"2.0","id":"startup","result":{}}"#,
+ );
+ debug_log.record_line(
+ AcpDebugMessageDirection::Outgoing,
+ r#"{"jsonrpc":"2.0","method":"session/cancel","params":{"sessionId":"session"}}"#,
+ );
+ assert_eq!(debug_log.trailing_stderr(), None);
+
+ debug_log.record_line(AcpDebugMessageDirection::Stderr, "recent error");
+ debug_log.record_line(
+ AcpDebugMessageDirection::Outgoing,
+ r#"{"jsonrpc":"2.0","id":"next","method":"session/new","params":{}}"#,
+ );
+ assert_eq!(debug_log.trailing_stderr().as_deref(), Some("recent error"));
+ }
+
#[test]
fn debug_log_records_each_json_rpc_batch_entry() {
let debug_log = AcpDebugLog::default();