Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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_namespac
test.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 = false
let 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(())
}