mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
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:
@@ -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
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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(),
|
||||
);
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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,
|
||||
)?;
|
||||
|
||||
@@ -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 = ¶ms.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() {
|
||||
¶ms.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(),
|
||||
¶ms.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(),
|
||||
¶ms.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(¶ms.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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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(),
|
||||
);
|
||||
|
||||
@@ -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(),
|
||||
);
|
||||
|
||||
@@ -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(),
|
||||
)
|
||||
|
||||
@@ -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),
|
||||
);
|
||||
|
||||
@@ -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(®istered)));
|
||||
|
||||
@@ -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,
|
||||
)
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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),
|
||||
|
||||
Reference in New Issue
Block a user