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.

acp_thread: Add generic permission prompts (#65080)

Ben Brandt3209c7d31f93
diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs
index 184da930509..6dcd8e309b8 100644
--- a/crates/acp_thread/src/acp_thread.rs
+++ b/crates/acp_thread/src/acp_thread.rs
@@ -1054,10 +1054,51 @@ pub struct PermissionRequestId(Uuid);
#[derive(Debug)]
pub struct PermissionRequest {
pub id: PermissionRequestId,
- pub tool_call_id: acp_v1::ToolCallId,
- pub options: PermissionOptions,
- pub kind: AuthorizationKind,
- respond_tx: oneshot::Sender<RequestPermissionOutcome>,
+ data: PermissionRequestData,
+}
+
+#[derive(Debug)]
+enum PermissionRequestData {
+ LegacyTool {
+ tool_call_id: acp_v1::ToolCallId,
+ options: PermissionOptions,
+ kind: AuthorizationKind,
+ respond_tx: oneshot::Sender<RequestPermissionOutcome>,
+ },
+ Generic {
+ request: acp_v2::RequestPermissionRequest,
+ respond_tx: oneshot::Sender<acp_v2::RequestPermissionOutcome>,
+ },
+}
+
+impl PermissionRequest {
+ pub fn legacy_tool_call_id(&self) -> Option<&acp_v1::ToolCallId> {
+ match &self.data {
+ PermissionRequestData::LegacyTool { tool_call_id, .. } => Some(tool_call_id),
+ PermissionRequestData::Generic { .. } => None,
+ }
+ }
+
+ pub fn legacy_options(&self) -> Option<&PermissionOptions> {
+ match &self.data {
+ PermissionRequestData::LegacyTool { options, .. } => Some(options),
+ PermissionRequestData::Generic { .. } => None,
+ }
+ }
+
+ pub fn legacy_kind(&self) -> Option<AuthorizationKind> {
+ match &self.data {
+ PermissionRequestData::LegacyTool { kind, .. } => Some(*kind),
+ PermissionRequestData::Generic { .. } => None,
+ }
+ }
+
+ pub fn generic_request(&self) -> Option<&acp_v2::RequestPermissionRequest> {
+ match &self.data {
+ PermissionRequestData::LegacyTool { .. } => None,
+ PermissionRequestData::Generic { request, .. } => Some(request),
+ }
+ }
}
struct ToolCallPatch {
@@ -3833,6 +3874,13 @@ impl AcpThread {
}
fn has_pending_turn_action(&self) -> bool {
+ if self
+ .permission_requests
+ .values()
+ .any(|request| request.generic_request().is_some())
+ {
+ return true;
+ }
for entry in self.entries.iter().rev() {
match entry {
AgentThreadEntry::UserMessage(_) => return false,
@@ -4900,6 +4948,8 @@ impl AcpThread {
for id in removed_requests {
self.resolve_permission_request(id, RequestPermissionOutcome::Cancelled, cx);
}
+ // Unanchored prompts cannot remain valid across a transcript rollback.
+ self.cancel_generic_permission_requests(cx);
}
pub fn push_context_compaction(
@@ -5409,6 +5459,88 @@ impl AcpThread {
self.permission_requests.values()
}
+ pub fn request_permission(
+ &mut self,
+ request: acp_v2::RequestPermissionRequest,
+ cx: &mut Context<Self>,
+ ) -> Result<(PermissionRequestId, Task<acp_v2::RequestPermissionOutcome>)> {
+ anyhow::ensure!(
+ acp_v1::SessionId::new(request.session_id.0.clone()) == self.session_id,
+ "Permission request belongs to a different session"
+ );
+ anyhow::ensure!(
+ !request.options.is_empty(),
+ "Permission request has no offered options"
+ );
+ let mut option_ids = HashSet::default();
+ anyhow::ensure!(
+ request
+ .options
+ .iter()
+ .all(|option| option_ids.insert(&option.option_id)),
+ "Permission request has duplicate option IDs"
+ );
+
+ let (respond_tx, receiver) = oneshot::channel();
+ let id = PermissionRequestId(Uuid::new_v4());
+ self.permission_requests.insert(
+ id,
+ PermissionRequest {
+ id,
+ data: PermissionRequestData::Generic {
+ request,
+ respond_tx,
+ },
+ },
+ );
+ cx.emit(AcpThreadEvent::ToolAuthorizationRequested(id));
+ Ok((
+ id,
+ cx.spawn(async move |_, _| {
+ receiver
+ .await
+ .unwrap_or(acp_v2::RequestPermissionOutcome::Cancelled)
+ }),
+ ))
+ }
+
+ pub fn select_permission_option(
+ &mut self,
+ id: PermissionRequestId,
+ option_id: acp_v2::PermissionOptionId,
+ cx: &mut Context<Self>,
+ ) {
+ let Some(request) = self
+ .permission_request(id)
+ .and_then(PermissionRequest::generic_request)
+ else {
+ return;
+ };
+ if !request
+ .options
+ .iter()
+ .any(|option| option.option_id == option_id)
+ {
+ log::debug!("Permission choice is not an offered option");
+ return;
+ }
+ let Some(PermissionRequest {
+ data: PermissionRequestData::Generic { respond_tx, .. },
+ ..
+ }) = self.take_permission_request(id, cx)
+ else {
+ return;
+ };
+ if respond_tx
+ .send(acp_v2::RequestPermissionOutcome::Selected(
+ acp_v2::SelectedPermissionOutcome::new(option_id),
+ ))
+ .is_err()
+ {
+ log::debug!("Permission request closed before the outcome was delivered");
+ }
+ }
+
pub fn request_tool_call_authorization(
&mut self,
tool_call: acp_v1::ToolCallUpdate,
@@ -5456,10 +5588,12 @@ impl AcpThread {
id,
PermissionRequest {
id,
- tool_call_id,
- options,
- respond_tx: tx,
- kind,
+ data: PermissionRequestData::LegacyTool {
+ tool_call_id,
+ options,
+ respond_tx: tx,
+ kind,
+ },
},
);
cx.emit(AcpThreadEvent::ToolAuthorizationRequested(id));
@@ -5499,8 +5633,8 @@ impl AcpThread {
let Some(request) = self.permission_requests.get(&id) else {
return;
};
- let tool_call_id = request.tool_call_id.clone();
- if let Some((_, call)) = self.tool_call_mut(&tool_call_id)
+ if let Some(tool_call_id) = request.legacy_tool_call_id().cloned()
+ && let Some((_, call)) = self.tool_call_mut(&tool_call_id)
&& call.authorization_id() == Some(id)
{
call.set_local_status(ToolCallStatus::Canceled);
@@ -5529,16 +5663,26 @@ impl AcpThread {
mut outcome: SelectedPermissionOutcome,
cx: &mut Context<Self>,
) {
- let Some(request) = self.permission_requests.get(&id) else {
+ let Some(PermissionRequest {
+ data:
+ PermissionRequestData::LegacyTool {
+ options,
+ tool_call_id,
+ kind,
+ ..
+ },
+ ..
+ }) = self.permission_requests.get(&id)
+ else {
return;
};
- let Some(option) = request.options.option_for_id(&outcome.option_id) else {
+ let Some(option) = options.option_for_id(&outcome.option_id) else {
log::debug!("Permission choice is not an offered option");
return;
};
outcome.option_kind = option.kind;
- let tool_call_id = request.tool_call_id.clone();
- let kind = request.kind;
+ let tool_call_id = tool_call_id.clone();
+ let kind = *kind;
let Some((_, call)) = self.tool_call_mut(&tool_call_id) else {
return;
};
@@ -5567,19 +5711,49 @@ impl AcpThread {
outcome: RequestPermissionOutcome,
cx: &mut Context<Self>,
) {
- let Some(request) = self.permission_requests.shift_remove(&id) else {
+ let Some(request) = self.take_permission_request(id, cx) else {
return;
};
- if let Some((index, call)) = self.tool_call_mut(&request.tool_call_id)
+ let delivered = match request.data {
+ PermissionRequestData::LegacyTool { respond_tx, .. } => {
+ respond_tx.send(outcome).is_ok()
+ }
+ PermissionRequestData::Generic { respond_tx, .. } => respond_tx
+ .send(acp_v2::RequestPermissionOutcome::Cancelled)
+ .is_ok(),
+ };
+ if !delivered {
+ log::debug!("Permission request closed before the outcome was delivered");
+ }
+ }
+
+ fn take_permission_request(
+ &mut self,
+ id: PermissionRequestId,
+ cx: &mut Context<Self>,
+ ) -> Option<PermissionRequest> {
+ let request = self.permission_requests.shift_remove(&id)?;
+ if let Some(tool_call_id) = request.legacy_tool_call_id()
+ && let Some((index, call)) = self.tool_call_mut(tool_call_id)
&& call.authorization_id() == Some(id)
{
call.authorization = None;
cx.emit(AcpThreadEvent::EntryUpdated(index));
}
- if request.respond_tx.send(outcome).is_err() {
- log::debug!("Permission request closed before the outcome was delivered");
- }
cx.emit(AcpThreadEvent::ToolAuthorizationReceived(id));
+ Some(request)
+ }
+
+ fn cancel_generic_permission_requests(&mut self, cx: &mut Context<Self>) {
+ let ids = self
+ .permission_requests
+ .values()
+ .filter(|request| request.generic_request().is_some())
+ .map(|request| request.id)
+ .collect::<Vec<_>>();
+ for id in ids {
+ self.cancel_permission_request(id, cx);
+ }
}
pub fn request_elicitation(
@@ -6029,6 +6203,9 @@ impl AcpThread {
// Handle refusal - distinguish between user prompt and tool call refusals
if let acp_v1::StopReason::Refusal = r.stop_reason {
this.had_error = true;
+ if is_same_turn {
+ this.cancel_generic_permission_requests(cx);
+ }
if let Some((user_msg_ix, _)) = this.last_user_message() {
// Check if there's a completed tool call with results after the last user message
// This indicates the refusal is in response to tool output, not the user's prompt
@@ -6122,6 +6299,7 @@ impl AcpThread {
) -> Task<()> {
self.flush_streaming_text(cx);
if self.uses_reported_activity() {
+ self.cancel_generic_permission_requests(cx);
let Some(receiver) = self.activity.wait_for_idle() else {
return Task::ready(());
};
@@ -6225,6 +6403,7 @@ impl AcpThread {
for id in canceled_requests {
self.resolve_permission_request(id, permission_outcome.clone(), cx);
}
+ self.cancel_generic_permission_requests(cx);
}
fn cancel_outstanding_elicitations(&mut self, cx: &mut Context<Self>) {
@@ -12935,8 +13114,8 @@ mod tests {
thread
.permission_request(request_id)
.expect("pending request")
- .tool_call_id,
- id
+ .legacy_tool_call_id(),
+ Some(&id)
);
assert_eq!(
serde_json::to_value(&call.reported_status).expect("reported status"),
@@ -19438,14 +19617,13 @@ mod tests {
let request = thread
.permission_request(old_id)
.expect("old request remains");
- assert_eq!(request.kind, AuthorizationKind::PermissionGrant);
- assert!(request.options.option_for_id(&"allow".into()).is_some());
- assert!(
- request
- .options
- .option_for_id(&"new-choice".into())
- .is_none()
+ assert_eq!(
+ request.legacy_kind(),
+ Some(AuthorizationKind::PermissionGrant)
);
+ let options = request.legacy_options().expect("legacy permission options");
+ assert!(options.option_for_id(&"allow".into()).is_some());
+ assert!(options.option_for_id(&"new-choice".into()).is_none());
assert_eq!(call.authorization_id(), Some(old_id));
assert_eq!(call.status(), ToolCallStatus::WaitingForConfirmation);
assert_eq!(*events.borrow(), [(true, old_id)]);
@@ -19860,8 +20038,8 @@ mod tests {
let request = thread
.permission_request(request_id)
.expect("invalid choice stays pending");
- assert_eq!(request.kind, kind);
- assert_eq!(request.tool_call_id, tool_id);
+ assert_eq!(request.legacy_kind(), Some(kind));
+ assert_eq!(request.legacy_tool_call_id(), Some(&tool_id));
assert_eq!(thread.pending_permission_requests().count(), 1);
let (_, call) = thread.tool_call(&tool_id).expect("waiting tool");
assert_eq!(call.authorization_id(), Some(request_id));
@@ -19996,6 +20174,665 @@ mod tests {
}
}
+ #[gpui::test]
+ async fn test_generic_permission_retains_sdk_request_without_transcript_entries(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let thread = new_test_thread(cx).await;
+ let (events, _subscription) = track_permission_events(&thread, cx);
+ let subjects = [
+ Some(
+ acp_v2::CommandPermissionSubject::new("cargo test", path!("/test"))
+ .tool_call_id(acp_v2::ToolCallId::new("context-only"))
+ .terminal_id(acp_v2::TerminalId::new("context-only-terminal"))
+ .meta(acp_v2::Meta::from_iter([(
+ "command-data".into(),
+ json!({"nested": [1, true, null]}),
+ )]))
+ .into(),
+ ),
+ None,
+ Some(acp_v2::RequestPermissionSubject::Other(
+ acp_v2::OtherRequestPermissionSubject::new(
+ "future_operation",
+ [
+ ("payload".into(), json!({"resource": ["one", "two"]})),
+ ("_meta".into(), json!({"opaque": true})),
+ ]
+ .into_iter()
+ .collect(),
+ ),
+ )),
+ Some(
+ acp_v2::ToolCallUpdate::new("not-a-transcript-tool")
+ .title("Context, not a tool update")
+ .status(acp_v2::ToolCallStatus::Completed)
+ .content(vec!["Context, not transcript content".into()])
+ .meta(acp_v2::Meta::from_iter([(
+ "tool-data".into(),
+ json!({"opaque": ["retained"]}),
+ )]))
+ .into(),
+ ),
+ ];
+ let mut pending = Vec::new();
+ for subject in subjects {
+ let request = thread.read_with(cx, |thread, _| {
+ test_generic_permission_request(thread, "future-choice").subject(subject)
+ });
+ let (id, response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(request.clone(), cx)
+ .expect("generic permission request")
+ });
+ thread.read_with(cx, |thread, _| {
+ let record = thread.permission_request(id).expect("pending record");
+ assert_eq!(record.generic_request(), Some(&request));
+ assert!(record.legacy_tool_call_id().is_none());
+ assert!(record.legacy_options().is_none());
+ assert!(record.legacy_kind().is_none());
+ assert!(thread.entries().is_empty());
+ assert!(thread.tool_call(&"context-only".into()).is_none());
+ assert!(thread.tool_call(&"not-a-transcript-tool".into()).is_none());
+ assert!(!thread.is_idle_for_retention());
+ });
+ pending.push((id, response));
+ }
+ thread.read_with(cx, |thread, _| {
+ assert_eq!(thread.pending_permission_requests().count(), 4);
+ });
+ assert_eq!(
+ *events.borrow(),
+ pending
+ .iter()
+ .map(|(id, _)| (true, *id))
+ .collect::<Vec<_>>()
+ );
+ for (id, response) in pending {
+ thread.update(cx, |thread, cx| thread.cancel_permission_request(id, cx));
+ assert_eq!(response.await, acp_v2::RequestPermissionOutcome::Cancelled);
+ }
+ thread.read_with(cx, |thread, _| {
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ assert!(thread.entries().is_empty());
+ assert!(thread.is_idle_for_retention());
+ });
+ }
+
+ #[gpui::test]
+ async fn test_generic_permissions_for_same_subject_have_independent_choices(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let thread = new_test_thread(cx).await;
+ let (events, _subscription) = track_permission_events(&thread, cx);
+ let subject = acp_v2::RequestPermissionSubject::from(
+ acp_v2::CommandPermissionSubject::new("cargo test", path!("/test")),
+ );
+ let (first_id, first_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(
+ test_generic_permission_request(thread, "first-choice")
+ .subject(subject.clone()),
+ cx,
+ )
+ .expect("first permission")
+ });
+ let (second_id, second_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(
+ test_generic_permission_request(thread, "second-choice").subject(subject),
+ cx,
+ )
+ .expect("second permission")
+ });
+ assert_ne!(first_id, second_id);
+ thread.update(cx, |thread, cx| {
+ thread.select_permission_option(first_id, "second-choice".into(), cx);
+ thread.select_permission_option(second_id, "not-offered".into(), cx);
+ assert_eq!(
+ thread
+ .pending_permission_requests()
+ .map(|request| request.id)
+ .collect::<Vec<_>>(),
+ [first_id, second_id]
+ );
+ });
+ assert_eq!(*events.borrow(), [(true, first_id), (true, second_id)]);
+ thread.update(cx, |thread, cx| {
+ thread.select_permission_option(first_id, "first-choice".into(), cx);
+ assert!(thread.permission_request(first_id).is_none());
+ thread.select_permission_option(first_id, "second-choice".into(), cx);
+ thread.cancel_permission_request(first_id, cx);
+ assert!(thread.permission_request(second_id).is_some());
+ assert_eq!(thread.pending_permission_requests().count(), 1);
+ });
+ assert_eq!(
+ *events.borrow(),
+ [(true, first_id), (true, second_id), (false, first_id)]
+ );
+ assert_eq!(
+ first_response.await,
+ acp_v2::RequestPermissionOutcome::Selected(acp_v2::SelectedPermissionOutcome::new(
+ "first-choice"
+ ))
+ );
+ thread.update(cx, |thread, cx| {
+ thread.cancel_permission_request(second_id, cx);
+ thread.cancel_permission_request(second_id, cx);
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ assert!(thread.entries().is_empty());
+ });
+ assert_eq!(
+ *events.borrow(),
+ [
+ (true, first_id),
+ (true, second_id),
+ (false, first_id),
+ (false, second_id)
+ ]
+ );
+ assert_eq!(
+ second_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ }
+
+ #[gpui::test]
+ async fn test_generic_tool_permissions_do_not_replace_or_mutate_legacy_authorization(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let thread = new_test_thread(cx).await;
+ let tool_id = acp_v1::ToolCallId::new("shared-tool");
+ let (legacy_id, legacy_response) =
+ request_test_permission_with_id(&thread, tool_id.clone(), cx);
+ let (events, _subscription) = track_permission_events(&thread, cx);
+ let transcript_events = Rc::new(RefCell::new(0));
+ let _transcript_subscription = cx.update(|cx| {
+ cx.subscribe(&thread, {
+ let transcript_events = transcript_events.clone();
+ move |_, event, _| {
+ if matches!(
+ event,
+ AcpThreadEvent::NewEntry
+ | AcpThreadEvent::EntryUpdated(_)
+ | AcpThreadEvent::EntriesRemoved(_)
+ ) {
+ *transcript_events.borrow_mut() += 1;
+ }
+ }
+ })
+ });
+ let request = thread.read_with(cx, |thread, _| {
+ test_generic_permission_request(thread, "future-choice").subject(
+ acp_v2::RequestPermissionSubject::from(
+ acp_v2::ToolCallUpdate::new("shared-tool")
+ .title("Must not replace the label")
+ .status(acp_v2::ToolCallStatus::Completed)
+ .content(vec!["Must not replace tool output".into()]),
+ ),
+ )
+ });
+ let (selected_id, selected_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(request.clone(), cx)
+ .expect("first generic tool permission")
+ });
+ let (cancelled_id, cancelled_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(request, cx)
+ .expect("second generic tool permission")
+ });
+ thread.update(cx, |thread, cx| {
+ thread.select_permission_option(selected_id, "future-choice".into(), cx);
+ thread.cancel_permission_request(cancelled_id, cx);
+ let (_, call) = thread.tool_call(&tool_id).expect("legacy tool");
+ assert_eq!(call.authorization_id(), Some(legacy_id));
+ assert_eq!(call.status(), ToolCallStatus::WaitingForConfirmation);
+ assert_eq!(call.label.read(cx).source(), "Needs permission");
+ assert!(call.content().is_empty());
+ assert_eq!(thread.entries().len(), 1);
+ assert_eq!(
+ thread
+ .permission_request_for_tool(&tool_id)
+ .expect("legacy link survives")
+ .id,
+ legacy_id
+ );
+ assert!(
+ thread
+ .permission_request(legacy_id)
+ .expect("legacy record")
+ .generic_request()
+ .is_none()
+ );
+ });
+ assert_eq!(*transcript_events.borrow(), 0);
+ assert_eq!(
+ selected_response.await,
+ acp_v2::RequestPermissionOutcome::Selected(acp_v2::SelectedPermissionOutcome::new(
+ "future-choice"
+ ))
+ );
+ assert_eq!(
+ cancelled_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ thread.update(cx, |thread, cx| {
+ thread.authorize_tool_call(
+ tool_id.clone(),
+ SelectedPermissionOutcome::new(
+ "allow".into(),
+ acp_v1::PermissionOptionKind::AllowOnce,
+ ),
+ cx,
+ );
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ assert_eq!(
+ thread
+ .tool_call(&tool_id)
+ .expect("authorized tool")
+ .1
+ .status(),
+ ToolCallStatus::InProgress
+ );
+ });
+ assert!(matches!(
+ legacy_response.await,
+ RequestPermissionOutcome::Selected(outcome) if outcome.option_id == "allow".into()
+ ));
+ assert_eq!(
+ *events.borrow(),
+ [
+ (true, selected_id),
+ (true, cancelled_id),
+ (false, selected_id),
+ (false, cancelled_id),
+ (false, legacy_id)
+ ]
+ );
+ }
+
+ #[gpui::test]
+ async fn test_generic_permission_completion_is_state_owned_not_waiter_owned(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let thread = new_test_thread(cx).await;
+ let (complete, turn) = start_test_turn(&thread, cx);
+ cx.run_until_parked();
+ assert_eq!(cx.active_idle_sleep_preventions(), 1);
+ let (events, _subscription) = track_permission_events(&thread, cx);
+ let (first_id, first_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(test_generic_permission_request(thread, "first-choice"), cx)
+ .expect("first permission")
+ });
+ let (second_id, second_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(test_generic_permission_request(thread, "second-choice"), cx)
+ .expect("second permission")
+ });
+ drop(first_response);
+ drop(second_response);
+ cx.run_until_parked();
+ assert_eq!(*events.borrow(), [(true, first_id), (true, second_id)]);
+ assert_eq!(cx.active_idle_sleep_preventions(), 0);
+ thread.update(cx, |thread, cx| {
+ assert_eq!(
+ thread.foreground_activity(),
+ ForegroundActivity::RequiresAction
+ );
+ thread.select_permission_option(first_id, "first-choice".into(), cx);
+ assert!(thread.permission_request(first_id).is_none());
+ assert!(thread.permission_request(second_id).is_some());
+ assert_eq!(
+ thread.foreground_activity(),
+ ForegroundActivity::RequiresAction
+ );
+ thread.cancel_permission_request(second_id, cx);
+ thread.cancel_permission_request(second_id, cx);
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ });
+ cx.run_until_parked();
+ thread.read_with(cx, |thread, _| {
+ assert_eq!(thread.foreground_activity(), ForegroundActivity::Running);
+ });
+ assert_eq!(
+ *events.borrow(),
+ [
+ (true, first_id),
+ (true, second_id),
+ (false, first_id),
+ (false, second_id)
+ ]
+ );
+ assert_eq!(cx.active_idle_sleep_preventions(), 1);
+ complete
+ .send(Ok(acp_v1::PromptResponse::new(acp_v1::StopReason::EndTurn)))
+ .expect("backend still running");
+ turn.await.expect("turn completes");
+ assert_eq!(cx.active_idle_sleep_preventions(), 0);
+
+ let released_thread = new_test_thread(cx).await;
+ let (_, response) = released_thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(
+ test_generic_permission_request(thread, "release-choice"),
+ cx,
+ )
+ .expect("permission before release")
+ });
+ let released = released_thread.downgrade();
+ drop(released_thread);
+ cx.run_until_parked();
+ assert!(released.upgrade().is_none());
+ assert_eq!(response.await, acp_v2::RequestPermissionOutcome::Cancelled);
+ }
+
+ #[gpui::test]
+ async fn test_generic_permission_validation_has_no_records_events_or_tool_mutations(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let thread = new_test_thread(cx).await;
+ let (events, _subscription) = track_permission_events(&thread, cx);
+ let valid = thread.read_with(cx, |thread, _| {
+ test_generic_permission_request(thread, "valid-choice").subject(
+ acp_v2::RequestPermissionSubject::from(
+ acp_v2::ToolCallUpdate::new("must-not-create")
+ .title("Must not create tool")
+ .status(acp_v2::ToolCallStatus::InProgress),
+ ),
+ )
+ });
+ let mut wrong_session = valid.clone();
+ wrong_session.session_id = acp_v2::SessionId::new("different-session");
+ let mut empty_options = valid.clone();
+ empty_options.options.clear();
+ let mut duplicate_options = valid.clone();
+ duplicate_options
+ .options
+ .push(acp_v2::PermissionOption::new(
+ "valid-choice",
+ "Different label, same ID",
+ acp_v2::PermissionOptionKind::AllowAlways,
+ ));
+ for request in [wrong_session, empty_options, duplicate_options] {
+ let result = thread.update(cx, |thread, cx| thread.request_permission(request, cx));
+ assert!(result.is_err());
+ thread.read_with(cx, |thread, _| {
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ assert!(thread.entries().is_empty());
+ assert!(thread.tool_call(&"must-not-create".into()).is_none());
+ assert!(thread.is_idle_for_retention());
+ });
+ assert!(events.borrow().is_empty());
+ }
+ let (id, response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(valid.clone(), cx)
+ .expect("valid request after rejection")
+ });
+ thread.read_with(cx, |thread, _| {
+ assert_eq!(
+ thread
+ .permission_request(id)
+ .expect("valid record")
+ .generic_request(),
+ Some(&valid)
+ );
+ });
+ thread.update(cx, |thread, cx| thread.cancel_permission_request(id, cx));
+ assert_eq!(response.await, acp_v2::RequestPermissionOutcome::Cancelled);
+ assert_eq!(*events.borrow(), [(true, id), (false, id)]);
+ }
+
+ #[gpui::test]
+ async fn test_generic_permissions_settle_on_cancellation_refusal_and_rewind(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ for lifecycle in [
+ "idle cancel",
+ "turn cancel",
+ "reported cancel",
+ "reported idle cancel",
+ "refusal",
+ "refusal without user",
+ "refusal after tool",
+ "rewind",
+ ] {
+ let thread = if matches!(lifecycle, "reported cancel" | "reported idle cancel") {
+ new_receipt_test_thread(cx).await.0
+ } else {
+ new_test_thread(cx).await
+ };
+ let (events, _subscription) = track_permission_events(&thread, cx);
+ let client_id = ClientUserMessageId::new();
+ thread.update(cx, |thread, cx| {
+ if lifecycle != "refusal without user" {
+ thread.push_user_content_block(None, "retained".into(), cx);
+ }
+ if lifecycle == "reported cancel" {
+ thread
+ .update_session_state(
+ acp_v2::StateUpdate::Running(acp_v2::RunningStateUpdate::new()),
+ cx,
+ )
+ .expect("reported running activity");
+ }
+ });
+ let running_turn = matches!(
+ lifecycle,
+ "turn cancel" | "refusal" | "refusal without user" | "refusal after tool"
+ )
+ .then(|| start_test_turn(&thread, cx));
+ let (first_id, first_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(test_generic_permission_request(thread, "first-choice"), cx)
+ .expect("permission before rollback boundary")
+ });
+ thread.update(cx, |thread, cx| {
+ if lifecycle != "refusal without user" {
+ thread.push_user_content_block(Some(client_id.clone()), "remove me".into(), cx);
+ }
+ if lifecycle == "refusal after tool" {
+ thread
+ .upsert_tool_call(
+ acp_v1::ToolCall::new("finished-tool", "Finished operation")
+ .status(acp_v1::ToolCallStatus::Completed)
+ .raw_output(json!("completed output")),
+ cx,
+ )
+ .expect("completed tool before refusal");
+ }
+ });
+ let (second_id, second_response) = thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(
+ test_generic_permission_request(thread, "second-choice"),
+ cx,
+ )
+ .expect("permission after rollback boundary")
+ });
+ if lifecycle == "reported idle cancel" {
+ thread.update(cx, |thread, cx| {
+ thread
+ .update_session_state(
+ acp_v2::StateUpdate::Idle(
+ acp_v2::IdleStateUpdate::new()
+ .stop_reason(acp_v2::StopReason::Refusal),
+ ),
+ cx,
+ )
+ .expect("reported idle is independent of pending requests");
+ assert_eq!(thread.foreground_activity(), ForegroundActivity::Idle);
+ assert_eq!(thread.pending_permission_requests().count(), 2);
+ });
+ }
+ let entry_count_before_stop = thread.read_with(cx, |thread, _| thread.entries().len());
+ if let Some((complete, turn)) = running_turn {
+ if matches!(
+ lifecycle,
+ "refusal" | "refusal without user" | "refusal after tool"
+ ) {
+ complete
+ .send(Ok(acp_v1::PromptResponse::new(acp_v1::StopReason::Refusal)))
+ .expect("backend still running");
+ } else {
+ let cancellation = thread.update(cx, |thread, cx| thread.cancel(cx));
+ thread.read_with(cx, |thread, _| {
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ });
+ complete
+ .send(Ok(acp_v1::PromptResponse::new(acp_v1::StopReason::EndTurn)))
+ .expect("backend still running after local cancellation");
+ cancellation.await;
+ }
+ turn.await.expect("turn settles");
+ } else if lifecycle == "rewind" {
+ thread
+ .update(cx, |thread, cx| thread.rewind(client_id, cx))
+ .await
+ .expect("rewind succeeds");
+ } else if lifecycle == "reported cancel" {
+ let cancellation = thread.update(cx, |thread, cx| thread.cancel(cx));
+ thread.update(cx, |thread, cx| {
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ thread
+ .update_session_state(
+ acp_v2::StateUpdate::Idle(acp_v2::IdleStateUpdate::new()),
+ cx,
+ )
+ .expect("reported cancellation completion");
+ });
+ cancellation.await;
+ } else {
+ thread.update(cx, |thread, cx| thread.cancel(cx)).await;
+ }
+ thread.update(cx, |thread, cx| {
+ assert_eq!(
+ thread.pending_permission_requests().count(),
+ 0,
+ "{lifecycle}"
+ );
+ if lifecycle == "refusal without user" {
+ assert!(thread.entries().is_empty());
+ } else if lifecycle == "refusal after tool" {
+ assert_eq!(thread.entries().len(), entry_count_before_stop);
+ let (_, call) = thread
+ .tool_call(&"finished-tool".into())
+ .expect("refusal retains completed tool");
+ assert_eq!(call.status(), ToolCallStatus::Completed);
+ }
+ thread.cancel_permission_request(first_id, cx);
+ thread.cancel_permission_request(second_id, cx);
+ });
+ assert_eq!(
+ *events.borrow(),
+ [
+ (true, first_id),
+ (true, second_id),
+ (false, first_id),
+ (false, second_id)
+ ],
+ "{lifecycle}"
+ );
+ assert_eq!(
+ first_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ assert_eq!(
+ second_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ }
+
+ for asynchronous_failure in [false, true] {
+ let fs = FakeFs::new(cx.executor());
+ let project = Project::test(fs, [], cx).await;
+ let (connection, truncate_gate): (Rc<dyn AgentConnection>, _) = if asynchronous_failure
+ {
+ let connection = Rc::new(StubAgentConnection::new());
+ let gate = connection.defer_next_truncate();
+ (connection, Some(gate))
+ } else {
+ (
+ Rc::new(FakeAgentConnection::new().without_truncate_support()),
+ None,
+ )
+ };
+ let thread = cx
+ .update(|cx| {
+ connection.new_session(project, PathList::new(&[Path::new(path!("/test"))]), cx)
+ })
+ .await
+ .expect("rewind test thread");
+ let (events, _subscription) = track_permission_events(&thread, cx);
+ let client_id = ClientUserMessageId::new();
+ let (id, response) = thread.update(cx, |thread, cx| {
+ thread.push_user_content_block(Some(client_id.clone()), "keep me".into(), cx);
+ thread
+ .request_permission(test_generic_permission_request(thread, "keep-choice"), cx)
+ .expect("permission before failed rewind")
+ });
+ let mut rewind = thread.update(cx, |thread, cx| thread.rewind(client_id.clone(), cx));
+ cx.run_until_parked();
+ assert_eq!(*events.borrow(), [(true, id)]);
+ if asynchronous_failure {
+ assert!((&mut rewind).now_or_never().is_none());
+ }
+ drop(truncate_gate);
+ assert!(rewind.await.is_err());
+ thread.read_with(cx, |thread, _| {
+ assert_eq!(thread.entries().len(), 1);
+ assert!(thread.permission_request(id).is_some());
+ assert_eq!(thread.pending_permission_requests().count(), 1);
+ });
+ assert_eq!(*events.borrow(), [(true, id)]);
+ if asynchronous_failure {
+ thread
+ .update(cx, |thread, cx| thread.rewind(client_id, cx))
+ .await
+ .expect("rewind succeeds after the backend failure");
+ thread.read_with(cx, |thread, _| assert!(thread.entries().is_empty()));
+ } else {
+ thread.update(cx, |thread, cx| thread.cancel_permission_request(id, cx));
+ }
+ assert_eq!(*events.borrow(), [(true, id), (false, id)]);
+ assert_eq!(response.await, acp_v2::RequestPermissionOutcome::Cancelled);
+ }
+ }
+
+ fn test_generic_permission_request(
+ thread: &AcpThread,
+ option_id: &str,
+ ) -> acp_v2::RequestPermissionRequest {
+ acp_v2::RequestPermissionRequest::new(
+ acp_v2::SessionId::new(thread.session_id().to_string()),
+ "Approve operation",
+ vec![
+ acp_v2::PermissionOption::new(
+ option_id,
+ "Future choice",
+ acp_v2::PermissionOptionKind::Other("future_choice".into()),
+ )
+ .meta(acp_v2::Meta::from_iter([(
+ "option-data".into(),
+ json!({"opaque": [1, null]}),
+ )])),
+ ],
+ )
+ .description("Explanation for the permission prompt".to_owned())
+ .meta(acp_v2::Meta::from_iter([(
+ "request-data".into(),
+ json!({"opaque": {"preserved": true}}),
+ )]))
+ }
+
fn track_permission_events(
thread: &Entity<AcpThread>,
cx: &mut TestAppContext,
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index d60713f729d..8b3dd83ac19 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -4777,7 +4777,7 @@ exit 7
let request = thread
.permission_request_for_tool(&tool_id)
.expect("first permission request");
- assert_eq!(request.tool_call_id, tool_id);
+ assert_eq!(request.legacy_tool_call_id(), Some(&tool_id));
request.id
});
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rs
index 185586de4ef..7a3acac17d9 100644
--- a/crates/agent_ui/src/conversation_view.rs
+++ b/crates/agent_ui/src/conversation_view.rs
@@ -307,6 +307,7 @@ impl Conversation {
AcpThreadEvent::NoticesUpdated => return,
AcpThreadEvent::ToolAuthorizationRequested(id) => {
this.add_permission_request(&session_id, id);
+ cx.notify();
}
AcpThreadEvent::ToolAuthorizationReceived(id) => {
this.permission_selections.remove(id);
@@ -357,6 +358,7 @@ impl Conversation {
});
self.subscriptions.push(subscription);
self.threads.insert(session_id, thread);
+ cx.notify();
}
fn set_permission_choice(
@@ -368,6 +370,7 @@ impl Conversation {
) {
if self
.permission_request(session_id, request_id, cx)
+ .and_then(PermissionRequest::legacy_options)
.is_none()
{
return;
@@ -387,7 +390,10 @@ impl Conversation {
let Some(request) = self.permission_request(session_id, request_id, cx) else {
return;
};
- let pattern_count = match &request.options {
+ let Some(options) = request.legacy_options() else {
+ return;
+ };
+ let pattern_count = match options {
PermissionOptions::DropdownWithPatterns { patterns, .. } => patterns.len(),
_ => 0,
};
@@ -477,8 +483,8 @@ impl Conversation {
let (result_session_id, request) = self.pending_permission_request(session_id, cx)?;
Some((
result_session_id,
- request.tool_call_id.clone(),
- &request.options,
+ request.legacy_tool_call_id()?.clone(),
+ request.legacy_options()?,
))
}
@@ -507,7 +513,7 @@ impl Conversation {
) -> Option<acp_v1::ToolCallId> {
Some(
self.pending_permission_request_for_session(session_id, cx)?
- .tool_call_id
+ .legacy_tool_call_id()?
.clone(),
)
}
@@ -521,7 +527,10 @@ impl Conversation {
.get(session_id)
.map(|ids| {
ids.iter()
- .filter(|id| self.permission_request(session_id, **id, cx).is_some())
+ .filter(|id| {
+ self.permission_request(session_id, **id, cx)
+ .is_some_and(|request| request.legacy_tool_call_id().is_some())
+ })
.count()
})
.unwrap_or(0)
@@ -548,7 +557,7 @@ impl Conversation {
cx: &mut Context<Self>,
) -> Option<()> {
let (authorize_session_id, request) = self.pending_permission_request(session_id, cx)?;
- let option = permission_option_for_action(&request.options, kind)?;
+ let option = permission_option_for_action(request.legacy_options()?, kind)?;
self.authorize_permission_request(
authorize_session_id,
request.id,
@@ -567,7 +576,7 @@ impl Conversation {
) -> Option<()> {
let request = self.permission_request(&session_id, request_id, cx)?;
let outcome = resolve_outcome_from_selection(
- &request.options,
+ request.legacy_options()?,
self.permission_selections.get(&request_id),
is_allow,
)?;
@@ -603,7 +612,12 @@ impl Conversation {
let Some(thread) = self.threads.get(&session_id) else {
return;
};
- if thread.read(cx).permission_request(request_id).is_none() {
+ if thread
+ .read(cx)
+ .permission_request(request_id)
+ .and_then(PermissionRequest::legacy_options)
+ .is_none()
+ {
return;
}
let agent_telemetry_id = thread.read(cx).connection().telemetry_id();
@@ -622,6 +636,37 @@ impl Conversation {
cx.notify();
}
+ fn select_permission_option(
+ &mut self,
+ session_id: &acp_v1::SessionId,
+ request_id: PermissionRequestId,
+ option_id: acp_v2::PermissionOptionId,
+ cx: &mut Context<Self>,
+ ) {
+ let Some(thread) = self.threads.get(session_id) else {
+ return;
+ };
+ thread.update(cx, |thread, cx| {
+ thread.select_permission_option(request_id, option_id, cx);
+ });
+ cx.notify();
+ }
+
+ fn cancel_permission_request(
+ &mut self,
+ session_id: &acp_v1::SessionId,
+ request_id: PermissionRequestId,
+ cx: &mut Context<Self>,
+ ) {
+ let Some(thread) = self.threads.get(session_id) else {
+ return;
+ };
+ thread.update(cx, |thread, cx| {
+ thread.cancel_permission_request(request_id, cx);
+ });
+ cx.notify();
+ }
+
fn set_work_dirs(&mut self, work_dirs: PathList, cx: &mut Context<Self>) {
for thread in self.threads.values() {
thread.update(cx, |thread, cx| {
@@ -12690,7 +12735,7 @@ pub(crate) mod tests {
.authorization_id()
.and_then(|id| thread.permission_request(id))
{
- let options = &authorization.options;
+ let options = authorization.legacy_options().expect("legacy options");
let PermissionOptions::Dropdown(choices) = options else {
panic!("Expected dropdown permission options");
};
@@ -12791,7 +12836,7 @@ pub(crate) mod tests {
.authorization_id()
.and_then(|id| thread.permission_request(id))
{
- let options = &authorization.options;
+ let options = authorization.legacy_options().expect("legacy options");
let PermissionOptions::Dropdown(choices) = options else {
panic!("Expected dropdown permission options");
};
@@ -12883,7 +12928,7 @@ pub(crate) mod tests {
.authorization_id()
.and_then(|id| thread.permission_request(id))
{
- let options = &authorization.options;
+ let options = authorization.legacy_options().expect("legacy options");
let PermissionOptions::Dropdown(choices) = options else {
panic!("Expected dropdown permission options");
};
@@ -12979,7 +13024,7 @@ pub(crate) mod tests {
.authorization_id()
.and_then(|id| thread.permission_request(id))
{
- let options = &authorization.options;
+ let options = authorization.legacy_options().expect("legacy options");
let PermissionOptions::Dropdown(choices) = options else {
panic!("Expected dropdown permission options");
};
@@ -14578,7 +14623,7 @@ pub(crate) mod tests {
let (session_id, request) = conversation
.pending_permission_request(&root_session_id, cx)
.expect("next grouped request");
- assert_eq!(request.tool_call_id, expected_tool.into());
+ assert_eq!(request.legacy_tool_call_id(), Some(&expected_tool.into()));
if expected_tool.starts_with("root") {
assert_eq!(session_id, root_session_id);
assert_eq!(
@@ -14865,6 +14910,577 @@ pub(crate) mod tests {
});
}
+ fn generic_permission_prompt(
+ thread: &Entity<AcpThread>,
+ subject: Option<serde_json::Value>,
+ cx: &mut VisualTestContext,
+ ) -> acp_v2::RequestPermissionRequest {
+ let session_id = thread.read_with(cx, |thread, _| thread.session_id().0.to_string());
+ serde_json::from_value(serde_json::json!({
+ "sessionId": session_id,
+ "title": "**Permission title**",
+ "description": "`Permission description`",
+ "subject": subject,
+ "options": [
+ {"optionId": "once", "name": "This time", "kind": "allow_once"},
+ {"optionId": "always", "name": "Remember", "kind": "allow_always"},
+ {"optionId": "reject", "name": "No", "kind": "reject_once"},
+ {"optionId": "reject-always", "name": "Never", "kind": "reject_always"},
+ {"optionId": "custom", "name": "Ask elsewhere", "kind": "_custom"}
+ ],
+ "_meta": {"source": "agent", "opaque": [1, 2]}
+ }))
+ .expect("generic permission fixture should match the SDK schema")
+ }
+
+ fn request_test_generic_permission(
+ thread: &Entity<AcpThread>,
+ request: acp_v2::RequestPermissionRequest,
+ cx: &mut VisualTestContext,
+ ) -> (PermissionRequestId, Task<acp_v2::RequestPermissionOutcome>) {
+ thread.update(cx, |thread, cx| {
+ thread
+ .request_permission(request, cx)
+ .expect("generic permission request")
+ })
+ }
+
+ fn click_generic_permission(
+ request_id: PermissionRequestId,
+ option_id: Option<&str>,
+ cx: &mut VisualTestContext,
+ ) {
+ let selector = match option_id {
+ Some(option_id) => format!("generic-permission-option-{request_id:?}-{option_id}"),
+ None => format!("generic-permission-cancel-{request_id:?}"),
+ };
+ let bounds = cx
+ .debug_bounds(Box::leak(selector.into_boxed_str()))
+ .expect("rendered permission control");
+ cx.simulate_click(bounds.center(), gpui::Modifiers::default());
+ cx.run_until_parked();
+ }
+
+ #[gpui::test]
+ async fn test_generic_permissions_render_without_transcript_anchors(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::default_response(), cx).await;
+ add_to_workspace_with_size(conversation_view.clone(), true, cx);
+ let thread_view = active_thread(&conversation_view, cx);
+ let thread = thread_view.read_with(cx, |view, _| view.thread.clone());
+ for (subject, selector) in [
+ (
+ Some(serde_json::json!({
+ "type": "command", "command": "echo **literal**", "cwd": "/tmp"
+ })),
+ Some("generic-permission-command-echo **literal**"),
+ ),
+ (None, None),
+ (
+ Some(serde_json::json!({
+ "type": "_future_subject",
+ "command": "not a command subject",
+ "nested": {"approval": true}
+ })),
+ Some("generic-permission-unknown-_future_subject"),
+ ),
+ (
+ Some(serde_json::json!({
+ "type": "tool_call", "toolCall": {"toolCallId": "unseen-tool"}
+ })),
+ Some("generic-permission-tool-unseen-tool"),
+ ),
+ ] {
+ let request = generic_permission_prompt(&thread, subject, cx);
+ let (request_id, response) =
+ request_test_generic_permission(&thread, request.clone(), cx);
+ cx.run_until_parked();
+ assert!(
+ cx.debug_bounds("generic-permission-title-**Permission title**")
+ .is_some()
+ );
+ assert!(
+ cx.debug_bounds("generic-permission-description-`Permission description`")
+ .is_some()
+ );
+ if let Some(selector) = selector {
+ assert!(cx.debug_bounds(selector).is_some());
+ }
+ assert!(
+ cx.debug_bounds("generic-permission-command-not a command subject")
+ .is_none()
+ );
+ thread_view.update_in(cx, |view, window, cx| {
+ assert!(
+ view.render_main_agent_awaiting_permission(window, cx)
+ .is_none()
+ );
+ });
+ for option in &request.options {
+ let selector: &'static str = Box::leak(
+ format!(
+ "generic-permission-option-{request_id:?}-{}",
+ option.option_id
+ )
+ .into_boxed_str(),
+ );
+ assert!(
+ cx.debug_bounds(selector).is_some(),
+ "every offered option, including unknown kinds, must be selectable"
+ );
+ }
+ thread.read_with(cx, |thread, _| {
+ assert!(thread.entries().is_empty());
+ assert_eq!(
+ thread
+ .permission_request(request_id)
+ .and_then(PermissionRequest::generic_request),
+ Some(&request)
+ );
+ });
+ click_generic_permission(request_id, None, cx);
+ assert_eq!(response.await, acp_v2::RequestPermissionOutcome::Cancelled);
+ assert!(
+ cx.debug_bounds("generic-permission-title-**Permission title**")
+ .is_none()
+ );
+ }
+ }
+
+ struct CapturedGenericPermissionCards {
+ thread_view: Entity<ThreadView>,
+ requests: Vec<(PermissionRequestId, acp_v2::RequestPermissionRequest)>,
+ }
+
+ impl Render for CapturedGenericPermissionCards {
+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+ v_flex()
+ .w(px(300.0))
+ .children(self.requests.iter().map(|(request_id, request)| {
+ self.thread_view.update(cx, |view, cx| {
+ view.render_generic_permission_card(
+ view.session_id.clone(),
+ *request_id,
+ request,
+ None,
+ cx,
+ )
+ })
+ }))
+ }
+ }
+
+ #[gpui::test]
+ async fn test_generic_permission_long_choices_fit_narrow_card(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::default_response(), cx).await;
+ add_to_workspace_with_size(conversation_view.clone(), true, cx);
+ let thread_view = active_thread(&conversation_view, cx);
+ let thread = thread_view.read_with(cx, |view, _| view.thread.clone());
+ let mut request = generic_permission_prompt(&thread, None, cx).description(None);
+ request.options = [
+ ("once", acp_v2::PermissionOptionKind::AllowOnce),
+ ("permanently", acp_v2::PermissionOptionKind::AllowAlways),
+ ]
+ .into_iter()
+ .map(|(suffix, kind)| {
+ acp_v2::PermissionOption::new(
+ suffix,
+ format!(
+ "Apply this permission to commands in /a/very/long/project/path — {suffix}"
+ ),
+ kind,
+ )
+ })
+ .collect();
+ let (request_id, response) = request_test_generic_permission(&thread, request.clone(), cx);
+ let original_root = cx.update(|window, _| {
+ window
+ .root::<MultiWorkspace>()
+ .flatten()
+ .expect("workspace root")
+ });
+ cx.replace_root_view(|_, _| CapturedGenericPermissionCards {
+ thread_view: thread_view.clone(),
+ requests: vec![(request_id, request)],
+ });
+ cx.run_until_parked();
+ let card_selector: &'static str =
+ Box::leak(format!("generic-permission-{request_id:?}").into_boxed_str());
+ let card = cx
+ .debug_bounds(card_selector)
+ .expect("narrow permission card");
+ assert_eq!(card.size.width, px(300.0));
+ for option_id in ["once", "permanently"] {
+ let selector: &'static str = Box::leak(
+ format!("generic-permission-option-{request_id:?}-{option_id}").into_boxed_str(),
+ );
+ let option = cx.debug_bounds(selector).expect("long-label choice");
+ assert!(
+ option.left() >= card.left() && option.right() <= card.right(),
+ "{option_id}: {option:?} exceeds {card:?}"
+ );
+ }
+ click_generic_permission(request_id, Some("permanently"), cx);
+ assert_eq!(
+ response.await,
+ acp_v2::RequestPermissionOutcome::Selected(acp_v2::SelectedPermissionOutcome::new(
+ "permanently"
+ ))
+ );
+ drop(original_root);
+ }
+
+ #[gpui::test]
+ async fn test_generic_permission_clicks_target_records_and_ignore_stale_cards(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::default_response(), cx).await;
+ add_to_workspace_with_size(conversation_view.clone(), true, cx);
+ let thread_view = active_thread(&conversation_view, cx);
+ let thread = thread_view.read_with(cx, |view, _| view.thread.clone());
+ let request = generic_permission_prompt(
+ &thread,
+ Some(serde_json::json!({
+ "type": "command", "command": "echo identical", "cwd": "/tmp"
+ })),
+ cx,
+ )
+ .description(None);
+ let (first_id, first_response) =
+ request_test_generic_permission(&thread, request.clone(), cx);
+ let (second_id, second_response) =
+ request_test_generic_permission(&thread, request.clone(), cx);
+ cx.run_until_parked();
+ let first_selector: &'static str =
+ Box::leak(format!("generic-permission-option-{first_id:?}-once").into_boxed_str());
+ let second_selector: &'static str =
+ Box::leak(format!("generic-permission-option-{second_id:?}-once").into_boxed_str());
+ let first = cx
+ .debug_bounds(first_selector)
+ .expect("first same-subject request");
+ let second = cx
+ .debug_bounds(second_selector)
+ .expect("second same-subject request");
+ assert!(first.top() < second.top());
+ click_generic_permission(second_id, Some("custom"), cx);
+ let acp_v2::RequestPermissionOutcome::Selected(outcome) = second_response.await else {
+ panic!("explicit unknown-kind option must return a selection");
+ };
+ assert_eq!(outcome.option_id, acp_v2::PermissionOptionId::new("custom"));
+ assert!(thread.read_with(cx, |thread, _| {
+ thread.permission_request(first_id).is_some()
+ }));
+ click_generic_permission(first_id, Some("once"), cx);
+ let acp_v2::RequestPermissionOutcome::Selected(outcome) = first_response.await else {
+ panic!("explicit known-kind option must return a selection");
+ };
+ assert_eq!(outcome.option_id, acp_v2::PermissionOptionId::new("once"));
+
+ let (third_id, third_response) =
+ request_test_generic_permission(&thread, request.clone(), cx);
+ // Keep a resolved request snapshot rendered so stale controls cannot
+ // target a successor with the same subject or offered option IDs.
+ let original_root = cx.update(|window, _| {
+ window
+ .root::<MultiWorkspace>()
+ .flatten()
+ .expect("workspace root")
+ });
+ cx.replace_root_view(|_, _| CapturedGenericPermissionCards {
+ thread_view: thread_view.clone(),
+ requests: vec![(second_id, request.clone()), (third_id, request)],
+ });
+ cx.run_until_parked();
+ click_generic_permission(second_id, Some("once"), cx);
+ click_generic_permission(second_id, None, cx);
+ thread.read_with(cx, |thread, _| {
+ assert!(thread.permission_request(third_id).is_some());
+ assert!(thread.entries().is_empty());
+ });
+ click_generic_permission(third_id, None, cx);
+ assert_eq!(
+ third_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ drop(original_root);
+ }
+
+ #[gpui::test]
+ async fn test_legacy_permission_shortcuts_do_not_skip_generic_requests(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::default_response(), cx).await;
+ add_to_workspace_with_size(conversation_view.clone(), true, cx);
+ let thread_view = active_thread(&conversation_view, cx);
+ let (thread, conversation) = thread_view.read_with(cx, |view, _| {
+ (view.thread.clone(), view.conversation.clone())
+ });
+ let session_id = thread.read_with(cx, |thread, _| thread.session_id().clone());
+ let request = generic_permission_prompt(&thread, None, cx);
+ let (generic_id, generic_response) = request_test_generic_permission(&thread, request, cx);
+ let options = ToolPermissionContext::new(TerminalTool::NAME, vec!["cargo build".into()])
+ .build_permission_options();
+ let (legacy_id, legacy_response) =
+ request_test_tool_authorization_with_options(&thread, "legacy", options, cx);
+ cx.run_until_parked();
+ cx.focus(&thread_view);
+ cx.dispatch_action(crate::AllowOnce);
+ cx.dispatch_action(crate::AllowAlways);
+ cx.dispatch_action(crate::RejectOnce);
+ cx.dispatch_action(crate::SelectPermissionGranularity {
+ tool_call_id: "".into(),
+ request_id: Some(generic_id),
+ session_id: Some(session_id.0.to_string()),
+ index: 0,
+ });
+ cx.dispatch_action(crate::ToggleCommandPattern {
+ tool_call_id: "".into(),
+ request_id: Some(generic_id),
+ session_id: Some(session_id.0.to_string()),
+ pattern_index: 0,
+ });
+ conversation.update(cx, |conversation, cx| {
+ conversation.set_permission_choice(&session_id, generic_id, 0, cx);
+ conversation.toggle_permission_pattern(&session_id, generic_id, 0, cx);
+ });
+ cx.run_until_parked();
+ thread.read_with(cx, |thread, _| {
+ assert!(thread.permission_request(generic_id).is_some());
+ assert!(thread.permission_request(legacy_id).is_some());
+ });
+ conversation.read_with(cx, |conversation, _| {
+ assert!(!conversation.permission_selections.contains_key(&generic_id));
+ });
+ conversation.read_with(cx, |conversation, cx| {
+ assert_eq!(
+ conversation.pending_tool_call_count_for_session(&session_id, cx),
+ 1
+ );
+ });
+ let legacy_selector: &'static str =
+ Box::leak(format!("PERMISSION_BUTTONS-{session_id}-Only this time").into_boxed_str());
+ assert!(cx.debug_bounds(legacy_selector).is_some());
+ click_generic_permission(generic_id, None, cx);
+ assert_eq!(
+ generic_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ cx.focus(&thread_view);
+ cx.dispatch_action(crate::AllowOnce);
+ cx.run_until_parked();
+ assert!(matches!(
+ legacy_response.await,
+ acp_thread::RequestPermissionOutcome::Selected(_)
+ ));
+ }
+
+ #[gpui::test]
+ async fn test_generic_subagent_permissions_are_visible_and_session_scoped(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::default_response(), cx).await;
+ add_to_workspace_with_size(conversation_view.clone(), true, cx);
+ let root_view = active_thread(&conversation_view, cx);
+ let (root, conversation) = root_view.read_with(cx, |view, _| {
+ (view.thread.clone(), view.conversation.clone())
+ });
+ let root_session_id = root.read_with(cx, |thread, _| thread.session_id().clone());
+ let child_session_id = acp_v1::SessionId::new("generic-child");
+ let child_view = conversation_view.update_in(cx, |view, window, cx| {
+ let child = create_test_acp_thread(
+ Some(root_session_id.clone()),
+ child_session_id.0.as_ref(),
+ Rc::new(StubAgentConnection::new()),
+ view.project.clone(),
+ cx,
+ );
+ conversation.update(cx, |conversation, cx| {
+ conversation.register_thread(child.clone(), cx);
+ });
+ let child_view =
+ view.new_thread_view(child, conversation.clone(), false, None, window, cx);
+ view.as_connected_mut()
+ .expect("connected")
+ .threads
+ .insert(child_session_id.clone(), child_view.clone());
+ child_view
+ });
+ let child = child_view.read_with(cx, |view, _| view.thread.clone());
+ let root_request = generic_permission_prompt(&root, None, cx).description(None);
+ let child_request = generic_permission_prompt(&child, None, cx).description(None);
+ let (root_id, root_response) = request_test_generic_permission(&root, root_request, cx);
+ let (child_id, child_response) =
+ request_test_generic_permission(&child, child_request.clone(), cx);
+ cx.run_until_parked();
+ assert!(
+ cx.debug_bounds("generic-permission-source-generic-child")
+ .is_some()
+ );
+ root.read_with(cx, |thread, _| assert!(thread.entries().is_empty()));
+ click_generic_permission(child_id, Some("custom"), cx);
+ let acp_v2::RequestPermissionOutcome::Selected(outcome) = child_response.await else {
+ panic!("root must render functional child controls without a spawning tool anchor");
+ };
+ assert_eq!(outcome.option_id, acp_v2::PermissionOptionId::new("custom"));
+ assert!(root.read_with(cx, |thread, _| thread.permission_request(root_id).is_some()));
+
+ let (child_id, child_response) = request_test_generic_permission(&child, child_request, cx);
+ root.update(cx, |thread, cx| {
+ let spawn = acp_v1::ToolCall::new("spawn-child", "Running child")
+ .name("spawn_agent")
+ .status(acp_v1::ToolCallStatus::InProgress)
+ .meta(acp_v1::Meta::from_iter([(
+ acp_thread::SUBAGENT_SESSION_INFO_META_KEY.into(),
+ serde_json::to_value(acp_thread::SubagentSessionInfo {
+ session_id: child_session_id.clone(),
+ message_start_index: 0,
+ message_end_index: None,
+ })
+ .expect("subagent session context"),
+ )]));
+ thread.upsert_tool_call(spawn, cx).expect("spawning tool");
+ });
+ cx.run_until_parked();
+ assert!(
+ cx.debug_bounds("generic-permission-source-generic-child")
+ .is_some()
+ );
+ conversation.read_with(cx, |conversation, cx| {
+ assert_eq!(
+ conversation.pending_tool_call_count_for_session(&child_session_id, cx),
+ 0
+ );
+ assert!(conversation.subagents_awaiting_permission(cx).is_empty());
+ });
+ conversation_view.update_in(cx, |view, window, cx| {
+ view.navigate_to_thread(child_session_id, window, cx);
+ });
+ cx.run_until_parked();
+ let root_selector: &'static str =
+ Box::leak(format!("generic-permission-cancel-{root_id:?}").into_boxed_str());
+ assert!(cx.debug_bounds(root_selector).is_none());
+ click_generic_permission(child_id, None, cx);
+ assert_eq!(
+ child_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ assert!(root.read_with(cx, |thread, _| thread.permission_request(root_id).is_some()));
+ conversation_view.update_in(cx, |view, window, cx| {
+ view.navigate_to_thread(root_session_id, window, cx);
+ });
+ cx.run_until_parked();
+ click_generic_permission(root_id, None, cx);
+ assert_eq!(
+ root_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ }
+
+ #[gpui::test]
+ async fn test_generic_permissions_pending_before_registration_render_without_another_event(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let (conversation_view, cx) =
+ setup_conversation_view(StubAgentServer::default_response(), cx).await;
+ add_to_workspace_with_size(conversation_view.clone(), true, cx);
+ let root_view = active_thread(&conversation_view, cx);
+ let (root, conversation) = root_view.read_with(cx, |view, _| {
+ (view.thread.clone(), view.conversation.clone())
+ });
+ let root_session_id = root.read_with(cx, |thread, _| thread.session_id().clone());
+ let project = conversation_view.read_with(cx, |view, _| view.project.clone());
+ cx.run_until_parked();
+
+ for queued_event in [false, true] {
+ let child_session_id = acp_v1::SessionId::new(if queued_event {
+ "queued-generic-child"
+ } else {
+ "late-generic-child"
+ });
+ let child = cx.update(|_, cx| {
+ create_test_acp_thread(
+ Some(root_session_id.clone()),
+ child_session_id.0.as_ref(),
+ Rc::new(StubAgentConnection::new()),
+ project.clone(),
+ cx,
+ )
+ });
+ let request = generic_permission_prompt(&child, None, cx).description(None);
+ let (request_id, response) = if queued_event {
+ cx.update(|_, cx| {
+ let pending = child.update(cx, |thread, cx| {
+ thread
+ .request_permission(request, cx)
+ .expect("queued request")
+ });
+ conversation.update(cx, |conversation, cx| {
+ conversation.register_thread(child.clone(), cx);
+ });
+ pending
+ })
+ } else {
+ let pending = request_test_generic_permission(&child, request, cx);
+ cx.run_until_parked();
+ conversation.update(cx, |conversation, cx| {
+ conversation.register_thread(child.clone(), cx);
+ });
+ pending
+ };
+ conversation.read_with(cx, |conversation, _| {
+ assert_eq!(
+ conversation.permission_requests.get(&child_session_id),
+ Some(&vec![request_id])
+ );
+ });
+ cx.run_until_parked();
+ let selector: &'static str =
+ Box::leak(format!("generic-permission-cancel-{request_id:?}").into_boxed_str());
+ assert!(
+ cx.debug_bounds(selector).is_some(),
+ "hydrated requests must render without focus, navigation, or another thread event"
+ );
+ conversation.read_with(cx, |conversation, _| {
+ assert_eq!(
+ conversation.permission_requests.get(&child_session_id),
+ Some(&vec![request_id]),
+ "queued request events must not duplicate hydrated state"
+ );
+ });
+ click_generic_permission(request_id, Some("custom"), cx);
+ assert_eq!(
+ response.await,
+ acp_v2::RequestPermissionOutcome::Selected(acp_v2::SelectedPermissionOutcome::new(
+ "custom"
+ ))
+ );
+ assert!(cx.debug_bounds(selector).is_none());
+ child.read_with(cx, |thread, _| {
+ assert!(thread.entries().is_empty());
+ assert_eq!(thread.pending_permission_requests().count(), 0);
+ });
+ let request = generic_permission_prompt(&child, None, cx).description(None);
+ let (later_id, later_response) = request_test_generic_permission(&child, request, cx);
+ cx.run_until_parked();
+ click_generic_permission(later_id, None, cx);
+ assert_eq!(
+ later_response.await,
+ acp_v2::RequestPermissionOutcome::Cancelled
+ );
+ }
+ root.read_with(cx, |thread, _| assert!(thread.entries().is_empty()));
+ }
+
/// Set up a `ConversationView` whose active thread has a single tool call
/// awaiting permission. Returns the conversation view, its active
/// `ThreadView`, and the entry index of the tool call within the thread.
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 8eee909d5a1..0aaf8d85b97 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -3116,6 +3116,7 @@ impl ThreadView {
.read(cx)
.permission_request_for_tool(&acp_v1::ToolCallId::new(tool_call_id))?
};
+ request.legacy_options()?;
Some((session_id, request.id))
}
@@ -3184,9 +3185,9 @@ impl ThreadView {
window: &mut Window,
cx: &mut Context<Self>,
) -> Option<()> {
- let result = self.conversation.update(cx, |conversation, cx| {
+ self.conversation.update(cx, |conversation, cx| {
conversation.authorize_with_granularity(session_id, request_id, is_allow, cx)
- });
+ })?;
if self.should_be_following {
self.workspace
.update(cx, |workspace, cx| {
@@ -3195,7 +3196,7 @@ impl ThreadView {
.ok();
}
cx.notify();
- result
+ Some(())
}
// edits
@@ -3399,6 +3400,17 @@ impl ThreadView {
let awaiting_permission = self
.render_main_agent_awaiting_permission(window, cx)
.or_else(|| self.render_subagents_awaiting_permission(cx));
+ let generic_permissions = self.render_generic_permissions(cx);
+ let awaiting_permission = match (generic_permissions, awaiting_permission) {
+ (Some(generic), Some(legacy)) => Some(
+ v_flex()
+ .child(generic)
+ .child(Divider::horizontal().color(DividerColor::Border))
+ .child(legacy)
+ .into_any(),
+ ),
+ (generic, legacy) => generic.or(legacy),
+ };
let has_awaiting_permission = awaiting_permission.is_some();
if changed_buffers.is_empty() && !has_plan && queue_is_empty && !has_awaiting_permission {
@@ -3752,6 +3764,181 @@ impl ThreadView {
.collect()
}
+ fn render_generic_permissions(&self, cx: &Context<Self>) -> Option<AnyElement> {
+ let conversation = self.conversation.read(cx);
+ let mut cards = Vec::new();
+ for (session_id, request_ids) in &conversation.permission_requests {
+ if self.is_subagent() && session_id != &self.session_id {
+ continue;
+ }
+ let Some(thread) = conversation.threads.get(session_id) else {
+ continue;
+ };
+ let thread = thread.read(cx);
+ for request_id in request_ids {
+ let Some(request) = thread
+ .permission_request(*request_id)
+ .and_then(PermissionRequest::generic_request)
+ else {
+ continue;
+ };
+ let source = if session_id == &self.session_id {
+ None
+ } else {
+ Some(format!(
+ "Subagent: {} ({session_id})",
+ thread.title().unwrap_or_else(|| "Subagent".into())
+ ))
+ };
+ cards.push(self.render_generic_permission_card(
+ session_id.clone(),
+ *request_id,
+ request,
+ source,
+ cx,
+ ));
+ }
+ }
+ if cards.is_empty() {
+ return None;
+ }
+ Some(
+ v_flex()
+ .id("generic-permissions")
+ .max_h(px(320.0))
+ .overflow_y_scroll()
+ .children(cards)
+ .into_any(),
+ )
+ }
+
+ pub(super) fn render_generic_permission_card(
+ &self,
+ session_id: acp_v1::SessionId,
+ request_id: PermissionRequestId,
+ request: &acp_v2::RequestPermissionRequest,
+ source: Option<String>,
+ cx: &Context<Self>,
+ ) -> AnyElement {
+ let subject = match &request.subject {
+ Some(acp_v2::RequestPermissionSubject::Command(command)) => Some(
+ v_flex()
+ .gap_1()
+ .child(
+ div()
+ .debug_selector(|| {
+ format!("generic-permission-command-{}", command.command)
+ })
+ .child(command.command.clone()),
+ )
+ .child(format!("Working directory: {}", command.cwd.0.display())),
+ ),
+ Some(acp_v2::RequestPermissionSubject::ToolCall(subject)) => Some(
+ v_flex()
+ .debug_selector(|| {
+ format!("generic-permission-tool-{}", subject.tool_call.tool_call_id)
+ })
+ .child(format!("Tool call: {}", subject.tool_call.tool_call_id)),
+ ),
+ Some(acp_v2::RequestPermissionSubject::Other(subject)) => Some(
+ v_flex()
+ .debug_selector(|| format!("generic-permission-unknown-{}", subject.type_))
+ .child(format!("Unknown permission subject: {}", subject.type_)),
+ ),
+ Some(_) => Some(v_flex().child("Unknown permission subject")),
+ None => None,
+ };
+ v_flex()
+ .id(format!("generic-permission-{request_id:?}"))
+ .debug_selector(|| format!("generic-permission-{request_id:?}"))
+ .p_2()
+ .gap_2()
+ .w_full()
+ .min_w_0()
+ .text_ui_sm(cx)
+ .children(source.map(|source| {
+ div()
+ .debug_selector(|| format!("generic-permission-source-{session_id}"))
+ .text_color(cx.theme().colors().text_muted)
+ .child(source)
+ }))
+ .child(
+ div()
+ .debug_selector(|| format!("generic-permission-title-{}", request.title))
+ .child(request.title.clone()),
+ )
+ .children(request.description.as_ref().map(|description| {
+ div()
+ .debug_selector(|| format!("generic-permission-description-{description}"))
+ .child(description.clone())
+ }))
+ .children(subject)
+ .child(
+ h_flex()
+ .w_full()
+ .min_w_0()
+ .gap_1()
+ .flex_wrap()
+ .children(request.options.iter().map(|option| {
+ let option_id = option.option_id.clone();
+ let session_id = session_id.clone();
+ div()
+ .min_w_0()
+ .max_w_full()
+ .debug_selector(|| {
+ format!("generic-permission-option-{request_id:?}-{option_id}")
+ })
+ .child(
+ Button::new(
+ format!("generic-permission-option-{request_id:?}-{option_id}"),
+ option.name.clone(),
+ )
+ .label_size(LabelSize::Small)
+ .full_width()
+ .truncate(true)
+ .tooltip(Tooltip::text(option.name.clone()))
+ .on_click(cx.listener(
+ move |this, _, _, cx| {
+ this.conversation.update(cx, |conversation, cx| {
+ conversation.select_permission_option(
+ &session_id,
+ request_id,
+ option_id.clone(),
+ cx,
+ );
+ });
+ cx.notify();
+ },
+ )),
+ )
+ }))
+ .child(
+ div()
+ .debug_selector(|| format!("generic-permission-cancel-{request_id:?}"))
+ .child(
+ Button::new(
+ format!("generic-permission-cancel-{request_id:?}"),
+ "Cancel",
+ )
+ .label_size(LabelSize::Small)
+ .on_click(cx.listener(
+ move |this, _, _, cx| {
+ this.conversation.update(cx, |conversation, cx| {
+ conversation.cancel_permission_request(
+ &session_id,
+ request_id,
+ cx,
+ );
+ });
+ cx.notify();
+ },
+ )),
+ ),
+ ),
+ )
+ .into_any()
+ }
+
fn render_subagents_awaiting_permission(&self, cx: &Context<Self>) -> Option<AnyElement> {
let awaiting = self.conversation.read(cx).subagents_awaiting_permission(cx);
@@ -9658,7 +9845,12 @@ impl ThreadView {
allow_disabled: bool,
cx: &Context<Self>,
) -> Div {
- match &request.options {
+ let (Some(options), Some(tool_call_id)) =
+ (request.legacy_options(), request.legacy_tool_call_id())
+ else {
+ return div();
+ };
+ match options {
PermissionOptions::Flat(options) => self.render_permission_buttons_flat(
session_id,
is_first,
@@ -9676,7 +9868,7 @@ impl ThreadView {
entry_ix,
session_id,
request.id,
- request.tool_call_id.clone(),
+ tool_call_id.clone(),
focus_handle,
allow_disabled,
cx,
@@ -9692,7 +9884,7 @@ impl ThreadView {
entry_ix,
session_id,
request.id,
- request.tool_call_id.clone(),
+ tool_call_id.clone(),
focus_handle,
allow_disabled,
cx,