mirror of
https://github.com/zed-industries/zed.git
synced 2026-11-19 06:59:22 +01:00
Select ACP v2 for beta connections (#65892)
- Select ACP v2 for new connections when the existing `acp-beta` feature flag is enabled; leave flag-off connections on v1 and preserve v1 beta behavior on fallback. - Start a fresh v1 process/transport only after a correlated initialization exchange establishes v1-only support: a valid v1 initialization response or structured `-32022` data with `requested: 2` and a well-formed `supported` list containing 1 but not 2. Do not guess from error-message text or retry malformed initialization, unrelated protocol errors, or ordinary transport failures. - Drain initialization output on natural process exit before classifying failure, preserving structured negotiation diagnostics even when the agent exits immediately after rejection. - Include v2 connections in the existing ACP logs UI without adding debug-log requirements to the generic connection trait. This is behavior-changing activation for the existing `acp-beta` audience. Release Notes: - N/A
This commit is contained in:
Generated
+2
@@ -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",
|
||||
|
||||
@@ -18,6 +18,7 @@ test = false
|
||||
test-support = ["workspace/test-support"]
|
||||
|
||||
[dependencies]
|
||||
acp_thread.workspace = true
|
||||
agent-client-protocol.workspace = true
|
||||
agent_servers.workspace = true
|
||||
agent_ui.workspace = true
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -37,6 +37,7 @@ chrono.workspace = true
|
||||
client.workspace = true
|
||||
collections.workspace = true
|
||||
env_logger = { workspace = true, optional = true }
|
||||
feature_flags.workspace = true
|
||||
fs.workspace = true
|
||||
futures.workspace = true
|
||||
gpui.workspace = true
|
||||
|
||||
@@ -12,7 +12,7 @@ use session_updates::{InboundSessionNotification, InboundSessionUpdate, PendingS
|
||||
pub 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/claude-agent-acp@0.94.0".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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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.message
|
||||
else {
|
||||
panic!("request message");
|
||||
};
|
||||
@@ -246,7 +394,7 @@ mod tests {
|
||||
let AcpDebugMessageContent::Response {
|
||||
id: response_id,
|
||||
result: Err(actual_error),
|
||||
} = &response.message
|
||||
} = &response.message.message
|
||||
else {
|
||||
panic!("error response");
|
||||
};
|
||||
|
||||
@@ -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 60
|
||||
child,
|
||||
stderr_task: Task::ready(()).shared(),
|
||||
runtime: Rc::new(RefCell::new(None)),
|
||||
drain: None,
|
||||
}),
|
||||
&mut cx,
|
||||
)
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user