Lightweight coding agent that runs in your terminal
Rust
Resolve MCP tool catalogs concurrently (#35777)
Charlie Marsh84ccb2938bfe
diff --git a/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rs b/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rsindex 47afb2242d..0a3447e56c 100644--- a/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rs+++ b/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rs@@ -7,6 +7,7 @@ use anyhow::Context;use anyhow::Result;use anyhow::anyhow;use codex_connectors::ConnectorRuntimeFetchSource;+use futures::future::join_all;use tracing::Instrument;use tracing::instrument;use tracing::trace;@@ -63,7 +64,7 @@ impl McpConnectionSet {let mut tools = Vec::new();let mut available_server_count = 0;let mut unavailable_server_count = 0;- for (server_name, view) in &self.servers {+ let server_results = join_all(self.servers.iter().map(|(server_name, view)| async move {view.connection.client.reconnect_failed_startup().await;let has_cached_tools = view.connection.client.has_cached_tools();let startup_complete = view@@ -76,7 +77,7 @@ impl McpConnectionSet {} else {None};- let Some(server_tools) = async {+ let server_tools = async {match catalog_override {Some(tools) => {let tools = filter_tools(tools, &view.tool_filter);@@ -94,23 +95,34 @@ impl McpConnectionSet {has_cached_tools,startup_complete))- .await- else {- unavailable_server_count += 1;- trace!(- server_name = %server_name,- has_cached_tools,- startup_complete,- "MCP server tools unavailable while building tool list"- );- continue;- };- available_server_count += 1;- tools.extend(- server_tools- .into_iter()- .map(|tool| Self::with_server_metadata(tool, &view.metadata)),- );+ .await;+ match server_tools {+ Some(server_tools) => Some(+ server_tools+ .into_iter()+ .map(|tool| Self::with_server_metadata(tool, &view.metadata))+ .collect::<Vec<_>>(),+ ),+ None => {+ trace!(+ server_name = %server_name,+ has_cached_tools,+ startup_complete,+ "MCP server tools unavailable while building tool list"+ );+ None+ }+ }+ }))+ .await;+ for server_tools in server_results {+ match server_tools {+ Some(server_tools) => {+ available_server_count += 1;+ tools.extend(server_tools);+ }+ None => unavailable_server_count += 1,+ }}let tools = normalize_tools_for_model_with_prefix(tools,@@ -142,7 +154,7 @@ impl McpConnectionSet {let optional_startup_deadline = *self.optional_startup_deadline.get_or_init(|| tokio::time::Instant::now() + OPTIONAL_MCP_STARTUP_GRACE);- for (server_name, view) in &self.servers {+ join_all(self.servers.iter().map(|(server_name, view)| async move {if !view.connection.client@@ -158,35 +170,50 @@ impl McpConnectionSet {.any(|required| required == server_name)|| (server_name == CODEX_APPS_MCP_SERVER_NAME && !has_cached_tools);if !must_wait_for_startup && has_cached_tools {- if let Some(server_tools) =- view.listed_tools(&self.tool_plugin_provenance).await- {- listed_tools.extend(server_tools.into_iter().map(|mut tool| {- if let Some(annotations) = tool.tool.annotations.as_mut() {- annotations.read_only_hint = None;- }- Self::with_server_metadata(tool, &view.metadata)- }));- }- continue;+ return;}- if !must_wait_for_startup- && tokio::time::timeout_at(+ if !must_wait_for_startup {+ if tokio::time::timeout_at(optional_startup_deadline,view.connection.client.client(),).await.is_err()- {- trace!(server_name = %server_name, "omitting pending optional MCP server");- continue;+ {+ trace!(server_name = %server_name, "omitting pending optional MCP server");+ }+ return;}let _ = view.connection.client.client().await;}+ }))+ .await;+ let server_results = join_all(self.servers.iter().map(|(server_name, view)| async move {+ if !view+ .connection+ .client+ .startup_complete+ .load(Ordering::Acquire)+ {+ if !view.connection.client.has_cached_tools() {+ return None;+ }+ let server_tools = view.listed_tools(&self.tool_plugin_provenance).await?;+ let server_tools = server_tools+ .into_iter()+ .map(|mut tool| {+ if let Some(annotations) = tool.tool.annotations.as_mut() {+ annotations.read_only_hint = None;+ }+ Self::with_server_metadata(tool, &view.metadata)+ })+ .collect::<Vec<_>>();+ return Some((server_name.clone(), None, server_tools));+ }view.connection.client.reconnect_failed_startup().await;let Ok(mut client) = view.connection.client.client().await else {trace!(server_name = %server_name, "omitting MCP server without an exact ready client");- continue;+ return None;};client.tool_timeout = view.tool_timeout;let catalog_override = if server_name == CODEX_APPS_MCP_SERVER_NAME {@@ -204,12 +231,18 @@ impl McpConnectionSet {&self.tool_plugin_provenance,)};- clients.insert(server_name.clone(), Arc::new(client));- listed_tools.extend(- server_tools- .into_iter()- .map(|tool| Self::with_server_metadata(tool, &view.metadata)),- );+ let server_tools = server_tools+ .into_iter()+ .map(|tool| Self::with_server_metadata(tool, &view.metadata))+ .collect::<Vec<_>>();+ Some((server_name.clone(), Some(Arc::new(client)), server_tools))+ }))+ .await;+ for (server_name, client, server_tools) in server_results.into_iter().flatten() {+ if let Some(client) = client {+ clients.insert(server_name, client);+ }+ listed_tools.extend(server_tools);}let clients = Arc::new(McpBindingClients::new(clients));let listed_tools = normalize_tools_for_model_with_prefix(diff --git a/codex-rs/codex-mcp/src/connection_manager_tests.rs b/codex-rs/codex-mcp/src/connection_manager_tests.rsindex ed8f226e1d..8230ff0334 100644--- a/codex-rs/codex-mcp/src/connection_manager_tests.rs+++ b/codex-rs/codex-mcp/src/connection_manager_tests.rs@@ -429,6 +429,42 @@ async fn create_ready_async_managed_client(tools: Vec<ToolInfo>) -> AsyncManaged}}+fn create_gated_async_managed_client(+ client: ManagedClient,+) -> (+ AsyncManagedClient,+ tokio::sync::oneshot::Receiver<()>,+ tokio::sync::oneshot::Sender<()>,+) {+ let (started_tx, started_rx) = tokio::sync::oneshot::channel();+ let (release_tx, release_rx) = tokio::sync::oneshot::channel();+ let startup_complete = Arc::new(AtomicBool::new(false));+ let startup_complete_for_client = Arc::clone(&startup_complete);+ let client = async move {+ started_tx.send(()).expect("signal client startup");+ release_rx.await.expect("release client startup");+ startup_complete_for_client.store(true, std::sync::atomic::Ordering::Release);+ Ok(client)+ }+ .boxed()+ .shared();++ (+ AsyncManagedClient {+ client,+ is_codex_apps_mcp_server: false,+ cached_server_info: None,+ codex_apps_tools_cache_context: None,+ tool_catalog_cache_context: None,+ startup_complete,+ startup_reconnect: None,+ cancel_token: CancellationToken::new(),+ },+ started_rx,+ release_tx,+ )+}+async fn create_test_manager_with_ready_apps_client(cache_context: ConnectorRuntimeContext<ToolInfo>,tool_name: &str,@@ -1749,6 +1785,99 @@ async fn capture_binding_skips_pending_optional_servers_after_one_shared_startupassert!(binding.is_err(), "explicitly requested servers must wait");}+#[tokio::test]+async fn capture_binding_resolves_concurrently_and_rechecks_cached_clients() {+ let codex_home = tempdir().expect("tempdir");+ let cache_context = create_codex_apps_tools_cache_context(+ codex_home.path().to_path_buf(),+ Some("account-one"),+ Some("user-one"),+ );+ store_current_tools(+ &cache_context,+ vec![create_test_tool(+ CODEX_APPS_MCP_SERVER_NAME,+ "shared_cached_tool",+ )],+ );+ let ready_apps_client = create_test_managed_client(vec![create_test_tool(+ CODEX_APPS_MCP_SERVER_NAME,+ "client_local_tool",+ )])+ .await;+ let (mut apps_client, apps_started, release_apps) =+ create_gated_async_managed_client(ready_apps_client);+ apps_client.is_codex_apps_mcp_server = true;+ apps_client.codex_apps_tools_cache_context = Some(cache_context);+ let first_client =+ create_test_managed_client(vec![create_test_tool("first", "first_tool")]).await;+ let second_client =+ create_test_managed_client(vec![create_test_tool("second", "second_tool")]).await;+ let (first_client, first_started, release_first) =+ create_gated_async_managed_client(first_client);+ let (second_client, second_started, release_second) =+ create_gated_async_managed_client(second_client);++ let approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ let permission_profile = Constrained::allow_any(PermissionProfile::default());+ let mut manager = McpConnectionSet::new_uninitialized(+ &approval_policy,+ &permission_profile,+ /*prefix_mcp_tool_names*/ true,+ );+ manager.insert_test_client(CODEX_APPS_MCP_SERVER_NAME, apps_client);+ manager.insert_test_client("first", first_client);+ manager.insert_test_client("second", second_client);+ let manager = Arc::new(manager);++ let manager_for_startup = Arc::clone(&manager);+ let startup = tokio::spawn(async move {+ manager_for_startup+ .wait_for_server_startup(CODEX_APPS_MCP_SERVER_NAME)+ .await+ });+ tokio::time::timeout(Duration::from_secs(1), apps_started)+ .await+ .expect("Codex Apps startup should begin")+ .expect("signal Codex Apps startup");++ let manager_for_binding = Arc::clone(&manager);+ let binding = tokio::spawn(async move { capture_binding(&manager_for_binding).await });+ tokio::time::timeout(Duration::from_secs(1), async {+ first_started.await.expect("first server startup");+ second_started.await.expect("second server startup");+ })+ .await+ .expect("both uncached servers should start before either is released");++ release_apps.send(()).expect("release Codex Apps startup");+ assert!(startup.await.expect("Codex Apps startup task"));+ release_first.send(()).expect("release first server");+ release_second.send(()).expect("release second server");++ let binding = binding.await.expect("binding capture should complete");+ assert_eq!(+ binding+ .tools()+ .iter()+ .map(|tool| tool.callable_name.as_str())+ .collect::<HashSet<_>>(),+ HashSet::from(["client_local_tool", "first_tool", "second_tool"])+ );+ assert!(+ binding+ .prepare_call(CODEX_APPS_MCP_SERVER_NAME, "client_local_tool")+ .is_some()+ );+ assert!(+ binding+ .prepare_call(CODEX_APPS_MCP_SERVER_NAME, "shared_cached_tool")+ .is_none()+ );+ assert!(binding.prepare_call("first", "first_tool").is_some());+ assert!(binding.prepare_call("second", "second_tool").is_some());+}+#[tokio::test]async fn list_all_tools_applies_legacy_mcp_prefix_by_default() {let managed_client =@@ -1780,6 +1909,47 @@ async fn list_all_tools_applies_legacy_mcp_prefix_by_default() {);}+#[tokio::test]+async fn list_all_tools_resolves_server_catalogs_concurrently() {+ let first_client = create_test_managed_client(vec![create_test_tool("first", "search")]).await;+ let second_client =+ create_test_managed_client(vec![create_test_tool("second", "lookup")]).await;+ let (first_client, first_started, release_first) =+ create_gated_async_managed_client(first_client);+ let (second_client, second_started, release_second) =+ create_gated_async_managed_client(second_client);+ let approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ let permission_profile = Constrained::allow_any(PermissionProfile::default());+ let mut manager = McpConnectionSet::new_uninitialized(+ &approval_policy,+ &permission_profile,+ /*prefix_mcp_tool_names*/ true,+ );+ manager.insert_test_client("first", first_client);+ manager.insert_test_client("second", second_client);+ let manager = Arc::new(manager);+ let manager_for_listing = Arc::clone(&manager);+ let listing = tokio::spawn(async move { manager_for_listing.list_all_tools().await });++ tokio::time::timeout(Duration::from_secs(1), async {+ first_started.await.expect("first server startup");+ second_started.await.expect("second server startup");+ })+ .await+ .expect("both server catalogs should start before either is released");+ release_first.send(()).expect("release first server");+ release_second.send(()).expect("release second server");++ let tools = listing.await.expect("tool listing should complete");+ assert_eq!(+ model_tool_names(&tools),+ HashSet::from([+ ToolName::namespaced("mcp__first", "search"),+ ToolName::namespaced("mcp__second", "lookup"),+ ])+ );+}+#[tokio::test]async fn list_all_tools_blocks_while_client_is_pending_without_cached_tools() {let pending_client = futures::future::pending::<Result<ManagedClient, StartupOutcomeError>>()