Snapshot resolved settings for each model step (#40651)

## Why

Thread settings can change while a turn is running, and delegated review or
compaction steps can select a different model. Each request needs a consistent
set of settings resolved against the model that will execute it.

## What changed

- Capture immutable resolved settings for each model step, including model
  metadata, reasoning options, service tier, approvals, and personality.
- Keep in-flight steps on their captured settings while applying thread updates
  to subsequent work.
- Resolve inherited reasoning summaries and filter service tiers against the
  selected model and feature configuration for review and compaction steps.

## Testing

Added coverage for settings updates during paused turns, model changes,
previous-model compaction, review-model defaults, and service-tier filtering.

GitOrigin-RevId: fca4b3b305379f1bf26a5cac75ee0dd1747ac1f6
This commit is contained in:
joeflorencio-openai authored and copyberry committed 2026-08-25 17:41:22 +00:00
1 parent ba6cf9c692
commit 68301fa45f
68 files changed
+1393 -516

No files matched your search

+13 -13
View File
@@ -249,7 +249,7 @@ async fn record_guardian_non_denial(session: &Arc<Session>, turn_id: &str) {
}
async fn record_guardian_denial(session: &Arc<Session>, turn: &Arc<TurnContext>, turn_id: &str) {
let policy = if turn.model_info.model_specialty.as_deref() == Some(MODEL_SPECIALTY_CYBER) {
let policy = if turn.model_info().model_specialty.as_deref() == Some(MODEL_SPECIALTY_CYBER) {
GuardianRejectionCircuitBreakerPolicy::CyberModel
} else {
GuardianRejectionCircuitBreakerPolicy::Standard
@@ -335,7 +335,7 @@ async fn run_guardian_review(
.config
.config_layer_stack
.requirements()
.auto_review_required_for_model(&turn.model_info.slug)
.auto_review_required_for_model(&turn.model_info().slug)
|| turn.config.features.enabled(Feature::GuardianV2))
&& !requires_synchronous_review
&& options
@@ -722,7 +722,7 @@ async fn run_guardian_review(
assessment.rationale.trim()
};
let rejection_instructions = turn
.model_info
.model_info()
.model_messages
.as_ref()
.and_then(|messages| messages.auto_review.as_ref())
@@ -847,7 +847,7 @@ pub(super) async fn guardian_review_session_config(
fallback
}
};
let model_override = turn.model_info.auto_review_model_override.as_deref();
let model_override = turn.model_info().auto_review_model_override.as_deref();
let review_model_id = model_override.unwrap_or(default_review_model_id);
let review_model = available_models
.iter()
@@ -868,17 +868,17 @@ pub(super) async fn guardian_review_session_config(
(review_model_id.to_string(), reasoning_effort)
} else {
let reasoning_effort = preferred_reasoning_effort(
turn.model_info
turn.model_info()
.supported_reasoning_levels
.iter()
.any(|preset| preset.effort == codex_protocol::openai_models::ReasoningEffort::Low),
turn.reasoning_effort
.clone()
.or_else(|| turn.model_info.default_reasoning_level.clone()),
turn.reasoning_effort()
.or(turn.model_info().default_reasoning_level.as_ref())
.cloned(),
);
(
model_override
.unwrap_or(turn.model_info.slug.as_str())
.unwrap_or(turn.model_info().slug.as_str())
.to_string(),
reasoning_effort,
)
@@ -899,7 +899,7 @@ pub(super) async fn guardian_review_session_config(
guardian_reasoning_effort.clone(),
guardian_model_info.model_messages.as_ref(),
)?;
if turn.model_info.node_repl_auto_review_required {
if turn.model_info().node_repl_auto_review_required {
spawn_config
.features
.enable(Feature::RetainClientDeveloperMessages)
@@ -909,7 +909,7 @@ pub(super) async fn guardian_review_session_config(
)
})?;
}
if guardian_model != turn.model_info.slug {
if guardian_model != turn.model_info().slug {
spawn_config.model_context_window = None;
spawn_config.model_auto_compact_token_limit = None;
}
@@ -974,8 +974,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: turn.reasoning_summary(),
personality: turn.personality(),
external_cancel,
deadline,
}),
+7 -7
View File
@@ -438,7 +438,7 @@ impl GuardianReviewSessionManager {
.with_node_repl_policy_eligibility(
parent_context
.turn()
.model_info
.model_info()
.node_repl_auto_review_required,
);
let spawn_cancel_token = self.cancellation_token.child_token();
@@ -528,7 +528,7 @@ impl GuardianReviewSessionManager {
params
.parent_context
.turn()
.model_info
.model_info()
.node_repl_auto_review_required,
);
let mut spawned_trunk = false;
@@ -952,7 +952,7 @@ async fn run_review_on_session(
.sync_session_approved_hosts_to(&review_session.session.services.network_approval)
.await;
if params.parent_context.turn().model_info.node_repl_auto_review_required
if params.parent_context.turn().model_info().node_repl_auto_review_required
&& matches!(
&params.request,
GuardianApprovalRequest::McpToolCall { server, tool_name, .. }
@@ -1607,10 +1607,10 @@ mod tests {
async fn test_review_params() -> GuardianReviewSessionParams {
let (session, turn) = crate::session::tests::make_session_and_context().await;
let model = turn.model_info.slug.clone();
let reasoning_effort = turn.reasoning_effort.clone();
let reasoning_summary = turn.reasoning_summary;
let personality = turn.personality;
let model = turn.model_info().slug.clone();
let reasoning_effort = turn.reasoning_effort().cloned();
let reasoning_summary = turn.reasoning_summary();
let personality = turn.personality();
#[allow(deprecated)]
let cwd = turn.cwd.clone();
let spawn_config = build_guardian_review_session_config(
+23 -19
View File
@@ -14,6 +14,7 @@ use crate::guardian::prompt::guardian_policy_prompt_with_config_and_template;
use crate::guardian::review::guardian_review_session_config;
use crate::guardian::review::routes_approval_to_guardian_with_reviewer;
use crate::session::session::Session;
use crate::session::tests::update_turn_settings_for_test;
use crate::session::turn_context::TurnContext;
use crate::test_support;
use codex_analytics::GuardianApprovalRequestSource;
@@ -1185,12 +1186,10 @@ async fn build_guardian_prompt_items_keeps_required_node_repl_reviews_generic()
{
let (session, mut turn) =
guardian_test_session_and_turn_with_base_url("http://localhost").await;
Arc::make_mut(
&mut Arc::get_mut(&mut turn)
.expect("turn should be uniquely owned")
.model_info,
)
.node_repl_auto_review_required = true;
update_turn_settings_for_test(
Arc::get_mut(&mut turn).expect("turn should be uniquely owned"),
|settings| Arc::make_mut(&mut settings.model_info).node_repl_auto_review_required = true,
);
seed_guardian_parent_history(&session, &turn).await;
let context = GuardianReviewContext::from(&turn);
@@ -1810,7 +1809,7 @@ async fn guardian_request_model_for_auto_review(
match catalog {
GuardianTestCatalog::Bundled => {}
GuardianTestCatalog::ParentOnly => {
let parent_model = turn.model_info.as_ref().clone();
let parent_model = turn.model_info().as_ref().clone();
let auth_manager = Arc::clone(&session.services.auth_manager);
let models_manager = StaticModelsManager::new(
Some(auth_manager),
@@ -1824,13 +1823,14 @@ async fn guardian_request_model_for_auto_review(
.models_manager = Arc::new(models_manager);
}
}
Arc::make_mut(
&mut Arc::get_mut(&mut turn)
.expect("turn should be unique")
.model_info,
)
.auto_review_model_override = auto_review_model_override;
let parent_model = turn.model_info.slug.clone();
update_turn_settings_for_test(
Arc::get_mut(&mut turn).expect("turn should be unique"),
|settings| {
Arc::make_mut(&mut settings.model_info).auto_review_model_override =
auto_review_model_override
},
);
let parent_model = turn.model_info().slug.clone();
let preferred_model = turn.provider.approval_review_preferred_model().to_string();
let parent_turn_id = turn.sub_id.clone();
seed_guardian_parent_history(&session, &turn).await;
@@ -2055,8 +2055,10 @@ async fn guardian_review_request_layout_matches_model_visible_request_snapshot()
session.services.skills_service.clear_cache();
turn.config = Arc::clone(&config);
turn.provider = create_model_provider(config.model_provider.clone(), turn.auth_manager.clone());
Arc::make_mut(&mut turn.model_info).auto_review_model_override =
Some("codex-auto-review".to_string());
update_turn_settings_for_test(&mut turn, |settings| {
Arc::make_mut(&mut settings.model_info).auto_review_model_override =
Some("codex-auto-review".to_string());
});
let session = Arc::new(session);
let turn = Arc::new(turn);
seed_guardian_parent_history(&session, &turn).await;
@@ -2330,8 +2332,10 @@ async fn guardian_reuses_prompt_cache_key_and_appends_prior_reviews() -> anyhow:
.enable(Feature::GuardianReuseParentCompaction)
.expect("Guardian parent-compaction reuse should be configurable");
let turn_mut = Arc::get_mut(&mut turn).expect("turn should be unique");
Arc::make_mut(&mut turn_mut.model_info).auto_review_model_override =
Some("codex-auto-review".to_string());
update_turn_settings_for_test(turn_mut, |settings| {
Arc::make_mut(&mut settings.model_info).auto_review_model_override =
Some("codex-auto-review".to_string());
});
turn_mut.config = Arc::new(config);
seed_guardian_parent_history(&session, &turn).await;
@@ -3542,7 +3546,7 @@ async fn guardian_review_session_config_clears_context_overrides_for_distinct_ef
async fn guardian_review_session_config_preserves_context_overrides_for_same_effective_model() {
let server = start_mock_server().await;
let (mut session, mut turn) = guardian_test_session_and_turn(&server).await;
let parent_model = turn.model_info.as_ref().clone();
let parent_model = turn.model_info().as_ref().clone();
let auth_manager = Arc::clone(&session.services.auth_manager);
Arc::get_mut(&mut session)
.expect("session should be unique")