Restrict enterprise MCP auth and fail closed on config refresh (#49260)

## Why

Configuration reloads must honor current managed restrictions without granting new enterprise MCP authority to existing sessions or overwriting newer configuration with stale snapshots.

## What changed

- Allow enterprise managed authentication only for configured MCP servers. Remove plugin `ema_auth` overlays from the schema and disable servers that still use them.
- Refresh ordinary MCP settings while preserving session settings and initially admitted enterprise registrations. Disable enterprise MCP when its registration changes, policy revokes access, or configuration loading or resolution fails; require a new session to restore enterprise authority.
- Publish refreshes only when their captured configuration is still current, with bounded retries in app-server reloads. Preserve updated managed restrictions even when a refresh is rejected.
- Finish processing other thread refreshes before `config/mcpServer/reload` reports a rejection, and document that an error can accompany partially applied changes.

## Testing

Add regression coverage for stale refreshes, bounded retries, managed-policy revocation, persistent enterprise disablement, ordinary MCP transport changes, and rejection of plugin enterprise authentication. Verify that denied enterprise servers receive no requests.

GitOrigin-RevId: 34429cd339c1ec152a2ee8697cb29f0cff5d9e5f
This commit is contained in:
Nick Steele
2026-09-29 13:08:37 +00:00
committed by copyberry
parent 4f16bdc265
commit af0d68a236
46 changed files with 1803 additions and 788 deletions
+39 -5
View File
@@ -161,6 +161,18 @@ pub struct CodexThreadSettingsOverrides {
pub disabled_plugin_ids: Option<Vec<String>>,
}
/// Result of publishing a loaded configuration snapshot for a thread.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[must_use]
pub enum ConfigRefreshOutcome {
/// The resolved configuration was published.
Published,
/// The captured owner changed; the caller must reload before retrying.
Stale,
/// Resolution failed and a configuration disabling enterprise MCP was published.
Rejected,
}
pub use codex_guardian_context::GuardianRootMessage;
/// Authorization state that changes on genuine user input or history resets.
@@ -985,14 +997,36 @@ impl CodexThread {
/// Refresh the thread's layer-backed user config state from a caller-supplied
/// config snapshot. Thread-scoped layers and session-static settings remain
/// unchanged.
pub async fn refresh_runtime_config(&self, next_config: crate::config::Config) {
self.session.refresh_runtime_config(next_config).await;
/// unchanged. A stale owner requires reloading from the current config before retrying.
pub async fn refresh_runtime_config(
&self,
expected_config: Arc<crate::config::Config>,
next_config: crate::config::Config,
) -> ConfigRefreshOutcome {
Box::pin(
self.session
.refresh_runtime_config(expected_config, next_config),
)
.await
}
/// Revokes enterprise MCP authority from the current owner after a failed reload.
pub async fn disable_mcp_enterprise_auth(&self) {
self.session.disable_mcp_enterprise_auth().await;
}
/// Refresh MCP configuration and managed requirements without reloading unrelated settings.
pub async fn refresh_mcp_config(&self, next_config: crate::config::Config) {
self.session.refresh_mcp_config(next_config).await;
/// A stale owner requires reloading from the current config before retrying.
pub async fn refresh_mcp_config(
&self,
expected_config: Arc<crate::config::Config>,
next_config: crate::config::Config,
) -> ConfigRefreshOutcome {
Box::pin(
self.session
.refresh_mcp_config(expected_config, next_config),
)
.await
}
/// Refreshes this thread's Apps tools before returning their runtime state.
+3 -2
View File
@@ -143,9 +143,10 @@ async fn local_compaction_respects_tool_metadata_state(
assert!(metadata_bytes > 2 * 1024 * 1024);
if !metadata_enabled {
let mut config = (*session.get_config().await).clone();
let current_config = session.get_config().await;
let mut config = current_config.as_ref().clone();
config.features.disable(Feature::ExecutedToolCallMetadata)?;
session.refresh_runtime_config(config).await;
let _ = session.refresh_runtime_config(current_config, config).await;
}
let mock = responses::mount_sse_once(
@@ -118,6 +118,28 @@ impl ManagedFeatures {
self.set(next)
}
/// Refresh ordinary MCP feature values and pins without changing session-static features.
pub(crate) fn refresh_mcp_features(&mut self, next: &Self) -> ConstraintResult<()> {
let mut refreshed = self.clone();
let mut values = self.get().clone();
for feature in [
Feature::EnableMcpApps,
Feature::SecretAuthStorage,
Feature::McpOAuthRefreshCoordination,
] {
values.set_enabled(feature, next.enabled(feature));
if let Some(enabled) = next.pinned_features.get(&feature) {
refreshed.pinned_features.insert(feature, *enabled);
} else {
refreshed.pinned_features.remove(&feature);
}
}
refreshed.value.source = next.value.source.clone().or(refreshed.value.source);
refreshed.set(values)?;
*self = refreshed;
Ok(())
}
pub fn enable(&mut self, feature: Feature) -> ConstraintResult<()> {
self.set_enabled(feature, /*enabled*/ true)
}
+2
View File
@@ -176,6 +176,8 @@ mod permission_profile_selection;
mod permissions;
mod requirements;
mod resolved_permission_profile;
mod runtime_refresh;
pub(crate) use runtime_refresh::RuntimeConfigRefresh;
#[cfg(test)]
mod schema;
mod token_budget_startup;
+171
View File
@@ -0,0 +1,171 @@
//! Resolves refreshable MCP inputs without rebuilding unrelated session configuration.
//! Existing sessions refresh ordinary MCP state without gaining enterprise authority.
use crate::config::Config;
use crate::config::ManagedFeatures;
use crate::config::constrain_mcp_servers;
use crate::config::resolve_tool_suggest_config_from_layer_stack;
use codex_config::McpServerAuth;
use codex_config::McpServerConfig;
use codex_features::Feature;
use codex_features::FeatureConfigSource;
use codex_features::FeatureOverrides;
use codex_features::Features;
use codex_features::FeaturesToml;
use serde::Deserialize;
use std::collections::HashMap;
#[cfg(test)]
#[path = "runtime_refresh_tests.rs"]
mod tests;
#[derive(Clone, Copy)]
pub(crate) enum RuntimeConfigRefresh {
User,
Mcp,
}
#[derive(Default, Deserialize)]
#[serde(default)]
struct McpRefreshToml {
features: Option<FeaturesToml>,
}
impl Config {
pub(crate) fn resolve_runtime_refresh(
&self,
incoming: &Self,
scope: RuntimeConfigRefresh,
) -> std::io::Result<Self> {
let layers = match scope {
RuntimeConfigRefresh::User => self
.config_layer_stack
.with_user_layer_from(&incoming.config_layer_stack),
RuntimeConfigRefresh::Mcp => Self::layer_stack_preserving_session(
&self.config_layer_stack,
&incoming.config_layer_stack,
)?
.with_user_layer_from(&self.config_layer_stack),
};
let cfg: McpRefreshToml = layers
.effective_config()
.try_into()
.map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidData, err))?;
let mut configured_features = Features::from_sources(
FeatureConfigSource {
features: cfg.features.as_ref(),
..Default::default()
},
FeatureConfigSource::default(),
FeatureOverrides::default(),
);
// These existing operational controls also accept host runtime overrides.
// Enterprise opt-in always comes from trusted layers instead.
for feature in [
Feature::SecretAuthStorage,
Feature::McpOAuthRefreshCoordination,
] {
// A publication wait may have allowed a newer host/user override.
configured_features.set_enabled(feature, incoming.features.enabled(feature));
}
let features = ManagedFeatures::from_configured(
configured_features,
layers.requirements().feature_requirements.clone(),
)?;
let is_enterprise = |server: &McpServerConfig| {
matches!(server.auth, McpServerAuth::EmaAuth) || server.ema_registration().is_some()
};
// Refresh ordinary servers from the complete host-owned set. Keep the
// initially admitted EMA configuration until a fresh session is constructed.
let mut servers: HashMap<_, _> = incoming
.mcp_servers
.get()
.iter()
.filter(|(name, server)| {
!is_enterprise(server)
&& !self.mcp_servers.get().get(*name).is_some_and(is_enterprise)
})
.map(|(name, server)| (name.clone(), server.clone()))
.collect();
servers.extend(
self.mcp_servers
.get()
.iter()
.filter(|(_, server)| is_enterprise(server))
.map(|(name, server)| (name.clone(), server.clone())),
);
let mut config = self.clone();
config
.features
.refresh_mcp_features(&features)
.map_err(std::io::Error::other)?;
config.mcp_servers =
constrain_mcp_servers(servers, layers.requirements().mcp_servers.as_ref())
.map_err(std::io::Error::other)?;
// A missing profile also carries the host's fail-closed load result.
let enterprise_retired = incoming.mcp_enterprise_managed_auth.is_none()
|| !incoming.features.enabled(Feature::UseXaa)
|| (self
.mcp_servers
.get()
.values()
.any(|server| is_enterprise(server) && server.enabled)
&& incoming.mcp_enterprise_managed_auth != self.mcp_enterprise_managed_auth)
|| self.mcp_servers.get().iter().any(|(name, server)| {
is_enterprise(server)
&& server.enabled
&& !incoming
.mcp_servers
.get()
.get(name)
.is_some_and(|incoming| {
incoming.enabled
&& incoming.auth == server.auth
&& incoming.transport == server.transport
&& incoming.oauth_resource == server.oauth_resource
&& incoming.oauth == server.oauth
&& incoming.scopes == server.scopes
&& incoming.environment_id == server.environment_id
&& incoming.ema_registration() == server.ema_registration()
})
})
|| self.mcp_servers.get().iter().any(|(name, server)| {
is_enterprise(server)
&& server.enabled
&& !config
.mcp_servers
.get()
.get(name)
.is_some_and(|server| server.enabled)
});
config.mcp_optional_startup_grace = incoming.mcp_optional_startup_grace;
config.mcp_oauth_credentials_store_mode = incoming.mcp_oauth_credentials_store_mode;
if !matches!(scope, RuntimeConfigRefresh::Mcp) {
config.active_project = incoming.active_project.clone();
config.tool_suggest = resolve_tool_suggest_config_from_layer_stack(&layers);
}
config.config_layer_stack = layers;
if enterprise_retired {
config.disable_mcp_enterprise_auth();
}
Ok(config)
}
/// Disables enterprise MCP authorization while preserving unrelated MCP servers.
pub fn disable_mcp_enterprise_auth(&mut self) {
self.mcp_enterprise_managed_auth = None;
let mut servers = self.mcp_servers.get().clone();
for server in servers.values_mut() {
if matches!(server.auth, McpServerAuth::EmaAuth) || server.ema_registration().is_some()
{
server.enabled = false;
if let Some(oauth) = &mut server.oauth {
oauth.ema_registration = None;
}
}
}
if self.mcp_servers.set(servers).is_err() {
tracing::warn!("failed to clear disabled enterprise registrations");
}
}
}
@@ -0,0 +1,237 @@
//! Ordinary refresh resolution and enterprise revocation without Session construction.
use super::*;
use crate::config::ConfigBuilder;
use codex_config::CONFIG_TOML_FILE;
use codex_config::ConfigLayerSource;
use codex_config::test_support::CloudConfigBundleFixture;
use codex_core_plugins::PluginLoadOutcome;
use pretty_assertions::assert_eq;
async fn base_config() -> (tempfile::TempDir, Config) {
let home = tempfile::tempdir().unwrap();
let config = ConfigBuilder::without_managed_config_for_tests()
.codex_home(home.path().to_path_buf())
.fallback_cwd(Some(home.path().to_path_buf()))
.build()
.await
.unwrap();
(home, config)
}
async fn layered_config(
base: &Config,
user: &str,
managed: &str,
requirements: &str,
session: &str,
) -> Config {
std::fs::write(base.codex_home.join(CONFIG_TOML_FILE), user).unwrap();
let overrides: toml::Table = toml::from_str(session).unwrap();
ConfigBuilder::without_managed_config_for_tests()
.codex_home(base.codex_home.to_path_buf())
.fallback_cwd(Some(base.cwd.to_path_buf()))
.cli_overrides(overrides.into_iter().collect())
.cloud_config_bundle(
CloudConfigBundleFixture::enterprise_config(managed)
.add_enterprise_requirement(format!("[features]\n{requirements}"))
.into_loader(),
)
.build()
.await
.unwrap()
}
fn enterprise_config(issuer: &str, resource: &str) -> String {
format!(
"[features]\nuse_xaa = true\napps = false\nsecret_auth_storage = false\n\
[mcp_servers.enterprise]\nurl = 'https://resource.example/mcp'\nauth = 'ema_auth'\n\
oauth_resource = '{resource}'\n\
[mcp_enterprise_managed_auth.idp]\nissuer = '{issuer}'\nclient_id = '{issuer}-client'\n"
)
}
fn runtime_servers(config: &Config) -> HashMap<String, McpServerConfig> {
codex_mcp::configured_mcp_servers(
&config.to_mcp_config_with_loaded_plugins(&PluginLoadOutcome::default(), []),
)
}
#[test_case::test_case(RuntimeConfigRefresh::User; "user refresh")]
#[test_case::test_case(RuntimeConfigRefresh::Mcp; "MCP refresh")]
#[tokio::test]
async fn refresh_honors_fresh_managed_denial(scope: RuntimeConfigRefresh) {
let (_home, base) = base_config().await;
let enterprise = enterprise_config("https://idp.example", "resource");
let current = layered_config(&base, &enterprise, "", "use_xaa = true", "").await;
let next = layered_config(&base, &enterprise, "", "use_xaa = false", "").await;
let refreshed = current.resolve_runtime_refresh(&next, scope).unwrap();
assert!(!runtime_servers(&refreshed)["enterprise"].enabled);
assert!(refreshed.mcp_enterprise_managed_auth.is_none());
assert_eq!(refreshed.model, current.model);
}
#[tokio::test]
async fn refresh_honors_disabled_enterprise_host_load_result() {
let (_home, base) = base_config().await;
let current = layered_config(
&base,
&enterprise_config("https://idp.example", "resource"),
"",
"",
"",
)
.await;
let mut failed = current.clone();
failed.disable_mcp_enterprise_auth();
let refreshed = current
.resolve_runtime_refresh(&failed, RuntimeConfigRefresh::Mcp)
.unwrap();
assert!(refreshed.mcp_enterprise_managed_auth.is_none());
assert!(!runtime_servers(&refreshed)["enterprise"].enabled);
}
#[tokio::test]
async fn ordinary_transport_transitions_use_the_resolved_incoming_map() {
let (_home, base) = base_config().await;
let command = "[mcp_servers.ordinary]\ncommand = 'ordinary-server'";
let url = "[mcp_servers.ordinary]\nurl = 'https://ordinary.example/mcp'";
for scope in [RuntimeConfigRefresh::User, RuntimeConfigRefresh::Mcp] {
let (current, incoming) = match scope {
RuntimeConfigRefresh::User => (
layered_config(&base, "", "", "", url).await,
layered_config(&base, command, "", "", "").await,
),
RuntimeConfigRefresh::Mcp => (
layered_config(&base, command, "", "", "").await,
layered_config(&base, "", url, "", "").await,
),
};
let refreshed = current.resolve_runtime_refresh(&incoming, scope).unwrap();
assert_eq!(refreshed.mcp_servers.get(), incoming.mcp_servers.get());
}
}
#[tokio::test]
async fn mcp_refresh_preserves_current_user_and_session_layers_without_reopening_ema() {
let (_home, base) = base_config().await;
let current = layered_config(
&base,
&enterprise_config("https://current-idp.example", "current-resource"),
"",
"",
"[mcp_servers.enterprise]\nenabled = false",
)
.await;
let next = layered_config(
&base,
&enterprise_config("https://old-idp.example", "old-resource"),
"",
"",
"",
)
.await;
let refreshed = current
.resolve_runtime_refresh(&next, RuntimeConfigRefresh::Mcp)
.unwrap();
let preserved_layers = |config: &Config| {
config
.config_layer_stack
.all_layers_low_to_high()
.filter(|layer| {
matches!(
layer.name,
ConfigLayerSource::User { .. } | ConfigLayerSource::SessionFlags
)
})
.cloned()
.collect::<Vec<_>>()
};
assert_eq!(preserved_layers(&refreshed), preserved_layers(&current));
let server = &runtime_servers(&refreshed)["enterprise"];
assert!(!server.enabled);
assert_eq!(
server.ema_registration(),
runtime_servers(&current)["enterprise"].ema_registration()
);
}
#[test_case::test_case("removed"; "removed")]
#[test_case::test_case("disabled"; "disabled")]
#[test_case::test_case("resource"; "resource changed")]
#[test_case::test_case("transport"; "transport changed")]
#[test_case::test_case("scopes"; "scopes changed")]
#[test_case::test_case("oauth"; "OAuth client changed")]
#[test_case::test_case("idp"; "IdP changed")]
#[tokio::test]
async fn refresh_revokes_changed_enterprise_admission(change: &str) {
let (_home, base) = base_config().await;
let current = layered_config(
&base,
&enterprise_config("https://idp.example", "resource"),
"",
"",
"",
)
.await;
let mut incoming = current.clone();
let mut servers = incoming.mcp_servers.get().clone();
match change {
"removed" => {
servers.remove("enterprise");
}
"disabled" => servers.get_mut("enterprise").unwrap().enabled = false,
"resource" => servers.get_mut("enterprise").unwrap().oauth_resource = Some("other".into()),
"scopes" => servers.get_mut("enterprise").unwrap().scopes = Some(vec!["other".into()]),
"oauth" => {
servers
.get_mut("enterprise")
.unwrap()
.oauth
.get_or_insert_default()
.client_id = Some("other-client".into())
}
"idp" => {
incoming
.mcp_enterprise_managed_auth
.as_mut()
.unwrap()
.idp
.client_id = "other-client".into()
}
"transport" => {
let codex_config::McpServerTransportConfig::StreamableHttp { url, .. } =
&mut servers.get_mut("enterprise").unwrap().transport
else {
unreachable!()
};
*url = "https://other.example/mcp".into();
}
_ => unreachable!(),
}
incoming.mcp_servers.set(servers).unwrap();
for scope in [RuntimeConfigRefresh::User, RuntimeConfigRefresh::Mcp] {
let revoked = current.resolve_runtime_refresh(&incoming, scope).unwrap();
assert!(revoked.mcp_enterprise_managed_auth.is_none());
assert!(!runtime_servers(&revoked)["enterprise"].enabled);
let restored = revoked.resolve_runtime_refresh(&current, scope).unwrap();
assert!(restored.mcp_enterprise_managed_auth.is_none());
assert!(!runtime_servers(&restored)["enterprise"].enabled);
}
}
#[tokio::test]
async fn mcp_refresh_preserves_apps_until_new_session() {
let (_home, base) = base_config().await;
let current = layered_config(&base, "[features]\napps = true", "", "", "").await;
let next = layered_config(&base, "[features]\napps = true", "", "apps = false", "").await;
let refreshed = current
.resolve_runtime_refresh(&next, RuntimeConfigRefresh::Mcp)
.unwrap();
assert!(refreshed.features.enabled(Feature::Apps));
let reloaded = refreshed
.resolve_runtime_refresh(&next, RuntimeConfigRefresh::User)
.unwrap();
assert!(reloaded.features.enabled(Feature::Apps));
assert!(!next.features.enabled(Feature::Apps));
}
+3 -2
View File
@@ -3449,7 +3449,8 @@ async fn guardian_review_routes_required_actions(
| RequiredGuardianReview::LiveManagedModelWithGuardianV2 => {
Arc::make_mut(&mut context.model_info).slug = "required-action-model".to_string();
// The admitted turn has neither this model nor the new requirement.
let mut config = session.get_config().await.as_ref().clone();
let current_config = session.get_config().await;
let mut config = current_config.as_ref().clone();
let requirements = codex_config::ConfigRequirements {
auto_review_required_models: Some(Sourced::new(
std::collections::BTreeSet::from([context.model_info.slug.clone()]),
@@ -3466,7 +3467,7 @@ async fn guardian_review_routes_required_actions(
requirements,
config.config_layer_stack.requirements_toml().clone(),
)?;
session.refresh_mcp_config(config).await;
let _ = session.refresh_mcp_config(current_config, config).await;
(
guardian_exec_command_request("shell-live-managed-model"),
ApprovalRequestReasons::default(),
+1
View File
@@ -47,6 +47,7 @@ pub use codex_protocol::protocol::EnvironmentConfig;
pub use codex_thread::BackgroundTerminalInfo;
pub use codex_thread::CodexThread;
pub use codex_thread::CodexThreadSettingsOverrides;
pub use codex_thread::ConfigRefreshOutcome;
pub use codex_thread::GuardianAuthorizationVersion;
pub use codex_thread::GuardianRootMessage;
pub use codex_thread::GuardianRootSnapshot;
+147
View File
@@ -0,0 +1,147 @@
//! Publishes resolved MCP configuration while preserving session-static settings.
use std::sync::Arc;
use crate::ConfigRefreshOutcome;
use crate::config::Config;
use crate::config::Constrained;
use crate::config::RuntimeConfigRefresh;
use crate::session::Session;
use codex_config::McpServerAuth;
use codex_features::Feature;
use tracing::warn;
impl Session {
pub(crate) async fn disable_mcp_enterprise_auth(&self) {
let mut state = self.state.lock().await;
let mut config = state
.session_configuration
.original_config_do_not_use
.as_ref()
.clone();
config.disable_mcp_enterprise_auth();
state.session_configuration.original_config_do_not_use = Arc::new(config);
self.services.mcp_runtime.invalidate_resource_caches();
self.mark_mcp_runtime_dirty();
drop(state);
self.schedule_mcp_prewarm();
}
pub(crate) async fn refresh_runtime_config(
&self,
expected_config: Arc<Config>,
next_config: Config,
) -> ConfigRefreshOutcome {
self.refresh_config(expected_config, next_config, RuntimeConfigRefresh::User)
.await
}
pub(crate) async fn refresh_mcp_config(
&self,
expected_config: Arc<Config>,
next_config: Config,
) -> ConfigRefreshOutcome {
self.refresh_config(expected_config, next_config, RuntimeConfigRefresh::Mcp)
.await
}
pub(super) async fn refresh_config(
&self,
expected_config: Arc<Config>,
next_config: Config,
scope: RuntimeConfigRefresh,
) -> ConfigRefreshOutcome {
let (mut config, outcome, rejection_kind) =
match expected_config.resolve_runtime_refresh(&next_config, scope) {
Ok(config) => (config, ConfigRefreshOutcome::Published, None),
Err(error) => {
let mut config = expected_config.as_ref().clone();
if matches!(scope, RuntimeConfigRefresh::Mcp) {
// The host-resolved map already carries fresh requirements and
// preserved session overrides. Keep ordinary-server revocations even
// when retained layers make the enterprise merge invalid.
let mut refreshed_servers = next_config.mcp_servers.clone();
let mut servers = refreshed_servers.get().clone();
// Retain enterprise identities so a later corrected refresh cannot
// admit an ordinary-auth replacement under a retired server's name.
for (name, server) in expected_config.mcp_servers.get() {
if matches!(server.auth, McpServerAuth::EmaAuth)
|| server.ema_registration().is_some()
{
let mut retired = server.clone();
retired.enabled = false;
servers.insert(name.clone(), retired);
}
}
config.mcp_servers = if refreshed_servers.set(servers).is_ok() {
refreshed_servers
} else {
Constrained::allow_any(Default::default())
};
}
config.config_layer_stack = config
.config_layer_stack
.with_mcp_requirements_from(&next_config.config_layer_stack);
if let Err(err) = config.features.refresh_mcp_features(&next_config.features) {
warn!(%err, "failed to apply managed MCP feature restrictions");
config.mcp_servers = Constrained::allow_any(Default::default());
}
config.disable_mcp_enterprise_auth();
(config, ConfigRefreshOutcome::Rejected, Some(error.kind()))
}
};
for (feature, description) in [
(Feature::Mcp20260728, "MCP protocol"),
(Feature::CodexAppsMcp20260728, "Codex Apps MCP protocol"),
] {
if let Err(err) = config
.features
.set_enabled(feature, next_config.features.enabled(feature))
{
warn!("failed to refresh {description} config: {err}");
}
}
let config = Arc::new(config);
let notify_contributors = !matches!(scope, RuntimeConfigRefresh::Mcp)
&& !self.services.extensions.config_contributors().is_empty();
let (previous_config, new_config) = {
let mut state = self.state.lock().await;
// Loaded snapshots can publish only while their captured owner is current.
if !Arc::ptr_eq(
&state.session_configuration.original_config_do_not_use,
&expected_config,
) {
return ConfigRefreshOutcome::Stale;
}
if let Some(rejection_kind) = rejection_kind {
warn!(
?rejection_kind,
"disabling enterprise MCP after rejected configuration refresh"
);
}
// A host refresh carries current rollout settings for recording. A
// legacy file reload uses its original snapshot and bypasses this path.
if matches!(scope, RuntimeConfigRefresh::User) {
self.services
.executed_tool_calls
.refresh(&next_config.features);
}
let previous_config = notify_contributors
.then(|| self.build_effective_session_config(&state.session_configuration));
state.session_configuration.original_config_do_not_use = Arc::clone(&config);
if matches!(scope, RuntimeConfigRefresh::Mcp) {
self.services.mcp_runtime.invalidate_resource_caches();
}
self.mark_mcp_runtime_dirty();
let new_config = notify_contributors
.then(|| self.build_effective_session_config(&state.session_configuration));
(previous_config, new_config)
};
self.emit_config_changed_contributors(previous_config.as_ref(), new_config.as_ref());
self.schedule_mcp_prewarm();
if !matches!(scope, RuntimeConfigRefresh::Mcp) {
self.refresh_hooks(config).await;
}
outcome
}
}
+1 -1
View File
@@ -238,7 +238,7 @@ pub fn refresh_mcp_servers(sess: &Session) {
}
pub async fn reload_user_config(sess: &Arc<Session>) {
sess.reload_user_config_layer().await;
Box::pin(sess.reload_user_config_layer()).await;
}
pub async fn compact(sess: &Arc<Session>, sub_id: String) {
+67 -109
View File
@@ -228,6 +228,7 @@ use codex_protocol::error::Result as CodexResult;
use codex_protocol::exec_output::StreamOutput;
mod code_mode_warning;
mod config_refresh;
pub(crate) mod context_window;
mod daemon_recovery;
mod environment;
@@ -2046,18 +2047,25 @@ impl Session {
state.session_configuration.provider.info().clone()
}
pub(crate) async fn refresh_runtime_config(&self, next_config: Config) {
self.refresh_runtime_config_inner(next_config, /*refresh_recording*/ true)
.await;
}
async fn refresh_runtime_config_inner(&self, next_config: Config, refresh_recording: bool) {
async fn refresh_file_config(
&self,
expected_config: Arc<Config>,
next_config: Config,
) -> crate::ConfigRefreshOutcome {
// Refresh only the user layer from the incoming snapshot. Preserve thread-local
// layers such as request/session overrides that were present when this session
// was created.
let notify_config_contributors = !self.services.extensions.config_contributors().is_empty();
let (previous_config, new_config, config) = {
let mut state = self.state.lock().await;
if !Arc::ptr_eq(
&state.session_configuration.original_config_do_not_use,
&expected_config,
) {
return crate::ConfigRefreshOutcome::Stale;
}
self.services.skills_service.clear_cache();
self.services.plugins_manager.clear_cache();
let previous_config = notify_config_contributors
.then(|| self.build_effective_session_config(&state.session_configuration));
let mut config = (*state.session_configuration.original_config_do_not_use).clone();
@@ -2070,13 +2078,6 @@ impl Session {
config.mcp_servers = next_config.mcp_servers.clone();
config.mcp_optional_startup_grace = next_config.mcp_optional_startup_grace;
config.mcp_oauth_credentials_store_mode = next_config.mcp_oauth_credentials_store_mode;
// Recording can follow rollout changes without changing the session's
// execution features (including Code Mode's dispatch gate).
if refresh_recording {
self.services
.executed_tool_calls
.refresh(&next_config.features);
}
if let Err(err) = config.features.set_enabled(
Feature::Mcp20260728,
next_config.features.enabled(Feature::Mcp20260728),
@@ -2113,6 +2114,7 @@ impl Session {
self.emit_config_changed_contributors(previous_config.as_ref(), new_config.as_ref());
self.schedule_mcp_prewarm();
self.refresh_hooks(config).await;
crate::ConfigRefreshOutcome::Published
}
pub(crate) async fn refresh_hooks(&self, config: Arc<Config>) {
@@ -2139,48 +2141,6 @@ impl Session {
}
}
pub(crate) async fn refresh_mcp_config(&self, next_config: Config) {
let mut state = self.state.lock().await;
let mut config = (*state.session_configuration.original_config_do_not_use).clone();
config.config_layer_stack = next_config
.config_layer_stack
.with_user_layer_from(&config.config_layer_stack);
config.mcp_servers = next_config.mcp_servers;
config.mcp_optional_startup_grace = next_config.mcp_optional_startup_grace;
config.mcp_oauth_credentials_store_mode = next_config.mcp_oauth_credentials_store_mode;
if let Err(err) = config.features.set_enabled(
Feature::Mcp20260728,
next_config.features.enabled(Feature::Mcp20260728),
) {
warn!("failed to refresh MCP protocol config: {err}");
}
if let Err(err) = config.features.set_enabled(
Feature::CodexAppsMcp20260728,
next_config.features.enabled(Feature::CodexAppsMcp20260728),
) {
warn!("failed to refresh Codex Apps MCP protocol config: {err}");
}
if let Err(err) = config.features.set_enabled(
Feature::SecretAuthStorage,
next_config.features.enabled(Feature::SecretAuthStorage),
) {
warn!("failed to refresh MCP auth storage config: {err}");
}
if let Err(err) = config.features.set_enabled(
Feature::McpOAuthRefreshCoordination,
next_config
.features
.enabled(Feature::McpOAuthRefreshCoordination),
) {
warn!("failed to refresh MCP OAuth coordination config: {err}");
}
state.session_configuration.original_config_do_not_use = Arc::new(config);
self.services.mcp_runtime.invalidate_resource_caches();
self.mark_mcp_runtime_dirty();
drop(state);
self.schedule_mcp_prewarm();
}
fn emit_config_changed_contributors(
&self,
previous_config: Option<&Config>,
@@ -2209,55 +2169,55 @@ impl Session {
//
// Prefer `refresh_runtime_config()` when the host can already provide a materialized
// config snapshot. This file-based path exists for legacy local reload flows.
let config_toml_paths = {
let state = self.state.lock().await;
let config = &state.session_configuration.original_config_do_not_use;
let user_config_paths = config
.config_layer_stack
.all_layers_low_to_high()
.filter_map(|layer| match &layer.name {
ConfigLayerSource::User { file, .. } => Some(file.clone()),
_ => None,
})
.collect::<Vec<_>>();
if user_config_paths.is_empty() {
vec![
state
.session_configuration
.codex_home
.join(CONFIG_TOML_FILE),
]
} else {
user_config_paths
}
};
loop {
let (expected_config, config_toml_paths) = {
let state = self.state.lock().await;
let config = Arc::clone(&state.session_configuration.original_config_do_not_use);
let user_config_paths = config
.config_layer_stack
.all_layers_low_to_high()
.filter_map(|layer| match &layer.name {
ConfigLayerSource::User { file, .. } => Some(file.clone()),
_ => None,
})
.collect::<Vec<_>>();
let paths = if user_config_paths.is_empty() {
vec![
state
.session_configuration
.codex_home
.join(CONFIG_TOML_FILE),
]
} else {
user_config_paths
};
(config, paths)
};
let mut reloaded_user_configs = Vec::with_capacity(config_toml_paths.len());
for config_toml_path in config_toml_paths {
let user_config = match std::fs::read_to_string(&config_toml_path) {
Ok(contents) => match toml::from_str::<toml::Value>(&contents) {
Ok(config) => config,
let mut reloaded_user_configs = Vec::with_capacity(config_toml_paths.len());
for config_toml_path in config_toml_paths {
let user_config = match std::fs::read_to_string(&config_toml_path) {
Ok(contents) => match toml::from_str::<toml::Value>(&contents) {
Ok(config) => config,
Err(err) => {
warn!("failed to parse user config while reloading layer: {err}");
return;
}
},
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
toml::Value::Table(Default::default())
}
Err(err) => {
warn!("failed to parse user config while reloading layer: {err}");
warn!("failed to read user config while reloading layer: {err}");
return;
}
},
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
toml::Value::Table(Default::default())
}
Err(err) => {
warn!("failed to read user config while reloading layer: {err}");
return;
}
};
reloaded_user_configs.push((config_toml_path, user_config));
}
};
reloaded_user_configs.push((config_toml_path, user_config));
}
let next_config = {
let state = self.state.lock().await;
let mut config = (*state.session_configuration.original_config_do_not_use).clone();
let mut next_config = expected_config.as_ref().clone();
for (config_toml_path, user_config) in reloaded_user_configs {
let config_layer_stack = match config
let config_layer_stack = match next_config
.config_layer_stack
.with_user_config(&config_toml_path, user_config)
{
@@ -2267,18 +2227,16 @@ impl Session {
return;
}
};
config.config_layer_stack = config_layer_stack;
next_config.config_layer_stack = config_layer_stack;
}
config.tool_suggest =
resolve_tool_suggest_config_from_layer_stack(&config.config_layer_stack);
config
};
self.services.skills_service.clear_cache();
self.services.plugins_manager.clear_cache();
// This legacy snapshot still has the original execution features, not
// the host's latest rollout settings. Leave the live recorder alone.
self.refresh_runtime_config_inner(next_config, /*refresh_recording*/ false)
.await;
next_config.tool_suggest =
resolve_tool_suggest_config_from_layer_stack(&next_config.config_layer_stack);
if self.refresh_file_config(expected_config, next_config).await
!= crate::ConfigRefreshOutcome::Stale
{
return;
}
}
}
/// Record a terminal CodexErr before the app-server completion notification is reduced.
+252 -10
View File
@@ -16,6 +16,7 @@ use crate::agents_md_manager::SessionInstructions;
use crate::compact::InitialContextInjection;
use crate::config::ConfigBuilder;
use crate::config::ConfigOverrides;
use crate::config::RuntimeConfigRefresh;
use crate::context::ContextualUserFragment;
use crate::context::DeveloperInstructions;
use crate::context::TurnAborted;
@@ -2028,8 +2029,11 @@ async fn refresh_runtime_config_refreshes_hooks() -> anyhow::Result<()> {
};
assert!(session.hooks().preview_session_start(&request).is_empty());
let current_config = session.get_config().await;
let next_config = load_latest_config_for_session(&session).await;
session.refresh_runtime_config(next_config).await;
let _ = session
.refresh_runtime_config(current_config, next_config)
.await;
assert_eq!(session.hooks().preview_session_start(&request).len(), 1);
Ok(())
@@ -2089,8 +2093,20 @@ disabled_tools = [
let mut next_config = load_latest_config_for_session(&session).await;
next_config.model = Some("gpt-5.4".to_string());
next_config.notify = Some(vec!["echo".to_string()]);
let mcp_protocol_enabled = !original.features.enabled(Feature::Mcp20260728);
let apps_protocol_enabled = !original.features.enabled(Feature::CodexAppsMcp20260728);
next_config
.features
.set_enabled(Feature::Mcp20260728, mcp_protocol_enabled)
.expect("set MCP protocol rollout");
next_config
.features
.set_enabled(Feature::CodexAppsMcp20260728, apps_protocol_enabled)
.expect("set Codex Apps MCP protocol rollout");
session.refresh_runtime_config(next_config).await;
let _ = session
.refresh_runtime_config(Arc::clone(&original), next_config)
.await;
let config = session.get_config().await;
let apps_toml = config
@@ -2111,6 +2127,14 @@ disabled_tools = [
assert_eq!(app.destructive_enabled, Some(false));
assert_eq!(config.model, original.model);
assert_eq!(config.notify, original.notify);
assert_eq!(
config.features.enabled(Feature::Mcp20260728),
mcp_protocol_enabled
);
assert_eq!(
config.features.enabled(Feature::CodexAppsMcp20260728),
apps_protocol_enabled
);
assert_eq!(
config.tool_suggest.disabled_tools,
vec![
@@ -2120,9 +2144,38 @@ disabled_tools = [
);
}
#[test_case::test_case(false; "published")]
#[test_case::test_case(true; "rejected")]
#[tokio::test]
async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements(reject: bool) {
let (session, _turn_context) = make_session_and_context().await;
let original = session.get_config().await;
if reject {
let mut config = original.as_ref().clone();
let mut layers: Vec<_> = config
.config_layer_stack
.all_layers_low_to_high()
.filter(|layer| !matches!(layer.name, codex_config::ConfigLayerSource::SessionFlags))
.cloned()
.collect();
layers.push(codex_config::ConfigLayerEntry::new(
codex_config::ConfigLayerSource::SessionFlags,
toml::from_str("features = 'invalid retained features'").unwrap(),
));
config.config_layer_stack = ConfigLayerStack::new(
layers,
config.config_layer_stack.requirements().clone(),
config.config_layer_stack.requirements_toml().clone(),
)
.unwrap();
session
.state
.lock()
.await
.session_configuration
.original_config_do_not_use = Arc::new(config);
}
let original = session.get_config().await;
let server = serde_json::from_value::<McpServerConfig>(json!({
"url": "https://example.com/mcp",
"enabled": true
@@ -2137,12 +2190,22 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
codex_config::PluginRequirementsToml {
mcp_servers: Some(std::collections::BTreeMap::from([(
"beta".to_string(),
requirement,
requirement.clone(),
)])),
},
)]);
let mut next_config = session.get_config().await.as_ref().clone();
let mut next_config = original.as_ref().clone();
let mcp_protocol_enabled = !original.features.enabled(Feature::Mcp20260728);
let apps_protocol_enabled = !original.features.enabled(Feature::CodexAppsMcp20260728);
next_config
.features
.set_enabled(Feature::Mcp20260728, mcp_protocol_enabled)
.expect("set MCP protocol rollout");
next_config
.features
.set_enabled(Feature::CodexAppsMcp20260728, apps_protocol_enabled)
.expect("set Codex Apps MCP protocol rollout");
next_config.mcp_servers = codex_config::Constrained::normalized(
HashMap::from([("beta".to_string(), server.clone())]),
|mut servers: HashMap<String, McpServerConfig>| {
@@ -2152,11 +2215,29 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
)
.expect("valid refreshed MCP constraints");
let mut requirements = next_config.config_layer_stack.requirements().clone();
let mcp_requirements = BTreeMap::from([("beta".to_string(), requirement)]);
requirements.mcp_servers = Some(Sourced::new(
mcp_requirements.clone(),
RequirementSource::LegacyManagedConfigTomlFromMdm,
));
requirements.plugins = Some(Sourced::new(
plugin_requirements.clone(),
RequirementSource::LegacyManagedConfigTomlFromMdm,
));
let feature_requirements: codex_config::FeatureRequirementsToml =
serde_json::from_value(json!({"secret_auth_storage": false})).unwrap();
requirements.feature_requirements = Some(Sourced::new(
feature_requirements.clone(),
RequirementSource::LegacyManagedConfigTomlFromMdm,
));
next_config.features = crate::config::ManagedFeatures::from_configured(
next_config.features.get().clone(),
requirements.feature_requirements.clone(),
)
.unwrap();
let mut requirements_toml = next_config.config_layer_stack.requirements_toml().clone();
requirements_toml.feature_requirements = Some(feature_requirements);
requirements_toml.mcp_servers = Some(mcp_requirements);
requirements_toml.plugins = Some(plugin_requirements.clone());
let layers = next_config
.config_layer_stack
@@ -2166,9 +2247,35 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
next_config.config_layer_stack = ConfigLayerStack::new(layers, requirements, requirements_toml)
.expect("managed MCP and plugin requirements");
session.refresh_mcp_config(next_config).await;
let outcome = session
.refresh_mcp_config(Arc::clone(&original), next_config)
.await;
assert_eq!(
outcome,
if reject {
crate::ConfigRefreshOutcome::Rejected
} else {
crate::ConfigRefreshOutcome::Published
}
);
let config = session.get_config().await;
assert!(!config.features.enabled(Feature::SecretAuthStorage));
assert!(
config
.config_layer_stack
.requirements()
.feature_requirements
.is_some()
);
assert_eq!(
config.features.enabled(Feature::Mcp20260728),
mcp_protocol_enabled
);
assert_eq!(
config.features.enabled(Feature::CodexAppsMcp20260728),
apps_protocol_enabled
);
let mut managed_servers = config.mcp_servers.clone();
managed_servers
.set(HashMap::from([
@@ -2176,10 +2283,13 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
("beta".to_string(), server.clone()),
]))
.expect("apply refreshed managed MCP constraints");
assert_eq!(
managed_servers.get(),
&HashMap::from([("beta".to_string(), server.clone())])
assert!(
!managed_servers
.get()
.get("alpha")
.is_some_and(|server| server.enabled)
);
assert_eq!(managed_servers.get()["beta"], server);
assert_eq!(
config
.config_layer_stack
@@ -2197,6 +2307,73 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
config.apply_plugin_mcp_server_requirements("example-plugin", &mut plugin_servers);
assert!(!plugin_servers["alpha"].enabled);
assert!(plugin_servers["beta"].enabled);
let reloaded = config.resolve_runtime_refresh(&config, RuntimeConfigRefresh::User);
if let Ok(reloaded) = reloaded {
assert_eq!(
reloaded.config_layer_stack.requirements().plugins,
config.config_layer_stack.requirements().plugins
);
} else {
assert!(reject);
}
}
#[test_case::test_case(RuntimeConfigRefresh::User; "user refresh")]
#[test_case::test_case(RuntimeConfigRefresh::Mcp; "MCP refresh")]
#[tokio::test]
async fn refresh_config_rejects_stale_owner_without_effects(scope: RuntimeConfigRefresh) {
let (session, _turn_context) = make_session_and_context().await;
let stale_owner = session.get_config().await;
let mut stale_config = stale_owner.as_ref().clone();
stale_config
.features
.set_enabled(
Feature::Mcp20260728,
!stale_owner.features.enabled(Feature::Mcp20260728),
)
.expect("set MCP protocol rollout");
assert_eq!(
session
.refresh_runtime_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
.await,
crate::ConfigRefreshOutcome::Published
);
let current_owner = session.get_config().await;
assert!(session.mcp_refresh.claim());
assert_eq!(
session
.refresh_config(stale_owner, stale_config, scope)
.await,
crate::ConfigRefreshOutcome::Stale
);
assert!(Arc::ptr_eq(&current_owner, &session.get_config().await));
assert!(!session.mcp_refresh.is_pending());
}
#[tokio::test]
async fn refresh_file_config_rejects_stale_owner_without_effects() {
let (session, _turn_context) = make_session_and_context().await;
let stale_owner = session.get_config().await;
assert_eq!(
session
.refresh_runtime_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
.await,
crate::ConfigRefreshOutcome::Published
);
let current_owner = session.get_config().await;
assert!(session.mcp_refresh.claim());
assert_eq!(
session
.refresh_file_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
.await,
crate::ConfigRefreshOutcome::Stale
);
assert!(Arc::ptr_eq(&current_owner, &session.get_config().await));
assert!(!session.mcp_refresh.is_pending());
}
#[test]
@@ -3771,8 +3948,11 @@ disabled_tools = [
"#,
)
.expect("write user config");
let current_config = session.get_config().await;
let next_config = load_latest_config_for_session(&session).await;
session.refresh_runtime_config(next_config).await;
let _ = session
.refresh_runtime_config(current_config, next_config)
.await;
let expected_disabled_tools = vec![
ToolSuggestDisabledTool::connector("calendar"),
@@ -13096,3 +13276,65 @@ async fn session_start_hooks_require_project_trust_without_config_toml() -> std:
Ok(())
}
#[tokio::test]
async fn rejected_mcp_refresh_then_corrected_user_config_blocks_ordinary_replacement() {
let (session, _turn_context) = make_session_and_context().await;
let base = session.get_config().await;
let enterprise: McpServerConfig = serde_json::from_value(json!({
"url": "https://enterprise.example/mcp", "auth": "ema_auth", "enabled": true
}))
.unwrap();
let ordinary: McpServerConfig = serde_json::from_value(json!({
"url": "https://ordinary.example/mcp", "enabled": true
}))
.unwrap();
let mut initial = base.as_ref().clone();
initial.mcp_servers = crate::config::Constrained::allow_any(HashMap::from([(
"enterprise".to_string(),
enterprise,
)]));
initial.config_layer_stack = ConfigLayerStack::new(
vec![codex_config::ConfigLayerEntry::new(
codex_config::ConfigLayerSource::User {
file: initial.codex_home.join(CONFIG_TOML_FILE),
profile: None,
},
toml::from_str("features = 'invalid retained features'").unwrap(),
)],
base.config_layer_stack.requirements().clone(),
base.config_layer_stack.requirements_toml().clone(),
)
.unwrap();
session
.state
.lock()
.await
.session_configuration
.original_config_do_not_use = Arc::new(initial);
let current = session.get_config().await;
let mut corrected = base.as_ref().clone();
corrected.mcp_servers = crate::config::Constrained::allow_any(HashMap::from([(
"enterprise".to_string(),
ordinary,
)]));
assert_eq!(
session.refresh_mcp_config(current, corrected.clone()).await,
crate::ConfigRefreshOutcome::Rejected
);
let rejected = session.get_config().await;
assert!(rejected.mcp_enterprise_managed_auth.is_none());
assert_eq!(
session.refresh_runtime_config(rejected, corrected).await,
crate::ConfigRefreshOutcome::Published
);
let final_config = session.get_config().await;
assert!(
!final_config
.mcp_servers
.get()
.get("enterprise")
.is_some_and(|server| server.enabled),
"rejection must not permit same-name ordinary-auth replacement in this session"
);
}
+13 -6
View File
@@ -361,9 +361,12 @@ async fn direct_results_keep_their_own_records_when_call_ids_repeat() {
}
// Reapplying an enabled config keeps the same recording lifetime.
session
.refresh_runtime_config((*session.get_config().await).clone())
.await;
let current_config = session.get_config().await;
let config = current_config.as_ref().clone();
assert_eq!(
session.refresh_runtime_config(current_config, config).await,
crate::ConfigRefreshOutcome::Published
);
// Await in reverse order: each result must already own its record before history attachment.
let mut outputs = Vec::new();
for (arguments, future) in pending.into_iter().rev() {
@@ -413,12 +416,15 @@ async fn direct_results_keep_their_own_records_when_call_ids_repeat() {
.expect("dispatched direct call"),
);
}
let mut config = (*session.get_config().await).clone();
let current_config = session.get_config().await;
let mut config = current_config.as_ref().clone();
config
.features
.disable(Feature::ExecutedToolCallMetadata)
.expect("disable metadata");
session.refresh_runtime_config(config.clone()).await;
let _ = session
.refresh_runtime_config(current_config, config.clone())
.await;
let result = pending
.remove(0)
.await
@@ -438,7 +444,8 @@ async fn direct_results_keep_their_own_records_when_call_ids_repeat() {
.features
.enable(Feature::ExecutedToolCallMetadata)
.expect("re-enable metadata");
session.refresh_runtime_config(config).await;
let current_config = session.get_config().await;
let _ = session.refresh_runtime_config(current_config, config).await;
let result = pending
.pop()
.expect("call prepared before disable")
@@ -426,6 +426,33 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {
);
}
#[tokio::test]
async fn stale_runtime_refresh_preserves_recording_state() {
let (session, _turn) = crate::session::tests::make_session_and_context().await;
let calls = session.services.executed_tool_calls.clone();
assert!(calls.lock_state().is_none());
let stale_owner = session.get_config().await;
let mut stale_config = stale_owner.as_ref().clone();
stale_config
.features
.enable(Feature::ExecutedToolCallMetadata)
.expect("enable executed tool call metadata");
assert_eq!(
session
.refresh_mcp_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
.await,
crate::ConfigRefreshOutcome::Published
);
assert_eq!(
session
.refresh_runtime_config(stale_owner, stale_config)
.await,
crate::ConfigRefreshOutcome::Stale
);
assert!(calls.lock_state().is_none());
}
#[tokio::test]
async fn recorder_refreshes_without_changing_execution_features_or_claiming_missing_history() {
struct MetadataLookup<'a>(std::cell::Cell<usize>, JsonValue, &'a ExecutedToolCalls);
@@ -462,11 +489,14 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
let mut retry_cache = HashMap::new();
let mut prior_generation = None;
for (index, enabled) in [false, true, false, true].into_iter().enumerate() {
let current_config = session.get_config().await;
next_config
.features
.set_enabled(Feature::ExecutedToolCallMetadata, enabled)
.expect("test feature must be configurable");
session.refresh_runtime_config(next_config.clone()).await;
let _ = session
.refresh_runtime_config(current_config, next_config.clone())
.await;
assert_eq!(calls.lock_state().is_some(), enabled);
// A legacy file reload has no new rollout snapshot and must keep this setting.
session.reload_user_config_layer().await;
@@ -509,6 +539,21 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
);
assert_eq!(tool_calls_complete(&direct_output), enabled.then_some(true));
if enabled {
// Reapplying an enabled config must preserve already-recorded calls.
let prepared = calls.prepare_direct_call(&call, &ToolCallSource::Direct, &step);
let current_config = session.get_config().await;
assert_eq!(
session
.refresh_runtime_config(current_config, next_config.clone())
.await,
crate::ConfigRefreshOutcome::Published
);
let mut replay = output(&call.call_id);
calls.attach_direct_call_to_output(&mut replay, prepared);
assert_eq!(replay, direct_output);
}
let cell = CellId::new(format!("cell-{index}"));
let origin = format!("exec-{index}");
calls.start_cell(&cell, &origin);
@@ -523,7 +568,13 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
nested.set_tool_result_metadata(ToolResultMetadata::new(&json!({})));
if enabled {
// Reapplying an enabled config must preserve pending calls and their metadata.
session.refresh_runtime_config(next_config.clone()).await;
let current_config = session.get_config().await;
assert_eq!(
session
.refresh_runtime_config(current_config, next_config.clone())
.await,
crate::ConfigRefreshOutcome::Published
);
}
calls.finish_cell_recording(&cell);
let mut prompt = vec![exec_input(&origin), exec_output(&origin)];