Lightweight coding agent that runs in your terminal
Rust
Reuse MCP handlers across equivalent bindings (#47988)
Henry Levy0f0efab8d3cb
diff --git a/codex-rs/core/src/mcp_tool_exposure.rs b/codex-rs/core/src/mcp_tool_exposure.rsindex a5e03e2ce5..fa9b6eb61b 100644--- a/codex-rs/core/src/mcp_tool_exposure.rs+++ b/codex-rs/core/src/mcp_tool_exposure.rs@@ -1,9 +1,8 @@use std::collections::HashMap;use std::collections::HashSet;-use std::collections::hash_map::Entry;+use std::num::NonZeroUsize;use std::sync::Arc;use std::sync::Mutex;-use std::sync::Weak;use codex_connectors::AppToolPolicyEvaluator;use codex_connectors::AppToolPolicyInput;@@ -25,12 +24,14 @@ use crate::tools::registry::ToolRegistry;#[derive(Default)]pub(crate) struct McpHandlerCache {- cached: Mutex<Option<CachedMcpHandlers>>,+ handlers: Mutex<HashMap<ToolName, CachedMcpHandler>>,}-struct CachedMcpHandlers {- binding: Weak<McpBinding>,- handlers: HashMap<ToolName, Arc<McpHandler>>,+struct CachedMcpHandler {+ tool_info: McpToolInfo,+ agent_plugin: bool,+ schema_max_bytes: Option<NonZeroUsize>,+ handler: Arc<McpHandler>,}impl McpHandlerCache {@@ -43,29 +44,17 @@ impl McpHandlerCache {search_tool_enabled: bool,registry: &mut ToolRegistry,) -> HashSet<ToolName> {- let mut cached = self- .cached+ let mut handlers = self+ .handlers.lock().unwrap_or_else(std::sync::PoisonError::into_inner);- if !cached- .as_ref()- .and_then(|cached| cached.binding.upgrade())- .is_some_and(|cached_binding| Arc::ptr_eq(&cached_binding, binding))- {- *cached = None;- }-- let cached = cached.get_or_insert_with(|| CachedMcpHandlers {- binding: Arc::downgrade(binding),- handlers: HashMap::new(),- });append_mcp_tools(binding.tools(),config,apps_enabled,mcp_server_catalog,search_tool_enabled,- &mut cached.handlers,+ &mut handlers,registry,)}@@ -78,9 +67,15 @@ fn append_mcp_tools(apps_enabled: bool,mcp_server_catalog: &codex_mcp::ResolvedMcpCatalog,search_tool_enabled: bool,- handlers: &mut HashMap<ToolName, Arc<McpHandler>>,+ handlers: &mut HashMap<ToolName, CachedMcpHandler>,registry: &mut ToolRegistry,) -> HashSet<ToolName> {+ let current_tools: HashSet<_> = all_mcp_tools+ .iter()+ .map(McpToolInfo::canonical_tool_name)+ .collect();+ handlers.retain(|name, _| current_tools.contains(name));+// Keep regular MCP tools first; Apps tools also require connector and policy checks.let non_app_tools = filter_non_codex_apps_mcp_tools_only(all_mcp_tools);let app_tools = apps_enabled@@ -100,25 +95,41 @@ fn append_mcp_tools(let agent_plugin = server.is_some_and(|server| server.source().is_agent_plugin());let tool_input_schema_max_bytes =server.and_then(|server| server.config().tool_input_schema_max_bytes);- let handler = match handlers.entry(tool_name.clone()) {- Entry::Occupied(entry) => Arc::clone(entry.get()),- Entry::Vacant(entry) => {- let handler = if agent_plugin {- McpHandler::new_agent_plugin(tool.clone())- } else if let Some(budget) = tool_input_schema_max_bytes {- McpHandler::new_with_schema_max_bytes(tool.clone(), budget.get())- } else {- McpHandler::new(tool.clone())- };+ // Handlers contain immutable tool metadata, not a connection or authorization snapshot.+ // Preserve their identity across equivalent bindings so the search index can also be reused.+ let handler = if let Some(cached) = handlers.get(&tool_name).filter(|cached| {+ cached.tool_info == *tool+ && cached.agent_plugin == agent_plugin+ && cached.schema_max_bytes == tool_input_schema_max_bytes+ }) {+ Arc::clone(&cached.handler)+ } else {+ handlers.remove(&tool_name);+ let handler = if agent_plugin {+ McpHandler::new_agent_plugin(tool.clone())+ } else if let Some(budget) = tool_input_schema_max_bytes {+ McpHandler::new_with_schema_max_bytes(tool.clone(), budget.get())+ } else {+ McpHandler::new(tool.clone())+ };- match handler {- Ok(handler) => Arc::clone(entry.insert(Arc::new(handler))),- Err(err) => {- warn!("Skipping MCP tool `{tool_name}`: failed to build tool spec: {err}");- continue;- }+ let handler = match handler {+ Ok(handler) => Arc::new(handler),+ Err(err) => {+ warn!("Skipping MCP tool `{tool_name}`: failed to build tool spec: {err}");+ continue;}- }+ };+ handlers.insert(+ tool_name.clone(),+ CachedMcpHandler {+ tool_info: tool.clone(),+ agent_plugin,+ schema_max_bytes: tool_input_schema_max_bytes,+ handler: Arc::clone(&handler),+ },+ );+ handler};let fits_agent_budget = if agent_plugin {diff --git a/codex-rs/core/tests/suite/mcp_tool_exposure.rs b/codex-rs/core/tests/suite/mcp_tool_exposure.rsindex e373cd86c5..b24a4d860a 100644--- a/codex-rs/core/tests/suite/mcp_tool_exposure.rs+++ b/codex-rs/core/tests/suite/mcp_tool_exposure.rs@@ -59,10 +59,18 @@ use std::collections::HashMap;use std::sync::Arc;use std::sync::Mutex;use std::sync::atomic::AtomicBool;+use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;use std::time::Duration;use tempfile::TempDir;use tokio::sync::Semaphore;+use tracing::Subscriber;+use tracing::span::Attributes;+use tracing::span::Id;+use tracing_subscriber::Layer;+use tracing_subscriber::layer::Context as LayerContext;+use tracing_subscriber::layer::SubscriberExt;+use tracing_subscriber::util::SubscriberInitExt;use wiremock::Mock;use wiremock::Request;use wiremock::ResponseTemplate;@@ -70,6 +78,27 @@ use wiremock::matchers::body_partial_json;use wiremock::matchers::method;use wiremock::matchers::path_regex;+#[derive(Clone, Default)]+struct McpCacheCounters {+ binding_captures: Arc<AtomicUsize>,+ search_index_builds: Arc<AtomicUsize>,+}++impl<S: Subscriber> Layer<S> for McpCacheCounters {+ fn on_new_span(&self, attributes: &Attributes<'_>, _id: &Id, _context: LayerContext<'_, S>) {+ let metadata = attributes.metadata();+ match (metadata.target(), metadata.name()) {+ ("codex_mcp::connection_manager::tool_catalog", "capture_binding_with_metadata") => {+ self.binding_captures.fetch_add(1, Ordering::SeqCst);+ }+ ("codex_core::tools::handlers::tool_search", "new") => {+ self.search_index_builds.fetch_add(1, Ordering::SeqCst);+ }+ _ => {}+ }+ }+}+struct McpResourceClientCapture {client: Arc<Mutex<Option<McpResourceClient>>>,}@@ -1080,10 +1109,18 @@ async fn deferred_tool_world_state_is_disabled_by_default() -> Result<()> {Ok(())}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+// Keep spawned tasks on the thread with the scoped tracing subscriber.+#[tokio::test(flavor = "current_thread")]async fn deferred_tool_world_state_tracks_initial_unchanged_and_removed_namespaces() -> Result<()> {skip_if_no_network!(Ok(()));+ let counters = McpCacheCounters::default();+ // Keep concurrent tests without a subscriber from caching these callsites as disabled.+ let _interest_cache_guard =+ tracing::Dispatch::new(tracing::subscriber::NoSubscriber::default());+ let _tracing = tracing_subscriber::registry()+ .with(counters.clone())+ .set_default();let server = responses::start_mock_server().await;let apps_server = AppsTestServer::mount_searchable(&server).await?;let response = mount_sse_sequence(&server, completed_response_sequence(/*count*/ 3)).await;@@ -1094,7 +1131,29 @@ async fn deferred_tool_world_state_tracks_initial_unchanged_and_removed_namespactest.submit_turn("inspect initially available deferred tools").await?;+ let initial_captures = counters.binding_captures.load(Ordering::SeqCst);+ let initial_index_builds = counters.search_index_builds.load(Ordering::SeqCst);+ assert!(+ initial_captures > 0,+ "the initial turn must capture an MCP binding"+ );+ assert!(+ initial_index_builds > 0,+ "the initial turn must build the search index"+ );++ // Publish a new catalog revision with the same metadata from the ready client.+ test.codex.refresh_codex_apps_tools().await?;test.submit_turn("inspect unchanged deferred tools").await?;+ assert!(+ counters.binding_captures.load(Ordering::SeqCst) > initial_captures,+ "the follow-up must capture a new binding after the refresh"+ );+ assert_eq!(+ counters.search_index_builds.load(Ordering::SeqCst),+ initial_index_builds,+ "equivalent bindings must preserve MCP handlers and reuse the search index"+ );let mut refresh_config = test.config.clone();let user_config_path = refresh_config.codex_home.join("config.toml");@@ -1113,6 +1172,14 @@ enabled = falselet requests = response.requests();assert_eq!(requests.len(), 3);+ assert!(+ requests[2].body_json()["tools"]+ .as_array()+ .expect("model request tools")+ .iter()+ .all(|tool| tool["type"] != "tool_search"),+ "removing all deferred tools must stop advertising the cached search tool"+ );let tools_states = requests.iter().map(tools_state_sections)@@ -1133,6 +1200,7 @@ enabled = false));+ test.codex.shutdown_and_wait().await?;Ok(())}