From a05444bbeb6bb07f2875fff0143f2e4cba994463 Mon Sep 17 00:00:00 2001 From: ioanbudea-OAI Date: Wed, 18 Nov 2026 12:47:17 +0000 Subject: [PATCH] Refresh managed Guardian policy independently of MCP (#62276) ## Why Managed approval requirements can change while an MCP runtime is still in use. Later turns need to honor those changes without restarting MCP, while in-flight MCP actions need to retain the mandatory review requirements of their issuing turn. ## What changed - Add `CodexThread::refresh_guardian_policy` to apply managed policy updates to an existing thread. MCP configuration refreshes preserve the active Guardian policy, including when a policy update lands while MCP configuration is loading. - Resolve MCP tool and elicitation reviewers against the issuing turn's policy. Live requirements can still require Guardian review, and a live policy change cannot waive mandatory review captured by the turn. ## Testing Extend coverage for overlapping Guardian and MCP refreshes and for an existing MCP runtime that must prompt the user on the next turn after a policy update allows only the `user` reviewer. GitOrigin-RevId: 5a1649f917313f6fb152a206bc89986fe6345481 --- codex-rs/core/src/codex_thread.rs | 9 ++ codex-rs/core/src/config/runtime_refresh.rs | 18 ++++ .../core/src/config/runtime_refresh_tests.rs | 84 ++++++++++++++- codex-rs/core/src/connectors.rs | 13 ++- codex-rs/core/src/connectors_tests.rs | 9 +- codex-rs/core/src/guardian/decision.rs | 33 ++++-- codex-rs/core/src/guardian/tests.rs | 37 +++---- codex-rs/core/src/mcp_tool_call.rs | 80 ++++++++------ codex-rs/core/src/mcp_tool_call/recorded.rs | 5 + codex-rs/core/src/mcp_tool_call_tests.rs | 21 +++- codex-rs/core/src/session/config_refresh.rs | 100 ++++++++++++++++-- .../core/src/session/config_refresh_tests.rs | 49 +++++++++ codex-rs/core/src/session/mcp.rs | 66 ++++++++---- codex-rs/core/src/session/mcp_runtime.rs | 1 - codex-rs/core/src/session/step_activation.rs | 20 +++- codex-rs/core/src/state/session.rs | 6 ++ .../core/tests/suite/mcp_turn_metadata.rs | 71 +++++++++++++ 17 files changed, 522 insertions(+), 100 deletions(-) diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rs index 1d443d3a4d..3e815d612e 100644 --- a/codex-rs/core/src/codex_thread.rs +++ b/codex-rs/core/src/codex_thread.rs @@ -1474,6 +1474,15 @@ impl CodexThread { self.session.disable_mcp_enterprise_auth().await; } + /// Refresh managed Guardian policy for future turns without changing MCP state. + /// Session and user policy fallbacks remain pinned until their own reload. + pub async fn refresh_guardian_policy( + &self, + snapshot: &codex_config::GuardianPolicySnapshot, + ) -> ConfigRefreshOutcome { + self.session.refresh_guardian_policy(snapshot).await + } + /// Refresh MCP configuration, managed requirements, and session plugin and app overrides. /// An omitted section preserves its current overrides. An empty map restores inheritance. /// A stale owner requires reloading from the current config before retrying. diff --git a/codex-rs/core/src/config/runtime_refresh.rs b/codex-rs/core/src/config/runtime_refresh.rs index c2f74a0a80..e1d527a4b8 100644 --- a/codex-rs/core/src/config/runtime_refresh.rs +++ b/codex-rs/core/src/config/runtime_refresh.rs @@ -214,6 +214,12 @@ impl Config { } config.config_layer_stack = layers .with_mcp_ema_cancellation(self.config_layer_stack.mcp_ema_cancellation().clone()); + // Startup and publication assign a revision when Guardian owns the policy. + if matches!(scope, RuntimeConfigRefresh::Mcp) && self.guardian_policy_revision != 0 { + config + .config_layer_stack + .retain_guardian_policy_from(&self.config_layer_stack); + } config.plugins = cfg.plugins; if enterprise_retired { config.disable_mcp_enterprise_auth(); @@ -222,6 +228,18 @@ impl Config { Ok(config) } + pub(crate) fn retain_guardian_policy_from(&mut self, current: &Self) { + self.config_layer_stack + .retain_guardian_policy_from(¤t.config_layer_stack); + self.guardian_policy_config + .clone_from(¤t.guardian_policy_config); + self.guardian_extra_policy + .clone_from(¤t.guardian_extra_policy); + self.guardian_policy_revision = current.guardian_policy_revision; + self.requested_approvals_reviewer = current.requested_approvals_reviewer; + self.approvals_reviewer = current.approvals_reviewer; + } + /// Disables enterprise MCP authorization while preserving unrelated MCP servers. pub fn disable_mcp_enterprise_auth(&mut self) { self.mcp_enterprise_managed_auth = None; diff --git a/codex-rs/core/src/config/runtime_refresh_tests.rs b/codex-rs/core/src/config/runtime_refresh_tests.rs index a777ba29c5..2ec2f694d8 100644 --- a/codex-rs/core/src/config/runtime_refresh_tests.rs +++ b/codex-rs/core/src/config/runtime_refresh_tests.rs @@ -3,9 +3,15 @@ use super::*; use crate::config::ConfigBuilder; use codex_config::CONFIG_TOML_FILE; +use codex_config::CloudConfigBundleLoader; +use codex_config::CloudConfigBundlePolicy; +use codex_config::CloudConfigBundleSnapshot; use codex_config::ConfigLayerSource; +use codex_config::LoaderOverrides; +use codex_config::loader::load_guardian_policy_snapshot; use codex_config::test_support::CloudConfigBundleFixture; use codex_core_plugins::PluginLoadOutcome; +use codex_exec_server::LOCAL_FS; use pretty_assertions::assert_eq; async fn base_config() -> (tempfile::TempDir, Config) { @@ -170,7 +176,7 @@ async fn ordinary_transport_transitions_use_the_resolved_incoming_map() { #[tokio::test] async fn mcp_refresh_preserves_current_user_and_session_layers_without_reopening_ema() { let (_home, base) = base_config().await; - let current = layered_config( + let mut current = layered_config( &base, &enterprise_config("https://current-idp.example", "current-resource"), "", @@ -178,14 +184,44 @@ async fn mcp_refresh_preserves_current_user_and_session_layers_without_reopening "[mcp_servers.enterprise]\nenabled = false", ) .await; + let bundle = CloudConfigBundleFixture::enterprise_config("auto_review.policy = 'published'") + .add_enterprise_requirement( + "allowed_approvals_reviewers = ['auto_review']\nauto_review.required_on_models = ['protected']", + ) + .into_bundle(); + let mut cloud = CloudConfigBundleSnapshot { + bundle: Ok(Some(bundle)), + config_server: None, + binding: None, + }; + CloudConfigBundlePolicy::default().publish_snapshot(&mut cloud); + let snapshot = load_guardian_policy_snapshot( + LOCAL_FS.as_ref(), + base.codex_home.as_path(), + &LoaderOverrides::without_managed_config_for_tests(), + &CloudConfigBundleLoader::from_snapshot(cloud), + /*revision*/ 1, + ) + .await + .unwrap(); let next = layered_config( &base, &enterprise_config("https://old-idp.example", "old-resource"), "", - "", + "mcp_shared_repl_cwd = true\n[auto_review]\nrequired_on_models = ['incoming']", "", ) .await; + let before_publication = current + .resolve_runtime_refresh(&next, RuntimeConfigRefresh::Mcp) + .unwrap(); + assert_eq!( + before_publication.config_layer_stack.requirements(), + next.config_layer_stack.requirements() + ); + + current.config_layer_stack.apply_guardian_policy(&snapshot); + current.guardian_policy_revision = snapshot.revision; let refreshed = current .resolve_runtime_refresh(&next, RuntimeConfigRefresh::Mcp) .unwrap(); @@ -203,6 +239,50 @@ async fn mcp_refresh_preserves_current_user_and_session_layers_without_reopening .collect::>() }; assert_eq!(preserved_layers(&refreshed), preserved_layers(¤t)); + let layers = &refreshed.config_layer_stack; + let reviewer = &layers.requirements().approvals_reviewer; + assert!( + reviewer + .can_set(&codex_config::types::ApprovalsReviewer::User) + .is_err() + ); + assert!( + reviewer + .can_set(&codex_config::types::ApprovalsReviewer::AutoReview) + .is_ok() + ); + assert_eq!( + layers + .requirements_toml() + .allowed_approvals_reviewers + .as_deref(), + Some([codex_config::types::ApprovalsReviewer::AutoReview].as_slice()) + ); + assert!( + layers + .requirements() + .auto_review_required_for_model("protected") + ); + assert!( + !layers + .requirements() + .auto_review_required_for_model("incoming") + ); + assert_eq!( + layers + .requirements_toml() + .auto_review + .as_ref() + .and_then(|review| review.required_on_models.as_deref()) + .unwrap(), + ["protected"] + ); + assert!(refreshed.features.enabled(Feature::McpSharedReplCwd)); + assert_eq!( + layers.guardian_config().unwrap().policy.as_deref(), + Some("published") + ); + assert!(layers.guardian_policy_binding().is_some()); let server = &runtime_servers(&refreshed)["enterprise"]; assert!(!server.enabled); assert_eq!( diff --git a/codex-rs/core/src/connectors.rs b/codex-rs/core/src/connectors.rs index 01ca99456e..057ad94c76 100644 --- a/codex-rs/core/src/connectors.rs +++ b/codex-rs/core/src/connectors.rs @@ -24,6 +24,7 @@ use crate::mcp::McpManager; use crate::plugins::list_tool_suggest_discoverable_plugins; use crate::plugins::plugins_manager_for_config_with_runtime; use crate::session::INITIAL_SUBMIT_ID; +use codex_config::ConfigRequirements; use codex_config::types::ApprovalsReviewer; use codex_config::types::ToolSuggestDiscoverableType; use codex_core_plugins::PluginsManager; @@ -509,13 +510,13 @@ pub fn with_app_plugin_sources( pub(crate) fn mcp_approvals_reviewer_from_layers( config_layer_stack: &codex_config::ConfigLayerStack, + requirements: &ConfigRequirements, default_reviewer: ApprovalsReviewer, model: Option<&str>, server_name: &str, connector_id: Option<&str>, link_id: Option<&str>, ) -> ApprovalsReviewer { - let requirements = config_layer_stack.requirements(); if model.is_some_and(|model| requirements.auto_review_required_for_model(model)) { return ApprovalsReviewer::AutoReview; } @@ -543,7 +544,15 @@ pub(crate) fn mcp_approvals_reviewer_from_layers( return reviewer; } - default_reviewer + if requirements + .approvals_reviewer + .can_set(&default_reviewer) + .is_ok() + { + default_reviewer + } else { + requirements.approvals_reviewer.value() + } } #[cfg(test)] diff --git a/codex-rs/core/src/connectors_tests.rs b/codex-rs/core/src/connectors_tests.rs index 9eb9cfed6c..75c0b42dbf 100644 --- a/codex-rs/core/src/connectors_tests.rs +++ b/codex-rs/core/src/connectors_tests.rs @@ -371,6 +371,7 @@ approvals_reviewer = "{app}" assert_eq!( mcp_approvals_reviewer_from_layers( &config.config_layer_stack, + config.config_layer_stack.requirements(), config.approvals_reviewer, config.model.as_deref(), CODEX_APPS_MCP_SERVER_NAME, @@ -384,6 +385,7 @@ approvals_reviewer = "{app}" assert_eq!( mcp_approvals_reviewer_from_layers( &config.config_layer_stack, + config.config_layer_stack.requirements(), config.approvals_reviewer, config.model.as_deref(), CODEX_APPS_MCP_SERVER_NAME, @@ -396,6 +398,7 @@ approvals_reviewer = "{app}" assert_eq!( mcp_approvals_reviewer_from_layers( &config.config_layer_stack, + config.config_layer_stack.requirements(), config.approvals_reviewer, config.model.as_deref(), CODEX_APPS_MCP_SERVER_NAME, @@ -407,6 +410,7 @@ approvals_reviewer = "{app}" assert_eq!( mcp_approvals_reviewer_from_layers( &config.config_layer_stack, + config.config_layer_stack.requirements(), config.approvals_reviewer, config.model.as_deref(), CODEX_APPS_MCP_SERVER_NAME, @@ -418,6 +422,7 @@ approvals_reviewer = "{app}" assert_eq!( mcp_approvals_reviewer_from_layers( &config.config_layer_stack, + config.config_layer_stack.requirements(), config.approvals_reviewer, config.model.as_deref(), "custom_server", @@ -456,7 +461,8 @@ approvals_reviewer = "user" assert_eq!( mcp_approvals_reviewer_from_layers( &config.config_layer_stack, - config.approvals_reviewer, + config.config_layer_stack.requirements(), + ApprovalsReviewer::User, config.model.as_deref(), CODEX_APPS_MCP_SERVER_NAME, Some("calendar"), @@ -497,6 +503,7 @@ approvals_reviewer = "user" assert_eq!( mcp_approvals_reviewer_from_layers( &config.config_layer_stack, + config.config_layer_stack.requirements(), config.approvals_reviewer, config.model.as_deref(), CODEX_APPS_MCP_SERVER_NAME, diff --git a/codex-rs/core/src/guardian/decision.rs b/codex-rs/core/src/guardian/decision.rs index 372ff1a8e9..6bf60c883e 100644 --- a/codex-rs/core/src/guardian/decision.rs +++ b/codex-rs/core/src/guardian/decision.rs @@ -2,6 +2,8 @@ //! The synchronous service captures one action; no outcome is stored by tool-call ID. use codex_async_utils::THREAD_STACK_SIZE_BYTES; +use codex_protocol::config_types::ApprovalsReviewer; +use codex_protocol::openai_models::GuardianScope; use codex_protocol::protocol::ReviewDecision; use std::sync::Arc; use tokio::sync::oneshot; @@ -104,15 +106,32 @@ pub(crate) fn decide_approval( let turn = context.turn(); turn.extension_data.insert_arc(Arc::clone(&turn.config)); let live_config = session.get_config().await; - let requirements = live_config.config_layer_stack.requirements(); - let model_requires_review = - requirements.auto_review_required_for_model(&context.model_info.slug); + let mcp_requirements = (matches!( + request.request, + Ok(GuardianApprovalRequest::McpToolCall { .. }) + ) || (request.request.is_err() + && matches!( + request.category, + GuardianScope::Mcp | GuardianScope::ComputerUse + ))) + .then(|| turn.config.config_layer_stack.requirements()); + // Live requirements can harden review. MCP also keeps any mandatory + // restrictions from the policy captured for its issuing turn. + let requirements = [ + Some(live_config.config_layer_stack.requirements()), + mcp_requirements, + ]; + let model_requires_review = requirements.iter().flatten().any(|requirements| { + requirements.auto_review_required_for_model(&context.model_info.slug) + }); let require_guardian = options.require_guardian || model_requires_review - || requirements - .approvals_reviewer - .can_set(&codex_protocol::config_types::ApprovalsReviewer::User) - .is_err(); + || requirements.iter().flatten().any(|requirements| { + requirements + .approvals_reviewer + .can_set(&ApprovalsReviewer::User) + .is_err() + }); let full_access = context.environments().has_full_access( context.approval_policy, &turn.config.permissions.effective_permission_profile(), diff --git a/codex-rs/core/src/guardian/tests.rs b/codex-rs/core/src/guardian/tests.rs index f02ffb2a3d..4a928ceb55 100644 --- a/codex-rs/core/src/guardian/tests.rs +++ b/codex-rs/core/src/guardian/tests.rs @@ -20,8 +20,6 @@ use codex_config::ConfigLayerStack; use codex_config::NetworkConstraints; use codex_config::NetworkDomainPermissionToml; use codex_config::NetworkDomainPermissionsToml; -use codex_config::RequirementSource; -use codex_config::Sourced; use codex_config::config_toml::ConfigToml; use codex_config::types::McpServerConfig; use codex_exec_server::LOCAL_FS; @@ -2952,25 +2950,22 @@ async fn guardian_review_routes_required_actions( | RequiredGuardianReview::LiveManagedModelWithGuardianV2 => { Arc::make_mut(&mut context.model_info).slug = "required-action-model".to_string(); // The admitted turn has neither this model nor the new requirement. - let current_config = session.get_config().await; - let mut config = current_config.as_ref().clone(); - let requirements = codex_config::ConfigRequirements { - auto_review_required_models: Some(Sourced::new( - std::collections::BTreeSet::from([context.model_info.slug.clone()]), - RequirementSource::Unknown, - )), - ..Default::default() - }; - config.config_layer_stack = ConfigLayerStack::new( - config - .config_layer_stack - .all_layers_low_to_high() - .cloned() - .collect(), - requirements, - config.config_layer_stack.requirements_toml().clone(), - )?; - let _ = session.refresh_mcp_config(current_config, config).await; + let model = &context.model_info.slug; + let loader = codex_config::test_support::CloudConfigBundleFixture::loader_with_enterprise_requirement( + format!("auto_review.required_on_models = [{model:?}]"), + ); + let snapshot = codex_config::loader::load_guardian_policy_snapshot( + LOCAL_FS.as_ref(), + turn.config.codex_home.as_path(), + &codex_config::LoaderOverrides::without_managed_config_for_tests(), + &loader, + /*revision*/ 1, + ) + .await?; + assert_eq!( + session.refresh_guardian_policy(&snapshot).await, + crate::ConfigRefreshOutcome::Published + ); ( guardian_exec_command_request("shell-live-managed-model"), ApprovalRequestReasons::default(), diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rs index 4a7d710008..05ceae80bc 100644 --- a/codex-rs/core/src/mcp_tool_call.rs +++ b/codex-rs/core/src/mcp_tool_call.rs @@ -35,6 +35,7 @@ use codex_analytics::build_track_events_context; use codex_api::HostedFileUploadContext; use codex_config::ConfigLayerSource; use codex_config::types::AppToolApproval; +use codex_config::types::ApprovalsReviewer; use codex_connectors::AppToolPolicy; use codex_connectors::AppToolPolicyEvaluator; use codex_connectors::AppToolPolicyInput; @@ -239,8 +240,6 @@ pub(crate) async fn handle_mcp_tool_call( } }; let item_metadata = McpToolCallItemMetadata::from_tool_metadata(&server, Some(&metadata)); - let connector_id = metadata.connector_id.clone(); - let connector_name = metadata.connector_name.clone(); let Some(approval_policy) = mcp_tool_approval_policy(&prepared_call, &metadata) else { let result = notify_mcp_tool_call_skip( @@ -260,8 +259,8 @@ pub(crate) async fn handle_mcp_tool_call( &outcome, &server, &tool_name, - connector_id.as_deref(), - connector_name.as_deref(), + metadata.connector_id.as_deref(), + metadata.connector_name.as_deref(), /*duration*/ None, ); return Ok(CompletedMcpToolCall { @@ -270,14 +269,17 @@ pub(crate) async fn handle_mcp_tool_call( .unwrap_or_else(|| JsonValue::Object(serde_json::Map::new())), }); }; - let _approval_metadata = sess.register_mcp_tool_approval_metadata( + let requested_reviewer = sess.mcp_requested_reviewer(&step_context.settings).await; + let approval_context = sess.register_mcp_tool_approval_metadata( &call_id, prepared_call.server_key(), &invocation, - metadata.clone(), + metadata, GuardianReviewContext::from(step_context), capture_environment_permissions(prepared_call.permission_source()), + requested_reviewer, ); + let metadata = &approval_context.metadata; notify_mcp_tool_call_started( sess.as_ref(), turn_context.as_ref(), @@ -295,12 +297,13 @@ pub(crate) async fn handle_mcp_tool_call( &invocation, &invocation_tool_name, &hook_tool_name, - &metadata, + metadata, prepared_call.config(), prepared_call.permission_source(), prepared_call.server_environment_id(), prepared_call.server_key(), approval_policy, + requested_reviewer, ) .await { @@ -392,8 +395,8 @@ pub(crate) async fn handle_mcp_tool_call( &outcome, &server, &tool_name, - connector_id.as_deref(), - connector_name.as_deref(), + metadata.connector_id.as_deref(), + metadata.connector_name.as_deref(), /*duration*/ None, ); @@ -482,7 +485,7 @@ async fn handle_approved_mcp_tool_call( originating_call: Option<&ToolCallOrigin>, invocation: McpInvocation, prepared_call: PreparedMcpCall, - metadata: McpToolApprovalMetadata, + metadata: &McpToolApprovalMetadata, item_metadata: McpToolCallItemMetadata, source: &crate::tools::context::ToolCallSource, approval_application: McpToolApprovalApplication, @@ -556,13 +559,13 @@ async fn handle_approved_mcp_tool_call( let session_approval_key = session_mcp_tool_approval_key( prepared_call.server_key(), &invocation, - Some(&metadata), + Some(metadata), policy.mode, ); let persistent_approval_key = if policy.allow_persistent { persistent_mcp_tool_approval_key( &invocation, - Some(&metadata), + Some(metadata), policy.mode, ) } else { @@ -605,7 +608,7 @@ async fn handle_approved_mcp_tool_call( step_context, &server, call_id, - Some(&metadata), + Some(metadata), prepared_call.is_host_owned_apps(), ); if let Some(recipient) = sess @@ -750,7 +753,7 @@ async fn handle_approved_mcp_tool_call( prepared_call.config().approval_policy.value(), call_id, &invocation.server, - Some(&metadata), + Some(metadata), result, ) .await) @@ -817,7 +820,7 @@ async fn handle_approved_mcp_tool_call( truncate_mcp_tool_result_for_event(&result), ) .await; - maybe_track_codex_app_used(sess, step_context, &server, &metadata, elicitation_type).await; + maybe_track_codex_app_used(sess, step_context, &server, metadata, elicitation_type).await; let outcome = mcp_call_metric_outcome(&result).with_request_error_code(request_error_code); emit_mcp_call_metrics( @@ -1367,11 +1370,11 @@ pub(crate) struct McpToolApprovalMetadata { openai_file_input_optional_fields: Option>>, } -#[derive(Clone)] pub(crate) struct McpToolApprovalContext { pub(crate) invocation: Option, pub(crate) metadata: McpToolApprovalMetadata, pub(crate) review_context: GuardianReviewContext, + pub(crate) requested_reviewer: ApprovalsReviewer, /// Rules captured when MCP prepared this call, if the server belongs to an environment. pub(crate) environment_permissions: Option<(String, Arc)>, } @@ -1389,6 +1392,7 @@ pub(crate) fn capture_environment_permissions( } impl Session { + #[expect(clippy::too_many_arguments)] fn register_mcp_tool_approval_metadata( &self, call_id: &str, @@ -1397,6 +1401,7 @@ impl Session { metadata: McpToolApprovalMetadata, review_context: GuardianReviewContext, environment_permissions: Option<(String, Arc)>, + requested_reviewer: ApprovalsReviewer, ) -> Arc { let key = (server_key.to_owned(), call_id.to_string()); let metadata = Arc::new(McpToolApprovalContext { @@ -1405,6 +1410,7 @@ impl Session { .then(|| invocation.clone()), metadata, review_context, + requested_reviewer, environment_permissions, }); let mut registry = self @@ -1422,13 +1428,12 @@ impl Session { &self, server: &McpServerKey, call_id: &str, - ) -> Option { + ) -> Option> { self.mcp_tool_approval_metadata .lock() .unwrap_or_else(std::sync::PoisonError::into_inner) .get(&(server.clone(), call_id.to_string())) .and_then(std::sync::Weak::upgrade) - .map(|metadata| (*metadata).clone()) } } @@ -1711,20 +1716,10 @@ async fn prepare_mcp_tool_approval( environment_id: &str, server_key: &McpServerKey, policy: McpToolApprovalPolicy, + requested_reviewer: ApprovalsReviewer, ) -> McpToolApprovalRequirement { let turn_context = &step_context.turn; let strict_auto_review = turn_context.strict_auto_review_enabled(); - let approvals_reviewer = connectors::mcp_approvals_reviewer_from_layers( - &config.config_layer_stack, - step_context - .settings - .mcp_approvals_reviewer_override - .unwrap_or(config.approvals_reviewer), - Some(turn_context.model_info().slug.as_str()), - &invocation.server, - metadata.connector_id.as_deref(), - metadata.link_id.as_deref(), - ); if !strict_auto_review && mcp_permission_prompt_is_auto_approved( config.approval_policy.value(), @@ -1756,6 +1751,15 @@ async fn prepare_mcp_tool_approval( return McpToolApprovalRequirement::Remembered; } + let approvals_reviewer = connectors::mcp_approvals_reviewer_from_layers( + &config.config_layer_stack, + turn_context.config.config_layer_stack.requirements(), + requested_reviewer, + Some(step_context.settings.model_info.slug.as_str()), + &invocation.server, + metadata.connector_id.as_deref(), + metadata.link_id.as_deref(), + ); let action = ApprovalAction::McpToolCall { id: call_id.to_string(), environment_id: environment_id.to_owned(), @@ -1808,6 +1812,7 @@ async fn maybe_request_mcp_tool_approval( environment_id: &str, server_key: &McpServerKey, policy: McpToolApprovalPolicy, + requested_reviewer: ApprovalsReviewer, ) -> Option { let (action, strict_auto_review) = match prepare_mcp_tool_approval( sess, @@ -1821,6 +1826,7 @@ async fn maybe_request_mcp_tool_approval( environment_id, server_key, policy, + requested_reviewer, ) .await { @@ -1943,9 +1949,11 @@ pub(crate) async fn request_mcp_tool_user_approval( .push_str(&format!(" Environment: {environment_id}.")); } let (decision, cancellation_reason) = if tool_call_mcp_elicitation_enabled { - let metadata = approval_context - .map(|context| context.metadata) - .unwrap_or_else(|| McpToolApprovalMetadata { + let fallback_metadata; + let metadata = if let Some(context) = approval_context.as_ref() { + &context.metadata + } else { + fallback_metadata = McpToolApprovalMetadata { connector_id: connector_id.clone(), connector_name: connector_name.clone(), connector_description: connector_description.clone(), @@ -1953,13 +1961,15 @@ pub(crate) async fn request_mcp_tool_user_approval( tool_title: tool_title.clone(), tool_description: tool_description.clone(), ..Default::default() - }); + }; + &fallback_metadata + }; let request_id = rmcp::model::RequestId::String(question_id.clone().into()); let request = build_mcp_tool_approval_elicitation_request(McpToolApprovalElicitationRequest { server, tool_name, - metadata: Some(&metadata), + metadata: Some(metadata), tool_params: rendered_template .as_ref() .and_then(|rendered_template| rendered_template.tool_params.as_ref()) @@ -1971,6 +1981,7 @@ pub(crate) async fn request_mcp_tool_user_approval( .map(|rendered_template| rendered_template.elicitation_message.as_str()), prompt_options, }); + drop(approval_context); let response = sess .request_mcp_server_elicitation(turn_context, server_key.clone(), request_id, request) .await; @@ -1990,6 +2001,7 @@ pub(crate) async fn request_mcp_tool_user_approval( cancellation_reason, ) } else { + drop(approval_context); if turn_context.root_capabilities_restricted { return ApprovalResolution { decision: ReviewDecision::denied(concat!( diff --git a/codex-rs/core/src/mcp_tool_call/recorded.rs b/codex-rs/core/src/mcp_tool_call/recorded.rs index e083176641..dce5d1e290 100644 --- a/codex-rs/core/src/mcp_tool_call/recorded.rs +++ b/codex-rs/core/src/mcp_tool_call/recorded.rs @@ -48,6 +48,10 @@ pub(crate) async fn prepare_approval_action( 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, @@ -60,6 +64,7 @@ pub(crate) async fn prepare_approval_action( call.server_environment_id(), call.server_key(), policy, + requested_reviewer, ) .await { diff --git a/codex-rs/core/src/mcp_tool_call_tests.rs b/codex-rs/core/src/mcp_tool_call_tests.rs index 5fbbf8e427..5c8ac7f9b4 100644 --- a/codex-rs/core/src/mcp_tool_call_tests.rs +++ b/codex-rs/core/src/mcp_tool_call_tests.rs @@ -3068,6 +3068,7 @@ async fn approve_mode_skips_when_annotations_do_not_require_approval() { test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Approve), + turn_context.config.approvals_reviewer, ) .await; @@ -3153,6 +3154,7 @@ async fn guardian_mode_skips_auto_when_annotations_do_not_require_approval() { test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Auto), + turn_context.config.approvals_reviewer, ) .await; @@ -3222,6 +3224,7 @@ async fn permission_request_hook_allows_mcp_tool_call() { test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Auto), + turn_context.config.approvals_reviewer, ), ) .await @@ -3307,6 +3310,7 @@ async fn permission_request_hook_uses_hook_tool_name_without_metadata() { test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Auto), + turn_context.config.approvals_reviewer, ), ) .await @@ -3410,6 +3414,7 @@ async fn permission_request_hook_runs_after_remembered_mcp_approval() { test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Auto), + turn_context.config.approvals_reviewer, ) .await; @@ -3528,6 +3533,7 @@ async fn strict_auto_review_forces_guardian_for_mcp_policy_skip( test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(approval_mode), + turn_context.config.approvals_reviewer, ) .await; @@ -3615,6 +3621,7 @@ async fn assert_mcp_user_approval_persistence( test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Auto), + turn_context.config.approvals_reviewer, ) .await } @@ -3705,6 +3712,7 @@ async fn prompt_mode_waits_for_approval_when_annotations_do_not_require_approval test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Prompt), + turn_context.config.approvals_reviewer, ) .await }) @@ -3775,6 +3783,7 @@ async fn full_access_mode_skips_mcp_tool_approval_for_all_approval_modes() { test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(approval_mode), + turn_context.config.approvals_reviewer, ) .await; @@ -3873,6 +3882,7 @@ async fn approve_mode_skips_guardian_in_every_permission_mode() { test_environment_id(&turn_context), &McpServerKey::unscoped(&invocation.server), McpToolApprovalPolicy::for_server(AppToolApproval::Approve), + turn_context.config.approvals_reviewer, ) .await; @@ -3905,6 +3915,7 @@ async fn approval_metadata_is_released_when_the_invocation_future_is_dropped() { metadata.clone(), review_context.clone(), /*environment_permissions*/ None, + ApprovalsReviewer::User, ); std::future::pending::<()>().await; }); @@ -3916,12 +3927,17 @@ async fn approval_metadata_is_released_when_the_invocation_future_is_dropped() { metadata.clone(), review_context.clone(), /*environment_permissions*/ None, + ApprovalsReviewer::User, ); assert_eq!( session .mcp_tool_approval_metadata(&McpServerKey::unscoped(CODEX_APPS_MCP_SERVER_NAME), "call") - .map(|context| (context.invocation, context.metadata.connector_id)), - Some((Some(invocation.clone()), Some("connector".to_string()))), + .as_ref() + .map(|context| ( + context.invocation.as_ref(), + context.metadata.connector_id.as_deref() + )), + Some((Some(&invocation), Some("connector"))), ); assert!( session @@ -3941,6 +3957,7 @@ async fn approval_metadata_is_released_when_the_invocation_future_is_dropped() { metadata, review_context, /*environment_permissions*/ None, + ApprovalsReviewer::User, ); let registry = session.mcp_tool_approval_metadata.lock().unwrap(); let mut keys = registry.keys().cloned().collect::>(); diff --git a/codex-rs/core/src/session/config_refresh.rs b/codex-rs/core/src/session/config_refresh.rs index 2e417271ff..f7091e4d7e 100644 --- a/codex-rs/core/src/session/config_refresh.rs +++ b/codex-rs/core/src/session/config_refresh.rs @@ -1,4 +1,5 @@ -//! Publishes refreshable configuration while preserving unrelated session settings. +//! Publishes independent Guardian policy, MCP configuration, and host rollouts. +//! Preserves unrelated session settings. use crate::McpRefreshReason; use std::sync::Arc; @@ -32,6 +33,76 @@ impl Session { self.schedule_mcp_prewarm(); } + /// Publishes managed Guardian requirements without validating or restarting MCP. + /// User and session fallbacks remain pinned until their own reload. + pub(crate) async fn refresh_guardian_policy( + &self, + snapshot: &codex_config::GuardianPolicySnapshot, + ) -> ConfigRefreshOutcome { + let mut state = self.state.lock().await; + let current = &state.session_configuration.original_config_do_not_use; + if snapshot.revision <= current.guardian_policy_revision { + return ConfigRefreshOutcome::Stale; + } + let binding = snapshot + .binding + .as_ref() + .map(codex_config::CloudConfigBundleBinding::read); + match binding + .as_ref() + .map(|guard| guard.status) + .unwrap_or(CloudConfigBundleBindingStatus::Current) + { + CloudConfigBundleBindingStatus::Stale => return ConfigRefreshOutcome::Stale, + CloudConfigBundleBindingStatus::Suspended => return ConfigRefreshOutcome::Rejected, + CloudConfigBundleBindingStatus::Current => {} + } + let mut config = current.as_ref().clone(); + config.config_layer_stack.apply_guardian_policy(snapshot); + let Ok(fallback) = config.config_layer_stack.guardian_config() else { + return ConfigRefreshOutcome::Rejected; + }; + (config.guardian_policy_config, config.guardian_extra_policy) = + crate::config::resolve_guardian_policy_text( + config.config_layer_stack.requirements_toml(), + Some(&fallback), + ); + let configuration = &state.session_configuration; + let model = (!configuration.trusted_guardian_reviewer) + .then_some(configuration.step_settings.collaboration_mode.model()); + let requested = config + .requested_approvals_reviewer + .unwrap_or(configuration.step_settings.approvals_reviewer); + let Ok(reviewer) = crate::config::resolve_guardian_reviewer( + requested, + model, + config.config_layer_stack.requirements(), + ) else { + return ConfigRefreshOutcome::Rejected; + }; + config.requested_approvals_reviewer = Some(requested); + config.approvals_reviewer = reviewer; + config.guardian_policy_revision = snapshot.revision; + let previous = Arc::downgrade(current); + let config = Arc::new(config); + let snapshots = &mut state.guardian_config_snapshots; + if snapshots + .last() + .is_none_or(|latest| !latest.ptr_eq(&previous)) + { + snapshots.clear(); + snapshots.push(previous); + } + snapshots.retain(|owner| owner.strong_count() != 0); + snapshots.push(Arc::downgrade(&config)); + let settings = &mut state.session_configuration.step_settings; + if settings.approvals_reviewer != reviewer { + Arc::make_mut(settings).approvals_reviewer = reviewer; + } + state.session_configuration.original_config_do_not_use = config; + ConfigRefreshOutcome::Published + } + pub(crate) async fn refresh_runtime_config( &self, expected_config: Arc, @@ -127,19 +198,29 @@ impl Session { && !self.services.extensions.config_contributors().is_empty(); let (previous_config, new_config) = { let mut state = self.state.lock().await; - // Loaded snapshots can publish only while their captured owner is current. - if !Arc::ptr_eq( - &state.session_configuration.original_config_do_not_use, - &expected_config, - ) { - return ConfigRefreshOutcome::Stale; + let current = &state.session_configuration.original_config_do_not_use; + if !Arc::ptr_eq(current, &expected_config) { + let snapshots = &state.guardian_config_snapshots; + if !matches!(scope, RuntimeConfigRefresh::Mcp) + || snapshots + .last() + .is_none_or(|latest| !std::ptr::eq(latest.as_ptr(), Arc::as_ptr(current))) + || !snapshots + .iter() + .any(|owner| std::ptr::eq(owner.as_ptr(), Arc::as_ptr(&expected_config))) + { + return ConfigRefreshOutcome::Stale; + } + // All MCP inputs still belong to the captured owner. Carry forward + // the Guardian policy that was published while we loaded them. + Arc::make_mut(&mut config).retain_guardian_policy_from(current); } // User-only refreshes retain the current managed inputs and their - // admission binding. Only MCP refreshes can publish a new policy. + // admission binding. Guardian policy has a separate publication path. let policy_guard = matches!(scope, RuntimeConfigRefresh::Mcp) .then(|| next_config.config_layer_stack.cloud_config_binding()) .flatten() - .map(|binding| binding.read()); + .map(codex_config::CloudConfigBundleBinding::read); let policy_status = policy_guard .as_ref() .map(|guard| guard.status) @@ -193,6 +274,7 @@ impl Session { .with_mcp_ema_cancellation(cancellation); } state.session_configuration.original_config_do_not_use = Arc::clone(&config); + state.guardian_config_snapshots.clear(); drop(policy_guard); self.mark_mcp_runtime_dirty(match scope { RuntimeConfigRefresh::User => McpRefreshReason::UserConfigReloaded, diff --git a/codex-rs/core/src/session/config_refresh_tests.rs b/codex-rs/core/src/session/config_refresh_tests.rs index b584558364..4c959277d6 100644 --- a/codex-rs/core/src/session/config_refresh_tests.rs +++ b/codex-rs/core/src/session/config_refresh_tests.rs @@ -1,8 +1,57 @@ //! Runtime-refresh regressions; pure authority resolution is tested with Config. use super::*; +use codex_config::loader::load_guardian_policy_snapshot; +use codex_config::test_support::CloudConfigBundleFixture; +use codex_exec_server::LOCAL_FS; use pretty_assertions::assert_eq; +#[tokio::test] +async fn mcp_reload_survives_guardian_only_publications() { + let (session, _) = make_session_and_context().await; + let before = session.get_config().await; + let mut incoming = before.as_ref().clone(); + incoming.config_layer_stack = incoming + .config_layer_stack + .with_session_plugins(toml::from_str("[_default]\nenabled = false").unwrap()) + .unwrap(); + let first_revision = before.guardian_policy_revision + 1; + let latest_revision = first_revision + 1; + for (revision, policy) in [ + (first_revision, "first policy"), + (latest_revision, "latest policy"), + ] { + let loader = CloudConfigBundleFixture::loader_with_enterprise_requirement(format!( + "guardian_policy_config = {policy:?}" + )); + let snapshot = load_guardian_policy_snapshot( + LOCAL_FS.as_ref(), + before.codex_home.as_path(), + &LoaderOverrides::without_managed_config_for_tests(), + &loader, + revision, + ) + .await + .unwrap(); + assert_eq!( + session.refresh_guardian_policy(&snapshot).await, + crate::ConfigRefreshOutcome::Published + ); + } + + assert_eq!( + session.refresh_mcp_config(before, incoming).await, + crate::ConfigRefreshOutcome::Published + ); + let published = session.get_config().await; + assert!(!published.plugins.allows_plugin("browser")); + assert_eq!(published.guardian_policy_revision, latest_revision); + assert_eq!( + published.guardian_policy_config.as_deref(), + Some("latest policy") + ); +} + async fn runtime_servers(session: &Session) -> HashMap { let config = session.get_config().await; codex_mcp::configured_mcp_servers( diff --git a/codex-rs/core/src/session/mcp.rs b/codex-rs/core/src/session/mcp.rs index bc3e2ac358..bc8308e9c9 100644 --- a/codex-rs/core/src/session/mcp.rs +++ b/codex-rs/core/src/session/mcp.rs @@ -805,6 +805,22 @@ impl Session { ) } + /// Older clients keep using the thread preference until a turn update + /// overrides it. That preference is resolved against the issuing turn's rules. + pub(crate) async fn mcp_requested_reviewer( + &self, + settings: &ResolvedStepSettings, + ) -> ApprovalsReviewer { + match settings.mcp_approvals_reviewer_override { + Some(reviewer) => reviewer, + None => self + .get_config() + .await + .requested_approvals_reviewer + .unwrap_or_else(|| settings.approvals_reviewer()), + } + } + pub(crate) fn mcp_elicitation_lifecycle(&self) -> codex_mcp::ElicitationLifecycle { self.mcp_elicitation_lifecycle_handle .get_or_init(|| { @@ -1053,7 +1069,6 @@ async fn review_guardian_mcp_elicitation( let Some(mcp_config) = session.services.mcp_runtime.current_config() else { return Ok(None); }; - let step_settings = turn_context.next_step_settings.load_full(); // A callback for a running call keeps the permissions captured by that call. let call_id = request .elicitation @@ -1065,13 +1080,18 @@ async fn review_guardian_mcp_elicitation( .and_then(Value::as_str); let approval_context = call_id .and_then(|call_id| session.mcp_tool_approval_metadata(&request.server_key, call_id)); + let step_settings = turn_context.next_step_settings.load_full(); + let reviewer = approval_context.as_ref().map_or_else( + || step_settings.approvals_reviewer(), + |context| context.review_context.approvals_reviewer, + ); let is_js_preflight = request.elicitation.meta().is_some_and(|meta| { metadata_str(meta, MCP_ELICITATION_TOOL_NAME_KEY) == Some("js") && metadata_str(meta, MCP_ELICITATION_CONNECTOR_ID_KEY) == Some("node_repl") }); // User approval skips ordinary CUA checks, not separate sensitive requests. - let user_cua_execution = step_settings.approvals_reviewer() == ApprovalsReviewer::User + let user_cua_execution = reviewer == ApprovalsReviewer::User && is_node_repl_backed_server(&request.server_name) && is_js_preflight && request.elicitation.meta().is_some_and(|meta| { @@ -1148,7 +1168,7 @@ async fn review_guardian_mcp_elicitation( invocation: Some(invocation), metadata, .. - }) = approval_context.as_ref() + }) = approval_context.as_deref() && invocation.server == request.server_name && is_node_repl_backed_connector(&invocation.server, metadata.connector_id.as_deref()) { @@ -1165,12 +1185,19 @@ async fn review_guardian_mcp_elicitation( Some(Value::Bool(true)) ); - // Bind the review to the issuing step, which may include environments that - // became ready after the turn started. Do not refresh an in-flight action. + // Use the issuing step, or the active turn's captured policy when there is no invocation. let mut review_context = approval_context .as_ref() .map(|context| context.review_context.clone()) - .unwrap_or_else(|| crate::guardian::GuardianReviewContext::from(&turn_context)); + .unwrap_or_else(|| { + crate::guardian::GuardianReviewContext::from_resolved_settings( + Arc::clone(&turn_context), + &step_settings, + &turn_context.initial_environments, + ) + }); + let review_config = &review_context.turn().config; + let requirements = review_config.config_layer_stack.requirements(); let strict_auto_review = matches!( request .elicitation @@ -1192,7 +1219,7 @@ async fn review_guardian_mcp_elicitation( invocation: Some(invocation), metadata, .. - }) = approval_context.as_ref() + }) = approval_context.as_deref() else { return Ok(None); }; @@ -1216,20 +1243,16 @@ async fn review_guardian_mcp_elicitation( } else { None }; - if !turn_context - .config - .features - .enabled(Feature::GuardianApproval) - || mcp_config - .config_layer_stack - .requirements() + if !review_config.features.enabled(Feature::GuardianApproval) + || requirements .approvals_reviewer .can_set(&ApprovalsReviewer::AutoReview) .is_err() || crate::connectors::mcp_approvals_reviewer_from_layers( &mcp_config.config_layer_stack, + requirements, ApprovalsReviewer::AutoReview, - Some(turn_context.model_info().slug.as_str()), + Some(review_context.model_info.slug.as_str()), request.server_name.as_str(), connector_id, /*link_id*/ None, @@ -1294,12 +1317,15 @@ async fn review_guardian_mcp_elicitation( | AskForApproval::Granular(_) => {} } + let requested_reviewer = match &approval_context { + Some(context) => context.requested_reviewer, + None => session.mcp_requested_reviewer(&step_settings).await, + }; let approvals_reviewer = crate::connectors::mcp_approvals_reviewer_from_layers( &mcp_config.config_layer_stack, - step_settings - .mcp_approvals_reviewer_override - .unwrap_or(mcp_config.approvals_reviewer), - Some(turn_context.model_info().slug.as_str()), + requirements, + requested_reviewer, + Some(review_context.model_info.slug.as_str()), request.server_name.as_str(), elicitation_connector_id(&request.elicitation), /*link_id*/ None, @@ -1360,6 +1386,8 @@ async fn review_guardian_mcp_elicitation( *prompt_permissions = Some(permissions); } let declined_reason = guardian_request.request.as_ref().err().cloned(); + // Release the registry entry before awaiting review. The tool owns its lifetime. + drop(approval_context); let decision = crate::guardian::decide_approval( session, review_context, diff --git a/codex-rs/core/src/session/mcp_runtime.rs b/codex-rs/core/src/session/mcp_runtime.rs index 21958ab925..4225dc7833 100644 --- a/codex-rs/core/src/session/mcp_runtime.rs +++ b/codex-rs/core/src/session/mcp_runtime.rs @@ -41,7 +41,6 @@ impl Session { || current.runtime_workspace_roots != next.runtime_workspace_roots || current.step_settings.approval_policy.value() != next.step_settings.approval_policy.value() - || current.step_settings.approvals_reviewer != next.step_settings.approvals_reviewer || current.permission_profile() != next.permission_profile() || current.windows_sandbox_level != next.windows_sandbox_level } diff --git a/codex-rs/core/src/session/step_activation.rs b/codex-rs/core/src/session/step_activation.rs index db3d472a08..f94ae3fda8 100644 --- a/codex-rs/core/src/session/step_activation.rs +++ b/codex-rs/core/src/session/step_activation.rs @@ -434,7 +434,7 @@ impl Session { environments, ), }; - current + let settings = current .apply_update( update, &constraints, @@ -443,7 +443,23 @@ impl Session { &self.features, ) .await - .map_err(|error| error.to_string()) + .map_err(|error| error.to_string())?; + // Changes to the selected model or reviewer must also satisfy the + // policy that continues to apply to this turn's MCP actions. + if update.approvals_reviewer.is_some() || update.model.is_some() { + let requirements = turn_context.config.config_layer_stack.requirements(); + requirements + .approvals_reviewer + .can_set(&settings.approvals_reviewer()) + .and_then(|()| { + settings.selected().validate(&StepSettingsConstraints { + requirements, + ..constraints + }) + }) + .map_err(|error| error.to_string())?; + } + Ok(settings) } /// Rechecks ordinary managed authorization after asynchronous resolution. diff --git a/codex-rs/core/src/state/session.rs b/codex-rs/core/src/state/session.rs index e90bd010c6..0f2ae05aab 100644 --- a/codex-rs/core/src/state/session.rs +++ b/codex-rs/core/src/state/session.rs @@ -9,6 +9,7 @@ use std::collections::BTreeSet; use std::collections::HashSet; use std::collections::VecDeque; use std::sync::Arc; +use std::sync::Weak; use super::AdditionalContextStore; use super::auto_compact_window::AutoCompactWindow; @@ -17,6 +18,7 @@ use super::auto_compact_window::AutoCompactWindowSnapshot; use super::auto_compact_window::ContextWindowIdGenerator; use crate::TurnStartOptions; use crate::agent::host::ServiceTierAcceptance; +use crate::config::Config; use crate::context_manager::ContextManager; use crate::context_manager::HistoryReplacement; use crate::session::PreviousTurnSettings; @@ -73,6 +75,9 @@ impl ReasoningEffortPin { /// Persistent, session-scoped state previously stored directly on `Session`. pub(crate) struct SessionState { pub(crate) session_configuration: SessionConfiguration, + /// Config identities reachable from the current one through Guardian-only publications. + /// A mismatch with the last entry means another kind of update replaced the config. + pub(crate) guardian_config_snapshots: Vec>, /// Shared root tier publication starts when the runtime wins registration. pub(crate) shared_service_tier_pending: bool, /// Receipt for the current host root tier, retained for callers retrying that commit. @@ -146,6 +151,7 @@ impl SessionState { active_disabled_plugin_ids: Vec::new(), persisted_dynamic_tools: Arc::clone(&session_configuration.dynamic_tools), session_configuration, + guardian_config_snapshots: Vec::new(), shared_service_tier_pending: false, service_tier_acceptance: None, base_instructions_provenance: None, diff --git a/codex-rs/core/tests/suite/mcp_turn_metadata.rs b/codex-rs/core/tests/suite/mcp_turn_metadata.rs index 6b1edb1547..b56c51c71a 100644 --- a/codex-rs/core/tests/suite/mcp_turn_metadata.rs +++ b/codex-rs/core/tests/suite/mcp_turn_metadata.rs @@ -2,12 +2,15 @@ #![allow(clippy::unwrap_used)] use anyhow::Result; +use codex_config::LoaderOverrides; +use codex_config::loader::load_guardian_policy_snapshot; use codex_config::test_support::CloudConfigBundleFixture; use codex_config::types::AppToolApproval; use codex_core::ConfigRefreshOutcome; use codex_core::TurnInputRequest; use codex_core::TurnStartOptions; use codex_core::config::Config; +use codex_exec_server::LOCAL_FS; use codex_features::Feature; use codex_history::RolloutItem; use codex_models_manager::bundled_models_response; @@ -989,6 +992,74 @@ approvals_reviewer = "auto_review" Some(&json!("Lunch")) ); + if !protected_model && !work_link_reviewer { + let after_policy_refresh = "calendar-after-policy-refresh"; + mount_sse_sequence( + &server, + vec![ + sse(vec![ + ev_response_created(after_policy_refresh), + ev_function_call_with_namespace( + after_policy_refresh, + SEARCH_CALENDAR_NAMESPACE, + SEARCH_CALENDAR_CREATE_TOOL, + &calendar_args, + ), + ev_completed(after_policy_refresh), + ]), + sse(vec![ev_response_created("done"), ev_completed("done")]), + ], + ) + .await; + let snapshot = load_guardian_policy_snapshot( + LOCAL_FS.as_ref(), + test.config.codex_home.as_path(), + &LoaderOverrides::without_managed_config_for_tests(), + &CloudConfigBundleFixture::loader_with_enterprise_requirement( + "allowed_approvals_reviewers = ['user']", + ), + /*revision*/ 1, + ) + .await?; + assert_eq!( + test.codex.refresh_guardian_policy(&snapshot).await, + ConfigRefreshOutcome::Published + ); + submit_user_turn( + &test, + "Use [$calendar](app://calendar) to create another event.", + AskForApproval::OnRequest, + PermissionProfile::Disabled, + /*collaboration_mode*/ None, + ) + .await?; + let EventMsg::ElicitationRequest(request) = wait_for_event(&test.codex, |event| { + matches!( + event, + EventMsg::ElicitationRequest(_) | EventMsg::TurnComplete(_) + ) + }) + .await + else { + anyhow::bail!("the existing MCP runtime skipped user approval"); + }; + assert_eq!(recorded_apps_tool_calls(&server).await.len(), 1); + test.codex + .submit(Op::ResolveElicitation { + server_name: request.server_name, + request_id: request.id, + decision: ElicitationAction::Accept, + content: None, + meta: None, + }) + .await?; + wait_for_event(&test.codex, |event| { + matches!(event, EventMsg::TurnComplete(_)) + }) + .await; + recorded_apps_tool_call_by_call_id(&server, after_policy_refresh).await; + } + Ok(()) }