mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
## Why Approval guidance is currently assembled entirely by the client. Model Messages V2 needs model catalogs to provide model-specific `on_request` guidance for both user-reviewed and auto-reviewed approval flows while retaining the existing generated prompt as a compatibility fallback. ## What changed - add nullable `on_request` and `on_request_auto_review` catalog messages - select the message matching the active approvals reviewer for `on_request` policies - replace the complete legacy approval section when the selected catalog value exists, including support for an empty string that suppresses the section - retain legacy rendering when the object or selected key is absent, and for non-`on_request` policies - preserve approval messages when base-instruction or personality overrides clear instruction templates - refresh permissions instructions when the active model changes - pass catalog messages through initial and incremental permissions construction ## Relationship to reviewer persistence PR #31309 independently persists the approvals reviewer in turn context and refreshes permissions when that reviewer changes. This PR is based directly on `main` and does not duplicate that rollout migration; once both land, reviewer switches will also select and append the new catalog variant. ## Testing - `just test -p codex-protocol` - `just test -p codex-prompts` - `just test -p codex-models-manager` - `just test -p codex-core permissions_messages`
562 lines
20 KiB
Rust
562 lines
20 KiB
Rust
use super::*;
|
|
use codex_execpolicy::Decision;
|
|
use codex_protocol::permissions::FileSystemAccessMode;
|
|
use codex_protocol::permissions::FileSystemPath;
|
|
use codex_protocol::permissions::FileSystemSandboxEntry;
|
|
use codex_protocol::permissions::FileSystemSandboxPolicy;
|
|
use codex_protocol::permissions::NetworkSandboxPolicy;
|
|
use codex_utils_absolute_path::AbsolutePathBuf;
|
|
use codex_utils_absolute_path::test_support::test_path_buf;
|
|
use pretty_assertions::assert_eq;
|
|
use std::path::PathBuf;
|
|
|
|
#[test]
|
|
fn renders_sandbox_mode_text() {
|
|
assert_eq!(
|
|
sandbox_text(SandboxMode::WorkspaceWrite, NetworkAccess::Restricted),
|
|
"Filesystem sandboxing defines which files can be read or written. `sandbox_mode` is `workspace-write`: The sandbox permits reading files, and editing files in `cwd` and `writable_roots`. Editing files in other directories requires approval. Network access is restricted."
|
|
);
|
|
|
|
assert_eq!(
|
|
sandbox_text(SandboxMode::ReadOnly, NetworkAccess::Restricted),
|
|
"Filesystem sandboxing defines which files can be read or written. `sandbox_mode` is `read-only`: The sandbox only permits reading files. Network access is restricted."
|
|
);
|
|
|
|
assert_eq!(
|
|
sandbox_text(SandboxMode::DangerFullAccess, NetworkAccess::Enabled),
|
|
"Filesystem sandboxing defines which files can be read or written. `sandbox_mode` is `danger-full-access`: No filesystem sandboxing - all commands are permitted. Network access is enabled."
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn builds_permissions_with_network_access_override() {
|
|
let instructions = PermissionsInstructions::from_permissions_with_network(
|
|
SandboxMode::WorkspaceWrite,
|
|
NetworkAccess::Enabled,
|
|
PermissionsPromptConfig {
|
|
approval_policy: AskForApproval::OnRequest,
|
|
approvals_reviewer: ApprovalsReviewer::User,
|
|
approval_messages: None,
|
|
exec_policy: &Policy::empty(),
|
|
exec_permission_approvals_enabled: false,
|
|
request_permissions_tool_enabled: false,
|
|
},
|
|
/*writable_roots*/ None,
|
|
);
|
|
|
|
let text = instructions.body();
|
|
assert!(
|
|
text.contains("Network access is enabled."),
|
|
"expected network access to be enabled in message"
|
|
);
|
|
assert!(
|
|
text.contains("How to request escalation"),
|
|
"expected approval guidance to be included"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn builds_permissions_from_profile() {
|
|
let cwd = PathBuf::from("/tmp");
|
|
let writable_root =
|
|
AbsolutePathBuf::from_absolute_path(cwd.join("repo")).expect("absolute path");
|
|
let permission_profile = PermissionProfile::from_runtime_permissions(
|
|
&FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
|
|
path: FileSystemPath::Path {
|
|
path: writable_root.clone(),
|
|
},
|
|
access: FileSystemAccessMode::Write,
|
|
}]),
|
|
NetworkSandboxPolicy::Enabled,
|
|
);
|
|
|
|
let instructions = PermissionsInstructions::from_permission_profile(
|
|
&permission_profile,
|
|
AskForApproval::UnlessTrusted,
|
|
ApprovalPromptContext::new(ApprovalsReviewer::User, /*messages*/ None),
|
|
&Policy::empty(),
|
|
&cwd,
|
|
/*exec_permission_approvals_enabled*/ false,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
let text = instructions.body();
|
|
assert!(text.contains("`sandbox_mode` is `workspace-write`"));
|
|
assert!(text.contains("Network access is enabled."));
|
|
assert!(text.contains(writable_root.to_string_lossy().as_ref()));
|
|
}
|
|
|
|
#[test]
|
|
fn builds_permissions_from_profile_with_denied_reads() {
|
|
let cwd = test_path_buf("/tmp");
|
|
let denied_root =
|
|
AbsolutePathBuf::from_absolute_path(cwd.join("blocked")).expect("absolute path");
|
|
let denied_glob = cwd.join("blocked").join("**");
|
|
let permission_profile = PermissionProfile::from_runtime_permissions(
|
|
&FileSystemSandboxPolicy::restricted(vec![
|
|
FileSystemSandboxEntry {
|
|
path: FileSystemPath::Special {
|
|
value: codex_protocol::permissions::FileSystemSpecialPath::Root,
|
|
},
|
|
access: FileSystemAccessMode::Read,
|
|
},
|
|
FileSystemSandboxEntry {
|
|
path: FileSystemPath::Path {
|
|
path: denied_root.clone(),
|
|
},
|
|
access: FileSystemAccessMode::Deny,
|
|
},
|
|
FileSystemSandboxEntry {
|
|
path: FileSystemPath::GlobPattern {
|
|
pattern: denied_glob.to_string_lossy().into_owned(),
|
|
},
|
|
access: FileSystemAccessMode::Deny,
|
|
},
|
|
]),
|
|
NetworkSandboxPolicy::Restricted,
|
|
);
|
|
|
|
let instructions = PermissionsInstructions::from_permission_profile(
|
|
&permission_profile,
|
|
AskForApproval::OnRequest,
|
|
ApprovalPromptContext::new(ApprovalsReviewer::AutoReview, /*messages*/ None),
|
|
&Policy::empty(),
|
|
&cwd,
|
|
/*exec_permission_approvals_enabled*/ false,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
let text = instructions.body();
|
|
assert!(text.contains("## Denied filesystem reads"));
|
|
assert!(text.contains("Do not request escalation or additional permissions"));
|
|
assert!(text.contains(denied_root.to_string_lossy().as_ref()));
|
|
assert!(text.contains(&format!("glob `{}`", denied_glob.to_string_lossy())));
|
|
}
|
|
|
|
#[test]
|
|
fn includes_request_rule_instructions_for_on_request() {
|
|
let mut exec_policy = Policy::empty();
|
|
exec_policy
|
|
.add_prefix_rule(&["git".to_string(), "pull".to_string()], Decision::Allow)
|
|
.expect("add rule");
|
|
let instructions = PermissionsInstructions::from_permissions_with_network(
|
|
SandboxMode::WorkspaceWrite,
|
|
NetworkAccess::Enabled,
|
|
PermissionsPromptConfig {
|
|
approval_policy: AskForApproval::OnRequest,
|
|
approvals_reviewer: ApprovalsReviewer::User,
|
|
approval_messages: None,
|
|
exec_policy: &exec_policy,
|
|
exec_permission_approvals_enabled: false,
|
|
request_permissions_tool_enabled: false,
|
|
},
|
|
/*writable_roots*/ None,
|
|
);
|
|
|
|
let text = instructions.body();
|
|
assert!(text.contains("prefix_rule"));
|
|
assert!(text.contains("Approved command prefixes"));
|
|
assert!(text.contains(r#"["git", "pull"]"#));
|
|
}
|
|
|
|
#[test]
|
|
fn includes_request_permissions_tool_instructions_for_unless_trusted_when_enabled() {
|
|
let instructions = PermissionsInstructions::from_permissions_with_network(
|
|
SandboxMode::WorkspaceWrite,
|
|
NetworkAccess::Enabled,
|
|
PermissionsPromptConfig {
|
|
approval_policy: AskForApproval::UnlessTrusted,
|
|
approvals_reviewer: ApprovalsReviewer::User,
|
|
approval_messages: None,
|
|
exec_policy: &Policy::empty(),
|
|
exec_permission_approvals_enabled: false,
|
|
request_permissions_tool_enabled: true,
|
|
},
|
|
/*writable_roots*/ None,
|
|
);
|
|
|
|
let text = instructions.body();
|
|
assert!(text.contains("`approval_policy` is `unless-trusted`"));
|
|
assert!(text.contains("# request_permissions Tool"));
|
|
}
|
|
|
|
#[test]
|
|
fn includes_request_permission_rule_instructions_for_on_request_when_enabled() {
|
|
let instructions = PermissionsInstructions::from_permissions_with_network(
|
|
SandboxMode::WorkspaceWrite,
|
|
NetworkAccess::Enabled,
|
|
PermissionsPromptConfig {
|
|
approval_policy: AskForApproval::OnRequest,
|
|
approvals_reviewer: ApprovalsReviewer::User,
|
|
approval_messages: None,
|
|
exec_policy: &Policy::empty(),
|
|
exec_permission_approvals_enabled: true,
|
|
request_permissions_tool_enabled: false,
|
|
},
|
|
/*writable_roots*/ None,
|
|
);
|
|
|
|
let text = instructions.body();
|
|
assert!(text.contains("with_additional_permissions"));
|
|
assert!(text.contains("additional_permissions"));
|
|
}
|
|
|
|
#[test]
|
|
fn includes_request_permissions_tool_instructions_for_on_request_when_tool_is_enabled() {
|
|
let instructions = PermissionsInstructions::from_permissions_with_network(
|
|
SandboxMode::WorkspaceWrite,
|
|
NetworkAccess::Enabled,
|
|
PermissionsPromptConfig {
|
|
approval_policy: AskForApproval::OnRequest,
|
|
approvals_reviewer: ApprovalsReviewer::User,
|
|
approval_messages: None,
|
|
exec_policy: &Policy::empty(),
|
|
exec_permission_approvals_enabled: false,
|
|
request_permissions_tool_enabled: true,
|
|
},
|
|
/*writable_roots*/ None,
|
|
);
|
|
|
|
let text = instructions.body();
|
|
assert!(text.contains("# request_permissions Tool"));
|
|
assert!(text.contains("The built-in `request_permissions` tool is available in this session."));
|
|
}
|
|
|
|
#[test]
|
|
fn on_request_includes_tool_guidance_alongside_inline_permission_guidance_when_both_exist() {
|
|
let instructions = PermissionsInstructions::from_permissions_with_network(
|
|
SandboxMode::WorkspaceWrite,
|
|
NetworkAccess::Enabled,
|
|
PermissionsPromptConfig {
|
|
approval_policy: AskForApproval::OnRequest,
|
|
approvals_reviewer: ApprovalsReviewer::User,
|
|
approval_messages: None,
|
|
exec_policy: &Policy::empty(),
|
|
exec_permission_approvals_enabled: true,
|
|
request_permissions_tool_enabled: true,
|
|
},
|
|
/*writable_roots*/ None,
|
|
);
|
|
|
|
let text = instructions.body();
|
|
assert!(text.contains("with_additional_permissions"));
|
|
assert!(text.contains("# request_permissions Tool"));
|
|
}
|
|
|
|
#[test]
|
|
fn catalog_approval_messages_select_reviewer_variant() {
|
|
let messages = ApprovalMessages {
|
|
on_request: Some("user catalog approvals".to_string()),
|
|
on_request_auto_review: Some("auto-review catalog approvals".to_string()),
|
|
};
|
|
|
|
for (reviewer, expected) in [
|
|
(ApprovalsReviewer::User, "user catalog approvals"),
|
|
(
|
|
ApprovalsReviewer::AutoReview,
|
|
"auto-review catalog approvals",
|
|
),
|
|
] {
|
|
assert_eq!(
|
|
approval_text(
|
|
AskForApproval::OnRequest,
|
|
reviewer,
|
|
Some(&messages),
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ true,
|
|
/*request_permissions_tool_enabled*/ true,
|
|
),
|
|
expected
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn empty_catalog_approval_message_suppresses_legacy_approval_section() {
|
|
let messages = ApprovalMessages {
|
|
on_request: Some(String::new()),
|
|
on_request_auto_review: None,
|
|
};
|
|
let mut exec_policy = Policy::empty();
|
|
exec_policy
|
|
.add_prefix_rule(&["git".to_string(), "pull".to_string()], Decision::Allow)
|
|
.expect("add rule");
|
|
let writable_root =
|
|
AbsolutePathBuf::from_absolute_path(test_path_buf("/tmp/repo")).expect("absolute path");
|
|
|
|
let instructions = PermissionsInstructions::from_permissions_with_network(
|
|
SandboxMode::WorkspaceWrite,
|
|
NetworkAccess::Restricted,
|
|
PermissionsPromptConfig {
|
|
approval_policy: AskForApproval::OnRequest,
|
|
approvals_reviewer: ApprovalsReviewer::User,
|
|
approval_messages: Some(&messages),
|
|
exec_policy: &exec_policy,
|
|
exec_permission_approvals_enabled: true,
|
|
request_permissions_tool_enabled: true,
|
|
},
|
|
Some(vec![WritableRoot {
|
|
root: writable_root.clone(),
|
|
read_only_subpaths: Vec::new(),
|
|
protected_metadata_names: Vec::new(),
|
|
}]),
|
|
);
|
|
let text = instructions.body();
|
|
|
|
assert!(text.contains("`sandbox_mode` is `workspace-write`"));
|
|
assert!(text.contains("Network access is restricted."));
|
|
assert!(text.contains(writable_root.to_string_lossy().as_ref()));
|
|
assert!(!text.contains("How to request escalation"));
|
|
assert!(!text.contains("request_permissions Tool"));
|
|
assert!(!text.contains("Approved command prefixes"));
|
|
}
|
|
|
|
#[test]
|
|
fn missing_catalog_key_and_non_on_request_policy_use_legacy_approval_text() {
|
|
let messages = ApprovalMessages {
|
|
on_request: None,
|
|
on_request_auto_review: Some("unused catalog approvals".to_string()),
|
|
};
|
|
|
|
let on_request = approval_text(
|
|
AskForApproval::OnRequest,
|
|
ApprovalsReviewer::User,
|
|
Some(&messages),
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ false,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
let never = approval_text(
|
|
AskForApproval::Never,
|
|
ApprovalsReviewer::User,
|
|
Some(&messages),
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ false,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
|
|
assert!(on_request.contains("How to request escalation"));
|
|
assert_eq!(never, APPROVAL_POLICY_NEVER);
|
|
}
|
|
|
|
#[test]
|
|
fn auto_review_approvals_append_auto_review_specific_guidance() {
|
|
let text = approval_text(
|
|
AskForApproval::OnRequest,
|
|
ApprovalsReviewer::AutoReview,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ false,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
|
|
assert!(text.contains("`approvals_reviewer` is `auto_review`"));
|
|
assert!(!text.contains("`approvals_reviewer` is `guardian_subagent`"));
|
|
assert!(text.contains("materially safer alternative"));
|
|
}
|
|
|
|
#[test]
|
|
fn auto_review_approvals_omit_auto_review_specific_guidance_when_approval_is_never() {
|
|
let text = approval_text(
|
|
AskForApproval::Never,
|
|
ApprovalsReviewer::AutoReview,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ false,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
|
|
assert!(!text.contains("`approvals_reviewer` is `auto_review`"));
|
|
assert!(!text.contains("`approvals_reviewer` is `guardian_subagent`"));
|
|
}
|
|
|
|
fn granular_categories_section(title: &str, categories: &[&str]) -> String {
|
|
format!("{title}\n{}", categories.join("\n"))
|
|
}
|
|
|
|
fn granular_prompt_expected(
|
|
prompted_categories: &[&str],
|
|
rejected_categories: &[&str],
|
|
include_shell_permission_request_instructions: bool,
|
|
include_request_permissions_tool_section: bool,
|
|
) -> String {
|
|
let mut sections = vec![granular_prompt_intro_text().to_string()];
|
|
if !prompted_categories.is_empty() {
|
|
sections.push(granular_categories_section(
|
|
"These approval categories may still prompt the user when needed:",
|
|
prompted_categories,
|
|
));
|
|
}
|
|
if !rejected_categories.is_empty() {
|
|
sections.push(granular_categories_section(
|
|
"These approval categories are automatically rejected instead of prompting the user:",
|
|
rejected_categories,
|
|
));
|
|
}
|
|
if include_shell_permission_request_instructions {
|
|
sections.push(APPROVAL_POLICY_ON_REQUEST_RULE_REQUEST_PERMISSION.to_string());
|
|
}
|
|
if include_request_permissions_tool_section {
|
|
sections.push(request_permissions_tool_prompt_section().to_string());
|
|
}
|
|
sections.join("\n\n")
|
|
}
|
|
|
|
#[test]
|
|
fn granular_policy_lists_prompted_and_rejected_categories_separately() {
|
|
let text = approval_text(
|
|
AskForApproval::Granular(GranularApprovalConfig {
|
|
sandbox_approval: false,
|
|
rules: true,
|
|
skill_approval: false,
|
|
request_permissions: true,
|
|
mcp_elicitations: false,
|
|
}),
|
|
ApprovalsReviewer::User,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ true,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
|
|
assert_eq!(
|
|
text,
|
|
[
|
|
granular_prompt_intro_text().to_string(),
|
|
granular_categories_section(
|
|
"These approval categories may still prompt the user when needed:",
|
|
&["- `rules`"],
|
|
),
|
|
granular_categories_section(
|
|
"These approval categories are automatically rejected instead of prompting the user:",
|
|
&[
|
|
"- `sandbox_approval`",
|
|
"- `skill_approval`",
|
|
"- `mcp_elicitations`",
|
|
],
|
|
),
|
|
]
|
|
.join("\n\n")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn granular_policy_includes_command_permission_instructions_when_sandbox_approval_can_prompt() {
|
|
let text = approval_text(
|
|
AskForApproval::Granular(GranularApprovalConfig {
|
|
sandbox_approval: true,
|
|
rules: true,
|
|
skill_approval: true,
|
|
request_permissions: true,
|
|
mcp_elicitations: true,
|
|
}),
|
|
ApprovalsReviewer::User,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ true,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
|
|
assert_eq!(
|
|
text,
|
|
granular_prompt_expected(
|
|
&[
|
|
"- `sandbox_approval`",
|
|
"- `rules`",
|
|
"- `skill_approval`",
|
|
"- `mcp_elicitations`",
|
|
],
|
|
&[],
|
|
/*include_shell_permission_request_instructions*/ true,
|
|
/*include_request_permissions_tool_section*/ false,
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn granular_policy_omits_shell_permission_instructions_when_inline_requests_are_disabled() {
|
|
let text = approval_text(
|
|
AskForApproval::Granular(GranularApprovalConfig {
|
|
sandbox_approval: true,
|
|
rules: true,
|
|
skill_approval: true,
|
|
request_permissions: true,
|
|
mcp_elicitations: true,
|
|
}),
|
|
ApprovalsReviewer::User,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ false,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
|
|
assert_eq!(
|
|
text,
|
|
granular_prompt_expected(
|
|
&[
|
|
"- `sandbox_approval`",
|
|
"- `rules`",
|
|
"- `skill_approval`",
|
|
"- `mcp_elicitations`",
|
|
],
|
|
&[],
|
|
/*include_shell_permission_request_instructions*/ false,
|
|
/*include_request_permissions_tool_section*/ false,
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn granular_policy_includes_request_permissions_tool_only_when_that_prompt_can_still_fire() {
|
|
let allowed = approval_text(
|
|
AskForApproval::Granular(GranularApprovalConfig {
|
|
sandbox_approval: true,
|
|
rules: true,
|
|
skill_approval: true,
|
|
request_permissions: true,
|
|
mcp_elicitations: true,
|
|
}),
|
|
ApprovalsReviewer::User,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ true,
|
|
/*request_permissions_tool_enabled*/ true,
|
|
);
|
|
assert!(allowed.contains("# request_permissions Tool"));
|
|
|
|
let rejected = approval_text(
|
|
AskForApproval::Granular(GranularApprovalConfig {
|
|
sandbox_approval: true,
|
|
rules: true,
|
|
skill_approval: true,
|
|
request_permissions: false,
|
|
mcp_elicitations: true,
|
|
}),
|
|
ApprovalsReviewer::User,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ true,
|
|
/*request_permissions_tool_enabled*/ true,
|
|
);
|
|
assert!(!rejected.contains("# request_permissions Tool"));
|
|
}
|
|
|
|
#[test]
|
|
fn granular_policy_lists_request_permissions_category_without_tool_section_when_tool_unavailable() {
|
|
let text = approval_text(
|
|
AskForApproval::Granular(GranularApprovalConfig {
|
|
sandbox_approval: false,
|
|
rules: false,
|
|
skill_approval: false,
|
|
request_permissions: true,
|
|
mcp_elicitations: false,
|
|
}),
|
|
ApprovalsReviewer::User,
|
|
/*approval_messages*/ None,
|
|
&Policy::empty(),
|
|
/*exec_permission_approvals_enabled*/ true,
|
|
/*request_permissions_tool_enabled*/ false,
|
|
);
|
|
|
|
assert!(!text.contains("- `request_permissions`"));
|
|
assert!(!text.contains("# request_permissions Tool"));
|
|
}
|