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.rsindex 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 refusalsif 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.rsindex d60713f729d..8b3dd83ac19 100644--- a/crates/agent_servers/src/acp.rs+++ b/crates/agent_servers/src/acp.rs@@ -4777,7 +4777,7 @@ exit 7let 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.rsindex 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.rsindex 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,