Return an assessment for explicit Guardian reviews (#62846)

## Why

An explicit `thread/guardianReview` request could return a null assessment when live execution would skip approval, leaving callers without a verdict on the recorded action.

## What changed

Require `assessment` on every successful `thread/guardianReview` response. Review eligible recorded calls even when a command is allowlisted, an MCP tool is configured for automatic approval or has a remembered approval, or the policy disables permission requests. The review runs without executing the call or granting permissions.

Include the MCP server's owning environment permissions in the review context, matching live review.

## Testing

Cover allowlisted commands, permission requests with prompting disabled, and automatically approved MCP tools. Compare live and recorded MCP review input for a server whose owning environment has denied paths.

GitOrigin-RevId: 54689dc043d77f940e10d29842308340f6937980
This commit is contained in:
swastik-oai
2026-11-20 21:58:11 +00:00
committed by copyberry
parent 2b5111917c
commit 9735367e18
15 changed files with 192 additions and 303 deletions
@@ -1863,8 +1863,7 @@ pub struct ThreadGuardianReviewParams {
#[ts(export_to = "v2/")]
pub struct ThreadGuardianReviewResponse {
pub call_id: String,
/// Null when current policy or a remembered approval skips review.
pub assessment: Option<ThreadGuardianAssessment>,
pub assessment: ThreadGuardianAssessment,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
@@ -227,14 +227,12 @@ impl TurnRequestProcessor {
Ok(Some(
ThreadGuardianReviewResponse {
call_id: result.call_id,
assessment: result
.assessment
.map(|assessment| ThreadGuardianAssessment {
outcome: assessment.outcome,
risk_level: assessment.risk_level.into(),
user_authorization: assessment.user_authorization.into(),
rationale: assessment.rationale,
}),
assessment: ThreadGuardianAssessment {
outcome: result.assessment.outcome,
risk_level: result.assessment.risk_level.into(),
user_authorization: result.assessment.user_authorization.into(),
rationale: result.assessment.rationale,
},
}
.into(),
))
@@ -783,8 +783,9 @@ async fn inline_review_delegate_runs_strict_guardian_assessment() -> Result<()>
}
#[tokio::test]
async fn guardian_review_reuses_private_recorded_call_history_per_parent() -> Result<()> {
let rationale = "Guardian approved the recorded file write.";
async fn guardian_review_assesses_allowlisted_calls_and_reuses_private_history_per_parent()
-> Result<()> {
let rationale = "Guardian approved the recorded listing.";
let verdict = assistant_response(
&json!({
"outcome": "allow",
@@ -798,6 +799,12 @@ async fn guardian_review_reuses_private_recorded_call_history_per_parent() -> Re
let requests = responses::mount_sse_sequence(&server, vec![verdict; 3]).await;
let codex_home = TempDir::new()?;
sync_config(&server.uri()).write(codex_home.path())?;
let rules = codex_home.path().join("rules");
std::fs::create_dir_all(&rules)?;
std::fs::write(
rules.join("default.rules"),
r#"prefix_rule(pattern=["git", "ls-files"], decision="allow")"#,
)?;
let mut app = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized()
@@ -816,7 +823,7 @@ async fn guardian_review_reuses_private_recorded_call_history_per_parent() -> Re
json!({
"type": "message",
"role": "user",
"content": [{"type": "input_text", "text": "Create the requested file."}],
"content": [{"type": "input_text", "text": "List tracked files."}],
})
};
let items = vec![
@@ -825,7 +832,7 @@ async fn guardian_review_reuses_private_recorded_call_history_per_parent() -> Re
"type": "function_call",
"name": "exec_command",
"call_id": call_id,
"arguments": r#"{"cmd":"echo reviewed > guardian-direct.txt","sandbox_permissions":"require_escalated","justification":"Create the requested file."}"#,
"arguments": r#"{"cmd":"git ls-files"}"#,
}),
];
let _: ThreadInjectItemsResponse = app
@@ -824,43 +824,3 @@ async fn turn_tool_output_retention_preserves_sender_metadata() -> Result<()> {
);
Ok(())
}
#[tokio::test]
async fn guardian_review_returns_the_injected_call_id_when_policy_skips_review() -> Result<()> {
let server = responses::start_mock_server().await;
let codex_home = TempDir::new()?;
MockResponsesConfig::new(&server.uri()).write(codex_home.path())?;
let rules = codex_home.path().join("rules");
std::fs::create_dir_all(&rules)?;
std::fs::write(
rules.join("default.rules"),
r#"prefix_rule(pattern=["git", "init", "guardian-skipped"], decision="allow")"#,
)?;
let mut app = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized()
.await?;
let start = app
.send_thread_start_request_with_auto_env(ThreadStartParams::default())
.await?;
let ThreadStartResponse { thread, .. } = app.read_response(start).await?;
let inject = app
.send_thread_inject_items_request(ThreadInjectItemsParams {
thread_id: thread.id.clone(),
items: vec![json!({
"type": "function_call", "name": "exec_command", "call_id": "recorded",
"arguments": r#"{"cmd":"git init guardian-skipped"}"#,
})],
})
.await?;
let _: ThreadInjectItemsResponse = app.read_response(inject).await?;
let review = app
.send_raw_request(
"thread/guardianReview",
Some(json!({"threadId": thread.id})),
)
.await?;
let response: Value = app.read_response(review).await?;
assert_eq!(response, json!({"callId":"recorded", "assessment":null}));
Ok(())
}
@@ -9,7 +9,6 @@ use codex_guardian_reviewer::ReviewDeadline;
use codex_protocol::error::CodexErr;
use codex_protocol::error::Result;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::AskForApproval;
use codex_tools::FunctionCallError;
use codex_tools::ToolName;
use tokio_util::sync::CancellationToken;
@@ -144,19 +143,15 @@ pub(crate) async fn review_tool_call(
PreToolUseError::Cancelled(_) => CodexErr::TurnAborted,
})?;
let step = &invocation.step_context;
let (requirement, action) = if let Some(tool_info) = advertised_mcp_tool {
let prepared = mcp_tool_call::recorded::prepare_approval_action(&invocation, tool_info)
let context = GuardianReviewContext::from(step);
let (approval, request) = if let Some(tool_info) = advertised_mcp_tool {
let request = mcp_tool_call::recorded::prepare_review_request(&invocation, tool_info)
.await
.map_err(tool_error)?;
let Some(action) = prepared else {
return Ok(GuardianReviewResult {
call_id: invocation.call_id,
assessment: None,
});
};
(None, action)
(None, request)
} else {
match (invocation.tool_name.name.as_str(), &invocation.payload) {
let name = invocation.tool_name.name.as_str();
let (requirement, action) = match (name, &invocation.payload) {
("exec_command", ToolPayload::Function { arguments }) => {
let args: ToolEnvironmentArgs =
parse_arguments(arguments).map_err(tool_error)?;
@@ -208,25 +203,6 @@ pub(crate) async fn review_tool_call(
.map_err(tool_error)?;
let prepared = PreparedPermissionRequest::parse(arguments, environment)
.map_err(tool_error)?;
match step.settings.approval_policy() {
AskForApproval::Never => {
return Ok(GuardianReviewResult {
call_id: invocation.call_id,
assessment: None,
});
}
AskForApproval::Granular(policy)
if !policy.allows_request_permissions() =>
{
return Ok(GuardianReviewResult {
call_id: invocation.call_id,
assessment: None,
});
}
AskForApproval::OnRequest
| AskForApproval::UnlessTrusted
| AskForApproval::Granular(_) => {}
}
let action = prepared.approval_action(&invocation.call_id, &step.turn.sub_id);
(None, action)
}
@@ -235,30 +211,24 @@ pub(crate) async fn review_tool_call(
"unsupported tool or payload for direct review".into(),
));
}
}
};
let approval = match &requirement {
None | Some(ExecApprovalRequirement::Skip { .. }) => None,
Some(ExecApprovalRequirement::NeedsApproval { reason, .. }) => reason.clone(),
Some(ExecApprovalRequirement::NeedsHumanApproval { .. }) => {
return Err(CodexErr::InvalidRequest(
"Managed command policy requires human approval.".into(),
));
}
Some(ExecApprovalRequirement::Forbidden { reason }) => {
return Err(CodexErr::InvalidRequest(reason.clone()));
}
};
let request = from_approval_action(action, &context)
.request
.map_err(CodexErr::InvalidRequest)?;
(approval, request)
};
let approval = match &requirement {
None => None,
Some(ExecApprovalRequirement::Skip { .. }) => {
return Ok(GuardianReviewResult {
call_id: invocation.call_id,
assessment: None,
});
}
Some(ExecApprovalRequirement::NeedsApproval { reason, .. }) => reason.clone(),
Some(ExecApprovalRequirement::NeedsHumanApproval { .. }) => {
return Err(CodexErr::InvalidRequest(
"Managed command policy requires human approval.".into(),
));
}
Some(ExecApprovalRequirement::Forbidden { reason }) => {
return Err(CodexErr::InvalidRequest(reason.clone()));
}
};
let context = GuardianReviewContext::from(step);
let request = from_approval_action(action, &context)
.request
.map_err(CodexErr::InvalidRequest)?;
let input = ReviewInput {
session: Arc::clone(session),
context,
@@ -279,7 +249,7 @@ pub(crate) async fn review_tool_call(
})?;
Ok(GuardianReviewResult {
call_id: invocation.call_id,
assessment: Some(assessment),
assessment,
})
};
tokio::select! {
+1 -2
View File
@@ -18,8 +18,7 @@ pub enum ReviewRetrieval {
#[derive(Debug, PartialEq, Eq)]
pub struct GuardianReviewResult {
pub call_id: String,
/// Absent when current policy or a remembered approval skips review.
pub assessment: Option<codex_guardian_reviewer::GuardianAssessment>,
pub assessment: codex_guardian_reviewer::GuardianAssessment,
}
/// Scope backend reviewer attribution to the provider-selected Guardian model.
+2 -1
View File
@@ -2086,6 +2086,7 @@ pub(crate) fn build_guardian_mcp_tool_review_request(
call_id: &str,
invocation: &McpInvocation,
metadata: Option<&McpToolApprovalMetadata>,
prompt_permissions: Option<(String, Arc<FileSystemSandboxContext>)>,
) -> GuardianApprovalRequest {
GuardianApprovalRequest::McpToolCall {
id: call_id.to_string(),
@@ -2107,7 +2108,7 @@ pub(crate) fn build_guardian_mcp_tool_review_request(
open_world_hint: annotations.open_world_hint,
read_only_hint: annotations.read_only_hint,
}),
prompt_permissions: None,
prompt_permissions,
}
}
+15 -33
View File
@@ -1,23 +1,22 @@
//! Prepares MCP approval actions using current bindings without dispatching or remembering approval.
//! Prepares Guardian review requests using current bindings without dispatching or remembering approval.
use codex_mcp::ToolInfo;
use codex_protocol::protocol::McpInvocation;
use codex_tools::FunctionCallError;
use super::McpToolApprovalRequirement;
use super::build_guardian_mcp_tool_review_request;
use super::capture_environment_permissions;
use super::mcp_tool_approval_policy;
use super::mcp_tool_metadata;
use super::parse_mcp_tool_arguments;
use super::prepare_mcp_tool_approval;
use crate::guardian::GuardianApprovalRequest;
use crate::tools::context::ToolInvocation;
use crate::tools::context::ToolPayload;
use crate::tools::handlers::McpHandler;
use crate::tools::sandboxing::ApprovalAction;
pub(crate) async fn prepare_approval_action(
pub(crate) async fn prepare_review_request(
invocation: &ToolInvocation,
advertised_tool: &ToolInfo,
) -> Result<Option<ApprovalAction>, FunctionCallError> {
) -> Result<GuardianApprovalRequest, FunctionCallError> {
let ToolPayload::Function { arguments } = &invocation.payload else {
return Err(FunctionCallError::RespondToModel(
"mcp handler received unsupported payload".into(),
@@ -45,32 +44,15 @@ pub(crate) async fn prepare_approval_action(
mcp_invocation.arguments.as_ref(),
)
.map_err(|error| FunctionCallError::RespondToModel(error.to_string()))?;
let policy = mcp_tool_approval_policy(&call, &metadata).ok_or_else(|| {
FunctionCallError::RespondToModel("MCP tool call blocked by app configuration".into())
})?;
let requested_reviewer = invocation
.session
.mcp_requested_reviewer(&invocation.step_context.settings)
.await;
match prepare_mcp_tool_approval(
&invocation.session,
&invocation.step_context,
if mcp_tool_approval_policy(&call, &metadata).is_none() {
return Err(FunctionCallError::RespondToModel(
"MCP tool call blocked by app configuration".into(),
));
}
Ok(build_guardian_mcp_tool_review_request(
&invocation.call_id,
&mcp_invocation,
&McpHandler::hook_tool_name_for(advertised_tool),
&metadata,
call.config(),
call.permission_source(),
call.server_environment_id(),
call.server_key(),
policy,
requested_reviewer,
)
.await
{
McpToolApprovalRequirement::NotRequired | McpToolApprovalRequirement::Remembered => {
Ok(None)
}
McpToolApprovalRequirement::Required { action, .. } => Ok(Some(*action)),
}
Some(&metadata),
capture_environment_permissions(call.permission_source()),
))
}
+18 -3
View File
@@ -2322,7 +2322,12 @@ fn guardian_mcp_review_request_includes_invocation_metadata() {
Some("Open a page"),
);
metadata.connected_account_email = Some("owner@example.com".to_string());
let request = build_guardian_mcp_tool_review_request("call-1", &invocation, Some(&metadata));
let request = build_guardian_mcp_tool_review_request(
"call-1",
&invocation,
Some(&metadata),
/*prompt_permissions*/ None,
);
assert_eq!(
request,
@@ -2369,7 +2374,12 @@ fn guardian_mcp_review_request_includes_annotations_when_present() {
openai_file_input_optional_fields: None,
};
let request = build_guardian_mcp_tool_review_request("call-1", &invocation, Some(&metadata));
let request = build_guardian_mcp_tool_review_request(
"call-1",
&invocation,
Some(&metadata),
/*prompt_permissions*/ None,
);
assert_eq!(
request,
@@ -2409,7 +2419,12 @@ fn guardian_mcp_review_request_ignores_untrusted_connected_account_email() {
);
metadata.connected_account_email = Some("spoofed@example.com".to_string());
let request = build_guardian_mcp_tool_review_request("call-1", &invocation, Some(&metadata));
let request = build_guardian_mcp_tool_review_request(
"call-1",
&invocation,
Some(&metadata),
/*prompt_permissions*/ None,
);
assert_eq!(
request,
+1
View File
@@ -1198,6 +1198,7 @@ async fn review_guardian_mcp_elicitation(
call_id,
invocation,
Some(metadata),
/*prompt_permissions*/ None,
),
)
} else {
@@ -1,6 +1,8 @@
//! Reviews bind each action to its captured target policy while reusing the reviewer context.
use super::*;
use crate::suite::scenarios::guardian_direct_mcp::recorded_mcp_items;
use crate::suite::scenarios::guardian_direct_review::model_input;
use codex_core::context::UserGoalUpdate;
use codex_history::RolloutItem;
use codex_protocol::permissions::FileSystemSpecialPath;
@@ -21,7 +23,7 @@ use wiremock::matchers::method;
use wiremock::matchers::path;
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn direct_mcp_approval_uses_the_server_owners_denied_paths() -> Result<()> {
async fn live_and_recorded_mcp_reviews_use_the_server_owners_denied_paths() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let workspace = TempDir::new()?;
@@ -41,6 +43,7 @@ async fn direct_mcp_approval_uses_the_server_owners_denied_paths() -> Result<()>
"cwd": workspace.path(),
"environment_id": REMOTE_ENVIRONMENT_ID,
"default_tools_approval_mode": "prompt",
"required": true,
}
}))?;
let test = test_codex()
@@ -77,13 +80,12 @@ async fn direct_mcp_approval_uses_the_server_owners_denied_paths() -> Result<()>
)
.await?;
let prompt = "Call the files tool.";
let call = ev_function_call_with_namespace("call", "mcp__files", "echo", r#"{"message":"hi"}"#);
let (release, gate) = tokio::sync::oneshot::channel();
let (parent, _) = start_streaming_sse_server(vec![vec![StreamingSseChunk {
gate: Some(gate),
body: sse(vec![
ev_function_call_with_namespace("call", "mcp__files", "echo", r#"{"message":"hi"}"#),
ev_completed("parent"),
]),
body: sse(vec![call, ev_completed("parent")]),
}]])
.await;
Mock::given(method("POST"))
@@ -104,6 +106,10 @@ async fn direct_mcp_approval_uses_the_server_owners_denied_paths() -> Result<()>
ev_completed("review"),
]),
sse(vec![ev_completed("done")]),
sse(vec![
ev_assistant_message("recorded-review", r#"{"outcome":"deny"}"#),
ev_completed("recorded-review"),
]),
],
)
.await;
@@ -118,17 +124,29 @@ async fn direct_mcp_approval_uses_the_server_owners_denied_paths() -> Result<()>
PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),
);
// The step didn't see the deny rule. MCP receives it before preparing the call.
tokio::try_join!(test.submit_text_turn("Call the files tool."), async {
tokio::try_join!(test.submit_text_turn(prompt), async {
parent.wait_for_request_count(/*count*/ 1).await;
test.codex.environment_ready(&owner, owner_config).await?;
release.send(()).expect("let the model call the tool");
Ok(())
})?;
let review = responses
.requests()
.into_iter()
.find(|request| request.body_json()["client_metadata"]["x-openai-subagent"] == "guardian")
.context("expected a Guardian review")?;
let options = test.start_thread_options().await;
let recorded = test.thread_manager.start_thread(options).await?;
let items = recorded_mcp_items(&test.codex, prompt).await?;
recorded.thread.inject_response_items(items).await?;
recorded
.thread
.guardian_review(&tokio_util::sync::CancellationToken::new())
.await?;
let requests = responses.requests();
let [review, _, replay] = requests.as_slice() else {
anyhow::bail!("expected live review, parent completion, and recorded review");
};
assert_eq!(
model_input(replay, recorded.thread_id)?,
model_input(review, test.session_configured.thread_id)?
);
recorded.thread.shutdown_and_wait().await?;
let owner_label = format!("permission profile for environment {REMOTE_ENVIRONMENT_ID:?}");
let permissions = review
.message_input_texts("user")
+2 -2
View File
@@ -220,10 +220,10 @@ mod guardian_async_elastic;
mod guardian_sender_context;
#[path = "scenarios_guardian_direct_review.rs"]
mod guardian_direct_review;
pub(super) mod guardian_direct_review;
#[path = "scenarios_guardian_direct_mcp.rs"]
mod guardian_direct_mcp;
pub(super) mod guardian_direct_mcp;
#[path = "scenarios_guardian_extra_policy.rs"]
mod guardian_extra_policy;
@@ -90,8 +90,60 @@ async fn direct_mcp_review_without_dispatch() -> Result<()> {
let prompt = "Use [$calendar](app://calendar) to create a lunch event.";
test.submit_text_turn(prompt).await?;
assert_eq!(recorded_apps_tool_calls(&server).await, Vec::<Value>::new());
test.codex.flush_rollout().await?;
let history = test.codex.load_history(/*include_archived*/ false).await?;
let items = recorded_mcp_items(&test.codex, prompt).await?;
let mut options = test.start_thread_options().await;
set_default_app_approval_mode_and_reviewer(
&mut options.config,
AppToolApproval::Approve,
ApprovalsReviewer::AutoReview,
);
let direct = test.thread_manager.start_thread(options).await?;
wait_for_mcp_server(&direct.thread, "codex_apps").await?;
direct.thread.inject_response_items(items).await?;
let result = direct
.thread
.guardian_review(&CancellationToken::new())
.await?;
assert_eq!(
result,
GuardianReviewResult {
call_id: "mcp-review".to_owned(),
assessment: serde_json::from_value(assessment)?,
}
);
let requests = mock.requests();
let [_, live, _, recorded] = requests.as_slice() else {
panic!("expected parent, live Guardian, parent, direct Guardian");
};
assert_eq!(
model_input(recorded, direct.thread_id)?,
model_input(live, test.session_configured.thread_id)?,
);
assert_eq!(recorded_apps_tool_calls(&server).await, Vec::<Value>::new());
direct.thread.shutdown_and_wait().await?;
let snapshot = context_snapshot::format_request_history_snapshot(
"A live MCP denial and a direct approval render the same action; neither dispatches the tool.",
&mock.requests(),
&ContextSnapshotOptions::default().rewrite_known_segments(),
);
let environment_id = &test.executor_environment().selection().environment_id;
let snapshot = snapshot.replace(
&format!("environment {environment_id:?}"),
"environment \"<ENVIRONMENT>\"",
);
insta::assert_snapshot!("guardian_direct_mcp", snapshot);
test.codex.shutdown_and_wait().await?;
Ok(())
}
pub(in crate::suite) async fn recorded_mcp_items(
thread: &codex_core::CodexThread,
prompt: &str,
) -> Result<Vec<ResponseItem>> {
thread.flush_rollout().await?;
let history = thread.load_history(/*include_archived*/ false).await?;
let items = history
.items
.into_iter()
@@ -109,60 +161,5 @@ async fn direct_mcp_review_without_dispatch() -> Result<()> {
})
.collect::<Vec<_>>();
assert_eq!(items.len(), 2);
// Review the same recorded call under each current policy, using one live baseline.
for (current_approval_mode, expected_assessment) in [
(
AppToolApproval::Prompt,
Some(serde_json::from_value(assessment)?),
),
(AppToolApproval::Approve, None),
] {
let mut options = test.start_thread_options().await;
set_default_app_approval_mode_and_reviewer(
&mut options.config,
current_approval_mode,
ApprovalsReviewer::AutoReview,
);
let direct = test.thread_manager.start_thread(options).await?;
wait_for_mcp_server(&direct.thread, "codex_apps").await?;
direct.thread.inject_response_items(items.clone()).await?;
let result = direct
.thread
.guardian_review(&CancellationToken::new())
.await?;
assert_eq!(
result,
GuardianReviewResult {
call_id: "mcp-review".to_owned(),
assessment: expected_assessment,
}
);
// The approve policy adds no Guardian request; both phases leave exactly four.
let requests = mock.requests();
let [_, live, _, recorded] = requests.as_slice() else {
panic!("expected parent, live Guardian, parent, direct Guardian");
};
if result.assessment.is_some() {
assert_eq!(
model_input(recorded, direct.thread_id)?,
model_input(live, history.thread_id)?,
);
}
assert_eq!(recorded_apps_tool_calls(&server).await, Vec::<Value>::new());
direct.thread.shutdown_and_wait().await?;
}
let snapshot = context_snapshot::format_request_history_snapshot(
"A live MCP denial and a direct approval render the same action; neither dispatches the tool.",
&mock.requests(),
&ContextSnapshotOptions::default().rewrite_known_segments(),
);
let environment_id = &test.executor_environment().selection().environment_id;
let snapshot = snapshot.replace(
&format!("environment {environment_id:?}"),
"environment \"<ENVIRONMENT>\"",
);
insta::assert_snapshot!("guardian_direct_mcp", snapshot);
test.codex.shutdown_and_wait().await?;
Ok(())
Ok(items)
}
@@ -135,7 +135,7 @@ async fn direct_exec_review_matches_live_action_without_execution() -> Result<()
result,
GuardianReviewResult {
call_id: "exec-review".to_owned(),
assessment: Some(serde_json::from_str(assessment)?),
assessment: serde_json::from_str(assessment)?,
}
);
assert!(!harness.path_exists("guardian-direct.txt").await?);
@@ -171,27 +171,7 @@ async fn direct_exec_review_matches_live_action_without_execution() -> Result<()
assert_eq!(follow_up.call_id, "follow-up");
assert!(!harness.path_exists("guardian-follow-up.txt").await?);
// The explicit allow rule skips review on every platform.
direct
.thread
.inject_response_items(vec![serde_json::from_value(json!({
"type": "function_call", "call_id": "skip-review", "name": "exec_command",
"arguments": r#"{"cmd":"git init guardian-skipped"}"#,
}))?])
.await?;
assert_eq!(
direct
.thread
.guardian_review(&CancellationToken::new())
.await?,
GuardianReviewResult {
call_id: "skip-review".to_owned(),
assessment: None,
}
);
assert!(!harness.path_exists("guardian-skipped").await?);
// The same allowlisted command cannot be assessed after a recorded permission grant.
// An allowlisted command cannot be assessed after a recorded permission grant.
direct
.thread
.inject_response_items(serde_json::from_value(json!([
@@ -361,7 +341,7 @@ async fn direct_patch_review_matches_live_action_without_writes(
.await?,
GuardianReviewResult {
call_id: "patch-review".to_owned(),
assessment: Some(serde_json::from_value(assessment)?),
assessment: serde_json::from_value(assessment)?,
}
);
// 3. Verify no writes despite approval, and parity with the normal review input.
@@ -490,7 +470,7 @@ async fn direct_permissions_review_matches_live_action() -> Result<()> {
.await?,
GuardianReviewResult {
call_id: "permissions-review".to_owned(),
assessment: Some(serde_json::from_value(assessment)?),
assessment: serde_json::from_value(assessment)?,
}
);
// 3. Verify parity with the live review input.
@@ -540,58 +520,6 @@ async fn direct_permissions_review_matches_live_action() -> Result<()> {
Ok(())
}
#[tokio::test]
async fn direct_patch_review_skips_writable_file_without_writes() -> Result<()> {
skip_if_no_network!(Ok(()));
let builder = test_codex().with_model("gpt-5.5").with_config(|config| {
super::configure_scenario_catalog(config);
config.approvals_reviewer = ApprovalsReviewer::AutoReview;
config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);
// Writable patches can bypass review only when a sandbox is available.
config.permissions.windows_sandbox_mode =
Some(codex_config::types::WindowsSandboxModeToml::Unelevated);
config
.permissions
.set_permission_profile(PermissionProfile::workspace_write())
.expect("workspace-write permissions");
});
let harness = TestCodexHarness::with_auto_env_builder(builder).await?;
let test = harness.test();
harness
.write_file("guardian-skipped.txt", "before\n")
.await?;
let mock = responses::mount_sse_once(
harness.server(),
sse(vec![ev_completed("unexpected-review")]),
)
.await;
test.codex
.inject_response_items(vec![serde_json::from_value(json!({
"type": "custom_tool_call",
"call_id": "patch-skip",
"name": "apply_patch",
"input": "*** Begin Patch\n*** Update File: guardian-skipped.txt\n@@\n-before\n+after\n*** End Patch",
}))?])
.await?;
assert_eq!(
test.codex
.guardian_review(&CancellationToken::new())
.await?,
GuardianReviewResult {
call_id: "patch-skip".to_owned(),
assessment: None,
}
);
assert!(mock.requests().is_empty());
assert_eq!(
harness.read_file_text("guardian-skipped.txt").await?,
"before\n"
);
test.codex.shutdown_and_wait().await?;
Ok(())
}
#[test_case::test_case(AskForApproval::Never; "never")]
#[test_case::test_case(AskForApproval::Granular(codex_protocol::protocol::GranularApprovalConfig {
sandbox_approval: true,
@@ -601,7 +529,7 @@ async fn direct_patch_review_skips_writable_file_without_writes() -> Result<()>
skill_approval: true,
}); "granular")]
#[tokio::test]
async fn direct_permissions_review_skips_when_policy_disallows_requests(
async fn direct_permissions_review_returns_assessment_when_policy_disallows_requests(
policy: AskForApproval,
) -> Result<()> {
skip_if_no_network!(Ok(()));
@@ -617,11 +545,23 @@ async fn direct_permissions_review_skips_when_policy_disallows_requests(
});
let harness = TestCodexHarness::with_auto_env_builder(builder).await?;
let test = harness.test();
let mock =
responses::mount_sse_once(harness.server(), sse(vec![ev_completed("unexpected")])).await;
let assessment = json!({
"outcome": "allow",
"risk_level": "low",
"user_authorization": "high",
"rationale": "The network request is authorized."
});
responses::mount_sse_once(
harness.server(),
sse(vec![
ev_assistant_message("review", &assessment.to_string()),
ev_completed("review"),
]),
)
.await;
test.codex
.inject_response_items(vec![serde_json::from_value(json!({
"type": "function_call", "name": "request_permissions", "call_id": "permissions-skip",
"type": "function_call", "name": "request_permissions", "call_id": "permissions-review",
"arguments": r#"{"permissions":{"network":{"enabled":true}}}"#,
}))?])
.await?;
@@ -630,16 +570,18 @@ async fn direct_permissions_review_skips_when_policy_disallows_requests(
.guardian_review(&CancellationToken::new())
.await?,
GuardianReviewResult {
call_id: "permissions-skip".into(),
assessment: None,
call_id: "permissions-review".into(),
assessment: serde_json::from_value(assessment)?,
}
);
assert!(mock.requests().is_empty());
test.codex.shutdown_and_wait().await?;
Ok(())
}
pub(super) fn model_input(request: &ResponsesRequest, parent: ThreadId) -> Result<String> {
pub(in crate::suite) fn model_input(
request: &ResponsesRequest,
parent: ThreadId,
) -> Result<String> {
let mut input = request.input();
for item in &mut input {
item.as_object_mut().expect("response item").remove("id");
@@ -718,7 +660,7 @@ prefix_rule(pattern=["git", "init", "guardian-rewritten"], decision="prompt")
.await?,
GuardianReviewResult {
call_id: "hook-review".to_owned(),
assessment: Some(serde_json::from_value(assessment)?),
assessment: serde_json::from_value(assessment)?,
}
);