Resolve MCP tool catalogs concurrently (#35777)

## What changed

- Resolve per-server tool catalogs concurrently in `list_all_tools` and binding capture.
- After the shared startup wait, recheck servers that previously exposed cached tools so a newly ready client contributes its current catalog and callable client.

## Testing

- Add gated-client tests that verify multiple server catalogs start before any one server is released.
- Verify binding capture replaces cached Codex Apps tools with the ready client's tools when startup completes during capture.

GitOrigin-RevId: a30d1a535ed1588f2bba21f2741e8bbd9342e339
This commit is contained in:
Charlie Marsh authored and copyberry committed 2026-07-28 14:13:03 +00:00
1 parent 03748ad5e1
commit 84ccb2938b
2 files changed
+246 -43

No files matched your search

@@ -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(