Lightweight coding agent that runs in your terminal
Rust
Preserve orchestrator skill caches across MCP runtime updates (#46033)
Henry Levy29e6bc814ef2
diff --git a/codex-rs/codex-mcp/src/connection_manager/resources.rs b/codex-rs/codex-mcp/src/connection_manager/resources.rsindex c84cc6b43f..fbb5889d05 100644--- a/codex-rs/codex-mcp/src/connection_manager/resources.rs+++ b/codex-rs/codex-mcp/src/connection_manager/resources.rs@@ -17,9 +17,23 @@ use tracing::warn;use super::McpConnectionSet;use crate::pagination::collect_paginated;+use crate::resource_client::McpResourceServerCacheKey;use crate::rmcp_client::ManagedClient;impl McpConnectionSet {+ pub(crate) fn resource_cache_key(+ &self,+ server: &str,+ generation: u64,+ ) -> Option<McpResourceServerCacheKey> {+ self.servers+ .get(server)+ .map(|view| McpResourceServerCacheKey {+ connection: Arc::downgrade(&view.connection),+ generation,+ })+ }+/// Returns resources from servers selected by `include_server`.pub async fn list_all_resources(&self,diff --git a/codex-rs/codex-mcp/src/lib.rs b/codex-rs/codex-mcp/src/lib.rsindex 8a4f489c90..77dc37f1a6 100644--- a/codex-rs/codex-mcp/src/lib.rs+++ b/codex-rs/codex-mcp/src/lib.rs@@ -18,6 +18,7 @@ pub use resource_client::McpResourceClient;pub use resource_client::McpResourceClientCacheKey;pub use resource_client::McpResourcePage;pub use resource_client::McpResourceReadResult;+pub use resource_client::McpResourceServerCacheKey;pub use rmcp::model::ReadResourceRequestParams;pub use rmcp_client::MCP_SANDBOX_STATE_META_CAPABILITY;pub use runtime::McpRuntime;diff --git a/codex-rs/codex-mcp/src/resource_client.rs b/codex-rs/codex-mcp/src/resource_client.rsindex 3c13695c73..6d2097f79a 100644--- a/codex-rs/codex-mcp/src/resource_client.rs+++ b/codex-rs/codex-mcp/src/resource_client.rs@@ -25,6 +25,7 @@ use tokio::sync::watch;use crate::McpEventStreamOpener;use crate::McpRuntime;use crate::connection_manager::McpConnectionSet;+use crate::connection_manager::McpServerConnection;use crate::mcp::CODEX_APPS_MCP_SERVER_NAME;/// One page of resources returned by an MCP server.@@ -200,6 +201,24 @@ impl PartialEq for McpResourceClientCacheKey {impl Eq for McpResourceClientCacheKey {}+/// Identity of one server's resource cache across MCP runtime publications.+///+/// Survives publications that reuse the same connection until resource caches are explicitly+/// invalidated. The key does not keep superseded connections alive.+#[derive(Clone)]+pub struct McpResourceServerCacheKey {+ pub(crate) connection: Weak<McpServerConnection>,+ pub(crate) generation: u64,+}++impl PartialEq for McpResourceServerCacheKey {+ fn eq(&self, other: &Self) -> bool {+ self.connection.ptr_eq(&other.connection) && self.generation == other.generation+ }+}++impl Eq for McpResourceServerCacheKey {}+impl std::fmt::Debug for McpResourceClient {fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {formatter@@ -219,6 +238,11 @@ impl McpResourceClient {McpResourceClientCacheKey(Arc::downgrade(&self.runtime.latest_connections()))}+ /// Returns a server's resource cache identity without starting its connection.+ pub fn server_cache_key(&self, server: &str) -> Option<McpResourceServerCacheKey> {+ self.runtime.resource_cache_key(server)+ }+/// Returns whether this client can address the named server.////// This does not wait for server startup.diff --git a/codex-rs/codex-mcp/src/runtime.rs b/codex-rs/codex-mcp/src/runtime.rsindex 85cefccf0d..804ae9e38a 100644--- a/codex-rs/codex-mcp/src/runtime.rs+++ b/codex-rs/codex-mcp/src/runtime.rs@@ -12,6 +12,7 @@ use std::sync::Arc;use std::sync::Mutex;use std::sync::Weak;use std::sync::atomic::AtomicBool;+use std::sync::atomic::AtomicU64;use std::sync::atomic::Ordering;use std::time::Duration;@@ -55,6 +56,7 @@ use crate::elicitation::ElicitationRequestRouter;use crate::elicitation::ElicitationReviewerHandle;use crate::event_stream::McpEventStreamOpener;use crate::mcp::CODEX_APPS_MCP_SERVER_NAME;+use crate::resource_client::McpResourceServerCacheKey;use crate::resource_origin::ResourceOrigins;use crate::server::EffectiveMcpServer;use crate::tool_catalog_cache::McpToolCatalogCache;@@ -98,6 +100,7 @@ pub struct McpRuntime {current: ArcSwap<PublishedMcpRuntime>,event_stream_cancellation: Mutex<EventStreamCancellation>,reconnect_pending: AtomicBool,+ resource_cache_generation: AtomicU64,elicitation_router: ElicitationRequestRouter,resource_origins: Mutex<ResourceOrigins>,}@@ -215,6 +218,7 @@ impl McpRuntime {retained_subscription_cancellation: None,}),reconnect_pending: AtomicBool::new(false),+ resource_cache_generation: AtomicU64::new(0),elicitation_router: ElicitationRequestRouter::default(),resource_origins: Mutex::default(),}@@ -357,6 +361,18 @@ impl McpRuntime {self.reconnect_pending.store(true, Ordering::Release);}+ /// Invalidates resource catalogs and contents even when connections can be reused.+ pub fn invalidate_resource_caches(&self) {+ self.resource_cache_generation+ .fetch_add(1, Ordering::AcqRel);+ }++ pub(crate) fn resource_cache_key(&self, server: &str) -> Option<McpResourceServerCacheKey> {+ let generation = self.resource_cache_generation.load(Ordering::Acquire);+ self.latest_connections()+ .resource_cache_key(server, generation)+ }+/// Captures the latest published configuration and live client handles.pub async fn current_binding(&self) -> Option<Arc<McpBinding>> {self.current_binding_with_requirements(&[], &HashSet::new())diff --git a/codex-rs/core/src/session/mcp_prewarm.rs b/codex-rs/core/src/session/mcp_prewarm.rsindex f4b45b6e21..b203472367 100644--- a/codex-rs/core/src/session/mcp_prewarm.rs+++ b/codex-rs/core/src/session/mcp_prewarm.rs@@ -7,6 +7,8 @@ use super::*;impl Session {pub(crate) fn request_mcp_runtime_refresh(&self) {+ // Plugin changes can reuse connections but still change their skill resources.+ self.services.mcp_runtime.invalidate_resource_caches();self.mark_mcp_runtime_dirty();self.schedule_mcp_prewarm();}diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 9af7af1561..8a1679bddc 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -2160,6 +2160,7 @@ impl Session {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();diff --git a/codex-rs/core/tests/suite/skills_extension.rs b/codex-rs/core/tests/suite/skills_extension.rsindex d6a819185c..d7b2a7973a 100644--- a/codex-rs/core/tests/suite/skills_extension.rs+++ b/codex-rs/core/tests/suite/skills_extension.rs@@ -1,6 +1,7 @@use std::sync::Arc;use std::sync::Mutex;use std::sync::atomic::AtomicBool;+use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;use anyhow::Result;@@ -43,6 +44,7 @@ use codex_protocol::permissions::FileSystemSandboxEntry;use codex_protocol::permissions::FileSystemSandboxPolicy;use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;+use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::Event;use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::Op;@@ -1334,19 +1336,31 @@ text({ names: result.skills.map(skill => skill.name), warnings: result.warnings,}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn production_turn_aliases_discovered_singleton_orchestrator_root() -> Result<()> {+async fn production_turn_reuses_orchestrator_skills_until_mcp_invalidation() -> Result<()> {skip_if_no_network!(Ok(()));const SKILL_ROOT: &str = "skill://plugin_connector_1p_2330815c823c8191941e5dc465bb899f";const SKILL_BODY: &str = "ORCHESTRATOR_SKILL_REMAINS_AVAILABLE_WITHOUT_HOST_DISCOVERY";+ const UPDATED_SKILL_BODY: &str = "UPDATED_ORCHESTRATOR_SKILL";let server = responses::start_mock_server().await;- let apps_server = AppsTestServer::mount(&server).await?;- let response = mount_sse_once(+ let (apps_server, startup) = AppsTestServer::mount_with_startup_control(&server).await?;+ let response = responses::mount_sse_sequence(&server,- sse(vec![ev_response_created("resp-1"), ev_completed("resp-1")]),+ (1..=5)+ .map(|index| {+ let id = format!("resp-{index}");+ sse(vec![ev_response_created(&id), ev_completed(&id)])+ })+ .collect(),).await;+ let list_calls = Arc::new(AtomicUsize::new(0));+ let read_calls = Arc::new(AtomicUsize::new(0));+ let updated = Arc::new(AtomicBool::new(false));+ let resource_list_calls = Arc::clone(&list_calls);+ let resource_read_calls = Arc::clone(&read_calls);+ let resource_updated = Arc::clone(&updated);Mock::given(method("POST")).and(path_regex("^/api/codex/ps/mcp/?$"))@@ -1358,20 +1372,27 @@ async fn production_turn_aliases_discovered_singleton_orchestrator_root() -> Res)})})- .respond_with(|request: &Request| {+ .respond_with(move |request: &Request| {let body: Value = serde_json::from_slice(&request.body).expect("MCP resource request should be valid JSON");let result = if body["method"] == "resources/read" {+ resource_read_calls.fetch_add(1, Ordering::SeqCst);let uri = format!("{SKILL_ROOT}/search/SKILL.md");assert_eq!(body["params"]["uri"], uri);+ let contents = if resource_updated.load(Ordering::SeqCst) {+ UPDATED_SKILL_BODY+ } else {+ SKILL_BODY+ };json!({"contents": [{"uri": uri,"mimeType": "text/markdown",- "text": SKILL_BODY,+ "text": contents,}],})} else {+ resource_list_calls.fetch_add(1, Ordering::SeqCst);json!({"resources": [{"name": "search",@@ -1452,6 +1473,46 @@ async fn production_turn_aliases_discovered_singleton_orchestrator_root() -> Res"orchestrator instruction reads must remain available without host discovery: {user_text}");+ // A normal turn and a policy change must reuse the same Apps skill snapshot.+ test.submit_text_turn("Use $demo:search again.").await?;+ test.submit_turn_with_approval_and_permission_profile(+ "Use $demo:search after updating approval policy.",+ AskForApproval::OnRequest,+ PermissionProfile::Disabled,+ )+ .await?;+ assert_eq!(+ startup.initialize_attempts(),+ 1,+ "Apps connection was reused"+ );+ assert_eq!(list_calls.load(Ordering::SeqCst), 1);+ assert_eq!(read_calls.load(Ordering::SeqCst), 1);++ // Plugin invalidation must refresh both the catalog and contents, even when+ // the underlying Apps connection is reused.+ updated.store(true, Ordering::SeqCst);+ test.thread_manager.invalidate_mcp_runtimes().await;+ test.submit_text_turn("Use $demo:search after its plugin changed.")+ .await?;+ assert_eq!(startup.initialize_attempts(), 1);+ assert_eq!(list_calls.load(Ordering::SeqCst), 2);+ assert_eq!(read_calls.load(Ordering::SeqCst), 2);+ assert!(+ response.requests()[3]+ .message_input_texts("user")+ .join("\n")+ .contains(UPDATED_SKILL_BODY)+ );++ // A forced reconnect must also refresh the skills snapshot.+ test.codex.submit(Op::RefreshMcpServers).await?;+ test.submit_text_turn("Use $demo:search after reconnecting.")+ .await?;+ assert_eq!(startup.initialize_attempts(), 2);+ assert_eq!(list_calls.load(Ordering::SeqCst), 3);+ assert_eq!(read_calls.load(Ordering::SeqCst), 3);+Ok(())}diff --git a/codex-rs/ext/skills/src/state.rs b/codex-rs/ext/skills/src/state.rsindex bb13611320..19e53c35b0 100644--- a/codex-rs/ext/skills/src/state.rs+++ b/codex-rs/ext/skills/src/state.rs@@ -7,8 +7,9 @@ use std::sync::Weak;use codex_exec_server::Environment;use codex_exec_server::FileSystemSandboxContext;use codex_extension_api::ExtensionMetrics;+use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;use codex_mcp::McpResourceClient;-use codex_mcp::McpResourceClientCacheKey;+use codex_mcp::McpResourceServerCacheKey;use codex_protocol::capabilities::SelectedCapabilityRoot;use tokio::sync::OnceCell;@@ -259,7 +260,8 @@ impl SkillsThreadState {.orchestrator_cache.lock().unwrap_or_else(std::sync::PoisonError::into_inner);- let cache_key = mcp_resources.map(McpResourceClient::cache_key);+ let cache_key =+ mcp_resources.and_then(|client| client.server_cache_key(CODEX_APPS_MCP_SERVER_NAME));if let Some(cache) = cache.as_ref().filter(|cache| cache.mcp_cache_key == cache_key)@@ -337,7 +339,7 @@ struct CachedExecutorDiscoveryCatalog {}struct OrchestratorGenerationCache {- mcp_cache_key: Option<McpResourceClientCacheKey>,+ mcp_cache_key: Option<McpResourceServerCacheKey>,catalog: OnceCell<SkillCatalog>,resources: Mutex<OrchestratorResourceCache>,}