Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Select ACP v2 for beta connections (#65892)
Ben Brandtfae8a354829e
diff --git a/Cargo.lock b/Cargo.lockindex 58f2fea2710..610dbc61920 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -136,6 +136,7 @@ dependencies = [name = "acp_tools"version = "0.1.0"dependencies = [+ "acp_thread","agent-client-protocol","agent_servers","agent_ui",@@ -382,6 +383,7 @@ dependencies = ["client","collections","env_logger 0.11.8",+ "feature_flags","fs","futures 0.3.34","gpui",diff --git a/crates/acp_tools/Cargo.toml b/crates/acp_tools/Cargo.tomlindex 4ee524b3687..c199d58b403 100644--- a/crates/acp_tools/Cargo.toml+++ b/crates/acp_tools/Cargo.toml@@ -18,6 +18,7 @@ test = falsetest-support = ["workspace/test-support"][dependencies]+acp_thread.workspace = trueagent-client-protocol.workspace = trueagent_servers.workspace = trueagent_ui.workspace = truediff --git a/crates/acp_tools/src/acp_tools.rs b/crates/acp_tools/src/acp_tools.rsindex 1440cfbcc3e..c6b747951ec 100644--- a/crates/acp_tools/src/acp_tools.rs+++ b/crates/acp_tools/src/acp_tools.rs@@ -62,7 +62,7 @@ struct AcpTools {struct WatchedConnection {agent_id: AgentId,- connection: Rc<agent_servers::AcpConnection>,+ connection: Rc<dyn acp_thread::AgentConnection>,messages: Vec<WatchedConnectionMessage>,list_state: ListState,incoming_request_methods: HashMap<RequestId, Arc<str>>,@@ -158,7 +158,9 @@ impl AcpTools {continue;}- let (backlog, messages_rx) = active_connection.connection.subscribe_debug_messages();+ let Some((backlog, messages_rx)) = active_connection.subscribe_debug_messages() else {+ continue;+ };let agent_id = active_connection.agent_id.clone();let task = cx.spawn({let agent_id = agent_id.clone();diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.tomlindex 50b6e1c09d9..6213fdb7767 100644--- a/crates/agent_servers/Cargo.toml+++ b/crates/agent_servers/Cargo.toml@@ -37,6 +37,7 @@ chrono.workspace = trueclient.workspace = truecollections.workspace = trueenv_logger = { workspace = true, optional = true }+feature_flags.workspace = truefs.workspace = truefutures.workspace = truegpui.workspace = truediff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rsindex 907f9f35ec1..fc8c7ad5a3c 100644--- a/crates/agent_servers/src/acp.rs+++ b/crates/agent_servers/src/acp.rs@@ -12,7 +12,7 @@ use session_updates::{InboundSessionNotification, InboundSessionUpdate, PendingSpub use terminal_updates::{DecodedTerminalNotification, DecodedTerminalUpdate};#[cfg(any(test, feature = "test-support"))]pub use v1::test_support;-pub use v1::{AcpConnection, AcpSessionList, GEMINI_TERMINAL_AUTH_METHOD_ID, connect};+pub use v1::{AcpConnection, AcpSessionList, GEMINI_TERMINAL_AUTH_METHOD_ID};pub use v2::AcpV2Connection;use acp_thread::{AcpThread, AuthRequired, ElicitationStore, LoadError};@@ -26,6 +26,7 @@ use agent_client_protocol::{};use anyhow::{Context as _, Result, anyhow};use collections::{HashMap, HashSet};+use feature_flags::{AcpBetaFeatureFlag, FeatureFlagAppExt as _};use futures::{Future, channel::mpsc};use gpui::{App, AsyncApp, Entity, SharedString, Subscription, Task, WeakEntity};use project::agent_server_store::{AgentServerCommand, AgentServerStore};@@ -102,6 +103,110 @@ async fn exited_load_error_after_drain(#[error("Unsupported version")]pub struct UnsupportedVersion;+#[derive(Debug, Error)]+#[error("ACP v1 fallback failed: {failure}; v2 negotiation: {negotiation:#}")]+struct V1FallbackFailure {+ failure: String,+ negotiation: anyhow::Error,+}++fn fallback_failure(failure: anyhow::Error, negotiation: anyhow::Error) -> anyhow::Error {+ let context = V1FallbackFailure {+ failure: format!("{failure:#}"),+ negotiation,+ };+ // The final attempt's typed error must remain authoritative for UI error classification.+ failure.context(context)+}++pub async fn connect(+ agent_id: AgentId,+ project: Entity<Project>,+ command: AgentServerCommand,+ agent_server_store: WeakEntity<AgentServerStore>,+ default_mode: Option<acp_v2::SessionConfigValueId>,+ default_config_options: HashMap<String, settings::AgentConfigOptionValue>,+ cx: &mut AsyncApp,+) -> Result<Rc<dyn acp_thread::AgentConnection>> {+ let negotiation_error = if cx.update(|cx| cx.has_flag::<AcpBetaFeatureFlag>()) {+ match AcpV2Connection::stdio(+ agent_id.clone(),+ project.clone(),+ command.clone(),+ agent_server_store.clone(),+ cx,+ )+ .await+ {+ Ok(connection) => return Ok(Rc::new(connection)),+ Err(error) if error.is::<UnsupportedVersion>() => Some(error),+ Err(error) => return Err(error),+ }+ } else {+ None+ };+ v1::connect(+ agent_id,+ project,+ command,+ agent_server_store,+ default_mode,+ default_config_options,+ cx,+ )+ .await+ .map_err(|error| match negotiation_error {+ Some(negotiation) => fallback_failure(error, negotiation),+ None => error,+ })+}++fn v1_only_mismatch(error: &agent_client_protocol::Error) -> bool {+ if error.code != agent_client_protocol::Error::new(-32022, "").code {+ return false;+ }+ let Some(data) = error.data.as_ref() else {+ return false;+ };+ let Some(supported) = data.get("supported").and_then(serde_json::Value::as_array) else {+ return false;+ };+ data.get("requested").and_then(serde_json::Value::as_u64) == Some(2)+ && supported+ .iter()+ .all(|value| value.as_u64().is_some_and(|version| version > 0))+ && supported.iter().any(|value| value.as_u64() == Some(1))+ && !supported.iter().any(|value| value.as_u64() == Some(2))+}++fn initialization_error(error: anyhow::Error, debug_log: &AcpDebugLog) -> anyhow::Error {+ match debug_log.initialization_response() {+ Some(Ok(Some(value))) => {+ if serde_json::from_value::<acp::InitializeResponse>(value).is_ok_and(|response| {+ response.protocol_version == agent_client_protocol::schema::ProtocolVersion::V1+ }) {+ error.context(UnsupportedVersion)+ } else {+ error+ }+ }+ Some(Err(protocol_error)) => {+ let retry_v1 = v1_only_mismatch(&protocol_error);+ let error = if error.is::<agent_client_protocol::Error>() {+ error+ } else {+ anyhow!(protocol_error).context(format!("ACP initialization failed: {error}"))+ };+ if retry_v1 {+ error.context(UnsupportedVersion)+ } else {+ error+ }+ }+ _ => error,+ }+}+/// Helper for flattening the nested `Result` shapes that come out of/// `entity.update(cx, |_, cx| fallible_op(cx))` into a single `Result<T,/// acp::Error>`.@@ -887,3 +992,338 @@ fn handle_v2_complete_elicitation(store.complete_url_elicitation(&elicitation_id, cx);})}++#[cfg(all(test, unix))]+mod selection_tests {+ use super::*;+ use gpui::{TestAppContext, UpdateGlobal as _};+ use serde_json::json;++ fn set_beta(enabled: bool, cx: &mut App) {+ cx.update_flags(+ false,+ if enabled {+ vec!["acp-beta".into()]+ } else {+ vec![]+ },+ );+ settings::SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ settings+ .feature_flags+ .get_or_insert_default()+ .insert("acp-beta".into(), if enabled { "on" } else { "off" }.into());+ });+ });+ assert_eq!(cx.has_flag::<AcpBetaFeatureFlag>(), enabled);+ }++ #[gpui::test]+ async fn beta_selection_uses_fresh_v1_fallback_only_for_version_mismatch(+ cx: &mut TestAppContext,+ ) {+ cx.update(|cx| {+ let mut store = settings::SettingsStore::test(cx);+ store.register_setting::<feature_flags::FeatureFlagsSettings>();+ cx.set_global(store);+ release_channel::init("0.0.0".parse().expect("version"), cx);+ });+ cx.executor().allow_parking();+ let directory = tempfile::tempdir().expect("working directory");+ let project = Project::example([directory.path()], &mut cx.to_async()).await;+ let v1 = r#""result":{"protocolVersion":1,"agentCapabilities":{},"agentInfo":{"name":"selected-v1","version":"1"}}"#;+ let v2 = r#""result":{"protocolVersion":2,"info":{"name":"selected-v2","version":"1"},"capabilities":{"session":{}}}"#;+ for (beta, response, exit_after_response, expected, requests) in [+ (false, v2, false, Some(false), "1"),+ (true, v2, false, Some(true), "2"),+ (true, v1, false, Some(false), "2 1"),+ (+ true,+ r#""error":{"code":-32022,"message":"Unsupported protocol version","data":{"requested":2,"supported":[1]}}"#,+ false,+ Some(false),+ "2 1",+ ),+ (+ true,+ r#""error":{"code":-32022,"message":"Unsupported protocol version","data":{"requested":2,"supported":[1]}}"#,+ true,+ Some(false),+ "2 1",+ ),+ (+ true,+ r#""error":{"code":-32022,"message":"Unsupported protocol version","data":{"requested":2,"supported":[3]}}"#,+ true,+ None,+ "2",+ ),+ (+ true,+ r#""error":{"code":-32022,"message":"Unsupported protocol version","data":{"requested":2,"supported":[1,2]}}"#,+ false,+ None,+ "2",+ ),+ (+ true,+ r#""error":{"code":-32602,"message":"Bad initialize parameters"}"#,+ false,+ None,+ "2",+ ),+ (+ true,+ r#""result":{"protocolVersion":1},"error":{"code":-32022,"message":"Invalid envelope","data":{"requested":2,"supported":[1]}}"#,+ true,+ None,+ "2",+ ),+ (+ true,+ r#""result":{"info":{"name":"malformed","version":"1"}}"#,+ false,+ None,+ "2",+ ),+ (+ true,+ r#""result":{"protocolVersion":"malformed","agentCapabilities":{}}"#,+ false,+ None,+ "2",+ ),+ (true, "", true, None, "2"),+ ] {+ cx.update(|cx| {+ set_beta(beta, cx);+ });+ let trace = directory.path().join("connections");+ std::fs::write(&trace, "").expect("clear trace");+ let command = AgentServerCommand {+ path: "/bin/sh".into(),+ args: vec!["-c".into(), r#"+printf 'start %s\n' "$$" >> "$ACP_SELECTION_TRACE"+while IFS= read -r request; do+ case "$request" in+ *'"method":"initialize"'*)+ id=${request#*\"id\":}; id=${id%%,*}+ case "$request" in+ *'"protocolVersion":2'*)+ printf 'initialize 2\n' >> "$ACP_SELECTION_TRACE"+ if [ -n "$ACP_SELECTION_RESPONSE" ]; then+ printf '{"jsonrpc":"2.0","id":%s,%s}\n' "$id" "$ACP_SELECTION_RESPONSE"+ fi+ if [ "$ACP_SELECTION_EXIT" = 1 ]; then exit 7; fi+ ;;+ *)+ printf 'initialize 1\n' >> "$ACP_SELECTION_TRACE"+ printf '{"jsonrpc":"2.0","id":%s,"result":{"protocolVersion":1,"agentCapabilities":{},"agentInfo":{"name":"selected-v1","version":"1"}}}\n' "$id"+ ;;+ esac+ ;;+ esac+done+"#.into()],+ env: Some(HashMap::from_iter([+ ("ACP_SELECTION_TRACE".into(), trace.to_string_lossy().into_owned()),+ ("ACP_SELECTION_RESPONSE".into(), response.into()),+ ("ACP_SELECTION_EXIT".into(), if exit_after_response { "1" } else { "0" }.into()),+ ])),+ };+ let connecting = cx.spawn({+ let project = project.clone();+ async move |mut cx| {+ connect(+ AgentId::new("selection"),+ project,+ command,+ WeakEntity::new_invalid(),+ None,+ HashMap::default(),+ &mut cx,+ )+ .await+ }+ });+ let timeout = cx+ .background_executor+ .timer(std::time::Duration::from_secs(10));+ futures::pin_mut!(connecting, timeout);+ let result = match futures::future::select(connecting, timeout).await {+ futures::future::Either::Left((result, _)) => result,+ _ => panic!("selection timed out: {response}"),+ };+ if let Some(v2) = expected {+ let connection = result.expect("selected connection");+ assert_eq!(+ connection.clone().downcast::<AcpV2Connection>().is_some(),+ v2+ );+ cx.update(|cx| set_beta(false, cx));+ assert_eq!(+ connection.clone().downcast::<AcpV2Connection>().is_some(),+ v2+ );+ connection.shutdown();+ drop(connection);+ } else {+ let error = result+ .err()+ .unwrap_or_else(|| panic!("unexpected successful selection for {response}"));+ if response.starts_with(r#""error":{"code":-32022"#) {+ let protocol_error = error+ .downcast_ref::<agent_client_protocol::Error>()+ .expect("structured mismatch retained");+ assert_eq!(+ protocol_error.code,+ agent_client_protocol::Error::new(-32022, "").code+ );+ assert!(protocol_error.data.is_some());+ }+ }+ let trace = std::fs::read_to_string(&trace).expect("connection trace");+ let actual = trace+ .lines()+ .filter_map(|line| line.strip_prefix("initialize "))+ .collect::<Vec<_>>()+ .join(" ");+ assert_eq!(actual, requests, "{response}");+ let processes = trace+ .lines()+ .filter_map(|line| line.strip_prefix("start "))+ .collect::<Vec<_>>();+ assert_eq!(processes.len(), requests.split_whitespace().count());+ if let [first, second] = processes.as_slice() {+ assert_ne!(first, second, "fallback must launch a fresh process");+ }+ }+ }++ #[test]+ fn version_mismatch_requires_valid_v1_only_support() {+ for data in [+ json!({"requested": 1, "supported": [1]}),+ json!({"requested": 2, "supported": [1, 2]}),+ json!({"requested": 2, "supported": [0, 1]}),+ json!({"requested": 2, "supported": [1, "2"]}),+ json!({"requested": 2}),+ ] {+ assert!(!v1_only_mismatch(+ &agent_client_protocol::Error::new(-32022, "").data(data)+ ));+ }+ assert!(!v1_only_mismatch(+ &agent_client_protocol::Error::invalid_params()+ .data(json!({"requested": 2, "supported": [1]}))+ ));+ }++ #[test]+ fn fallback_failure_keeps_the_final_error_authoritative() {+ let negotiation_data = json!({"requested": 2, "supported": [1]});+ let final_data = json!({"attempt": "v1"});+ let error = fallback_failure(+ anyhow!(agent_client_protocol::Error::invalid_params().data(final_data.clone())),+ anyhow!(+ agent_client_protocol::Error::new(-32022, "Unsupported")+ .data(negotiation_data.clone())+ )+ .context(UnsupportedVersion),+ );+ let info = acp_thread::ProtocolErrorInfo::from_error(&error).expect("final protocol error");+ assert_eq!(info.code, -32602);+ assert_eq!(info.data, Some(&final_data));+ assert!(!error.is::<UnsupportedVersion>());+ let context = error+ .downcast_ref::<V1FallbackFailure>()+ .expect("negotiation context");+ assert_eq!(+ context+ .negotiation+ .downcast_ref::<agent_client_protocol::Error>()+ .expect("original negotiation")+ .data,+ Some(negotiation_data)+ );+ }++ #[gpui::test]+ #[cfg_attr(not(feature = "e2e"), ignore)]+ async fn claude_adapter_initialize_smoke(cx: &mut TestAppContext) {+ cx.update(|cx| {+ let mut store = settings::SettingsStore::test(cx);+ store.register_setting::<feature_flags::FeatureFlagsSettings>();+ cx.set_global(store);+ release_channel::init("0.0.0".parse().expect("version"), cx);+ });+ cx.executor().allow_parking();+ let directory = tempfile::tempdir().expect("isolated working directory");+ let config = directory.path().join("claude-config");+ std::fs::create_dir(&config).expect("isolated Claude configuration");+ let project = Project::example([directory.path()], &mut cx.to_async()).await;+ for (beta, adapter_v2, expected_v2) in [+ (false, true, false),+ (true, true, true),+ (true, false, false),+ ] {+ cx.update(|cx| set_beta(beta, cx));+ let command = AgentServerCommand {+ path: "npx".into(),+ args: vec![+ "--yes".into(),+ "@agentclientprotocol/[email protected]".into(),+ ],+ env: Some(HashMap::from_iter([+ (+ "CLAUDE_CONFIG_DIR".into(),+ config.to_string_lossy().into_owned(),+ ),+ (+ "CLAUDE_AGENT_ACP_EXPERIMENTAL_V2".into(),+ if adapter_v2 { "1" } else { "0" }.into(),+ ),+ ("ANTHROPIC_API_KEY".into(), "".into()),+ ("CLAUDE_CODE_OAUTH_TOKEN".into(), "".into()),+ ])),+ };+ let connecting = cx.spawn({+ let project = project.clone();+ async move |mut cx| {+ connect(+ AgentId::new("claude-acp"),+ project,+ command,+ WeakEntity::new_invalid(),+ None,+ HashMap::default(),+ &mut cx,+ )+ .await+ }+ });+ let timeout = cx+ .background_executor+ .timer(std::time::Duration::from_secs(30));+ futures::pin_mut!(connecting, timeout);+ let connection = match futures::future::select(connecting, timeout).await {+ futures::future::Either::Left((result, _)) => {+ result.expect("Claude adapter handshake")+ }+ _ => panic!("Claude adapter handshake timed out"),+ };+ let actual_v2 = connection.clone().downcast::<AcpV2Connection>().is_some();+ assert_eq!(+ actual_v2, expected_v2,+ "beta={beta} adapter_v2={adapter_v2}"+ );+ println!(+ "Claude ACP 0.94.0: beta={beta}, adapter_v2={adapter_v2}, selected_v2={actual_v2}"+ );+ connection.shutdown();+ drop(connection);+ cx.run_until_parked();+ }+ }+}diff --git a/crates/agent_servers/src/acp/debug_log.rs b/crates/agent_servers/src/acp/debug_log.rsindex bdf16320be3..b384beec4ec 100644--- a/crates/agent_servers/src/acp/debug_log.rs+++ b/crates/agent_servers/src/acp/debug_log.rs@@ -40,14 +40,23 @@ pub struct AcpDebugMessage {pub message: AcpDebugMessageContent,}+#[derive(Clone)]+struct ParsedDebugMessage {+ message: AcpDebugMessage,+ valid_envelope: bool,+}+impl AcpDebugMessage {- fn parse_line(direction: AcpDebugMessageDirection, line: &str) -> Vec<Self> {+ fn parse_line(direction: AcpDebugMessageDirection, line: &str) -> Vec<ParsedDebugMessage> {if direction == AcpDebugMessageDirection::Stderr {- return vec![Self {- direction,- message: AcpDebugMessageContent::Stderr {- line: Arc::from(line),+ return vec![ParsedDebugMessage {+ message: Self {+ direction,+ message: AcpDebugMessageContent::Stderr {+ line: Arc::from(line),+ },},+ valid_envelope: false,}];}@@ -64,8 +73,23 @@ impl AcpDebugMessage {}}- fn parse_value(direction: AcpDebugMessageDirection, value: serde_json::Value) -> Option<Self> {+ fn parse_value(+ direction: AcpDebugMessageDirection,+ value: serde_json::Value,+ ) -> Option<ParsedDebugMessage> {let object = value.as_object()?;+ // Malformed frames are useful diagnostics, but cannot authorize protocol fallback.+ let valid_envelope = object.get("jsonrpc").and_then(serde_json::Value::as_str)+ == Some("2.0")+ && if object.contains_key("method") {+ object+ .get("method")+ .is_some_and(serde_json::Value::is_string)+ && !object.contains_key("result")+ && !object.contains_key("error")+ } else {+ object.contains_key("result") != object.contains_key("error")+ };let parsed_id = object.get("id")@@ -118,7 +142,10 @@ impl AcpDebugMessage {return None;};- Some(Self { direction, message })+ Some(ParsedDebugMessage {+ message: Self { direction, message },+ valid_envelope,+ })}}@@ -126,6 +153,13 @@ impl AcpDebugMessage {struct AcpDebugLogState {messages: VecDeque<AcpDebugMessage>,subscribers: Vec<async_channel::Sender<AcpDebugMessage>>,+ // Startup fallback must not depend on eviction from the diagnostic backlog.+ initialization: Option<InitializationExchange>,+}++struct InitializationExchange {+ request_id: RequestId,+ response: Option<ParsedDebugMessage>,}#[derive(Clone, Default)]@@ -134,6 +168,23 @@ pub(super) struct AcpDebugLog {}impl AcpDebugLog {+ pub(super) fn initialization_response(+ &self,+ ) -> Option<Result<Option<serde_json::Value>, Error>> {+ let state = self+ .state+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner());+ let response = state.initialization.as_ref()?.response.as_ref()?;+ if !response.valid_envelope {+ return None;+ }+ match &response.message.message {+ AcpDebugMessageContent::Response { result, .. } => Some(result.clone()),+ _ => None,+ }+ }+pub(super) fn subscribe(&self,) -> (@@ -158,14 +209,41 @@ impl AcpDebugLog {self.record_messages(messages);}- fn record_messages(&self, messages: Vec<AcpDebugMessage>) {+ fn record_messages(&self, messages: Vec<ParsedDebugMessage>) {let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());state.subscribers.retain(|sender| !sender.is_closed());- for message in messages {+ for parsed in messages {+ let message = &parsed.message;+ match (message.direction, &message.message) {+ (+ AcpDebugMessageDirection::Outgoing,+ AcpDebugMessageContent::Request { id, method, .. },+ ) if parsed.valid_envelope+ && method.as_ref() == "initialize"+ && state.initialization.is_none() =>+ {+ state.initialization = Some(InitializationExchange {+ request_id: id.clone(),+ response: None,+ });+ }+ (+ AcpDebugMessageDirection::Incoming,+ AcpDebugMessageContent::Response { id, .. },+ ) => {+ if let Some(initialization) = &mut state.initialization+ && initialization.request_id == *id+ && initialization.response.is_none()+ {+ initialization.response = Some(parsed.clone());+ }+ }+ _ => {}+ }if state.messages.len() == MAX_DEBUG_BACKLOG_MESSAGES {state.messages.pop_front();}@@ -206,6 +284,76 @@ impl AcpDebugLog {mod tests {use super::*;+ #[test]+ fn malformed_initialization_envelopes_never_become_fallback_evidence() {+ for response in [+ r#"{"id":"initialize","result":{"protocolVersion":1}}"#,+ r#"{"jsonrpc":"1.0","id":"initialize","result":{"protocolVersion":1}}"#,+ r#"{"jsonrpc":"2.0","id":"initialize","result":{"protocolVersion":1},"error":{"code":-32022,"message":"Unsupported","data":{"requested":2,"supported":[1]}}}"#,+ r#"{"jsonrpc":"2.0","id":"initialize","method":null,"result":{"protocolVersion":1}}"#,+ ] {+ let log = AcpDebugLog::default();+ log.record_line(+ AcpDebugMessageDirection::Outgoing,+ r#"{"jsonrpc":"2.0","id":"initialize","method":"initialize","params":{"protocolVersion":2}}"#,+ );+ log.record_line(AcpDebugMessageDirection::Incoming, response);+ assert!(log.initialization_response().is_none(), "{response}");+ log.record_line(+ AcpDebugMessageDirection::Incoming,+ r#"{"jsonrpc":"2.0","id":"initialize","result":{"protocolVersion":1}}"#,+ );+ assert!(+ log.initialization_response().is_none(),+ "invalid first response must not be replaced"+ );+ assert_eq!(log.subscribe().0.len(), 3, "diagnostics remain visible");+ }+ }++ #[test]+ fn initialization_evidence_is_correlated_and_survives_backlog_eviction() {+ let log = AcpDebugLog::default();+ log.record_line(+ AcpDebugMessageDirection::Outgoing,+ r#"{"jsonrpc":"2.0","id":"initialize","method":"initialize","params":{"protocolVersion":2}}"#,+ );+ log.record_line(+ AcpDebugMessageDirection::Incoming,+ r#"{"jsonrpc":"2.0","id":"unrelated","result":{"protocolVersion":1}}"#,+ );+ assert!(log.initialization_response().is_none());+ log.record_line(+ AcpDebugMessageDirection::Incoming,+ r#"{"jsonrpc":"2.0","id":"initialize","error":{"code":-32022,"message":"Unsupported","data":{"requested":2,"supported":[1]}}}"#,+ );+ log.record_line(+ AcpDebugMessageDirection::Incoming,+ r#"{"jsonrpc":"2.0","id":"initialize","result":{"protocolVersion":2}}"#,+ );+ for _ in 0..MAX_DEBUG_BACKLOG_MESSAGES {+ log.record_line(+ AcpDebugMessageDirection::Incoming,+ r#"{"jsonrpc":"2.0","method":"_noise"}"#,+ );+ }+ let error = log+ .initialization_response()+ .expect("retained initialization")+ .expect_err("first response wins");+ assert_eq!(error.code, Error::new(-32022, "").code);+ assert_eq!(+ error.data,+ Some(serde_json::json!({"requested": 2, "supported": [1]}))+ );+ assert!(+ log.subscribe().0.iter().all(|message| matches!(+ message.message,+ AcpDebugMessageContent::Notification { .. }+ ))+ );+ }+#[test]fn preserves_shared_request_ids_payloads_and_runtime_error_data() {let id = RequestId::Str("opaque/request:雪".into());@@ -225,7 +373,7 @@ mod tests {id: request_id,method,params: actual_params,- } = &request.message+ } = &request.message.messageelse {panic!("request message");};@@ -246,7 +394,7 @@ mod tests {let AcpDebugMessageContent::Response {id: response_id,result: Err(actual_error),- } = &response.message+ } = &response.message.messageelse {panic!("error response");};diff --git a/crates/agent_servers/src/acp/v2.rs b/crates/agent_servers/src/acp/v2.rsindex 1338bce8d0a..7c22cbcab4d 100644--- a/crates/agent_servers/src/acp/v2.rs+++ b/crates/agent_servers/src/acp/v2.rs@@ -183,7 +183,7 @@ fn shared_session_error(error: Arc<anyhow::Error>) -> anyhow::Error {}}-/// An unselected v2 backend with auth, initial sessions/config and receipt-driven prompts.+/// An ACP v2 backend with auth, initial sessions/config and receipt-driven prompts.pub struct AcpV2Connection {id: AgentId,connection: V2ConnectionTo<Agent>,@@ -211,6 +211,7 @@ struct StdioStartup {child: transport::OwnedChild,stderr_task: Shared<Task<()>>,runtime: Rc<RefCell<Option<ConnectionRuntime>>>,+ drain: Option<futures::channel::oneshot::Sender<LocalBoxFuture<'static, ()>>>,}impl AcpV2Connection {@@ -251,6 +252,7 @@ impl AcpV2Connection {// Keep cleanup from killing the child before startup error arbitration can// distinguish a protocol rejection from a natural process exit.let startup_runtime = Rc::new(RefCell::new(None));+ let (drain_sender, drain_received) = futures::channel::oneshot::channel();let initialized = {let mut cx = cx.clone();let debug_log = debug_log.clone();@@ -267,6 +269,7 @@ impl AcpV2Connection {child,stderr_task,runtime,+ drain: Some(drain_sender),}),&mut cx,)@@ -274,17 +277,17 @@ impl AcpV2Connection {}}.boxed_local();- let result = runtime::race_startup(initialized, status, stderr_task, &debug_log, cx).await;+ let drained = async move {+ match drain_received.await {+ Ok(drained) => drained.await,+ Err(_) => stderr_task.await,+ }+ }+ .boxed_local();+ let result = runtime::race_startup(initialized, status, drained, &debug_log, cx).await;drop(startup_runtime);- let (connection, status, stderr_task) = result?;- let drained = {- let sdk_connection = connection.connection.clone();- runtime::drain_transport(- async move { sdk_connection.incoming_closed().await },- connection.dispatch_tx.clone(),- stderr_task,- )- };+ let (connection, status, drained) =+ result.map_err(|error| super::initialization_error(error, &debug_log))?;let mut runtime = connection.runtime.borrow_mut();let owned = runtime.as_mut()@@ -311,9 +314,19 @@ impl AcpV2Connection {startup: Option<StdioStartup>,cx: &mut AsyncApp,) -> Result<Self> {- let (runtime, child, stderr_task) = match startup {- Some(startup) => (startup.runtime, Some(startup.child), startup.stderr_task),- None => (Rc::new(RefCell::new(None)), None, Task::ready(()).shared()),+ let (runtime, child, stderr_task, drain_sender) = match startup {+ Some(startup) => (+ startup.runtime,+ Some(startup.child),+ startup.stderr_task,+ startup.drain,+ ),+ None => (+ Rc::new(RefCell::new(None)),+ None,+ Task::ready(()).shared(),+ None,+ ),};let request_elicitations = cx.new(|_| ElicitationStore::default());let sessions = Rc::new(RefCell::new(HashMap::default()));@@ -344,6 +357,7 @@ impl AcpV2Connection {.await});client_runtime.start_io(runtime::finish_connection(connection_future, cleanup), cx);+ let stderr_for_drain = stderr_task.clone();*runtime.borrow_mut() = Some(ConnectionRuntime {_client: client_runtime,_stderr_task: stderr_task,@@ -369,6 +383,18 @@ impl AcpV2Connection {let connection = received.await.context("Failed to receive ACP v2 connection handle")?;+ if let Some(sender) = drain_sender {+ let sdk_connection = connection.clone();+ let drained = runtime::drain_transport(+ async move { sdk_connection.incoming_closed().await },+ dispatch_tx.clone(),+ stderr_for_drain,+ )+ .boxed_local();+ if sender.send(drained).is_err() {+ log::debug!("ACP startup drain observer was released");+ }+ }let supports_terminal_auth = agent_server_store.upgrade().is_some_and(|store| {store.update(cx, |store, _| store.get_external_agent(&id).is_some())});@@ -6866,6 +6892,7 @@ exec sleep 60child,stderr_task: Task::ready(()).shared(),runtime: Rc::new(RefCell::new(None)),+ drain: None,}),&mut cx,)diff --git a/crates/agent_ui/src/agent_connection_store.rs b/crates/agent_ui/src/agent_connection_store.rsindex 76e292280c6..320f6f8c563 100644--- a/crates/agent_ui/src/agent_connection_store.rs+++ b/crates/agent_ui/src/agent_connection_store.rs@@ -1,7 +1,7 @@use std::rc::{Rc, Weak};use acp_thread::{AgentConnection, LoadError};-use agent_servers::AcpConnection;+use agent_servers::{AcpConnection, AcpDebugMessage, AcpV2Connection};use agent_servers::{AgentServer, AgentServerDelegate};use anyhow::Result;use collections::HashMap;@@ -63,7 +63,25 @@ impl EventEmitter<AgentConnectionEntryEvent> for AgentConnectionEntry {}#[derive(Clone)]pub struct ActiveAcpConnection {pub agent_id: project::AgentId,- pub connection: Rc<AcpConnection>,+ pub connection: Rc<dyn AgentConnection>,+}++impl ActiveAcpConnection {+ pub fn subscribe_debug_messages(+ &self,+ ) -> Option<(+ Vec<AcpDebugMessage>,+ async_channel::Receiver<AcpDebugMessage>,+ )> {+ if let Some(connection) = self.connection.clone().downcast::<AcpConnection>() {+ Some(connection.subscribe_debug_messages())+ } else {+ self.connection+ .clone()+ .downcast::<AcpV2Connection>()+ .map(|connection| connection.subscribe_debug_messages())+ }+ }}pub struct AgentConnectionStore {@@ -132,14 +150,16 @@ impl AgentConnectionStore {self.entries.values().filter_map(|entry| match entry.read(cx) {- AgentConnectionEntry::Connected(state) => state- .connection- .clone()- .downcast::<AcpConnection>()- .map(|connection| ActiveAcpConnection {- agent_id: state.connection.agent_id(),- connection,- }),+ AgentConnectionEntry::Connected(state) => {+ let connection = state.connection.clone();+ let concrete = connection.clone().into_any();+ (concrete.is::<AcpConnection>() || concrete.is::<AcpV2Connection>()).then(+ || ActiveAcpConnection {+ agent_id: connection.agent_id(),+ connection,+ },+ )+ }AgentConnectionEntry::Connecting { .. } | AgentConnectionEntry::Error { .. } => {None}