Use captured action settings for Guardian reviews (#44574)

## Why

Model changes during a turn and catalog refreshes can leave Guardian reviews using settings or metadata that do not match the action being reviewed.

## What changed

- Use the action's captured model, reasoning effort, reasoning summary, and personality when configuring reviews.
- Preserve captured model metadata when falling back to the parent model, while resolving a separate reviewer against the current catalog on each attempt.
- Evaluate live managed review requirements against the action's model and use its metadata for computer-use review behavior.
- Include personality in the review session reuse key so personality changes invalidate cached sessions.

## Testing

Add regression coverage for delayed and new actions across model changes and catalog refreshes, required-review routing, and session reuse when policy or personality changes. Extend integration tests to cover reviewer reuse across parent model changes and verify that interrupted reviews cannot execute commands after a delayed approval arrives.

GitOrigin-RevId: 5b434568e113e44bf7177780f2ae13192b55e942
This commit is contained in:
Abhinav authored and copyberry committed 2026-09-10 16:17:25 +00:00
1 parent 6baa076eb6
commit 6bb5be869f
10 files changed
+667 -161

No files matched your search

+3 -2
View File
@@ -59,9 +59,10 @@ pub(crate) async fn decide_approval(
let context = context.into();
let request = request.into();
let turn = context.turn();
let requirements = turn.config.config_layer_stack.requirements();
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(&turn.model_info().slug);
requirements.auto_review_required_for_model(&context.model_info.slug);
let require_guardian = options.require_guardian
|| model_requires_review
|| requirements
+5 -4
View File
@@ -23,6 +23,7 @@ mod runtime;
use std::sync::Arc;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::config_types::Personality;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::openai_models::ModelInfo;
use codex_protocol::openai_models::ReasoningEffort;
@@ -81,13 +82,10 @@ pub(crate) struct GuardianReviewContext {
pub(crate) parent_response_id: Option<String>,
turn: Arc<TurnContext>,
environments: TurnEnvironmentSnapshot,
// Model and reasoning inputs are carried for the follow-up Guardian and V2 migrations.
#[expect(dead_code)]
pub(crate) model_info: Arc<ModelInfo>,
#[expect(dead_code)]
pub(crate) reasoning_effort: Option<ReasoningEffort>,
#[expect(dead_code)]
pub(crate) reasoning_summary: ReasoningSummary,
pub(crate) personality: Option<Personality>,
pub(crate) approval_policy: AskForApproval,
pub(crate) approvals_reviewer: ApprovalsReviewer,
}
@@ -106,6 +104,7 @@ impl GuardianReviewContext {
model_info: Arc::clone(&settings.model_info),
reasoning_effort: settings.reasoning_effort().cloned(),
reasoning_summary: settings.reasoning_summary,
personality: settings.personality(),
approval_policy: settings.approval_policy(),
approvals_reviewer: settings.approvals_reviewer(),
turn,
@@ -134,6 +133,7 @@ impl From<&Arc<StepContext>> for GuardianReviewContext {
model_info: Arc::clone(&step.settings.model_info),
reasoning_effort: step.settings.reasoning_effort().cloned(),
reasoning_summary: step.settings.reasoning_summary,
personality: step.settings.personality(),
approval_policy: step.settings.approval_policy(),
approvals_reviewer: step.settings.approvals_reviewer(),
}
@@ -151,6 +151,7 @@ impl From<Arc<TurnContext>> for GuardianReviewContext {
model_info: Arc::clone(turn.model_info()),
reasoning_effort: turn.reasoning_effort().cloned(),
reasoning_summary: turn.reasoning_summary(),
personality: turn.personality(),
approval_policy: turn.approval_policy(),
approvals_reviewer: turn.config.approvals_reviewer,
turn,
+28 -18
View File
@@ -213,8 +213,9 @@ pub(super) struct GuardianReviewSessionConfig {
pub(super) async fn guardian_review_session_config(
session: &Session,
turn: &TurnContext,
context: &GuardianReviewContext,
) -> anyhow::Result<GuardianReviewSessionConfig> {
let turn = context.turn();
let network_proxy = session.services.network_proxy.load_full();
let live_network_config = match network_proxy.as_ref() {
Some(network_proxy) => Some(network_proxy.proxy().current_cfg().await?),
@@ -237,28 +238,39 @@ pub(super) async fn guardian_review_session_config(
model_overridden: guardian_review_model_overridden,
model_override: guardian_review_model_override,
} = codex_guardian_reviewer::select_review_model(
turn.model_info(),
turn.reasoning_effort(),
&context.model_info,
context.reasoning_effort.as_ref(),
default_review_model_id,
&available_models,
);
let guardian_model_info = session
.services
.models_manager
.get_model_info(
guardian_model.as_str(),
&turn.config.to_models_manager_config(),
)
.await;
// Resolve a separate reviewer against the current catalog on every attempt.
// Parent fallback must retain the action's metadata even after a catalog refresh.
let guardian_model_info =
if !guardian_catalog_contains_auto_review && !guardian_review_model_overridden {
Arc::clone(&context.model_info)
} else {
Arc::new(
session
.services
.models_manager
.get_model_info(
guardian_model.as_str(),
&turn.config.to_models_manager_config(),
)
.await,
)
};
let mut spawn_config = build_guardian_review_session_config(
turn.config.as_ref(),
live_network_config,
guardian_model.as_str(),
guardian_reasoning_effort.clone(),
context.reasoning_summary,
context.personality,
guardian_model_info.model_messages.as_ref(),
)?;
if turn.model_info().computer_use_review_required() {
if context.model_info.computer_use_review_required() {
spawn_config
.features
.enable(Feature::RetainClientDeveloperMessages)
@@ -268,7 +280,7 @@ pub(super) async fn guardian_review_session_config(
)
})?;
}
if guardian_model != turn.model_info().slug {
if guardian_model != context.model_info.slug {
spawn_config.model_context_window = None;
spawn_config.model_auto_compact_token_limit = None;
}
@@ -310,9 +322,7 @@ async fn run_guardian_review_session_before_deadline(
external_cancel: Option<CancellationToken>,
deadline: Instant,
) -> (GuardianReviewOutcome, GuardianReviewAnalyticsResult) {
let turn = context.turn();
let session_config = match guardian_review_session_config(session.as_ref(), turn.as_ref()).await
{
let session_config = match guardian_review_session_config(session.as_ref(), &context).await {
Ok(session_config) => session_config,
Err(err) => {
return (
@@ -340,8 +350,8 @@ async fn run_guardian_review_session_before_deadline(
guardian_catalog_contains_auto_review: session_config.catalog_contains_auto_review,
guardian_review_model_overridden: session_config.model_overridden,
guardian_review_model_override: session_config.model_override,
reasoning_summary: turn.reasoning_summary(),
personality: turn.personality(),
reasoning_summary: context.reasoning_summary,
personality: context.personality,
external_cancel,
deadline,
},
@@ -216,6 +216,7 @@ pub struct GuardianReviewSessionReuseKey {
model_auto_compact_token_limit_scope: AutoCompactTokenLimitScope,
model_reasoning_effort: Option<ReasoningEffortConfig>,
model_reasoning_summary: Option<ReasoningSummaryConfig>,
personality: Option<Personality>,
permissions: Permissions,
developer_instructions: Option<String>,
base_instructions: Option<String>,
@@ -257,6 +258,7 @@ impl GuardianReviewSessionReuseKey {
model_auto_compact_token_limit_scope: spawn_config.model_auto_compact_token_limit_scope,
model_reasoning_effort: spawn_config.model_reasoning_effort.clone(),
model_reasoning_summary: spawn_config.model_reasoning_summary,
personality: spawn_config.personality,
permissions: spawn_config.permissions.clone(),
developer_instructions: spawn_config.developer_instructions.clone(),
base_instructions: spawn_config.base_instructions.clone(),
@@ -37,9 +37,7 @@ impl PreparedSession {
parent.guardian_context_mode,
)
.with_environments(context.environments())
.with_node_repl_policy_eligibility(
context.turn().model_info().computer_use_review_required(),
)
.with_node_repl_policy_eligibility(context.model_info.computer_use_review_required())
.with_node_repl_policy(node_repl_policy);
key.root_authorization_version = root_authorization_version;
let host = parent
@@ -230,11 +228,12 @@ pub(crate) fn prewarm_guardian_review_session(
) -> BoxFuture<'static, anyhow::Result<()>> {
// Keep the Session -> Guardian -> Session startup future on the heap.
Box::pin(async move {
let config = guardian_review_session_config(&parent, &turn).await?;
let context = GuardianReviewContext::from(turn);
let config = guardian_review_session_config(&parent, &context).await?;
let history = parent.clone_history().await;
let factory = PreparedSession::prepare(
Arc::clone(&parent),
GuardianReviewContext::from(turn),
context,
config.spawn_config,
&history,
&config.node_repl_policy,
@@ -35,6 +35,8 @@ async fn run_review_preserves_evidence_during_parent_compaction() {
/*live_network_config*/ None,
&params.model,
params.reasoning_effort.clone(),
params.reasoning_summary,
params.personality,
/*model_messages*/ None,
)
.unwrap();
@@ -210,6 +212,8 @@ async fn test_review_params() -> GuardianReviewSessionParams {
/*live_network_config*/ None,
model.as_str(),
reasoning_effort.clone(),
reasoning_summary,
personality,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -279,6 +283,8 @@ async fn guardian_review_session_config_change_invalidates_cached_session() {
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("cached guardian config");
@@ -297,6 +303,8 @@ async fn guardian_review_session_config_change_invalidates_cached_session() {
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("next guardian config");
@@ -474,6 +482,8 @@ async fn guardian_review_session_compact_scope_change_invalidates_cached_session
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("cached guardian config");
@@ -492,6 +502,8 @@ async fn guardian_review_session_compact_scope_change_invalidates_cached_session
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("next guardian config");
@@ -518,6 +530,8 @@ async fn guardian_review_session_config_disables_hooks() {
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -535,6 +549,8 @@ async fn guardian_review_session_config_disables_skill_instructions() {
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -574,6 +590,8 @@ async fn guardian_review_session_config_prefers_managed_policy_and_uses_catalog_
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
Some(&model_messages),
)
.expect("guardian config");
@@ -616,6 +634,8 @@ async fn guardian_review_session_config_preserves_explicit_empty_catalog_policy(
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
Some(&model_messages),
)
.expect("guardian config");
@@ -666,6 +686,8 @@ async fn guardian_review_session_config_preserves_explicit_empty_catalog_templat
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummaryConfig::default(),
/*personality*/ None,
Some(&model_messages),
)
.expect("guardian config");
@@ -21,6 +21,8 @@ pub fn build_guardian_review_session_config(
live_network_config: Option<codex_network_proxy::NetworkProxyConfig>,
active_model: &str,
reasoning_effort: Option<codex_protocol::openai_models::ReasoningEffort>,
reasoning_summary: codex_protocol::config_types::ReasoningSummary,
personality: Option<codex_protocol::config_types::Personality>,
model_messages: Option<&ModelMessages>,
) -> anyhow::Result<Config> {
let mut guardian_config = parent_config.clone();
@@ -31,6 +33,8 @@ pub fn build_guardian_review_session_config(
);
guardian_config.model = Some(overrides.model);
guardian_config.model_reasoning_effort = overrides.reasoning_effort;
guardian_config.model_reasoning_summary = Some(reasoning_summary);
guardian_config.personality = personality;
guardian_config.model_provider.request_max_retries = Some(overrides.request_max_retries);
guardian_config.model_provider.stream_max_retries = Some(overrides.stream_max_retries);
guardian_config.include_skill_instructions = overrides.include_skill_instructions;
+222 -23
View File
@@ -43,6 +43,7 @@ use codex_protocol::ThreadId;
use codex_protocol::approvals::GuardianAssessmentAction;
use codex_protocol::approvals::NetworkApprovalProtocol;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::models::ContentItem;
use codex_protocol::models::FunctionCallOutputContentItem;
use codex_protocol::models::PermissionProfile;
@@ -1803,6 +1804,106 @@ enum GuardianTestCatalog {
ParentOnly,
}
#[test_case::test_case(None; "captured_policy")]
#[test_case::test_case(Some("configured policy wins"); "configured_policy")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn guardian_reuse_respects_effective_policy_and_personality(
configured_policy: Option<&str>,
) -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let responses = mount_sse_sequence(
&server,
(0..3)
.map(|index| {
sse(vec![
ev_response_created(&format!("review-{index}")),
ev_assistant_message("assessment", r#"{"outcome":"allow"}"#),
ev_completed(&format!("review-{index}")),
])
})
.collect(),
)
.await;
let (mut session, mut turn) = guardian_test_session_and_turn(&server).await;
Arc::make_mut(&mut Arc::get_mut(&mut turn).expect("unshared turn").config)
.guardian_policy_config = configured_policy.map(str::to_owned);
let mut captured = GuardianReviewContext::from(&turn);
let parent = Arc::make_mut(&mut captured.model_info);
parent.slug = "captured-parent".to_string();
parent.auto_review_model_override = None;
parent.model_messages = Some(serde_json::from_value(serde_json::json!({
"auto_review": {
"policy": "captured policy",
"policy_template": "captured template: {{ tenant_policy_config }}",
},
}))?);
captured.personality = Some(codex_protocol::config_types::Personality::Friendly);
Arc::get_mut(&mut session)
.expect("unshared session")
.services
.models_manager = Arc::new(StaticModelsManager::new(
/*auth_manager*/ None,
ModelsResponse { models: vec![] },
));
seed_guardian_parent_history(&session, &turn).await;
let mut changed_policy = captured.clone();
Arc::make_mut(&mut changed_policy.model_info)
.model_messages
.as_mut()
.unwrap()
.auto_review
.as_mut()
.unwrap()
.policy = Some("changed action policy".to_string());
let mut different_personality = changed_policy.clone();
different_personality.personality = Some(codex_protocol::config_types::Personality::Pragmatic);
for (index, context) in [captured, changed_policy, different_personality]
.into_iter()
.enumerate()
{
let (outcome, _) = run_guardian_review_session_for_test(
Arc::clone(&session),
context,
guardian_exec_command_request(&format!("action-{index}")),
ApprovalRequestReasons::default(),
guardian_output_schema(),
/*external_cancel*/ None,
/*max_attempts*/ 1,
)
.await;
assert!(matches!(outcome, GuardianReviewOutcome::Completed(_)));
}
let requests = responses.requests();
assert_eq!(requests.len(), 3);
let initial_policy = configured_policy.unwrap_or("captured policy");
assert_eq!(
requests[0].instructions_text(),
guardian_policy_prompt_with_config_and_template(
initial_policy,
"captured template: {{ tenant_policy_config }}"
)
);
let changed_policy = configured_policy.unwrap_or("changed action policy");
assert_eq!(
requests[1].instructions_text(),
guardian_policy_prompt_with_config_and_template(
changed_policy,
"captured template: {{ tenant_policy_config }}"
)
);
let thread_ids = requests
.iter()
.map(|request| request.body_json()["client_metadata"]["thread_id"].clone())
.collect::<Vec<_>>();
assert_eq!(thread_ids[0] == thread_ids[1], configured_policy.is_some());
assert_ne!(thread_ids[1], thread_ids[2]);
Ok(())
}
async fn guardian_request_model_for_auto_review(
auto_review_model_override: Option<String>,
catalog: GuardianTestCatalog,
@@ -3191,8 +3292,21 @@ async fn guardian_review_does_not_retry_valid_denial() -> anyhow::Result<()> {
Ok(())
}
enum RequiredGuardianReview {
SandboxRetry,
EscalatedPermission,
LiveManagedModel,
LiveManagedModelWithGuardianV2,
}
#[test_case::test_case(RequiredGuardianReview::SandboxRetry; "sandbox_retry")]
#[test_case::test_case(RequiredGuardianReview::EscalatedPermission; "escalated_permission")]
#[test_case::test_case(RequiredGuardianReview::LiveManagedModel; "live_managed_action_model")]
#[test_case::test_case(RequiredGuardianReview::LiveManagedModelWithGuardianV2; "live_managed_action_model_with_guardian_v2")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn escalated_retry_bypasses_extension_approval_and_runs_guardian() -> anyhow::Result<()> {
async fn guardian_review_routes_required_actions(
required_review: RequiredGuardianReview,
) -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
struct AutoApprovingReviewContributor;
@@ -3225,34 +3339,97 @@ async fn escalated_retry_bypasses_extension_approval_and_runs_guardian() -> anyh
)
.await;
let (mut session, turn) = guardian_test_session_and_turn(&server).await;
let (mut session, mut turn) = guardian_test_session_and_turn(&server).await;
let mut extensions = codex_extension_api::ExtensionRegistryBuilder::<Config>::new();
extensions.approval_review_contributor(Arc::new(AutoApprovingReviewContributor));
Arc::get_mut(&mut session)
.expect("session should be uniquely owned")
.services
.extensions = Arc::new(extensions.build());
let guardian_v2_enabled = matches!(
required_review,
RequiredGuardianReview::LiveManagedModelWithGuardianV2
);
let turn_mut = Arc::get_mut(&mut turn).expect("turn should be uniquely owned");
Arc::make_mut(&mut turn_mut.config)
.features
.set_enabled(Feature::GuardianV2, guardian_v2_enabled)?;
seed_guardian_parent_history(&session, &turn).await;
let retry_reason = "The sandbox blocked the original command.";
let mut context = GuardianReviewContext::from(&turn);
let (request, reasons) = match required_review {
RequiredGuardianReview::SandboxRetry => (
guardian_exec_command_request("shell-sandbox-retry"),
ApprovalRequestReasons {
approval: None,
retry: Some(retry_reason.to_string()),
},
),
RequiredGuardianReview::EscalatedPermission => (
GuardianApprovalRequest::ExecCommand {
id: "shell-escalated-permission".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::RequireEscalated,
additional_permissions: None,
justification: Some("Need to push the reviewed docs fix.".to_string()),
tty: false,
},
ApprovalRequestReasons::default(),
),
RequiredGuardianReview::LiveManagedModel
| 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 mut config = session.get_config().await.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(),
)?;
session.refresh_mcp_config(config).await;
(
guardian_exec_command_request("shell-live-managed-model"),
ApprovalRequestReasons::default(),
)
}
};
let is_retry = reasons.retry.is_some();
let decision = review_approval_request(
&session,
&turn,
"review-escalated-retry".to_string(),
guardian_exec_command_request("shell-escalated-retry"),
ApprovalRequestReasons {
approval: None,
retry: Some(retry_reason.to_string()),
},
context,
"review-required-guardian".to_string(),
request,
reasons,
)
.await;
assert!(matches!(decision, ReviewDecision::Denied { .. }));
assert!(
request_log
.single_request()
.body_contains_text(retry_reason)
);
if guardian_v2_enabled {
assert_eq!(decision, ReviewDecision::Approved);
assert!(request_log.requests().is_empty());
} else {
assert!(matches!(decision, ReviewDecision::Denied { .. }));
assert_eq!(
request_log
.single_request()
.body_contains_text(retry_reason),
is_retry,
);
}
Ok(())
}
@@ -3601,6 +3778,8 @@ async fn guardian_review_session_config_preserves_parent_network_proxy() {
/*live_network_config*/ None,
"parent-active-model",
Some(codex_protocol::openai_models::ReasoningEffort::Low),
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3636,10 +3815,11 @@ async fn guardian_review_session_config_clears_context_overrides_for_distinct_ef
.expect("turn should be unique")
.config = Arc::new(config);
let guardian_config = guardian_review_session_config(session.as_ref(), turn.as_ref())
.await
.expect("guardian config")
.spawn_config;
let guardian_config =
guardian_review_session_config(session.as_ref(), &GuardianReviewContext::from(&turn))
.await
.expect("guardian config")
.spawn_config;
assert_eq!(
(
@@ -3673,10 +3853,11 @@ async fn guardian_review_session_config_preserves_context_overrides_for_same_eff
.expect("turn should be unique")
.config = Arc::new(config);
let guardian_config = guardian_review_session_config(session.as_ref(), turn.as_ref())
.await
.expect("guardian config")
.spawn_config;
let guardian_config =
guardian_review_session_config(session.as_ref(), &GuardianReviewContext::from(&turn))
.await
.expect("guardian config")
.spawn_config;
assert_eq!(
(
@@ -3698,6 +3879,8 @@ async fn guardian_review_session_config_clears_parent_developer_instructions() {
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3725,6 +3908,8 @@ async fn guardian_review_session_config_clears_legacy_notify() {
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3760,6 +3945,8 @@ async fn guardian_review_session_config_uses_live_network_proxy_state() {
Some(live_network.clone()),
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3807,6 +3994,8 @@ async fn guardian_review_session_config_disables_mcp_apps_plugins_memories_and_g
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3839,6 +4028,8 @@ async fn guardian_review_session_config_allows_pinned_disabled_feature() {
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config should continue when a disabled feature is pinned on");
@@ -3858,6 +4049,8 @@ async fn guardian_review_session_config_uses_parent_active_model_instead_of_hard
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3877,6 +4070,8 @@ async fn guardian_review_session_config_keeps_bedrock_provider_for_bedrock_gpt_5
/*live_network_config*/ None,
AMAZON_BEDROCK_GPT_5_4_MODEL_ID,
Some(ReasoningEffort::Low),
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3932,6 +4127,8 @@ async fn guardian_review_session_config_uses_requirements_guardian_policy_config
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");
@@ -3972,6 +4169,8 @@ async fn guardian_review_session_config_uses_default_guardian_policy_without_req
/*live_network_config*/ None,
"active-model",
/*reasoning_effort*/ None,
ReasoningSummary::default(),
/*personality*/ None,
/*model_messages*/ None,
)
.expect("guardian config");