Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent_ui: Fix permissions getting granted to wrong tool call (#54683)
Tom Houlé89d2dcebbaeb
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rsindex 992d5ac937e..96b963de19c 100644--- a/crates/agent_ui/src/conversation_view.rs+++ b/crates/agent_ui/src/conversation_view.rs@@ -296,6 +296,20 @@ impl Conversation {self.threads.insert(session_id, thread);}+ pub fn permission_options_for_tool_call<'a>(+ &'a self,+ session_id: &acp::SessionId,+ tool_call_id: acp::ToolCallId,+ cx: &'a App,+ ) -> Option<&'a PermissionOptions> {+ let thread = self.threads.get(session_id)?;+ let (_, tool_call) = thread.read(cx).tool_call(&tool_call_id)?;+ let ToolCallStatus::WaitingForConfirmation { options, .. } = &tool_call.status else {+ return None;+ };+ Some(options)+ }+pub fn pending_tool_call<'a>(&'a self,session_id: &acp::SessionId,@@ -352,6 +366,21 @@ impl Conversation {Some(())}+ pub fn authorize_with_granularity(+ &mut self,+ session_id: acp::SessionId,+ tool_call_id: acp::ToolCallId,+ selection: Option<&thread_view::PermissionSelection>,+ is_allow: bool,+ cx: &mut Context<Self>,+ ) -> Option<()> {+ let options =+ self.permission_options_for_tool_call(&session_id, tool_call_id.clone(), cx)?;+ let outcome = resolve_outcome_from_selection(options, selection, is_allow)?;+ self.authorize_tool_call(session_id, tool_call_id, outcome, cx);+ Some(())+ }+pub fn authorize_tool_call(&mut self,session_id: acp::SessionId,@@ -391,6 +420,43 @@ pub(crate) struct RootThreadUpdated;impl EventEmitter<RootThreadUpdated> for ConversationView {}+fn resolve_outcome_from_selection(+ options: &PermissionOptions,+ selection: Option<&thread_view::PermissionSelection>,+ is_allow: bool,+) -> Option<SelectedPermissionOutcome> {+ let choices = match options {+ PermissionOptions::Dropdown(choices) => choices.as_slice(),+ PermissionOptions::DropdownWithPatterns { choices, .. } => choices.as_slice(),+ PermissionOptions::Flat(_) => {+ let kind = if is_allow {+ acp::PermissionOptionKind::AllowOnce+ } else {+ acp::PermissionOptionKind::RejectOnce+ };+ let option = options.first_option_of_kind(kind)?;+ return Some(SelectedPermissionOutcome::new(+ option.option_id.clone(),+ option.kind,+ ));+ }+ };++ // When in per-command pattern mode, use the checked patterns.+ if let Some(thread_view::PermissionSelection::SelectedPatterns(checked)) = selection {+ if let Some(outcome) = options.build_outcome_for_checked_patterns(checked, is_allow) {+ return Some(outcome);+ }+ }++ // Use the selected granularity choice ("Always for terminal" or "Only this time").+ let selected_index = selection+ .and_then(|s| s.choice_index())+ .unwrap_or_else(|| choices.len().saturating_sub(1));+ let selected_choice = choices.get(selected_index).or(choices.last())?;+ Some(selected_choice.build_outcome(is_allow))+}+fn affects_thread_metadata(event: &AcpThreadEvent) -> bool {match event {AcpThreadEvent::NewEntry@@ -6629,6 +6695,143 @@ pub(crate) mod tests {);}+ fn flat_allow_deny_options() -> PermissionOptions {+ PermissionOptions::Flat(vec![+ acp::PermissionOption::new(+ acp::PermissionOptionId::new("allow"),+ "Yes",+ acp::PermissionOptionKind::AllowOnce,+ ),+ acp::PermissionOption::new(+ acp::PermissionOptionId::new("deny"),+ "No",+ acp::PermissionOptionKind::RejectOnce,+ ),+ ])+ }++ #[test]+ fn resolve_outcome_from_selection_flat_allow_picks_allow_once() {+ let options = flat_allow_deny_options();++ let outcome = super::resolve_outcome_from_selection(&options, None, true).unwrap();++ assert_eq!(outcome.option_id.0.as_ref(), "allow");+ assert_eq!(outcome.option_kind, acp::PermissionOptionKind::AllowOnce);+ }++ #[test]+ fn resolve_outcome_from_selection_flat_deny_picks_reject_once() {+ let options = flat_allow_deny_options();++ let outcome = super::resolve_outcome_from_selection(&options, None, false).unwrap();++ assert_eq!(outcome.option_id.0.as_ref(), "deny");+ assert_eq!(outcome.option_kind, acp::PermissionOptionKind::RejectOnce);+ }++ #[test]+ fn resolve_outcome_from_selection_flat_ignores_selection() {+ let options = flat_allow_deny_options();+ // Flat options never consult the granularity choice, even if one is set.+ let selection = thread_view::PermissionSelection::Choice(42);++ let outcome =+ super::resolve_outcome_from_selection(&options, Some(&selection), true).unwrap();++ assert_eq!(outcome.option_id.0.as_ref(), "allow");+ }++ #[test]+ fn resolve_outcome_from_selection_dropdown_defaults_to_last_choice_when_no_selection() {+ let options =+ ToolPermissionContext::new(TerminalTool::NAME, vec!["cargo build".to_string()])+ .build_permission_options();++ let outcome = super::resolve_outcome_from_selection(&options, None, true).unwrap();++ // Last choice is "Only this time" → option_id "allow".+ assert_eq!(outcome.option_id.0.as_ref(), "allow");+ assert_eq!(outcome.option_kind, acp::PermissionOptionKind::AllowOnce);+ }++ #[test]+ fn resolve_outcome_from_selection_dropdown_uses_selected_choice() {+ let options =+ ToolPermissionContext::new(TerminalTool::NAME, vec!["cargo build".to_string()])+ .build_permission_options();+ let selection = thread_view::PermissionSelection::Choice(0);++ let outcome =+ super::resolve_outcome_from_selection(&options, Some(&selection), true).unwrap();++ // Choice 0 = "Always for terminal".+ assert!(outcome.option_id.0.contains("always_allow:terminal"));+ assert_eq!(outcome.option_kind, acp::PermissionOptionKind::AllowAlways);+ }++ #[test]+ fn resolve_outcome_from_selection_dropdown_out_of_range_falls_back_to_last() {+ let options =+ ToolPermissionContext::new(TerminalTool::NAME, vec!["cargo build".to_string()])+ .build_permission_options();+ let selection = thread_view::PermissionSelection::Choice(999);++ let outcome =+ super::resolve_outcome_from_selection(&options, Some(&selection), true).unwrap();++ // choices.get(999) is None, falls back to choices.last() → "Only this time".+ assert_eq!(outcome.option_id.0.as_ref(), "allow");+ }++ #[test]+ fn resolve_outcome_from_selection_pattern_mode_with_empty_checked_falls_back_to_last_choice() {+ // Pipeline commands produce `DropdownWithPatterns`, which is required for+ // `SelectedPatterns` to be meaningful.+ let options = ToolPermissionContext::new(+ TerminalTool::NAME,+ vec!["cargo test 2>&1 | tail".to_string()],+ )+ .build_permission_options();+ assert!(matches!(+ options,+ PermissionOptions::DropdownWithPatterns { .. }+ ));+ // Pattern mode with zero checked patterns: `build_outcome_for_checked_patterns`+ // returns None, so we fall through to `choice_index()` (which is None for+ // `SelectedPatterns`) and default to `choices.last()`.+ let selection = thread_view::PermissionSelection::SelectedPatterns(vec![]);++ let outcome =+ super::resolve_outcome_from_selection(&options, Some(&selection), true).unwrap();++ assert_eq!(outcome.option_id.0.as_ref(), "allow");+ assert_eq!(outcome.option_kind, acp::PermissionOptionKind::AllowOnce);+ }++ #[test]+ fn resolve_outcome_from_selection_pattern_mode_with_checked_uses_always_with_params() {+ let options = ToolPermissionContext::new(+ TerminalTool::NAME,+ vec!["cargo test 2>&1 | tail".to_string()],+ )+ .build_permission_options();+ assert!(matches!(+ options,+ PermissionOptions::DropdownWithPatterns { .. }+ ));+ let selection = thread_view::PermissionSelection::SelectedPatterns(vec![0]);++ let outcome =+ super::resolve_outcome_from_selection(&options, Some(&selection), true).unwrap();++ assert_eq!(outcome.option_kind, acp::PermissionOptionKind::AllowAlways);+ assert!(+ outcome.params.is_some(),+ "checked patterns should attach terminal params"+ );+ }+#[gpui::test]async fn test_manually_editing_title_updates_acp_thread_title(cx: &mut TestAppContext) {init_test(cx);diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex 6f134850c1a..439d5f19290 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -1857,64 +1857,40 @@ impl ThreadView {cx: &mut Context<Self>,) -> Option<()> {let session_id = self.thread.read(cx).session_id().clone();- let (returned_session_id, tool_call_id, options) = self+ let (returned_session_id, tool_call_id, _) = self.conversation.read(cx).pending_tool_call(&session_id, cx)?;- let options = options.clone();- self.authorize_with_granularity(- returned_session_id,- tool_call_id,- &options,- is_allow,- window,- cx,- )+ self.authorize_with_granularity(returned_session_id, tool_call_id, is_allow, window, cx)}fn authorize_with_granularity(&mut self,session_id: acp::SessionId,tool_call_id: acp::ToolCallId,- options: &PermissionOptions,is_allow: bool,window: &mut Window,cx: &mut Context<Self>,) -> Option<()> {- let choices = match options {- PermissionOptions::Dropdown(choices) => choices.as_slice(),- PermissionOptions::DropdownWithPatterns { choices, .. } => choices.as_slice(),- _ => {- let kind = if is_allow {- acp::PermissionOptionKind::AllowOnce- } else {- acp::PermissionOptionKind::RejectOnce- };- return self.authorize_pending_tool_call(kind, window, cx);- }- };-- let selection = self.permission_selections.get(&tool_call_id);-- // When in per-command pattern mode, use the checked patterns.- if let Some(PermissionSelection::SelectedPatterns(checked)) = selection {- if let Some(outcome) = options.build_outcome_for_checked_patterns(checked, is_allow) {- self.authorize_tool_call(session_id, tool_call_id, outcome, window, cx);- return Some(());- }+ let selection = self.permission_selections.get(&tool_call_id).cloned();+ let result = self.conversation.update(cx, |conversation, cx| {+ conversation.authorize_with_granularity(+ session_id,+ tool_call_id,+ selection.as_ref(),+ is_allow,+ cx,+ )+ });+ if self.should_be_following {+ self.workspace+ .update(cx, |workspace, cx| {+ workspace.follow(CollaboratorId::Agent, window, cx);+ })+ .ok();}-- // Use the selected granularity choice ("Always for terminal" or "Only this time")- let selected_index = selection- .and_then(|s| s.choice_index())- .unwrap_or_else(|| choices.len().saturating_sub(1));-- let selected_choice = choices.get(selected_index).or(choices.last())?;- let outcome = selected_choice.build_outcome(is_allow);-- self.authorize_tool_call(session_id, tool_call_id, outcome, window, cx);-- Some(())+ cx.notify();+ result}// edits@@ -6786,6 +6762,7 @@ impl ThreadView {choices,None,entry_ix,+ session_id,tool_call_id,focus_handle,cx,@@ -6799,6 +6776,7 @@ impl ThreadView {choices,Some((patterns, tool_name)),entry_ix,+ session_id,tool_call_id,focus_handle,cx,@@ -6812,6 +6790,7 @@ impl ThreadView {choices: &[PermissionOptionChoice],patterns: Option<(&[PermissionPattern], &str)>,entry_ix: usize,+ session_id: acp::SessionId,tool_call_id: acp::ToolCallId,focus_handle: &FocusHandle,cx: &Context<Self>,@@ -6885,8 +6864,16 @@ impl ThreadView {)}).on_click(cx.listener({+ let session_id = session_id.clone();+ let tool_call_id = tool_call_id.clone();move |this, _, window, cx| {- this.authorize_pending_with_granularity(true, window, cx);+ this.authorize_with_granularity(+ session_id.clone(),+ tool_call_id.clone(),+ true,+ window,+ cx,+ );}})),)@@ -6910,7 +6897,13 @@ impl ThreadView {}).on_click(cx.listener({move |this, _, window, cx| {- this.authorize_pending_with_granularity(false, window, cx);+ this.authorize_with_granularity(+ session_id.clone(),+ tool_call_id.clone(),+ false,+ window,+ cx,+ );}})),),