Support a host-selected inference provider for Guardian (#62588)

## Why

Guardian inherits the actor's inference provider by default. Hosts that run
actors on a different provider need to route Guardian reviews independently
and resolve reviewer policy and model capabilities from the Guardian provider.

## What changed

- Share the selected provider and its model catalog between asynchronous
  scoring and blocking approval reviews. Use the provider's preferred
  reviewer and resolve policy from managed requirements or reviewer model
  metadata.
- Keep Guardian review history independent of actor compaction when the
  host selects a provider. Preserve inherited routing when no provider is
  selected.

## Testing

Add integration coverage for separate actor and Guardian endpoints, catalog
isolation when both share an endpoint, and routing after resuming a compacted
thread.

GitOrigin-RevId: 1eb15421f746a58eefe27257e86d948de31bcf86
This commit is contained in:
XMLIU-oai
2026-11-19 20:43:32 +00:00
committed by copyberry
parent 8b2070d29f
commit 5f8c36e836
35 changed files with 1279 additions and 179 deletions
+9
View File
@@ -102,6 +102,15 @@ pub(crate) async fn run_codex_thread_interactive(
};
let mut thread_extension_init = codex_extension_api::ExtensionDataInit::default();
thread_extension_init.insert(isolation);
if config.guardian_model_provider.is_some()
&& Arc::ptr_eq(&auth_manager, &parent_session.services.auth_manager)
&& let Some(context) = parent_session
.services
.thread_extension_data
.get::<crate::guardian::GuardianInferenceContext>()
{
thread_extension_init.insert((*context).clone());
}
let spawn_result = Session::spawn(SessionSpawnArgs {
attached_thread: false,
startup: Some(Arc::clone(&startup)),
@@ -322,7 +322,9 @@ async fn reviewer_compaction_hash(sess: &Session, turn_context: &TurnContext) ->
// reviewer, including model changes accepted while compaction was running.
let mut review_context = crate::guardian::GuardianReviewContext::from(&review_turn);
review_context.model_info = review_turn.capture_current_model_info();
let (_, reviewer) = crate::guardian::resolve_review_model(sess, &review_context).await;
let (_, reviewer) = crate::guardian::resolve_review_model(sess, &review_context)
.await
.ok()?;
reviewer.comp_hash.clone()
} else {
None
+45 -5
View File
@@ -246,7 +246,7 @@ pub use windows_sandbox_config::windows_mxc_allowed_by_config;
const DEFAULT_IGNORE_LARGE_UNTRACKED_DIRS: i64 = 200;
const DEFAULT_IGNORE_LARGE_UNTRACKED_FILES: i64 = 10 * 1024 * 1024;
const DEFAULT_ASYNC_COMPACTION_THRESHOLD_PERCENT: u8 = 65;
pub(crate) const DEFAULT_ASYNC_COMPACTION_THRESHOLD_PERCENT: u8 = 65;
/// Signals that a public config selected the retired `untrusted` approval policy.
#[derive(Debug, thiserror::Error)]
@@ -638,6 +638,13 @@ pub enum ThreadStoreConfig {
InMemory { id: String },
}
/// Provider resolved by the host for Guardian inference on this thread.
#[derive(Debug, Clone, PartialEq)]
pub struct GuardianInferenceProvider {
pub id: String,
pub info: ModelProviderInfo,
}
/// Application configuration loaded from disk and merged with overrides.
#[derive(Debug, Clone, PartialEq)]
pub struct Config {
@@ -691,6 +698,11 @@ pub struct Config {
/// Info needed to make an API request to the model.
pub model_provider: ModelProviderInfo,
/// Host-selected inference provider for Guardian. When set, Guardian keeps review
/// history independent of actor compaction and never reuses actor checkpoints.
/// When unset, Guardian inherits the actor's provider and existing history policy.
pub guardian_model_provider: Option<Arc<GuardianInferenceProvider>>,
/// Deprecated: `friendly` and `pragmatic` no longer select a style.
pub personality: Option<Personality>,
@@ -1729,6 +1741,14 @@ impl Config {
}
}
/// A host-selected Guardian provider cannot reuse the actor's opaque checkpoints.
pub(crate) fn guardian_reuses_parent_compaction(&self) -> bool {
self.guardian_model_provider.is_none()
&& self
.features
.enabled(Feature::GuardianReuseParentCompaction)
}
/// Capture storage and sync preparation use one session-static rollout choice.
pub(crate) fn guardian_context_budgeting(&self) -> codex_guardian_context::ContextBudgeting {
if self.guardian_sync_elastic_budget.is_some() {
@@ -1762,9 +1782,21 @@ impl Config {
&'a self,
model_messages: ResolvedModelMessages<'a>,
) -> &'a str {
self.guardian_policy_config
let configured_policy = if self.guardian_model_provider.is_some() {
self.managed_guardian_policy()
} else {
self.guardian_policy_config.as_deref()
};
configured_policy.unwrap_or(model_messages.auto_review().policy)
}
pub(crate) fn managed_guardian_policy(&self) -> Option<&str> {
self.config_layer_stack
.requirements_toml()
.guardian_policy_config
.as_deref()
.unwrap_or(model_messages.auto_review().policy)
.map(str::trim)
.filter(|policy| !policy.is_empty())
}
/// Native Guardian agent history requires the reviewed thread's OpenAI provider.
@@ -1878,6 +1910,14 @@ impl Config {
/// Creates the HTTP client factory resolved from the effective feature configuration.
pub fn http_client_factory(&self) -> HttpClientFactory {
self.http_client_factory_for_provider(&self.model_provider)
}
/// Applies the thread's network settings and the selected provider's header policy.
pub(crate) fn http_client_factory_for_provider(
&self,
provider: &ModelProviderInfo,
) -> HttpClientFactory {
let outbound_proxy_policy = if self.respect_system_proxy {
OutboundProxyPolicy::RespectSystemProxy
} else {
@@ -1885,8 +1925,7 @@ impl Config {
};
let mut factory = HttpClientFactory::new(outbound_proxy_policy)
.with_network_policy(self.application_network_policy.clone());
if self
.model_provider
if provider
.gateway_oauth
.as_ref()
.is_some_and(GatewayOAuthConfig::uses_credential_export)
@@ -4745,6 +4784,7 @@ impl Config {
async_compaction_threshold_percent,
model_provider_id,
model_provider,
guardian_model_provider: None,
cwd: resolved_cwd,
workspace_roots: workspace_roots.clone(),
workspace_roots_explicit,
+2 -1
View File
@@ -364,10 +364,11 @@ impl ContextManager {
pub(crate) fn for_session(
root_capabilities_restricted: bool,
features: &ManagedFeatures,
reuse_parent_compaction: bool,
budgeting: ContextBudgeting,
item_id_generator: ItemIdGenerator,
) -> Self {
let independent = !features.enabled(Feature::GuardianReuseParentCompaction);
let independent = !reuse_parent_compaction;
Self {
retain_inherited_user_messages: !root_capabilities_restricted,
guardian_include_additional_context: features
@@ -158,6 +158,7 @@ fn root_history() -> ContextManager {
ContextManager::for_session(
/*root_capabilities_restricted*/ false,
&ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
)
@@ -591,6 +592,7 @@ fn guardian_checkpoint_applies_additional_context_policy_after_resume(include: b
let mut history = ContextManager::for_session(
/*root_capabilities_restricted*/ false,
&features,
features.enabled(Feature::GuardianReuseParentCompaction),
codex_guardian_context::ContextBudgeting::Fixed,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
);
@@ -634,6 +636,7 @@ fn guardian_checkpoint_applies_additional_context_policy_after_resume(include: b
let mut resumed = ContextManager::for_session(
/*root_capabilities_restricted*/ false,
&features,
features.enabled(Feature::GuardianReuseParentCompaction),
codex_guardian_context::ContextBudgeting::Fixed,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
);
+86
View File
@@ -0,0 +1,86 @@
//! Owns the host-selected Guardian inference route and its shared model catalog.
//! The actor thread resolves this once; both scoring and blocking review consume it.
//! An explicit Guardian route resolves inference settings from the selected provider
//! and trusted host defaults, independently of Actor inference configuration.
use std::sync::Arc;
use codex_extension_api::ExtensionData;
use codex_http_client::HttpClientFactory;
use codex_model_provider::ProviderAuthContext;
use codex_model_provider::SharedModelProvider;
use codex_models_manager::manager::SharedModelsManager;
use crate::config::Config;
use crate::config::GuardianInferenceProvider;
/// Resolved inference dependencies for a host-selected Guardian provider.
#[derive(Clone)]
pub struct GuardianInferenceContext {
pub(crate) auth: ProviderAuthContext,
pub provider_id: String,
pub provider: SharedModelProvider,
pub models_manager: SharedModelsManager,
pub http_client_factory: HttpClientFactory,
pub service_tier: Option<String>,
}
/// Inference dependencies supplied by Core to an internal Guardian reviewer.
pub(crate) struct GuardianReviewerInference(pub Arc<GuardianInferenceContext>);
impl GuardianInferenceContext {
pub(crate) fn resolve(
config: &Config,
selected: &GuardianInferenceProvider,
auth: ProviderAuthContext,
provider: SharedModelProvider,
models_manager: SharedModelsManager,
) -> Self {
Self {
auth,
provider_id: selected.id.clone(),
provider,
models_manager,
http_client_factory: config.http_client_factory_for_provider(&selected.info),
// The actor's tier belongs to a different inference provider.
service_tier: None,
}
}
/// Returns the host-selected route, or an error if its startup state is missing.
pub fn for_config(config: &Config, store: &ExtensionData) -> anyhow::Result<Option<Arc<Self>>> {
if config.guardian_model_provider.is_none() {
return Ok(None);
}
store.get::<Self>().map(Some).ok_or_else(|| {
anyhow::anyhow!("host-selected Guardian inference context is not initialized")
})
}
pub(crate) fn configure_reviewer(&self, config: &mut Config) {
let mut provider = self.provider.info().clone();
// The reviewer config already contains the host's blocking-review retry policy.
provider.request_max_retries = config.model_provider.request_max_retries;
provider.stream_max_retries = config.model_provider.stream_max_retries;
config.model_providers.remove(&config.model_provider_id);
config.model_provider_id.clone_from(&self.provider_id);
config.model_provider = provider;
config
.model_providers
.insert(self.provider_id.clone(), config.model_provider.clone());
config.guardian_policy_config = config.managed_guardian_policy().map(str::to_owned);
config.guardian_transcript_mode = Default::default();
config.guardian_conversation_history_prompt = None;
config.guardian_model_provider = None;
config.model_catalog = None;
config.model_context_window = None;
config.async_compaction_threshold_percent =
crate::config::DEFAULT_ASYNC_COMPACTION_THRESHOLD_PERCENT;
config.model_auto_compact_token_limit = None;
config.model_auto_compact_token_limit_scope = Default::default();
config.tool_output_token_limit = None;
config.model_verbosity = None;
config.compact_prompt = None;
config.service_tier.clone_from(&self.service_tier);
}
}
+3
View File
@@ -20,9 +20,12 @@ pub(crate) use request_budget::ExhaustedReviewBudget;
pub(crate) use request_budget::prepare_prompt as prepare_guardian_prompt;
mod response_resampling;
pub(crate) use response_resampling::ResponseResampling;
mod inference;
mod review;
mod review_session;
mod reviewer_config;
pub use inference::GuardianInferenceContext;
pub(crate) use inference::GuardianReviewerInference;
pub use reviewer_config::guardian_policy_model;
pub(crate) use reviewer_config::resolve_review_model;
mod routing;
+15 -4
View File
@@ -135,20 +135,31 @@ pub(super) async fn guardian_review_session_config(
None => None,
};
let (review_model, guardian_model_info) =
super::reviewer_config::resolve_review_model(session, context).await;
super::reviewer_config::resolve_review_model(session, context).await?;
let reviewer_config = session
.services
.thread_extension_data
.get::<codex_guardian_reviewer::ReviewerConfig<crate::config::Config>>()
.ok_or_else(|| anyhow::anyhow!("Guardian reviewer configuration is not installed"))?;
let model_messages = ResolvedModelMessages::from_model(&guardian_model_info);
let mut reviewer_config = (reviewer_config.0)(turn.config.as_ref())?;
let inference = super::GuardianInferenceContext::for_config(
&turn.config,
&session.services.thread_extension_data,
)?;
let (reasoning_summary, personality) = if let Some(inference) = inference {
inference.configure_reviewer(&mut reviewer_config);
(Default::default(), None)
} else {
(context.reasoning_summary, context.personality)
};
let mut spawn_config = build_guardian_review_session_config(
(reviewer_config.0)(turn.config.as_ref())?,
reviewer_config,
live_network_config,
review_model.model.as_str(),
review_model.reasoning_effort.clone(),
context.reasoning_summary,
context.personality,
reasoning_summary,
personality,
model_messages,
retrieval,
)?;
+15 -7
View File
@@ -270,8 +270,8 @@ pub(super) fn review_turn(
parent_turn_environments,
),
permission_profile: config.permissions.permission_profile().clone(),
reasoning_summary: context.reasoning_summary,
personality: context.personality,
reasoning_summary: config.model_reasoning_summary.unwrap_or_default(),
personality: config.personality,
model: review_model.model.clone(),
reasoning_effort: review_model.reasoning_effort.clone(),
cyber_access_program: parent_turn.cyber_access_program.filter(|_| {
@@ -296,10 +296,18 @@ async fn run_review_on_session(
deadline: ReviewDeadline,
) -> ReviewSessionResult {
let review_model = &params.review_model;
let model_info = params
.parent_session
.services
.models_manager
let actor_turn = params.parent_context.turn();
let inherited_turn = actor_turn
.config
.guardian_model_provider
.is_none()
.then_some(actor_turn.as_ref());
let models_manager = if inherited_turn.is_some() {
&params.parent_session.services.models_manager
} else {
&review_session.session.services.models_manager
};
let model_info = models_manager
.get_model_info(
review_model.model.as_str(),
&params.spawn_config.to_models_manager_config(),
@@ -360,7 +368,7 @@ async fn run_review_on_session(
&& crate::session::context_window::context_window_token_status_for_model(
review_session.session.as_ref(),
&params.spawn_config,
params.parent_context.turn(),
inherited_turn,
&model_info,
)
.await
@@ -49,7 +49,7 @@ pub(super) async fn build_guardian_prompt_items(
.executed_tool_calls
.exec_output_matches(output, selected_tool_names)
};
let collected = collect_guardian_prompt_items_with_parent_turn(
let mut collected = collect_guardian_prompt_items_with_parent_turn(
params.parent_session.as_ref(),
history,
Some(&params.parent_context),
@@ -59,6 +59,7 @@ pub(super) async fn build_guardian_prompt_items(
reviewed_node_repl_evidence_sequence,
)
.await?;
collected.profile.transcript_format = params.spawn_config.guardian_transcript_mode;
let context_window = model_info.resolved_context_window().map(|supported| {
params
.spawn_config
@@ -22,6 +22,7 @@ pub struct PreparedGuardianContext {
parent: Arc<Session>,
context: GuardianReviewContext,
config: Config,
inference: Option<Arc<crate::guardian::GuardianInferenceContext>>,
context_policy: ReviewContextPolicy,
key: GuardianReviewSessionReuseKey,
parent_compaction: Option<ResponseItem>,
@@ -62,10 +63,15 @@ impl PreparedGuardianContext {
.with_node_repl_policy(node_repl_policy);
key.root_review_version = root_review_version;
key.parent_reset_version = history.reset_version;
let inference = crate::guardian::GuardianInferenceContext::for_config(
&context.turn().config,
&parent.services.thread_extension_data,
)?;
Ok(Self {
parent,
context,
config,
inference,
context_policy,
key,
parent_compaction,
@@ -116,12 +122,14 @@ impl PreparedGuardianContext {
self.parent_compaction.as_ref(),
);
let mut config = self.config.clone();
config.model_provider.supports_websockets &= self
.parent
.services
.model_client
.responses_websocket_enabled();
let options = crate::StartThreadOptions {
if self.inference.is_none() {
config.model_provider.supports_websockets &= self
.parent
.services
.model_client
.responses_websocket_enabled();
}
let mut options = crate::StartThreadOptions {
request_country: self.context.request_country.clone(),
prompt_cache_key: self.parent.services.model_client.prompt_cache_key_policy(),
history_mode: Some(codex_protocol::protocol::ThreadHistoryMode::Paginated),
@@ -155,6 +163,13 @@ impl PreparedGuardianContext {
client_mcp_extensions: self.parent.services.client_mcp_extensions.clone(),
..crate::StartThreadOptions::new(config)
};
if let Some(inference) = &self.inference {
options
.thread_extension_init
.insert(crate::guardian::GuardianReviewerInference(Arc::clone(
inference,
)));
}
(options, state)
}
+129 -41
View File
@@ -1,8 +1,8 @@
//! Resolves reviewer models and adds policy context and live network state to reviewer configuration.
//! Both prewarming and reviews finish this setup before context preparation and reuse checks.
//! A missing default reviewer gets one shared catalog refresh per parent session.
//! Inherited routing refreshes a missing default reviewer once per parent session.
//! Refresh work survives cancelled waiters and precedes checkpoint compatibility decisions.
//! Async classification shares reviewer eligibility and the parent session's catalog.
//! Both review paths use the host's Guardian catalog when the host selects a provider.
use crate::guardian_review::ReviewRetrieval;
use codex_protocol::openai_models::CatalogModel;
@@ -11,7 +11,11 @@ use std::sync::Arc;
use codex_features::Feature;
use codex_guardian_reviewer::reviewer_instructions;
use codex_http_client::HttpClientFactory;
use codex_login::AuthManager;
use codex_model_provider::ProviderAuthContext;
use codex_models_manager::ModelsManagerConfig;
use codex_models_manager::manager::ModelsManager;
use codex_models_manager::manager::RefreshStrategy;
use codex_models_manager::model_info::with_config_overrides;
use codex_prompts::ResolvedModelMessages;
@@ -30,6 +34,11 @@ use crate::context::GuardianConversationHistory;
struct GuardianModelCatalogRefresh(Shared<BoxFuture<'static, ()>>);
enum GuardianCatalogLookup {
InitializeIfNeeded,
UseAvailable,
}
/// Adds the captured model, policy prompt and live network rules before reuse selection.
#[allow(clippy::too_many_arguments)]
pub fn build_guardian_review_session_config(
@@ -109,12 +118,24 @@ pub fn build_guardian_review_session_config(
Ok(guardian_config)
}
/// Retries a missing default reviewer once before retaining the parent fallback.
/// Resolves the reviewer from its inference provider's catalog.
/// Inherited routing retries a missing default once before falling back to the parent;
/// host-selected routing keeps its provider's preferred model on a catalog miss.
pub(crate) async fn resolve_review_model(
session: &crate::session::session::Session,
context: &super::GuardianReviewContext,
) -> (codex_guardian_reviewer::ReviewModel, Arc<CatalogModel>) {
) -> anyhow::Result<(codex_guardian_reviewer::ReviewModel, Arc<CatalogModel>)> {
let turn = context.turn();
if let Some(inference) = super::GuardianInferenceContext::for_config(
&turn.config,
&session.services.thread_extension_data,
)? {
return Ok(resolve_explicit_guardian_reviewer(
&inference,
GuardianCatalogLookup::InitializeIfNeeded,
)
.await);
}
// Check before resolving: a refresh that finishes during the lookup still
// requires a reread, but later calls only need one catalog resolution.
let refresh_completed = session
@@ -151,9 +172,9 @@ pub(crate) async fn resolve_review_model(
)
});
refresh.0.clone().await;
return resolve_review_model_from_catalog(session, context).await;
return Ok(resolve_review_model_from_catalog(session, context).await);
}
resolved
Ok(resolved)
}
async fn resolve_review_model_from_catalog(
@@ -162,7 +183,7 @@ async fn resolve_review_model_from_catalog(
) -> (codex_guardian_reviewer::ReviewModel, Arc<CatalogModel>) {
let turn = context.turn();
let (review_model, model_info) = resolve_catalog_review_model(
session,
session.services.models_manager.as_ref(),
&turn.config,
&context.model_info,
context.reasoning_effort.as_ref(),
@@ -175,54 +196,92 @@ async fn resolve_review_model_from_catalog(
)
}
/// Resolves async classification policy against the reviewed thread's catalog.
/// A missing eligible reviewer retains the captured parent metadata, as synchronous review does.
/// Resolves async classification policy against the catalog used for Guardian requests.
pub async fn guardian_policy_model(
thread: &crate::CodexThread,
config: &Config,
parent_model: Arc<ModelInfo>,
) -> Arc<ModelInfo> {
) -> anyhow::Result<Arc<ModelInfo>> {
let thread_store = thread.thread_extension_data();
if let Some(inference) = super::GuardianInferenceContext::for_config(config, thread_store)? {
let (_, model) =
resolve_explicit_guardian_reviewer(&inference, GuardianCatalogLookup::UseAvailable)
.await;
return Ok(Arc::clone(&model.model));
}
#[expect(clippy::expect_used, reason = "Required thread startup invariant")]
let auth = thread
.thread_extension_data()
.get::<codex_model_provider::ProviderAuthContext>()
let auth = thread_store
.get::<ProviderAuthContext>()
.expect("Core installs provider auth before starting Guardian");
let provider = auth.model_provider(config.model_provider.clone());
let (_, model_info) = resolve_catalog_review_model(
&thread.session,
thread.session.services.models_manager.as_ref(),
config,
&parent_model,
config.model_reasoning_effort.as_ref(),
provider.approval_review_preferred_model(),
)
.await;
model_info.map_or(parent_model, |model| model.model)
Ok(model_info.map_or(parent_model, |model| model.model))
}
async fn resolve_explicit_guardian_reviewer(
inference: &super::GuardianInferenceContext,
lookup: GuardianCatalogLookup,
) -> (codex_guardian_reviewer::ReviewModel, Arc<CatalogModel>) {
let catalog = &inference.models_manager;
let preferred = inference.provider.approval_review_preferred_model();
let http_client_factory = inference.http_client_factory.clone();
let model_config = ModelsManagerConfig::default();
// Async scoring uses the available metadata while its background retry runs.
if matches!(lookup, GuardianCatalogLookup::InitializeIfNeeded) {
catalog
.ensure_initialized(http_client_factory.clone())
.await;
}
let eligible = eligible_review_models(
catalog.as_ref(),
http_client_factory,
/*model_override*/ None,
)
.await;
let reviewer = codex_guardian_reviewer::select_catalog_reviewer(eligible, preferred);
let catalog_contains_auto_review = reviewer.is_some();
let model_info = match reviewer {
Some(entry) => with_reviewer_config_overrides(entry, &model_config),
None => catalog.get_model_info(preferred, &model_config).await,
};
// An advertised reviewer gets an explicit "none" when it has no default effort.
let fallback_effort = model_info
.default_reasoning_level
.clone()
.or_else(|| catalog_contains_auto_review.then_some(ReasoningEffort::None));
let reasoning_effort =
codex_guardian_reviewer::preferred_reasoning_effort(&model_info, fallback_effort);
let review_model = codex_guardian_reviewer::ReviewModel {
model: preferred.to_owned(),
reasoning_effort,
default_review_model_id: preferred.to_owned(),
catalog_contains_auto_review,
model_overridden: false,
model_override: None,
};
(review_model, Arc::new(model_info))
}
async fn resolve_catalog_review_model(
session: &crate::session::session::Session,
models_manager: &dyn ModelsManager,
config: &Config,
parent_model: &ModelInfo,
reasoning_effort: Option<&ReasoningEffort>,
default_review_model_id: &str,
) -> (codex_guardian_reviewer::ReviewModel, Option<CatalogModel>) {
// Keep a successful refresh even if writing it to the disk cache failed.
let models_manager = &session.services.models_manager;
let mut catalog = models_manager
.model_catalog_with_origins(RefreshStrategy::InMemory, config.http_client_factory())
.await;
let uses_codex_backend = models_manager
.auth_manager()
.is_some_and(AuthManager::current_auth_uses_codex_backend);
catalog.retain(|entry| {
(uses_codex_backend || entry.supported_in_api)
&& (parent_model.auto_review_model_override.is_some()
|| matches!(
entry.origin,
codex_models_manager::ModelOrigin::Provider
| codex_models_manager::ModelOrigin::ExplicitConfig
))
});
let catalog = eligible_review_models(
models_manager,
config.http_client_factory(),
parent_model.auto_review_model_override.as_deref(),
)
.await;
let (review_model, reviewer) = codex_guardian_reviewer::select_review_model(
parent_model,
reasoning_effort,
@@ -237,14 +296,43 @@ async fn resolve_catalog_review_model(
.await,
)
} else {
reviewer.map(|entry| CatalogModel {
model: with_config_overrides(
Arc::unwrap_or_clone(entry.model),
&config.to_models_manager_config(),
)
.into(),
origin: entry.origin,
})
reviewer
.map(|entry| with_reviewer_config_overrides(entry, &config.to_models_manager_config()))
};
(review_model, guardian_model_info)
}
fn with_reviewer_config_overrides(
entry: CatalogModel,
config: &ModelsManagerConfig,
) -> CatalogModel {
CatalogModel {
model: with_config_overrides(Arc::unwrap_or_clone(entry.model), config).into(),
origin: entry.origin,
}
}
/// Preserve provider eligibility while selecting from the latest in-memory catalog.
async fn eligible_review_models(
models_manager: &dyn ModelsManager,
http_client_factory: HttpClientFactory,
model_override: Option<&str>,
) -> Vec<CatalogModel> {
// Keep a successful refresh even if writing it to the disk cache failed.
let mut catalog = models_manager
.model_catalog_with_origins(RefreshStrategy::InMemory, http_client_factory)
.await;
let uses_codex_backend = models_manager
.auth_manager()
.is_some_and(AuthManager::current_auth_uses_codex_backend);
catalog.retain(|entry| {
(uses_codex_backend || entry.supported_in_api)
&& (model_override.is_some()
|| matches!(
entry.origin,
codex_models_manager::ModelOrigin::Provider
| codex_models_manager::ModelOrigin::ExplicitConfig
))
});
catalog
}
+203 -1
View File
@@ -3,6 +3,7 @@ use super::*;
use crate::config::Config;
use crate::config::ConfigOverrides;
use crate::config::Constrained;
use crate::config::GuardianInferenceProvider;
use crate::config::NetworkProxySpec;
use crate::config::PermissionProfileSnapshot;
use crate::config::test_config;
@@ -28,6 +29,7 @@ use codex_guardian_context::ConversationTranscriptEntry;
use codex_guardian_context::ConversationTranscriptEntryKind;
use codex_guardian_reviewer::guardian_output_contract_prompt;
use codex_history::RolloutItem;
use codex_model_provider::ProviderAuthContext;
use codex_model_provider::create_model_provider;
use codex_model_provider_info::AMAZON_BEDROCK_GPT_5_5_MODEL_ID;
use codex_model_provider_info::AMAZON_BEDROCK_PROVIDER_ID;
@@ -41,6 +43,7 @@ use codex_protocol::ThreadId;
use codex_protocol::TranscriptFormat;
use codex_protocol::approvals::GuardianAssessmentAction;
use codex_protocol::approvals::NetworkApprovalProtocol;
use codex_protocol::config_types::AutoCompactTokenLimitScope;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::models::ContentItem;
use codex_protocol::models::PermissionProfile;
@@ -3454,19 +3457,49 @@ async fn guardian_review_session_config_preserves_context_overrides_for_same_eff
config.model = Some("stale-parent-model".to_string());
config.model_context_window = Some(128_000);
config.model_auto_compact_token_limit = Some(100_000);
config.async_compaction_threshold_percent = 50;
config.features.enable(Feature::AsyncCompaction).unwrap();
Arc::get_mut(&mut turn)
.expect("turn should be unique")
.config = Arc::new(config);
let mut context = GuardianReviewContext::from(&turn);
context.reasoning_summary = ReasoningSummary::Detailed;
context.personality = Some(codex_protocol::config_types::Personality::Friendly);
let (review_model, _) = resolve_review_model(session.as_ref(), &context)
.await
.unwrap();
let guardian_config = guardian_review_session_config(
session.as_ref(),
&GuardianReviewContext::from(&turn),
&context,
ReviewRetrieval::ConversationHistory,
)
.await
.expect("guardian config")
.spawn_config;
let request = super::review_session::review_turn(
session.as_ref(),
&context,
&guardian_config,
&review_model,
Vec::new(),
serde_json::json!({}),
);
assert_eq!(
(
request.thread_settings.summary,
request.thread_settings.personality
),
(Some(context.reasoning_summary), context.personality)
);
assert_eq!(
(
guardian_config.features.enabled(Feature::AsyncCompaction),
guardian_config.async_compaction_threshold_percent,
),
(true, 50)
);
assert_eq!(
(
guardian_config.model_context_window,
@@ -3476,6 +3509,175 @@ async fn guardian_review_session_config_preserves_context_overrides_for_same_eff
);
}
#[tokio::test]
async fn guardian_review_session_config_uses_explicit_provider_catalog_limits_for_same_model_slug()
{
let (session, mut turn) =
guardian_test_session_and_turn_with_base_url("http://localhost").await;
let auth_manager = Arc::clone(&session.services.auth_manager);
let auth = ProviderAuthContext {
credentials: Arc::clone(&auth_manager),
runtime_auth: None,
};
let mut provider = turn.config.model_provider.clone();
provider.base_url = Some("http://guardian.example/v1".to_owned());
provider.supports_websockets = true;
provider.request_max_retries = Some(4);
provider.stream_max_retries = Some(5);
let model = auth
.model_provider(provider.clone())
.approval_review_preferred_model();
let mut guardian_model = turn.model_info().model.as_ref().clone();
guardian_model.slug = model.to_owned();
guardian_model.default_reasoning_level = Some(ReasoningEffort::Low);
guardian_model.context_window = Some(128_000);
guardian_model.max_context_window = Some(128_000);
guardian_model.auto_compact_token_limit = Some(90_000);
let catalog = Arc::new(StaticModelsManager::new(
Some(auth_manager),
ModelsResponse {
models: vec![guardian_model],
},
codex_models_manager::ModelOrigin::ExplicitConfig,
));
let mut config = (*turn.config).clone();
config.config_layer_stack = ConfigLayerStack::new(
Vec::new(),
Default::default(),
codex_config::ConfigRequirementsToml {
guardian_policy_config: Some("Managed Guardian policy.".to_owned()),
..Default::default()
},
)
.expect("managed config stack");
config.guardian_policy_config = Some("Actor Guardian policy.".to_owned());
config.compact_prompt = Some("Actor compact prompt".to_owned());
config.model = Some(model.to_owned());
config.model_provider.supports_websockets = false;
config.model_context_window = Some(11_000);
config.async_compaction_threshold_percent = 50;
config.features.enable(Feature::AsyncCompaction).unwrap();
config
.features
.enable(Feature::AsyncCompactionRootOnly)
.unwrap();
config.model_auto_compact_token_limit = Some(8_000);
config.model_auto_compact_token_limit_scope = AutoCompactTokenLimitScope::BodyAfterPrefix;
config.tool_output_token_limit = Some(17);
config.model_provider.request_max_retries = Some(12);
config.model_provider.stream_max_retries = Some(13);
config.guardian_model_provider = Some(Arc::new(GuardianInferenceProvider {
id: "guardian-test-provider".to_owned(),
info: provider.clone(),
}));
session
.services
.thread_extension_data
.insert(GuardianInferenceContext::resolve(
&config,
config.guardian_model_provider.as_ref().unwrap(),
auth.clone(),
auth.model_provider(provider.clone()),
catalog,
));
let turn_mut = Arc::get_mut(&mut turn).expect("turn should be unique");
turn_mut.config = Arc::new(config);
update_turn_settings_for_test(turn_mut, |settings| {
Arc::make_mut(&mut settings.model_info).slug = model.to_owned();
});
let mut context = GuardianReviewContext::from(&turn);
context.reasoning_effort = Some(ReasoningEffort::High);
context.reasoning_summary = ReasoningSummary::Detailed;
context.personality = Some(codex_protocol::config_types::Personality::Friendly);
let (review_model, model_info) = resolve_review_model(session.as_ref(), &context)
.await
.unwrap();
assert_eq!(
(
model_info.resolved_context_window(),
model_info.auto_compact_token_limit()
),
(Some(128_000), Some(90_000))
);
let guardian_config = guardian_review_session_config(
session.as_ref(),
&context,
ReviewRetrieval::ConversationHistory,
)
.await
.expect("guardian config")
.spawn_config;
let request = super::review_session::review_turn(
session.as_ref(),
&context,
&guardian_config,
&review_model,
Vec::new(),
serde_json::json!({}),
);
assert_eq!(
(
request.thread_settings.summary,
request.thread_settings.personality
),
(Some(ReasoningSummary::default()), None)
);
assert_eq!(
(
guardian_config.async_compaction_threshold_percent,
guardian_config.features.enabled(Feature::AsyncCompaction),
guardian_config
.features
.enabled(Feature::AsyncCompactionRootOnly),
),
(
crate::config::DEFAULT_ASYNC_COMPACTION_THRESHOLD_PERCENT,
false,
false
)
);
assert_eq!(
guardian_config.model.as_deref(),
Some(context.model_info.slug.as_str())
);
let instructions = guardian_config
.base_instructions
.as_deref()
.expect("review instructions");
assert!(instructions.contains("Managed Guardian policy."));
assert!(!instructions.contains("Actor Guardian policy."));
assert!(guardian_config.compact_prompt.is_none());
let mut expected_provider = provider;
expected_provider.request_max_retries = Some(1);
expected_provider.stream_max_retries = Some(1);
assert_eq!(
(
guardian_config.model_context_window,
guardian_config.model_auto_compact_token_limit,
guardian_config.model_auto_compact_token_limit_scope,
guardian_config.tool_output_token_limit,
guardian_config.model_reasoning_effort,
guardian_config.model_reasoning_summary,
guardian_config.personality,
guardian_config.model_provider,
),
(
None,
None,
AutoCompactTokenLimitScope::Total,
None,
Some(ReasoningEffort::Low),
Some(ReasoningSummary::default()),
None,
expected_provider
)
);
}
#[tokio::test]
async fn guardian_review_session_config_uses_live_network_proxy_state() {
let mut parent_config = test_config().await;
+1
View File
@@ -62,6 +62,7 @@ pub use codex_thread::GuardianAuthorizationVersion;
pub use codex_thread::GuardianRootMessage;
pub use codex_thread::GuardianRootSnapshot;
pub use codex_thread::ThreadConfigSnapshot;
pub use guardian::GuardianInferenceContext;
pub use guardian::ScoreAuthorization as GuardianScoreAuthorization;
pub use guardian::guardian_policy_model;
pub use session::turn_context::TurnContext;
+6 -3
View File
@@ -38,13 +38,16 @@ pub(crate) async fn context_window_token_status(
pub(crate) async fn context_window_token_status_for_model(
sess: &Session,
config: &Config,
turn_context: &TurnContext,
actor_turn: Option<&TurnContext>,
model_info: &ModelInfo,
) -> ContextWindowTokenStatus {
let Some(actor_turn) = actor_turn else {
return context_window_token_status_with_config(sess, config, model_info).await;
};
let mut config = config.clone();
config.token_budget = super::token_budget::resolve_token_budget(
turn_context.configured_token_budget.as_ref(),
turn_context.use_model_token_budget_defaults,
actor_turn.configured_token_budget.as_ref(),
actor_turn.use_model_token_budget_defaults,
model_info,
);
context_window_token_status_with_config(sess, &config, model_info).await
@@ -38,6 +38,7 @@ async fn guardian_checkpoint_preserves_live_context_without_storage(
state.history = ContextManager::for_session(
/*root_capabilities_restricted*/ false,
&crate::config::ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
uuid_v7_item_id_generator_for_test(),
);
@@ -111,6 +112,7 @@ async fn guardian_checkpoint_preserves_live_context_without_storage(
fork.state.lock().await.history = ContextManager::for_session(
/*root_capabilities_restricted*/ false,
&crate::config::ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
uuid_v7_item_id_generator_for_test(),
);
+24 -10
View File
@@ -1036,12 +1036,27 @@ impl Session {
let enable_full_access_form_input = !root_capabilities_restricted
&& matches!(thread_source.as_ref(), Some(ThreadSource::User))
&& client_mcp_extensions.contains(OPENAI_STANDARD_FORM_INPUT_EXTENSION_ID);
let provider_auth = codex_model_provider::ProviderAuthContext {
credentials: Arc::clone(&auth_manager),
runtime_auth: configured_runtime.map(|runtime| (runtime, config.runtime_auth_mode)),
};
let provider_auth = thread_extension_init
.get::<crate::guardian::GuardianReviewerInference>()
.map_or_else(
|| codex_model_provider::ProviderAuthContext {
credentials: Arc::clone(&auth_manager),
runtime_auth: configured_runtime
.map(|runtime| (runtime, config.runtime_auth_mode)),
},
|inference| inference.0.auth.clone(),
);
// Replace any inherited context before startup hooks see this thread's effective auth.
thread_extension_init.insert(provider_auth.clone());
if config.guardian_model_provider.is_some()
&& thread_extension_init
.get::<crate::guardian::GuardianInferenceContext>()
.is_none()
{
return Err(CodexErr::InvalidRequest(
"host-selected Guardian inference context is not initialized".to_string(),
));
}
let session_configuration = SessionConfiguration {
turn_extension_init,
provider: provider_auth.model_provider(config.model_provider.clone()),
@@ -2049,14 +2064,13 @@ impl Session {
// checkpoint can make reconstruction depend on reviewer compatibility.
let reviewer_compaction_hash = if codex_history::CompactionCheckpoint::latest(&history)
.is_some_and(codex_history::CompactionCheckpoint::is_usable)
&& turn_context
.config
.features
.enabled(Feature::GuardianReuseParentCompaction)
&& turn_context.config.guardian_reuses_parent_compaction()
{
let context = crate::guardian::GuardianReviewContext::from(turn_context);
let (_, reviewer) = crate::guardian::resolve_review_model(self, &context).await;
reviewer.comp_hash.clone()
crate::guardian::resolve_review_model(self, &context)
.await
.ok()
.and_then(|(_, reviewer)| reviewer.comp_hash.clone())
} else {
None
};
@@ -199,6 +199,7 @@ impl Session {
ContextManager::for_session(
turn_context.root_capabilities_restricted,
&turn_context.config.features,
turn_context.config.guardian_reuses_parent_compaction(),
turn_context.config.guardian_context_budgeting(),
// Reconstructing retained evidence may mint temporary revisions before restoring
// the durable originals. Replay must not consume the live thread's item sequence.
@@ -129,6 +129,7 @@ async fn sender_context_follows_its_delivery_through_checkpoint_and_rollback() {
let mut live = ContextManager::for_session(
/*root_capabilities_restricted*/ false,
&crate::config::ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
uuid_v7_item_id_generator_for_test(),
);
+7 -1
View File
@@ -1611,6 +1611,7 @@ impl Session {
ContextManager::for_session(
session_configuration.root_capabilities_restricted,
&config.features,
config.guardian_reuses_parent_compaction(),
config.guardian_context_budgeting(),
Arc::clone(&item_id_generator),
),
@@ -1886,7 +1887,12 @@ impl Session {
.enabled(Feature::ConcurrentReasoningSummaries),
config.features.enabled(Feature::OutputTokenReplay),
attestation_provider.clone(),
config.http_client_factory(),
thread_extension_data
.get::<crate::guardian::GuardianReviewerInference>()
.map_or_else(
|| config.http_client_factory(),
|inference| inference.0.http_client_factory.clone(),
),
workspace_routing.as_ref().clone(),
extensions.model_request_contributors().to_vec(),
)
+2
View File
@@ -6910,6 +6910,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
state.history = ContextManager::for_session(
session_configuration.root_capabilities_restricted,
&config.features,
config.guardian_reuses_parent_compaction(),
config.guardian_context_budgeting(),
Arc::clone(&item_id_generator),
);
@@ -9268,6 +9269,7 @@ where
state.history = ContextManager::for_session(
session_configuration.root_capabilities_restricted,
&config.features,
config.guardian_reuses_parent_compaction(),
config.guardian_context_budgeting(),
Arc::clone(&item_id_generator),
);
+88 -33
View File
@@ -1158,8 +1158,9 @@ impl ThreadManager {
/// Select the app-server catalog using the same owner as thread requests.
pub fn models_manager_for_config(&self, config: &Config) -> SharedModelsManager {
self.state.model_catalog.for_config(
config,
&config.model_provider,
config.model_catalog.as_ref(),
config.features.enabled(Feature::ApiKeyModelDiscovery),
self.catalog_auth_context(config),
/*same_owner*/ true,
)
@@ -1180,17 +1181,8 @@ impl ThreadManager {
}
fn catalog_auth_context(&self, config: &Config) -> ProviderAuthContext {
let credentials = self.auth_manager();
let runtime = crate::runtime_auth::runtime_for_config(
&self.state.runtime_auth,
config,
Arc::clone(&credentials),
&self.state.installation_id,
);
ProviderAuthContext {
credentials,
runtime_auth: runtime.map(|runtime| (runtime, config.runtime_auth_mode)),
}
self.state
.thread_provider_auth(config, &self.state.auth_manager, &self.state.runtime_auth)
}
/// Resolves the model before starting or cold-resuming a thread with this manager's credentials.
@@ -1221,8 +1213,7 @@ impl ThreadManager {
.state
.models_for_thread(
&options.config,
&self.state.auth_manager,
&self.state.runtime_auth,
&self.catalog_auth_context(&options.config),
&originator,
&source,
)
@@ -2069,27 +2060,44 @@ impl ThreadManagerState {
async fn models_for_thread(
&self,
config: &Config,
auth_manager: &Arc<AuthManager>,
runtime_auth: &crate::runtime_auth::RuntimeAuthSlot,
provider_auth: &ProviderAuthContext,
originator: &str,
session_source: &SessionSource,
) -> SharedModelsManager {
let manager = self.model_catalog.for_thread(
&config.model_provider,
config.model_catalog.as_ref(),
config.features.enabled(Feature::ApiKeyModelDiscovery),
provider_auth.clone(),
Arc::ptr_eq(&provider_auth.credentials, &self.auth_manager),
originator,
);
if session_source.is_non_root_agent() {
// The final provider/auth/originator catalog may be new even when the base
// manager was reused. Preserve loaded snapshots, including unsaved updates.
manager
.ensure_initialized(config.http_client_factory())
.await;
}
manager
}
fn thread_provider_auth(
&self,
config: &Config,
auth_manager: &Arc<AuthManager>,
runtime_auth: &crate::runtime_auth::RuntimeAuthSlot,
) -> ProviderAuthContext {
let runtime = crate::runtime_auth::runtime_for_config(
runtime_auth,
config,
Arc::clone(auth_manager),
&self.installation_id,
);
self.model_catalog
.for_thread(
config,
Arc::clone(auth_manager),
runtime,
Arc::ptr_eq(auth_manager, &self.auth_manager),
originator,
session_source,
)
.await
ProviderAuthContext {
credentials: Arc::clone(auth_manager),
runtime_auth: runtime.map(|runtime| (runtime, config.runtime_auth_mode)),
}
}
pub(crate) fn shared_thread_instructions_provider(
@@ -2993,6 +3001,18 @@ impl ThreadManagerState {
} else {
Arc::new(mcp_manager.for_plugins_manager(Arc::clone(&plugins_manager)))
};
let inherited_guardian =
thread_extension_init.get::<crate::guardian::GuardianReviewerInference>();
if inherited_guardian.is_some()
&& !matches!(
&session_source,
SessionSource::Internal(InternalSessionSource::Guardian)
)
{
return Err(CodexErr::InvalidRequest(
"a shared Guardian catalog requires an internal Guardian reviewer".to_string(),
));
}
let models_manager = tokio::select! {
biased;
_ = agent_control.runtime().shutdown.cancelled() => {
@@ -3001,13 +3021,48 @@ impl ThreadManagerState {
}
return Err(CodexErr::TurnAborted);
}
manager = self.models_for_thread(
&config,
&auth_manager,
&runtime_auth,
&startup_context.originator,
&session_source,
) => manager,
manager = async {
let provider_auth = self.thread_provider_auth(&config, &auth_manager, &runtime_auth);
if let Some(guardian_provider) = &config.guardian_model_provider {
let provider = provider_auth.model_provider(guardian_provider.info.clone());
// A trusted provider catalog must not read snapshots from the Actor's cache.
let mut settings = codex_models_manager::manager::ModelCatalogSettings::default();
settings.skip_bundled_seed = guardian_provider.info.model_catalog_url.is_some();
settings.api_key_model_discovery_default = config
.config_layer_stack
.requirements_toml()
.feature_requirements
.as_ref()
.and_then(|requirements| requirements.entries.get(Feature::ApiKeyModelDiscovery.key()))
.copied()
.unwrap_or(true);
let guardian_catalog = provider.models_manager_with_settings(
/*config_model_catalog*/ None,
settings,
);
let guardian_catalog = guardian_catalog
.for_originator(&startup_context.originator)
.unwrap_or(guardian_catalog);
thread_extension_init.insert(crate::guardian::GuardianInferenceContext::resolve(
&config,
guardian_provider,
provider_auth.clone(),
provider,
guardian_catalog,
));
}
if let Some(inference) = inherited_guardian {
Arc::clone(&inference.0.models_manager)
} else {
self.models_for_thread(
&config,
&provider_auth,
&startup_context.originator,
&session_source,
)
.await
}
} => manager,
};
let registered = Arc::new(AtomicBool::new(false));
thread_extension_init.insert(ThreadRegistrationReceipt(Arc::clone(&registered)));
@@ -12,7 +12,6 @@ use codex_model_provider_info::ModelProviderInfo;
use codex_models_manager::manager::ModelCatalogSettings;
use codex_models_manager::manager::SharedModelsManager;
use codex_protocol::openai_models::ModelsResponse;
use codex_protocol::protocol::SessionSource;
use codex_runtime_agent_instance::RuntimeAuthManager;
use std::sync::Arc;
@@ -116,56 +115,48 @@ impl ThreadModelCatalog {
}
}
#[allow(clippy::too_many_arguments)]
pub(super) async fn for_thread(
pub(super) fn for_thread(
&self,
config: &Config,
credentials: Arc<AuthManager>,
runtime: Option<Arc<RuntimeAuthManager>>,
provider: &ModelProviderInfo,
configured_catalog: Option<&ModelsResponse>,
api_key_model_discovery_default: bool,
auth: ProviderAuthContext,
same_owner: bool,
originator: &str,
session_source: &SessionSource,
) -> SharedModelsManager {
let models = config.model_catalog.as_ref().or_else(|| {
let models = configured_catalog.or_else(|| {
self.catalog
.as_ref()
.filter(|_| self.matches_catalog_provider(&config.model_provider))
.filter(|_| self.matches_catalog_provider(provider))
});
let auth = ProviderAuthContext {
credentials,
runtime_auth: runtime.map(|runtime| (runtime, config.runtime_auth_mode)),
};
let manager = self.for_config(config, models, auth, same_owner);
let manager = manager.for_originator(originator).unwrap_or(manager);
if session_source.is_non_root_agent() {
// The final provider/auth/originator catalog may be new even when the base
// manager was reused. Preserve loaded snapshots, including unsaved updates.
manager
.ensure_initialized(config.http_client_factory())
.await;
}
manager
let manager = self.for_config(
provider,
models,
api_key_model_discovery_default,
auth,
same_owner,
);
manager.for_originator(originator).unwrap_or(manager)
}
pub(super) fn for_config(
&self,
config: &Config,
provider: &ModelProviderInfo,
models: Option<&ModelsResponse>,
api_key_model_discovery_default: bool,
auth: ProviderAuthContext,
same_owner: bool,
) -> SharedModelsManager {
let api_key_model_discovery_default =
config.features.enabled(Feature::ApiKeyModelDiscovery);
if same_owner
&& self.runtime_mode == auth.runtime_auth.as_ref().map(|(_, mode)| *mode)
&& self.matches_catalog_provider(&config.model_provider)
&& self.matches_catalog_provider(provider)
&& self.catalog.as_ref() == models
&& self.api_key_model_discovery_default == api_key_model_discovery_default
{
return Arc::clone(&self.manager);
}
self.factory.build(
auth.model_provider(config.model_provider.clone()),
auth.model_provider(provider.clone()),
models.cloned(),
api_key_model_discovery_default,
)
+14 -2
View File
@@ -1,5 +1,8 @@
use std::sync::Arc;
use codex_core::TurnInputRequest;
use codex_core::config::Constrained;
use codex_core::config::GuardianInferenceProvider;
use codex_exec_server::CreateDirectoryOptions;
use codex_features::Feature;
use codex_protocol::config_types::ApprovalsReviewer;
@@ -35,8 +38,10 @@ use core_test_support::test_codex::test_codex;
use core_test_support::wait_for_event;
use pretty_assertions::assert_eq;
#[test_case::test_case(false; "ordinary")]
#[test_case::test_case(true; "explicit_guardian")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn codex_delegate_ignores_legacy_deltas() {
async fn codex_delegate_ignores_legacy_deltas(explicit_guardian: bool) {
skip_if_no_network!();
// Single response with reasoning summary deltas.
@@ -50,7 +55,14 @@ async fn codex_delegate_ignores_legacy_deltas() {
let server = start_mock_server().await;
mount_sse_sequence(&server, vec![sse_stream]).await;
let mut builder = test_codex();
let mut builder = test_codex().with_config(move |config| {
if explicit_guardian {
config.guardian_model_provider = Some(Arc::new(GuardianInferenceProvider {
id: "guardian".to_string(),
info: config.model_provider.clone(),
}));
}
});
let test = builder.build(&server).await.expect("build test codex");
// Kick off review (delegated).
@@ -4,23 +4,42 @@ use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::Duration;
use anyhow::Context;
use anyhow::Result;
use codex_config::FeatureRequirementsToml;
use codex_config::RequirementSource;
use codex_config::Sourced;
use codex_core::TurnInputRequest;
use codex_core::config::Config;
use codex_core::config::Constrained;
use codex_core::config::GuardianInferenceProvider;
use codex_core::config::ManagedFeatures;
use codex_core::context::NodeReplReviewEvidence;
use codex_features::Feature;
use codex_history::CodexHarnessMetadata;
use codex_history::CompactedItem;
use codex_history::InitialHistory;
use codex_history::ResponseItemEnvelope;
use codex_history::ResumedHistory;
use codex_history::RetainedContextEvent;
use codex_history::RolloutItem;
use codex_history::VerifiedAnswer;
use codex_history::VerifiedQuestionAnswer;
use codex_login::CodexAuth;
use codex_otel::MetricsClient;
use codex_otel::MetricsConfig;
use codex_protocol::ResponseItemId;
use codex_protocol::approvals::GuardianAssessmentStatus;
use codex_protocol::approvals::GuardianReviewReason;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::models::ImageReference;
use codex_protocol::models::NetworkPermissions;
use codex_protocol::models::PermissionProfile;
use codex_protocol::models::ResponseItem;
use codex_protocol::openai_models::GuardianModelPolicy;
use codex_protocol::openai_models::GuardianReviewMode;
use codex_protocol::openai_models::InputModality;
use codex_protocol::openai_models::ModelsResponse;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ThreadSettingsOverrides;
@@ -39,6 +58,7 @@ use core_test_support::skip_if_no_network;
use core_test_support::skip_if_target_windows;
use core_test_support::streaming_sse::StreamingSseChunk;
use core_test_support::streaming_sse::start_streaming_sse_server;
use core_test_support::test_codex::TestCodex;
use core_test_support::test_codex::test_codex;
use core_test_support::wait_for_event;
use opentelemetry_sdk::metrics::data::AggregatedMetrics;
@@ -48,11 +68,431 @@ use serde_json::json;
use tokio::sync::oneshot;
use tokio::time::timeout;
use wiremock::Mock;
use wiremock::MockServer;
use wiremock::Request;
use wiremock::ResponseTemplate;
use wiremock::matchers::body_partial_json;
use wiremock::matchers::method;
use wiremock::matchers::path;
const BYO_ACTOR_MODEL: &str = "external-actor";
const LUNA_MODEL: &str = "gpt-5.6-luna";
const GUARDIAN_SCREENSHOT: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg==";
const BYO_HEADERS: [(&str, &str); 2] = [
("x-byo-key", "actor-only"),
("authorization", "Bearer actor-only"),
];
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn compacted_cold_resume_respects_guardian_provider_override() -> Result<()> {
skip_if_no_network!(Ok(()));
let actor = responses::start_mock_server().await;
let guardian = responses::start_mock_server().await;
let guardian_url = format!("{}/v1", guardian.uri());
let builder = || {
let guardian_url = guardian_url.clone();
test_codex()
.with_model_info_override(BYO_ACTOR_MODEL, |model| {
model.guardian = Some(GuardianModelPolicy {
computer_use: Some(GuardianReviewMode::Adaptive),
..Default::default()
});
})
.with_config(move |config| {
configure_explicit_guardian_provider(config, &guardian_url);
config
.features
.enable(Feature::GuardianV2)
.expect("enable scoring");
pin_guardian_parent_compaction_reuse(config);
config.guardian_policy_config = None;
config.approvals_reviewer = ApprovalsReviewer::User;
config.permissions.approval_policy =
Constrained::allow_any(AskForApproval::OnRequest);
config
.permissions
.set_permission_profile(PermissionProfile::read_only())
.expect("set permissions");
})
};
let test = builder().build_with_auto_env(&actor).await?;
let mut compacted: CompactedItem = serde_json::from_value(json!({"message": ""}))?;
compacted.replacement_history = Some(vec![ResponseItemEnvelope {
item: ResponseItem::Compaction {
id: Some(ResponseItemId::with_suffix("cmp", "checkpoint")),
encrypted_content: "opaque checkpoint".to_owned(),
internal_chat_message_metadata_passthrough: None,
},
metadata: Some(CodexHarnessMetadata {
compaction_model_hash: Some("reviewer".to_owned()),
..Default::default()
}),
}]);
test.codex.ensure_rollout_materialized().await;
test.codex
.append_rollout_items(&[RolloutItem::Compacted(Box::new(compacted))])
.await?;
let resumed = builder().restart_with_auto_env(&actor, &test).await?;
let snapshot = resumed.codex.conversation_history_snapshot().await;
let checkpoint = snapshot
.latest_compaction()
.context("restored opaque checkpoint")?;
assert!(checkpoint.is_usable());
assert!(snapshot.uses_independent_review_history());
assert!(
resumed
.codex
.config()
.await
.features
.enabled(Feature::GuardianReuseParentCompaction),
"the managed feature must remain enabled",
);
resumed.codex.shutdown_and_wait().await?;
assert!(
guardian
.received_requests()
.await
.expect("record Guardian requests")
.is_empty(),
"compacted cold resume should not request Guardian /models"
);
Ok(())
}
fn pin_guardian_parent_compaction_reuse(config: &mut Config) {
config.features = ManagedFeatures::from_configured_with_warnings(
config.features.get().clone(),
Some(Sourced::new(
FeatureRequirementsToml {
entries: BTreeMap::from([(
Feature::GuardianReuseParentCompaction.key().to_owned(),
true,
)]),
..Default::default()
},
RequirementSource::EnterpriseManaged {
id: "test".to_owned(),
name: "test".to_owned(),
},
)),
&mut Vec::new(),
)
.expect("pin parent compaction reuse");
}
fn configure_explicit_guardian_provider(config: &mut Config, guardian_url: &str) {
let mut provider = config.model_provider.clone();
provider.base_url = Some(guardian_url.to_owned());
provider.model_catalog_url = Some(format!("{guardian_url}/models").into());
provider.supports_websockets = false;
provider.http_headers = None;
config.guardian_model_provider = Some(Arc::new(GuardianInferenceProvider {
id: "responsesapi".to_owned(),
info: provider,
}));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn explicit_guardian_provider_is_separate() -> Result<()> {
let actor_model_name = LUNA_MODEL;
let actor_context_window = Some(11_000);
skip_if_no_network!(Ok(()));
let actor = responses::start_mock_server().await;
let guardian = MockServer::start().await;
let guardian_url = format!("{}/v1", guardian.uri());
let mut reviewer_model = codex_models_manager::bundled_models_response()?
.models
.into_iter()
.find(|model| model.slug == LUNA_MODEL)
.expect("bundled Luna model");
reviewer_model.supported_in_api = true;
reviewer_model.use_responses_lite = false;
reviewer_model.input_modalities = vec![InputModality::Text, InputModality::Image];
let messages = reviewer_model.model_messages.get_or_insert_default();
messages.auto_review = Some(
serde_json::from_value(json!({"policy": "Trusted Guardian catalog policy."}))
.expect("catalog policy"),
);
let catalog = ModelsResponse {
models: vec![reviewer_model],
};
responses::mount_models_once(&guardian, catalog.clone()).await;
let builder = |guardian_url: &str| {
let guardian_url = guardian_url.to_owned();
test_codex()
.with_pre_build_hook(|home| {
std::fs::write(
home.join("config.toml"),
r#"[auto_review]
policy = "Actor config policy."
[features]
guardian_enhanced_node_repl_transcripts = true
guardian_node_repl_transcript_images = true
[features.guardianv2]
enabled = true
"#,
)
.expect("write Guardian configuration");
})
.with_model_info_override(actor_model_name, move |actor_model| {
actor_model.input_modalities = vec![InputModality::Text];
actor_model.guardian = Some(GuardianModelPolicy::default());
let messages = actor_model.model_messages.get_or_insert_default();
messages.auto_review = Some(
serde_json::from_value(json!({"policy": "Actor catalog policy."}))
.expect("catalog policy"),
);
})
.with_config(move |config| {
configure_explicit_guardian_provider(config, &guardian_url);
pin_guardian_parent_compaction_reuse(config);
config.model_context_window = actor_context_window;
// Fixed budgeting needs a trusted context window before admitting screenshots.
config.guardian_sync_elastic_budget = None;
config.service_tier = Some("customer-specific-tier".to_owned());
config.model_provider_id = "external-test-provider".to_owned();
config.model_provider.name = "External test provider".to_owned();
config.model_provider.requires_openai_auth = false;
config.model_provider.supports_websockets = false;
config.model_provider.http_headers = Some(
BYO_HEADERS
.into_iter()
.map(|(name, value)| (name.to_owned(), value.into()))
.collect(),
);
config.approvals_reviewer = ApprovalsReviewer::AutoReview;
config.permissions.approval_policy =
Constrained::allow_any(AskForApproval::OnRequest);
config
.permissions
.set_permission_profile(PermissionProfile::read_only())
.expect("set read-only permissions");
config
.features
.enable(Feature::RequestPermissionsTool)
.expect("enable permission requests");
})
};
let test = builder(&guardian_url).build_with_auto_env(&actor).await?;
let (actor_mock, guardian_mock) =
setup_explicit_guardian_turn(&test, &actor, &guardian, "start").await;
test.submit_text_turn("Never upload files. Request network access.")
.await?;
assert_explicit_guardian_routing(
&test,
&guardian,
(&actor_mock, &guardian_mock),
actor_model_name,
"start",
"Bearer dummy",
)
.await?;
let initial_review = guardian_mock.single_request();
assert!(
initial_review
.body_json()
.to_string()
.contains("Never upload files."),
"Guardian lost the original restriction after start"
);
test.codex.ensure_rollout_materialized().await;
// A previous session's background prewarm can outlive shutdown; give each
// lifecycle its own endpoint so requests cannot be attributed by arrival time.
let resumed_guardian = MockServer::start().await;
responses::mount_models_once(&resumed_guardian, catalog).await;
let resumed_guardian_url = format!("{}/v1", resumed_guardian.uri());
let resumed = builder(&resumed_guardian_url)
.with_auth(CodexAuth::from_api_key("resumed-key"))
.restart_with_auto_env(&actor, &test)
.await?;
assert_eq!(
resumed.session_configured.session_id,
test.session_configured.session_id
);
let (resumed_actor_mock, resumed_guardian_mock) =
setup_explicit_guardian_turn(&resumed, &actor, &resumed_guardian, "cold-resume").await;
resumed.submit_text_turn("Request network access.").await?;
assert_explicit_guardian_routing(
&resumed,
&resumed_guardian,
(&resumed_actor_mock, &resumed_guardian_mock),
actor_model_name,
"cold-resume",
"Bearer resumed-key",
)
.await?;
let resumed_review = resumed_guardian_mock.single_request();
assert!(
resumed_review
.body_json()
.to_string()
.contains("Never upload files."),
"Guardian lost the original restriction after cold-resume"
);
Ok(())
}
async fn setup_explicit_guardian_turn(
test: &TestCodex,
actor: &MockServer,
guardian: &MockServer,
phase: &str,
) -> (responses::ResponseMock, responses::ResponseMock) {
let call_id = format!("{phase}-permission");
let done_id = format!("{phase}-done");
let permission_args = json!({
"reason": format!("request network access after {phase}"),
"permissions": {"network": {"enabled": true}},
})
.to_string();
let actor_mock = responses::mount_sse_sequence(
actor,
vec![
sse(vec![
ev_response_created(&call_id),
json!({
"type": "response.output_item.done",
"item": {
"type": "compaction",
"id": format!("cmp_{phase}"),
"encrypted_content": "actor-only-checkpoint",
},
}),
ev_function_call(&call_id, "request_permissions", &permission_args),
ev_completed(&call_id),
]),
sse(vec![
ev_response_created(&done_id),
ev_assistant_message(&done_id, "Finished."),
ev_completed(&done_id),
]),
],
)
.await;
let blocking = responses::mount_sse_once(guardian, sse(vec![
ev_response_created("reviewer"),
ev_assistant_message("reviewer", r#"{"risk_level":"high","user_authorization":"low","outcome":"deny","rationale":"Test review."}"#),
ev_completed("reviewer"),
])).await;
test.codex
.thread_extension_data()
.get_or_init(NodeReplReviewEvidence::default)
.record(
"cua_repl.js",
phase,
&call_id,
vec![UserInput::Image {
image: ImageReference::Inline {
image_url: GUARDIAN_SCREENSHOT.to_owned(),
},
detail: None,
}],
);
(actor_mock, blocking)
}
async fn assert_explicit_guardian_routing(
test: &TestCodex,
guardian: &MockServer,
(actor_mock, blocking): (&responses::ResponseMock, &responses::ResponseMock),
actor_model_name: &str,
phase: &str,
guardian_auth: &str,
) -> Result<()> {
let snapshot = test.codex.conversation_history_snapshot().await;
assert!(snapshot.uses_independent_review_history());
let checkpoint = snapshot
.latest_compaction()
.context("actor stream checkpoint was not recorded")?;
assert!(matches!(
checkpoint.item,
ResponseItem::Compaction { encrypted_content, .. }
if encrypted_content == "actor-only-checkpoint"
));
let actor_requests = actor_mock.requests();
for request in &actor_requests {
let body = request.body_json();
assert_eq!(body["model"], actor_model_name);
assert!(!body.to_string().contains("Trusted Guardian"));
for (name, value) in BYO_HEADERS {
assert_eq!(request.header(name).as_deref(), Some(value));
}
}
let guardian_requests = guardian
.received_requests()
.await
.expect("record Guardian requests");
assert_guardian_headers(&guardian_requests, guardian_auth);
assert_eq!(
guardian_requests
.iter()
.filter(|request| request.url.path() == "/v1/models")
.count(),
1,
"catalog should be fetched once after {phase}"
);
assert_eq!(
responses::received_responses_requests(guardian).await.len(),
1,
"blocking layer must not classify"
);
let review = blocking.single_request();
let body = review.body_json();
let serialized = body.to_string();
assert!(
body["service_tier"].is_null(),
"Guardian inherited the actor tier after {phase}"
);
assert!(
serialized.contains("Trusted Guardian catalog policy."),
"{serialized}"
);
assert!(
!serialized.contains("Actor config") && !serialized.contains("Actor catalog"),
"{serialized}"
);
assert_eq!(
(&body["model"], &body["text"]["format"]["type"]),
(&json!(LUNA_MODEL), &json!("json_schema"))
);
assert!(
body["input"]
.as_array()
.expect("Guardian input")
.iter()
.all(|item| !matches!(
item["type"].as_str(),
Some("compaction" | "context_compaction")
)),
"Guardian reused an actor checkpoint after {phase}"
);
assert_eq!(
review.message_input_image_urls("user"),
[GUARDIAN_SCREENSHOT],
"blocking review should use the Guardian catalog's image support after {phase}",
);
Ok(())
}
fn assert_guardian_headers(requests: &[Request], expected_auth: &str) {
for request in requests {
assert!(!request.headers.contains_key("x-byo-key"));
assert!(
request.headers["authorization"] == expected_auth,
"incorrect Guardian authorization for {} {}",
request.method,
request.url.path(),
);
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn delayed_score_only_covers_the_tool_call_it_classified() -> Result<()> {
skip_if_no_network!(Ok(()));
@@ -318,6 +318,65 @@ async fn guardian_session_inherits_parent_http_fallback(
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn explicit_guardian_does_not_inherit_actor_inline_catalog_with_same_provider_info()
-> Result<()> {
skip_if_no_network!(Ok(()));
const MODEL: &str = "gpt-5.6-luna";
let server = wiremock::MockServer::start().await;
let mut actor_model = codex_models_manager::model_info::model_info_from_slug(MODEL);
actor_model.context_window = Some(11_000);
let mut guardian_model = actor_model.clone();
guardian_model.context_window = Some(73_000);
let catalog = mount_models_once(
&server,
ModelsResponse {
models: vec![guardian_model],
},
)
.await;
let url = format!("{}/v1/models", server.uri());
let test = test_codex()
.with_model(MODEL)
.with_config(move |config| {
config
.features
.enable(Feature::ApiKeyModelDiscovery)
.expect("enable discovery");
config.model_provider.model_catalog_url = Some(url.into());
config.model_catalog = Some(ModelsResponse {
models: vec![actor_model],
});
let info = config.model_provider.clone();
config.guardian_model_provider =
Some(Arc::new(codex_core::config::GuardianInferenceProvider {
id: "host-guardian".to_owned(),
info,
}));
})
.build_with_auto_env(&server)
.await?;
let guardian = test
.codex
.thread_extension_data()
.get::<codex_core::GuardianInferenceContext>()
.context("host Guardian route installed at thread start")?;
guardian
.models_manager
.ensure_initialized(guardian.http_client_factory.clone())
.await;
let model = guardian
.models_manager
.get_model_info(MODEL, &Default::default())
.await;
assert_eq!(
(model.origin, model.context_window, catalog.requests().len()),
(ModelOrigin::Provider, Some(73_000), 1),
"Guardian should use the provider catalog even when it shares the actor endpoint",
);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[test_case(ModelOrigin::Bundled, "gateway-main"; "bundled_reviewer_falls_back")]
#[test_case(ModelOrigin::Provider, "codex-auto-review"; "advertised_reviewer")]
@@ -75,6 +75,8 @@ pub(crate) use circuit_breaker::GuardianRejectionCircuitBreakerAction;
pub(crate) use circuit_breaker::GuardianRejectionCircuitBreakerPolicy;
pub use metrics::token_usage_delta;
pub use model::ReviewModel;
pub use model::preferred_reasoning_effort;
pub use model::select_catalog_reviewer;
pub use model::select_review_model;
pub use outcome::GuardianReviewError;
pub use outcome::GuardianReviewOutcome;
+30 -19
View File
@@ -14,6 +14,33 @@ pub struct ReviewModel {
pub model_override: Option<String>,
}
/// Selects the eligible entry with the lowest priority value for the requested slug.
pub fn select_catalog_reviewer(
available_models: Vec<CatalogModel>,
model_id: &str,
) -> Option<CatalogModel> {
available_models
.into_iter()
.filter(|entry| entry.slug == model_id)
.min_by_key(|entry| entry.priority)
}
/// Prefers low effort when supported, otherwise preserving the caller's fallback.
pub fn preferred_reasoning_effort(
model: &ModelInfo,
fallback: Option<ReasoningEffort>,
) -> Option<ReasoningEffort> {
if model
.supported_reasoning_levels
.iter()
.any(|preset| preset.effort == ReasoningEffort::Low)
{
Some(ReasoningEffort::Low)
} else {
fallback
}
}
/// Prefers the review model and low effort when advertised; preserves the parent fallback.
/// Returns the matching catalog entry so its metadata comes from the same selection.
pub fn select_review_model(
@@ -22,30 +49,17 @@ pub fn select_review_model(
default_review_model_id: &str,
available_models: Vec<CatalogModel>,
) -> (ReviewModel, Option<CatalogModel>) {
let preferred_reasoning_effort = |supports_low: bool, fallback| {
if supports_low {
Some(codex_protocol::openai_models::ReasoningEffort::Low)
} else {
fallback
}
};
let model_override = parent_model.auto_review_model_override.as_deref();
let review_model_id = model_override.unwrap_or(default_review_model_id);
let guardian_catalog_contains_auto_review = available_models
.iter()
.any(|entry| entry.slug == default_review_model_id);
let reviewer = available_models
.into_iter()
.filter(|entry| entry.slug == review_model_id)
.min_by_key(|entry| entry.priority);
let reviewer = select_catalog_reviewer(available_models, review_model_id);
let guardian_review_model_overridden = model_override.is_some();
let guardian_review_model_override = model_override.map(str::to_string);
let (guardian_model, guardian_reasoning_effort) = if let Some(model) = &reviewer {
let reasoning_effort = preferred_reasoning_effort(
model
.supported_reasoning_levels
.iter()
.any(|effort| effort.effort == codex_protocol::openai_models::ReasoningEffort::Low),
model,
Some(
model
.default_reasoning_level
@@ -56,10 +70,7 @@ pub fn select_review_model(
(review_model_id.to_string(), reasoning_effort)
} else {
let reasoning_effort = preferred_reasoning_effort(
parent_model
.supported_reasoning_levels
.iter()
.any(|preset| preset.effort == codex_protocol::openai_models::ReasoningEffort::Low),
parent_model,
parent_reasoning_effort
.or(parent_model.default_reasoning_level.as_ref())
.cloned(),
@@ -80,15 +80,24 @@ impl GuardianApprovalReviewer {
.map_or_else(|| GuardianV2Config::resolve(config), Ok)
.ok();
let requirements = config.config_layer_stack.requirements();
let mut policy = guardian_config.as_ref().map_or_else(
|| {
codex_config::GuardianPolicyLoader::new(Some(
&codex_features::FeatureToml::Enabled(true),
))
.resolve(model.as_deref(), requirements)
},
|config| config.policy_for_model(model.as_deref(), requirements),
);
let mut policy = if config.guardian_model_provider.is_some() {
let mut policy = codex_config::GuardianPolicyLoader::new(Some(
&codex_features::FeatureToml::Enabled(true),
))
.resolve(/*model*/ None, requirements);
policy.disable_scoring();
policy
} else {
guardian_config.as_ref().map_or_else(
|| {
codex_config::GuardianPolicyLoader::new(Some(
&codex_features::FeatureToml::Enabled(true),
))
.resolve(model.as_deref(), requirements)
},
|config| config.policy_for_model(model.as_deref(), requirements),
)
};
// Live mandatory restrictions may harden the turn's captured policy.
thread
.config()
@@ -305,7 +305,7 @@ impl Classification {
let review_model = if config.guardian_policy_config.is_none()
&& let Some(parent_model) = parent_model.as_ref()
{
Some(codex_core::guardian_policy_model(&thread, &config, Arc::clone(parent_model)).await)
Some(codex_core::guardian_policy_model(&thread, &config, Arc::clone(parent_model)).await.map_err(|error| error.to_string())?)
} else {
None
};
@@ -45,7 +45,9 @@ impl ThreadLifecycleContributor<Config> for GuardianV2Extension {
input: ThreadStartInput<'a, Config>,
) -> ExtensionFuture<'a, ()> {
Box::pin(async move {
if !input.config.features.enabled(Feature::GuardianApproval) {
if !input.config.features.enabled(Feature::GuardianApproval)
|| input.config.guardian_model_provider.is_some()
{
return;
}
@@ -45,13 +45,20 @@ pub(crate) fn build_reviewer_config(parent_config: &Config) -> anyhow::Result<Co
Feature::GuardianV2,
Feature::TokenBudget,
Feature::ContextManagement,
Feature::AsyncCompaction,
Feature::AsyncCompactionRootOnly,
Feature::CodexHooks,
Feature::Apps,
Feature::Plugins,
Feature::WebSearchRequest,
Feature::WebSearchCached,
] {
if feature == Feature::Apps && conversation_history_tools {
if (feature == Feature::Apps && conversation_history_tools)
|| (matches!(
feature,
Feature::AsyncCompaction | Feature::AsyncCompactionRootOnly
) && parent_config.guardian_model_provider.is_none())
{
continue;
}
config.features.disable(feature).map_err(|err| {
+6 -1
View File
@@ -378,6 +378,7 @@ impl CatalogSource {
pub struct ModelCatalogSettings {
cache: Option<Arc<dyn ModelsCache>>,
pub api_key_model_discovery_default: bool,
pub skip_bundled_seed: bool,
// Before the host publishes a live change, each thread uses its configured default.
live_discovery: Arc<std::sync::Mutex<Option<bool>>>,
}
@@ -487,7 +488,11 @@ impl OpenAiModelsManager {
etag: None,
client_version: Some(crate::client_version_to_whole()),
identity: endpoint_client.identity(),
models: BUNDLED_MODELS.to_vec(),
models: if settings.skip_bundled_seed {
Vec::new()
} else {
BUNDLED_MODELS.to_vec()
},
})),
settings,
endpoint_client,
+10 -3
View File
@@ -590,9 +590,16 @@ async fn initialization_retains_loaded_catalogs_including_empty_responses() {
vec![remote_model("remote", "Remote", /*priority*/ 0)],
] {
let endpoint = TestModelsEndpoint::new(vec![models.clone()]);
let manager =
OpenAiModelsManager::new_without_cache(endpoint.clone(), /*auth_manager*/ None)
.with_provider_catalog();
let manager = OpenAiModelsManager::with_settings(
ModelCatalogSettings {
skip_bundled_seed: true,
..Default::default()
},
endpoint.clone(),
/*auth_manager*/ None,
);
assert!(manager.remote_models.read().await.entry.models.is_empty());
let manager = manager.with_provider_catalog();
manager
.ensure_initialized(DEFAULT_HTTP_CLIENT_FACTORY)
.await;
@@ -257,6 +257,7 @@ async fn new_config(
async_compaction_threshold_percent: 65,
model_provider_id,
model_provider,
guardian_model_provider: None,
personality: None,
permissions: Permissions::from_approval_and_profile(
Constrained::allow_any(AskForApproval::Never),