diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rs index 6c027cd09d..b52999a296 100644 --- a/codex-rs/core/src/mcp_tool_call.rs +++ b/codex-rs/core/src/mcp_tool_call.rs @@ -1026,10 +1026,6 @@ async fn maybe_request_mcp_tool_approval( pre_tool_use_permission_decision.as_ref(), Some(PreToolUsePermissionDecision::Ask { .. }) ); - let pre_tool_use_allows = matches!( - pre_tool_use_permission_decision.as_ref(), - Some(PreToolUsePermissionDecision::Allow { .. }) - ); let auto_approved_by_permissions = mcp_permission_prompt_is_auto_approved( turn_context.approval_policy.value(), &turn_context.permission_profile(), @@ -1076,22 +1072,18 @@ async fn maybe_request_mcp_tool_approval( if auto_approved_by_policy && approval_required && !must_prompt_user { return None; } - if pre_tool_use_allows && !must_prompt_user { - return None; - } - let session_approval_key = session_mcp_tool_approval_key(invocation, metadata, approval_mode); let persistent_approval_key = persistent_mcp_tool_approval_key(invocation, metadata, approval_mode); if !must_prompt_user - && pre_tool_use_permission_decision.is_none() + && !pre_tool_use_asks_user && let Some(key) = session_approval_key.as_ref() && mcp_tool_approval_is_remembered(sess, key).await { return Some(McpToolApprovalDecision::Accept); } - if !must_prompt_user && pre_tool_use_permission_decision.is_none() { + if !must_prompt_user && !pre_tool_use_asks_user { match run_permission_request_hooks( sess, turn_context, diff --git a/codex-rs/core/src/mcp_tool_call_tests.rs b/codex-rs/core/src/mcp_tool_call_tests.rs index d83307e808..317cd209f6 100644 --- a/codex-rs/core/src/mcp_tool_call_tests.rs +++ b/codex-rs/core/src/mcp_tool_call_tests.rs @@ -2070,6 +2070,75 @@ async fn permission_request_hook_allows_mcp_tool_call() { ); } +#[tokio::test] +async fn pre_tool_use_allow_does_not_skip_mcp_permission_request_hook() { + let (mut session, turn_context) = make_session_and_context().await; + let log_path = install_mcp_permission_request_hook( + &mut session, + &turn_context, + "mcp__memory__.*", + &serde_json::json!({ + "hookSpecificOutput": { + "hookEventName": "PermissionRequest", + "decision": { + "behavior": "deny", + "message": "denied by permission request hook" + } + } + }), + ); + turn_context.record_pre_tool_use_permission_decision( + "call-mcp-pretool-allow".to_string(), + PreToolUsePermissionDecision::Allow { + reason: Some("approved by pre tool use hook".to_string()), + }, + ); + let session = Arc::new(session); + let turn_context = Arc::new(turn_context); + let invocation = McpInvocation { + server: "memory".to_string(), + tool: "create_entities".to_string(), + arguments: Some(serde_json::json!({ "entities": [] })), + }; + let metadata = McpToolApprovalMetadata { + annotations: Some(annotations( + Some(false), + Some(true), + /*open_world*/ None, + )), + connector_id: None, + connector_name: None, + connector_description: None, + tool_title: Some("Create entities".to_string()), + tool_description: None, + mcp_app_resource_uri: None, + codex_apps_meta: None, + openai_file_input_params: None, + }; + + let decision = maybe_request_mcp_tool_approval( + &session, + &turn_context, + "call-mcp-pretool-allow", + &invocation, + "mcp__memory__create_entities", + Some(&metadata), + AppToolApproval::Auto, + ) + .await; + + assert_eq!( + decision, + Some(McpToolApprovalDecision::Decline { + message: Some("denied by permission request hook".to_string()), + }) + ); + assert!( + log_path.exists(), + "pre tool use allow should not skip PermissionRequest hooks" + ); +} + #[tokio::test] async fn permission_request_hook_uses_hook_tool_name_without_metadata() { let (mut session, turn_context) = make_session_and_context().await; diff --git a/codex-rs/core/src/tools/network_approval.rs b/codex-rs/core/src/tools/network_approval.rs index ccbde8c207..d495ca60cc 100644 --- a/codex-rs/core/src/tools/network_approval.rs +++ b/codex-rs/core/src/tools/network_approval.rs @@ -476,11 +476,7 @@ impl NetworkApprovalService { let command = owner_call .as_ref() .map_or_else(|| prompt_command.join(" "), |call| call.command.clone()); - let pre_tool_use_allows = matches!( - pre_tool_use_permission_decision, - Some(PreToolUsePermissionDecision::Allow { .. }) - ); - if pre_tool_use_permission_decision.is_none() + if !pre_tool_use_asks_user && let Some(permission_request_decision) = run_permission_request_hooks( &session, &turn_context, @@ -513,14 +509,6 @@ impl NetworkApprovalService { } } } - if pre_tool_use_allows { - pending - .set_decision(PendingApprovalDecision::AllowOnce) - .await; - let mut pending_approvals = self.pending_host_approvals.lock().await; - pending_approvals.remove(&key); - return NetworkDecision::Allow; - } let guardian_review_id = (routes_approval_to_guardian(&turn_context) && !pre_tool_use_asks_user) .then(new_guardian_review_id); diff --git a/codex-rs/core/src/tools/orchestrator.rs b/codex-rs/core/src/tools/orchestrator.rs index 1ea71a28fd..db0f9b5515 100644 --- a/codex-rs/core/src/tools/orchestrator.rs +++ b/codex-rs/core/src/tools/orchestrator.rs @@ -146,10 +146,6 @@ impl ToolOrchestrator { pre_tool_use_permission_decision.as_ref(), Some(PreToolUsePermissionDecision::Ask { .. }) ); - let pre_tool_use_allows = matches!( - pre_tool_use_permission_decision.as_ref(), - Some(PreToolUsePermissionDecision::Allow { .. }) - ) && !strict_auto_review; let pre_tool_use_reason = match &pre_tool_use_permission_decision { Some(PreToolUsePermissionDecision::Ask { reason }) => reason.clone(), Some(PreToolUsePermissionDecision::Allow { .. }) | None => None, @@ -203,39 +199,30 @@ impl ToolOrchestrator { return Err(ToolError::Rejected(reason)); } ExecApprovalRequirement::NeedsApproval { reason, .. } => { - if pre_tool_use_allows { - otel.tool_decision( - otel_tn, - otel_ci, - &ReviewDecision::Approved, - ToolDecisionSource::Config, - ); - } else { - let guardian_review_id = use_guardian.then(new_guardian_review_id); - let approval_ctx = ApprovalCtx { - session: &tool_ctx.session, - turn: &tool_ctx.turn, - call_id: &tool_ctx.call_id, - guardian_review_id: guardian_review_id.clone(), - retry_reason: pre_tool_use_reason.clone().or(reason), - network_approval_context: None, - bypass_approval_cache: pre_tool_use_asks_user, - }; - let decision = Self::request_approval( - tool, - req, - tool_ctx.call_id.as_str(), - approval_ctx, - tool_ctx, - /*evaluate_permission_request_hooks*/ - !strict_auto_review && !pre_tool_use_asks_user, - ) - .await?; + let guardian_review_id = use_guardian.then(new_guardian_review_id); + let approval_ctx = ApprovalCtx { + session: &tool_ctx.session, + turn: &tool_ctx.turn, + call_id: &tool_ctx.call_id, + guardian_review_id: guardian_review_id.clone(), + retry_reason: pre_tool_use_reason.clone().or(reason), + network_approval_context: None, + bypass_approval_cache: pre_tool_use_asks_user, + }; + let decision = Self::request_approval( + tool, + req, + tool_ctx.call_id.as_str(), + approval_ctx, + tool_ctx, + /*evaluate_permission_request_hooks*/ + !strict_auto_review && !pre_tool_use_asks_user, + ) + .await?; - Self::reject_if_not_approved(tool_ctx, guardian_review_id.as_deref(), decision) - .await?; - already_approved = true; - } + Self::reject_if_not_approved(tool_ctx, guardian_review_id.as_deref(), decision) + .await?; + already_approved = true; } } @@ -345,7 +332,7 @@ impl ToolOrchestrator { let bypass_retry_approval = !strict_auto_review && tool.should_bypass_approval(approval_policy, already_approved) && network_approval_context.is_none(); - if !bypass_retry_approval && !pre_tool_use_allows { + if !bypass_retry_approval { let guardian_review_id = use_guardian.then(new_guardian_review_id); let approval_ctx = ApprovalCtx { session: &tool_ctx.session, diff --git a/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs b/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs index 04f711c5ef..914a844f0b 100644 --- a/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs +++ b/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs @@ -410,25 +410,13 @@ impl CoreShellActionProvider { pre_tool_use_permission_decision.as_ref(), Some(PreToolUsePermissionDecision::Ask { .. }) ); - let pre_tool_use_allows = matches!( - pre_tool_use_permission_decision.as_ref(), - Some(PreToolUsePermissionDecision::Allow { .. }) - ); let guardian_review_id = (routes_approval_to_guardian(&turn) && !pre_tool_use_asks_user) .then(new_guardian_review_id); Ok(stopwatch .pause_for(async move { - if pre_tool_use_allows { - return PromptDecision { - decision: ReviewDecision::Approved, - guardian_review_id: None, - rejection_message: None, - }; - } - // 1) Run PermissionRequest hooks when PreToolUse did not already - // provide the approval directive for this tool call. - if pre_tool_use_permission_decision.is_none() { + // require the user to answer this tool call. + if !pre_tool_use_asks_user { let permission_request = PermissionRequestPayload::bash( codex_shell_command::parse_command::shlex_join(&command), /*description*/ None, diff --git a/codex-rs/core/tests/suite/hooks.rs b/codex-rs/core/tests/suite/hooks.rs index 1794a2f4ae..5c646dfd83 100644 --- a/codex-rs/core/tests/suite/hooks.rs +++ b/codex-rs/core/tests/suite/hooks.rs @@ -1440,78 +1440,6 @@ async fn permission_request_hook_allows_shell_command_without_user_approval() -> Ok(()) } -#[tokio::test] -async fn pre_tool_use_allow_skips_shell_command_approval() -> Result<()> { - skip_if_no_network!(Ok(())); - - let server = start_mock_server().await; - let call_id = "pretooluse-allow-shell-command"; - let marker = std::env::temp_dir().join("pretooluse-allow-shell-command-marker"); - let command = format!("rm -f {}", marker.display()); - let args = serde_json::json!({ "command": command }); - let responses = mount_sse_sequence( - &server, - vec![ - sse(vec![ - ev_response_created("resp-1"), - ev_function_call(call_id, "shell_command", &serde_json::to_string(&args)?), - ev_completed("resp-1"), - ]), - sse(vec![ - ev_response_created("resp-2"), - ev_assistant_message("msg-1", "pre tool use allowed it"), - ev_completed("resp-2"), - ]), - ], - ) - .await; - - let mut builder = test_codex() - .with_pre_build_hook(|home| { - if let Err(error) = - write_pre_tool_use_hook(home, Some("^Bash$"), "json_allow", "approved by hook") - { - panic!("failed to write pre tool use hook test fixture: {error}"); - } - }) - .with_config(|config| { - config - .features - .enable(Feature::CodexHooks) - .expect("test config should allow feature update"); - }); - let test = builder.build(&server).await?; - - fs::write(&marker, "seed").context("create pre tool use marker")?; - - test.submit_turn_with_approval_and_permission_profile( - "run the shell command after pre tool use approval", - AskForApproval::OnRequest, - PermissionProfile::Disabled, - ) - .await?; - - assert_eq!(responses.requests().len(), 2); - assert!( - !marker.exists(), - "pre tool use allow should execute without prompting" - ); - assert!( - timeout( - Duration::from_secs(2), - wait_for_event(&test.codex, |event| matches!( - event, - EventMsg::ExecApprovalRequest(_) - )) - ) - .await - .is_err(), - "pre tool use allow should bypass the approval prompt" - ); - - Ok(()) -} - #[tokio::test] async fn pre_tool_use_ask_prompts_user_with_hook_reason() -> Result<()> { skip_if_no_network!(Ok(())); diff --git a/codex-rs/hooks/src/events/pre_tool_use.rs b/codex-rs/hooks/src/events/pre_tool_use.rs index ab9aff0157..7d1a57ed8e 100644 --- a/codex-rs/hooks/src/events/pre_tool_use.rs +++ b/codex-rs/hooks/src/events/pre_tool_use.rs @@ -42,11 +42,11 @@ pub struct PreToolUseOutcome { pub additional_contexts: Vec, } -/// Hook-authored approval guidance to apply later at the concrete permission -/// boundary for the same tool call. +/// Hook-authored approval guidance to apply later at concrete permission +/// boundaries for the same tool call. #[derive(Debug, Clone, PartialEq, Eq)] pub enum PreToolUsePermissionDecision { - /// Skip an otherwise-required permission prompt when policy allows it. + /// Record hook-level approval without waiving later concrete permission checks. Allow { reason: Option }, /// Require explicit human-user confirmation. Ask { reason: Option },