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
@@ -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 {