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: Fix ACP reasoning options after applying defaults (#65233)

Ben Brandt78a0da201cec
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index 714d04af966..07cd62d8c07 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -391,6 +391,28 @@ impl ConfigOptions {
rx,
}
}
+
+ async fn set_config_option(
+ &self,
+ connection: &ConnectionTo<Agent>,
+ session_id: acp::SessionId,
+ config_id: acp_v2::SessionConfigId,
+ value: acp_v2::SessionConfigOptionValue,
+ ) -> Result<Vec<acp_v2::SessionConfigOption>> {
+ let value = acp_thread::config_options::value_to_v1(value)?;
+ let response = connection
+ .send_request(acp::SetSessionConfigOptionRequest::new(
+ session_id,
+ acp::SessionConfigId::new(config_id.0),
+ value,
+ ))
+ .block_task()
+ .await?;
+ let config_options = acp_thread::config_options::from_v1(response.config_options)?;
+ *self.config_options.borrow_mut() = config_options.clone();
+ self.tx.borrow_mut().send(()).ok();
+ Ok(config_options)
+ }
}
pub struct AcpSession {
@@ -398,6 +420,7 @@ pub struct AcpSession {
suppress_abort_err: bool,
session_modes: Option<Rc<RefCell<acp::SessionModeState>>>,
config_options: Option<ConfigOptions>,
+ default_config_task: Option<Task<()>>,
_release_subscription: Subscription,
}
@@ -1036,6 +1059,7 @@ impl AcpConnection {
thread: &Entity<AcpThread>,
session_modes: Option<Rc<RefCell<acp::SessionModeState>>>,
config_options: Option<ConfigOptions>,
+ default_config_task: Option<Task<()>>,
cx: &mut App,
) {
let release_subscription = cx.observe_release(thread, {
@@ -1055,6 +1079,7 @@ impl AcpConnection {
suppress_abort_err: false,
session_modes,
config_options,
+ default_config_task,
_release_subscription: release_subscription,
},
);
@@ -1096,6 +1121,10 @@ impl AcpConnection {
return;
}
+ if let Some(session) = self.sessions.borrow_mut().get_mut(&session_id) {
+ session.default_config_task.take();
+ }
+
let task = cx
.spawn({
let this = Rc::downgrade(self);
@@ -1201,7 +1230,7 @@ impl AcpConnection {
cx,
)
});
- self.register_session(session_id.clone(), &thread, None, None, cx);
+ self.register_session(session_id.clone(), &thread, None, None, None, cx);
// The connection owns this task, so retaining the thread (which owns the
// connection) here would keep both alive after all callers abandon the load.
@@ -1257,14 +1286,14 @@ impl AcpConnection {
)));
};
session.session_modes = modes;
- session.config_options = config_options.clone().map(ConfigOptions::new);
- }
- if let Some(config_opts) = config_options.as_ref() {
- connection_state.apply_default_config_options(
- &session_id,
- config_opts,
- cx,
- );
+ session.config_options = config_options.clone();
+ session.default_config_task = config_options.as_ref().map(|options| {
+ connection_state.apply_default_config_options(
+ &session_id,
+ options,
+ cx,
+ )
+ });
}
connection_state.remove_pending_session(&session_id, thread.entity_id());
return Ok(());
@@ -1304,143 +1333,92 @@ impl AcpConnection {
fn apply_default_config_options(
&self,
session_id: &acp::SessionId,
- config_options: &Rc<RefCell<Vec<acp_v2::SessionConfigOption>>>,
+ config_options: &ConfigOptions,
cx: &mut AsyncApp,
- ) {
+ ) -> Task<()> {
let id = self.id.clone();
- let defaults_to_apply: Vec<_> = {
- let config_opts_ref = config_options.borrow();
- config_opts_ref
- .iter()
- .filter_map(|config_option| {
- let default_value = self
- .defaults
- .config_option(config_option.config_id.0.as_ref())?;
-
- let value_to_apply = match &config_option.kind {
+ let defaults = self.defaults.clone();
+ let session_id = session_id.clone();
+ let config_options = config_options.clone();
+ let connection = self.connection.clone();
+ cx.spawn(async move |_| {
+ let mut attempted_defaults = Vec::new();
+ loop {
+ let current_options = config_options.config_options.borrow().clone();
+ let next_default = current_options.iter().find_map(|option| {
+ // Retry deferred or reset defaults after dependent changes, but
+ // do not repeat an attempt in the same state if defaults conflict.
+ if attempted_defaults.iter().any(|(config_id, options)| {
+ config_id == &option.config_id && options == &current_options
+ }) {
+ return None;
+ }
+ let value = defaults.config_option(option.config_id.0.as_ref())?;
+ let already_set = match &option.kind {
acp_v2::SessionConfigKind::Select(select) => {
- let value_id = default_value.as_value_id()?;
- match &select.options {
- acp_v2::SessionConfigSelectOptions::Ungrouped(options) => options
- .iter()
- .any(|opt| &*opt.value.0 == value_id)
- .then(|| {
- acp_v2::SessionConfigOptionValue::id(value_id.to_string())
- }),
- acp_v2::SessionConfigSelectOptions::Grouped(groups) => groups
- .iter()
- .any(|group| {
- group.options.iter().any(|opt| &*opt.value.0 == value_id)
- })
- .then(|| {
- acp_v2::SessionConfigOptionValue::id(value_id.to_string())
- }),
- _ => None,
- }
+ value.as_value_id() == Some(select.current_value.0.as_ref())
}
- acp_v2::SessionConfigKind::Boolean(_) => default_value
- .as_bool()
- .map(acp_v2::SessionConfigOptionValue::boolean),
- _ => None,
- };
-
- if let Some(value_to_apply) = value_to_apply {
- let initial_value = match &config_option.kind {
- acp_v2::SessionConfigKind::Select(select) => {
- acp_v2::SessionConfigOptionValue::id(select.current_value.clone())
- }
- acp_v2::SessionConfigKind::Boolean(boolean) => {
- acp_v2::SessionConfigOptionValue::boolean(boolean.current_value)
- }
- _ => return None,
- };
-
- Some((
- config_option.config_id.clone(),
- value_to_apply,
- initial_value,
- ))
- } else {
- log::warn!(
- "`{}` is not a valid value for config option `{}` in {}",
- default_value,
- config_option.config_id.0,
- id
- );
- None
- }
- })
- .collect()
- };
-
- for (config_id, default_value, initial_value) in defaults_to_apply {
- let Some(wire_value) =
- acp_thread::config_options::value_to_v1(default_value.clone()).log_err()
- else {
- continue;
- };
- cx.spawn({
- let session_id = session_id.clone();
- let config_id_clone = config_id.clone();
- let config_opts = config_options.clone();
- let conn = self.connection.clone();
- async move |_| {
- let result = conn
- .send_request(acp::SetSessionConfigOptionRequest::new(
- session_id,
- acp::SessionConfigId::new(config_id_clone.0.clone()),
- wire_value,
- ))
- .block_task()
- .await
- .log_err();
-
- if result.is_none() {
- let mut opts = config_opts.borrow_mut();
- if let Some(opt) = opts
- .iter_mut()
- .find(|option| option.config_id == config_id_clone)
- {
- match (&mut opt.kind, &initial_value) {
- (
- acp_v2::SessionConfigKind::Select(select),
- acp_v2::SessionConfigOptionValue::Id { value },
- ) => {
- select.current_value = value.clone();
- }
- (
- acp_v2::SessionConfigKind::Boolean(boolean),
- acp_v2::SessionConfigOptionValue::Boolean { value },
- ) => {
- boolean.current_value = *value;
- }
- _ => {}
- }
+ acp_v2::SessionConfigKind::Boolean(boolean) => {
+ value.as_bool() == Some(boolean.current_value)
}
+ _ => false,
+ };
+ if already_set {
+ return None;
}
- }
- })
- .detach();
+ Some((option.clone(), value))
+ });
+ let Some((config_option, default_value)) = next_default else {
+ break;
+ };
+ attempted_defaults.push((config_option.config_id.clone(), current_options));
+
+ let value_to_apply = match &config_option.kind {
+ acp_v2::SessionConfigKind::Select(select) => default_value
+ .as_value_id()
+ .and_then(|value_id| match &select.options {
+ acp_v2::SessionConfigSelectOptions::Ungrouped(options) => options
+ .iter()
+ .any(|opt| &*opt.value.0 == value_id)
+ .then(|| {
+ acp_v2::SessionConfigOptionValue::id(value_id.to_string())
+ }),
+ acp_v2::SessionConfigSelectOptions::Grouped(groups) => groups
+ .iter()
+ .any(|group| {
+ group.options.iter().any(|opt| &*opt.value.0 == value_id)
+ })
+ .then(|| {
+ acp_v2::SessionConfigOptionValue::id(value_id.to_string())
+ }),
+ _ => None,
+ }),
+ acp_v2::SessionConfigKind::Boolean(_) => default_value
+ .as_bool()
+ .map(acp_v2::SessionConfigOptionValue::boolean),
+ _ => None,
+ };
- let mut opts = config_options.borrow_mut();
- if let Some(opt) = opts.iter_mut().find(|option| option.config_id == config_id) {
- match (&mut opt.kind, &default_value) {
- (
- acp_v2::SessionConfigKind::Select(select),
- acp_v2::SessionConfigOptionValue::Id { value },
- ) => {
- select.current_value = value.clone();
- }
- (
- acp_v2::SessionConfigKind::Boolean(boolean),
- acp_v2::SessionConfigOptionValue::Boolean { value },
- ) => {
- boolean.current_value = *value;
- }
- _ => {}
- }
+ let Some(value_to_apply) = value_to_apply else {
+ log::warn!(
+ "`{}` is not a valid value for config option `{}` in {}",
+ default_value,
+ config_option.config_id.0,
+ id
+ );
+ continue;
+ };
+ config_options
+ .set_config_option(
+ &connection,
+ session_id.clone(),
+ config_option.config_id,
+ value_to_apply,
+ )
+ .await
+ .log_err();
}
- }
+ })
}
}
@@ -1674,9 +1652,9 @@ impl AgentConnection for AcpConnection {
}
}
- if let Some(config_opts) = config_options.as_ref() {
- self.apply_default_config_options(&response.session_id, config_opts, cx);
- }
+ let default_config_task = config_options.as_ref().map(|options| {
+ self.apply_default_config_options(&response.session_id, options, cx)
+ });
let action_log = cx.new(|_| ActionLog::new(project.clone()));
let thread: Entity<AcpThread> = cx.new(|cx| {
@@ -1699,7 +1677,8 @@ impl AgentConnection for AcpConnection {
response.session_id,
&thread,
modes,
- config_options.map(ConfigOptions::new),
+ config_options,
+ default_config_task,
cx,
)
});
@@ -1994,9 +1973,7 @@ impl AgentConnection for AcpConnection {
Some(Rc::new(AcpSessionConfigOptions {
session_id: session_id.clone(),
connection: self.connection.clone(),
- state: config_opts.config_options.clone(),
- watch_tx: config_opts.tx.clone(),
- watch_rx: config_opts.rx.clone(),
+ config_options: config_opts.clone(),
}) as _)
}
@@ -4092,7 +4069,15 @@ mod tests {
#[gpui::test]
async fn default_config_options_apply_boolean_defaults(cx: &mut gpui::TestAppContext) {
- let (connection, set_config_requests) = connect_config_defaults_test_agent(cx).await;
+ let (connection, set_config_requests) = connect_config_defaults_test_agent_with_handler(
+ |_| {
+ Ok(acp::SetSessionConfigOptionResponse::new(vec![
+ acp::SessionConfigOption::boolean("web_search", "Web Search", true),
+ ]))
+ },
+ cx,
+ )
+ .await;
connection.defaults.set(
None,
HashMap::from_iter([(
@@ -4100,14 +4085,12 @@ mod tests {
AgentConfigOptionValue::Boolean(true),
)]),
);
- let config_options = Rc::new(RefCell::new(vec![acp_v2::SessionConfigOption::boolean(
- "web_search",
- "Web Search",
- false,
- )]));
+ let config_options = ConfigOptions::new(Rc::new(RefCell::new(vec![
+ acp_v2::SessionConfigOption::boolean("web_search", "Web Search", false),
+ ])));
let mut async_cx = cx.to_async();
- connection.apply_default_config_options(
+ let _default_config_task = connection.apply_default_config_options(
&acp::SessionId::new("session-config-defaults"),
&config_options,
&mut async_cx,
@@ -4126,12 +4109,349 @@ mod tests {
})]
);
- let options = config_options.borrow();
+ let options = config_options.config_options.borrow();
assert!(
matches!(&options[0].kind, acp_v2::SessionConfigKind::Boolean(boolean) if boolean.current_value)
);
}
+ #[gpui::test]
+ async fn default_config_options_refresh_dependent_options(cx: &mut gpui::TestAppContext) {
+ for (initial_efforts, updated_efforts, default_effort, reasoning_first) in [
+ (vec!["medium", "high"], vec!["medium", "ultra"], None, false),
+ (
+ vec!["medium", "high"],
+ vec!["medium", "ultra"],
+ Some("ultra"),
+ false,
+ ),
+ (vec![], vec!["medium", "ultra"], Some("ultra"), false),
+ (
+ vec!["medium", "high"],
+ vec!["medium", "ultra"],
+ Some("high"),
+ false,
+ ),
+ (vec!["medium", "high"], vec![], Some("high"), false),
+ (
+ vec!["medium", "high"],
+ vec!["medium", "ultra"],
+ Some("ultra"),
+ true,
+ ),
+ (
+ vec!["medium", "ultra"],
+ vec!["medium", "ultra"],
+ Some("ultra"),
+ true,
+ ),
+ ] {
+ let expected_effort = if default_effort == Some("ultra") {
+ "ultra"
+ } else {
+ "medium"
+ };
+ let mut initial_options =
+ model_config_options("initial-model", "medium", &initial_efforts);
+ if reasoning_first {
+ initial_options.reverse();
+ }
+ let initially_supported = reasoning_first && initial_efforts.contains(&"ultra");
+ let expected_options =
+ model_config_options("new-model", expected_effort, &updated_efforts);
+ let selected_model = Mutex::new("initial-model");
+ let (connection, requests) = connect_config_defaults_test_agent_with_handler(
+ move |request| {
+ let mut selected_model = selected_model.lock().expect("selected model");
+ let effort = if request.config_id == acp::SessionConfigId::new("model") {
+ assert_eq!(
+ request.value,
+ acp::SessionConfigOptionValue::value_id("new-model")
+ );
+ *selected_model = "new-model";
+ "medium"
+ } else {
+ assert_eq!(
+ request.config_id,
+ acp::SessionConfigId::new("reasoning_effort")
+ );
+ assert_eq!(
+ request.value,
+ acp::SessionConfigOptionValue::value_id("ultra")
+ );
+ "ultra"
+ };
+ let efforts = if *selected_model == "initial-model" {
+ &initial_efforts
+ } else {
+ &updated_efforts
+ };
+ Ok(acp::SetSessionConfigOptionResponse::new(
+ model_config_options(*selected_model, effort, efforts),
+ ))
+ },
+ cx,
+ )
+ .await;
+ let mut defaults = HashMap::from_iter([(
+ "model".to_string(),
+ AgentConfigOptionValue::from("new-model"),
+ )]);
+ if let Some(effort) = default_effort {
+ defaults.insert(
+ "reasoning_effort".to_string(),
+ AgentConfigOptionValue::from(effort),
+ );
+ }
+ connection.defaults.set(None, defaults);
+ let (_, config_options) =
+ config_state(None, Some(initial_options)).expect("initial config");
+ let config_options = config_options.expect("config options");
+ let mut receiver = config_options.rx.clone();
+ let _default_config_task = connection.apply_default_config_options(
+ &acp::SessionId::new("session"),
+ &config_options,
+ &mut cx.to_async(),
+ );
+ cx.run_until_parked();
+
+ assert_eq!(
+ *config_options.config_options.borrow(),
+ acp_thread::config_options::from_v1(expected_options).expect("expected config"),
+ );
+ assert_eq!(receiver.changed().now_or_never(), Some(Ok(())));
+ let mut expected_requests = vec![serde_json::json!({
+ "sessionId": "session", "configId": "model", "value": "new-model"
+ })];
+ if initially_supported {
+ expected_requests.insert(
+ 0,
+ serde_json::json!({
+ "sessionId": "session", "configId": "reasoning_effort", "value": "ultra"
+ }),
+ );
+ }
+ if default_effort == Some("ultra") {
+ expected_requests.push(serde_json::json!({
+ "sessionId": "session", "configId": "reasoning_effort", "value": "ultra"
+ }));
+ }
+ assert_eq!(*requests.lock().expect("requests"), expected_requests);
+ }
+ }
+
+ fn model_config_options(
+ model: &str,
+ effort: &str,
+ efforts: &[&str],
+ ) -> Vec<acp::SessionConfigOption> {
+ let mut options = vec![serde_json::json!({
+ "id": "model", "name": "Model", "category": "model", "type": "select",
+ "currentValue": model,
+ "options": [
+ {"value": "initial-model", "name": "Initial model"},
+ {"value": "new-model", "name": "New model"}
+ ]
+ })];
+ if !efforts.is_empty() {
+ options.push(serde_json::json!({
+ "id": "reasoning_effort", "name": "Reasoning effort", "category": "thought_level",
+ "type": "select", "currentValue": effort,
+ "options": efforts.iter().map(|value| serde_json::json!({
+ "value": value, "name": value
+ })).collect::<Vec<_>>()
+ }));
+ }
+ serde_json::from_value(serde_json::json!(options)).expect("model config options")
+ }
+
+ #[gpui::test]
+ async fn default_config_options_preserve_state_on_error(cx: &mut gpui::TestAppContext) {
+ let (connection, requests) = connect_config_defaults_test_agent_with_handler(
+ |_| Err(acp::Error::invalid_params()),
+ cx,
+ )
+ .await;
+ connection.defaults.set(
+ None,
+ HashMap::from_iter([(
+ "web_search".to_string(),
+ AgentConfigOptionValue::Boolean(true),
+ )]),
+ );
+ let original_options = vec![acp_v2::SessionConfigOption::boolean(
+ "web_search",
+ "Web Search",
+ false,
+ )];
+ let config_options = ConfigOptions::new(Rc::new(RefCell::new(original_options.clone())));
+ let mut receiver = config_options.rx.clone();
+ let _default_config_task = connection.apply_default_config_options(
+ &acp::SessionId::new("session"),
+ &config_options,
+ &mut cx.to_async(),
+ );
+ cx.run_until_parked();
+
+ assert_eq!(*config_options.config_options.borrow(), original_options);
+ assert!(receiver.changed().now_or_never().is_none());
+ assert_eq!(requests.lock().expect("requests").len(), 1);
+ }
+
+ #[gpui::test]
+ async fn default_config_options_stop_when_defaults_conflict(cx: &mut gpui::TestAppContext) {
+ let (connection, requests) = connect_config_defaults_test_agent_with_handler(
+ |request| {
+ Ok(acp::SetSessionConfigOptionResponse::new(vec![
+ acp::SessionConfigOption::boolean(
+ "first",
+ "First",
+ request.config_id.0.as_ref() == "first",
+ ),
+ acp::SessionConfigOption::boolean(
+ "second",
+ "Second",
+ request.config_id.0.as_ref() == "second",
+ ),
+ ]))
+ },
+ cx,
+ )
+ .await;
+ connection.defaults.set(
+ None,
+ HashMap::from_iter([
+ ("first".to_string(), AgentConfigOptionValue::Boolean(true)),
+ ("second".to_string(), AgentConfigOptionValue::Boolean(true)),
+ ]),
+ );
+ let config_options = ConfigOptions::new(Rc::new(RefCell::new(vec![
+ acp_v2::SessionConfigOption::boolean("first", "First", false),
+ acp_v2::SessionConfigOption::boolean("second", "Second", false),
+ ])));
+ let _default_config_task = connection.apply_default_config_options(
+ &acp::SessionId::new("session"),
+ &config_options,
+ &mut cx.to_async(),
+ );
+ cx.run_until_parked();
+ assert_eq!(requests.lock().expect("requests").len(), 3);
+ }
+
+ #[gpui::test]
+ async fn default_config_options_cancel_on_session_release(cx: &mut gpui::TestAppContext) {
+ cx.update(|cx| {
+ let store = settings::SettingsStore::test(cx);
+ cx.set_global(store);
+ });
+ let fs = fs::FakeFs::new(cx.executor());
+ fs.insert_tree("/", serde_json::json!({"a": {}})).await;
+ let project = project::Project::test(fs, [std::path::Path::new("/a")], cx).await;
+ let (response_sender, response_receiver) = async_channel::bounded::<()>(1);
+ let (connection, requests) = connect_config_defaults_test_agent_with_async_handler(
+ move |request| {
+ let response_receiver = response_receiver.clone();
+ async move {
+ assert_eq!(request.config_id, acp::SessionConfigId::new("model"));
+ response_receiver
+ .recv()
+ .await
+ .expect("release model response");
+ Ok(acp::SetSessionConfigOptionResponse::new(
+ model_config_options("new-model", "medium", &["medium", "ultra"]),
+ ))
+ }
+ },
+ cx,
+ )
+ .await;
+ let connection = Rc::new(connection);
+ connection.defaults.set(
+ None,
+ HashMap::from_iter([
+ (
+ "model".to_string(),
+ AgentConfigOptionValue::from("new-model"),
+ ),
+ (
+ "reasoning_effort".to_string(),
+ AgentConfigOptionValue::from("ultra"),
+ ),
+ ]),
+ );
+ let session_id = acp::SessionId::new("session");
+ let initial_options = model_config_options("initial-model", "medium", &["medium"]);
+ let thread = cx
+ .update(|cx| {
+ connection.clone().open_or_create_session(
+ session_id.clone(),
+ project.clone(),
+ PathList::new(&[std::path::Path::new("/a")]),
+ None,
+ move |_, _, _| {
+ async move {
+ Ok(SessionConfigResponse {
+ modes: None,
+ config_options: Some(initial_options),
+ })
+ }
+ .boxed_local()
+ },
+ cx,
+ )
+ })
+ .await
+ .expect("load initial session");
+ cx.run_until_parked();
+ assert_eq!(requests.lock().expect("requests").len(), 1);
+ drop(thread);
+ release_dropped_entities(cx);
+
+ let replacement_options = vec![acp::SessionConfigOption::boolean(
+ "web_search",
+ "Web Search",
+ false,
+ )];
+ let expected_options = acp_thread::config_options::from_v1(replacement_options.clone())
+ .expect("replacement config");
+ let _replacement_thread = cx
+ .update(|cx| {
+ connection.clone().open_or_create_session(
+ session_id.clone(),
+ project,
+ PathList::new(&[std::path::Path::new("/a")]),
+ None,
+ move |_, _, _| {
+ async move {
+ Ok(SessionConfigResponse {
+ modes: None,
+ config_options: Some(replacement_options),
+ })
+ }
+ .boxed_local()
+ },
+ cx,
+ )
+ })
+ .await
+ .expect("load replacement session");
+ response_sender
+ .send(())
+ .await
+ .expect("unblock stale response");
+ cx.run_until_parked();
+
+ assert_eq!(requests.lock().expect("requests").len(), 1);
+ let sessions = connection.sessions.borrow();
+ let config_options = sessions
+ .get(&session_id)
+ .expect("replacement session")
+ .config_options
+ .as_ref()
+ .expect("replacement config");
+ assert_eq!(*config_options.config_options.borrow(), expected_options);
+ }
+
#[gpui::test]
async fn shared_config_values_use_v1_wire_shapes(cx: &mut gpui::TestAppContext) {
use acp_thread::AgentSessionConfigOptions;
@@ -4143,9 +4463,7 @@ mod tests {
let options = AcpSessionConfigOptions {
session_id: acp::SessionId::new("session"),
connection: connection.connection.clone(),
- state: config.config_options,
- watch_tx: config.tx,
- watch_rx: config.rx,
+ config_options: config,
};
let original = options.config_options();
let unknown =
@@ -4186,6 +4504,35 @@ mod tests {
async fn connect_config_defaults_test_agent(
cx: &mut gpui::TestAppContext,
+ ) -> (AcpConnection, Arc<Mutex<Vec<serde_json::Value>>>) {
+ connect_config_defaults_test_agent_with_handler(
+ |_| Ok(acp::SetSessionConfigOptionResponse::new(Vec::new())),
+ cx,
+ )
+ .await
+ }
+
+ async fn connect_config_defaults_test_agent_with_handler(
+ handler: impl Fn(
+ acp::SetSessionConfigOptionRequest,
+ ) -> Result<acp::SetSessionConfigOptionResponse, acp::Error>
+ + Send
+ + Sync
+ + 'static,
+ cx: &mut gpui::TestAppContext,
+ ) -> (AcpConnection, Arc<Mutex<Vec<serde_json::Value>>>) {
+ connect_config_defaults_test_agent_with_async_handler(
+ move |request| futures::future::ready(handler(request)),
+ cx,
+ )
+ .await
+ }
+
+ async fn connect_config_defaults_test_agent_with_async_handler<
+ F: Future<Output = Result<acp::SetSessionConfigOptionResponse, acp::Error>> + Send + 'static,
+ >(
+ handler: impl Fn(acp::SetSessionConfigOptionRequest) -> F + Send + Sync + 'static,
+ cx: &mut gpui::TestAppContext,
) -> (AcpConnection, Arc<Mutex<Vec<serde_json::Value>>>) {
let set_config_requests = Arc::new(Mutex::new(Vec::new()));
let (client_transport, client_inspection) = agent_client_protocol::Channel::duplex();
@@ -4223,8 +4570,11 @@ mod tests {
.builder()
.name("config-defaults-test-agent")
.on_receive_request(
- async move |_request: acp::SetSessionConfigOptionRequest, responder, _cx| {
- responder.respond(acp::SetSessionConfigOptionResponse::new(Vec::new()))
+ async move |request: acp::SetSessionConfigOptionRequest, responder, _cx| {
+ match handler(request).await {
+ Ok(response) => responder.respond(response),
+ Err(error) => responder.respond_with_error(error),
+ }
},
agent_client_protocol::on_receive_request!(),
)
@@ -5833,11 +6183,12 @@ fn config_state(
config_options: Option<Vec<acp::SessionConfigOption>>,
) -> Result<(
Option<Rc<RefCell<acp::SessionModeState>>>,
- Option<Rc<RefCell<Vec<acp_v2::SessionConfigOption>>>>,
+ Option<ConfigOptions>,
)> {
if let Some(opts) = config_options {
let opts = acp_thread::config_options::from_v1(opts)?;
- return Ok((None, Some(Rc::new(RefCell::new(opts)))));
+ let opts = ConfigOptions::new(Rc::new(RefCell::new(opts)));
+ return Ok((None, Some(opts)));
}
let modes = modes.map(|modes| Rc::new(RefCell::new(modes)));
@@ -5889,14 +6240,12 @@ impl acp_thread::AgentSessionModes for AcpSessionModes {
struct AcpSessionConfigOptions {
session_id: acp::SessionId,
connection: ConnectionTo<Agent>,
- state: Rc<RefCell<Vec<acp_v2::SessionConfigOption>>>,
- watch_tx: Rc<RefCell<watch::Sender<()>>>,
- watch_rx: watch::Receiver<()>,
+ config_options: ConfigOptions,
}
impl acp_thread::AgentSessionConfigOptions for AcpSessionConfigOptions {
fn config_options(&self) -> Vec<acp_v2::SessionConfigOption> {
- self.state.borrow().clone()
+ self.config_options.config_options.borrow().clone()
}
fn set_config_option(
@@ -5905,34 +6254,19 @@ impl acp_thread::AgentSessionConfigOptions for AcpSessionConfigOptions {
value: acp_v2::SessionConfigOptionValue,
cx: &mut App,
) -> Task<Result<Vec<acp_v2::SessionConfigOption>>> {
- let value = match acp_thread::config_options::value_to_v1(value) {
- Ok(value) => value,
- Err(error) => return Task::ready(Err(error)),
- };
- let config_id = acp::SessionConfigId::new(config_id.0);
let connection = self.connection.clone();
let session_id = self.session_id.clone();
- let state = self.state.clone();
-
- let watch_tx = self.watch_tx.clone();
+ let config_options = self.config_options.clone();
cx.foreground_executor().spawn(async move {
- let response = connection
- .send_request(acp::SetSessionConfigOptionRequest::new(
- session_id, config_id, value,
- ))
- .block_task()
- .await?;
-
- let config_options = acp_thread::config_options::from_v1(response.config_options)?;
- *state.borrow_mut() = config_options.clone();
- watch_tx.borrow_mut().send(()).ok();
- Ok(config_options)
+ config_options
+ .set_config_option(&connection, session_id, config_id, value)
+ .await
})
}
fn watch(&self, _cx: &mut App) -> Option<watch::Receiver<()>> {
- Some(self.watch_rx.clone())
+ Some(self.config_options.rx.clone())
}
}