Keep PreToolUse allow monotonic

This commit is contained in:
Abhinav Vedmala
2026-05-04 15:15:45 -07:00
parent 7bc1c3610e
commit ea59e08790
7 changed files with 101 additions and 149 deletions
+2 -10
View File
@@ -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,
+69
View File
@@ -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;
+1 -13
View File
@@ -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);
+24 -37
View File
@@ -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,
@@ -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,
-72
View File
@@ -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(()));
+3 -3
View File
@@ -42,11 +42,11 @@ pub struct PreToolUseOutcome {
pub additional_contexts: Vec<String>,
}
/// 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<String> },
/// Require explicit human-user confirmation.
Ask { reason: Option<String> },