From 378444bdfe352037fa4fca70061102c903466212 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:26:03 +0300 Subject: [PATCH 01/13] feat(registry): add workspace-scoped tool lookup for multi-host tests Add `all_connected_tools_for_config` to resolve tools through a specific `Config` rather than the process-wide default host. This prevents test binaries from silently reporting no tools when multiple tests each open their own temporary workspace, since the ambient lookup returns `None` once a second host exists. A host that cannot be opened yields an empty list so that MCP unavailability does not fail tool listing. Auto-committed-on: dragonfly Co-authored-by: Medulla --- src/openhuman/mcp/registry/mod.rs | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/src/openhuman/mcp/registry/mod.rs b/src/openhuman/mcp/registry/mod.rs index 875417437c..a76966f2fe 100644 --- a/src/openhuman/mcp/registry/mod.rs +++ b/src/openhuman/mcp/registry/mod.rs @@ -88,6 +88,35 @@ pub mod connections { } } + /// Every tool on every connected server in `config`'s workspace. + /// + /// The counterpart to [`all_connected_tools`] for a caller that holds a + /// `Config`. It resolves through [`host::for_config`], which is keyed by + /// workspace, rather than through the process-wide default — so it answers + /// about the workspace the caller named instead of whichever one + /// `mcp::init` happened to claim first. + /// + /// That distinction is invisible in the shipped app, which opens one + /// workspace, and decisive in a test binary: `resolve` hands back a lone + /// host but returns `None` once a second one exists, so an ambient lookup + /// silently reports nothing connected as soon as two tests each open their + /// own temporary workspace in one process. + /// + /// A host that cannot be opened yields an empty list rather than an error: + /// the callers fold this into a tool list, and MCP being unavailable must + /// not fail the listing. + pub async fn all_connected_tools_for_config( + config: &Config, + ) -> Vec<(String, String, tinymcp_bus::McpTool)> { + match host::for_config(config) { + Ok(service) => service.dynamic().connections().all_connected_tools().await, + Err(error) => { + tracing::debug!(?error, "[mcp] no host for workspace; reporting no tools"); + Vec::new() + } + } + } + /// Every tool on every connected server, paired with its server. pub async fn all_connected_tools() -> Vec<(String, String, tinymcp_bus::McpTool)> { match host::try_service() { From ca9e82e4db2f5b86cf32cda9ef024e0367edfb23 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:26:17 +0300 Subject: [PATCH 02/13] feat(mcp): add stub for all_connected_tools_for_config Add a stub implementation of `all_connected_tools_for_config` in the MCP registry's stub module, and import the `Config` type in the connections module. This provides a no-op fallback when the MCP feature is disabled, matching the existing pattern for `all_connected_tools`. Auto-committed-on: dragonfly Co-authored-by: Medulla --- src/openhuman/mcp/registry/mod.rs | 1 + src/openhuman/mcp/registry/stub.rs | 6 ++++++ 2 files changed, 7 insertions(+) diff --git a/src/openhuman/mcp/registry/mod.rs b/src/openhuman/mcp/registry/mod.rs index a76966f2fe..e8b7a0ba38 100644 --- a/src/openhuman/mcp/registry/mod.rs +++ b/src/openhuman/mcp/registry/mod.rs @@ -73,6 +73,7 @@ pub use types::{ConnStatus, InstalledServer, McpTool}; /// completes should see. #[cfg(feature = "mcp")] pub mod connections { + use crate::openhuman::config::Config; pub use tinymcp_bus::ConnectedServerOverview; use crate::openhuman::mcp::host; diff --git a/src/openhuman/mcp/registry/stub.rs b/src/openhuman/mcp/registry/stub.rs index e05db03fcc..c176888119 100644 --- a/src/openhuman/mcp/registry/stub.rs +++ b/src/openhuman/mcp/registry/stub.rs @@ -124,4 +124,10 @@ pub mod connections { pub async fn all_connected_tools() -> Vec<(String, String, McpTool)> { Vec::new() } + + /// Empty, for the same reason as [`all_connected_tools`]. The workspace the + /// caller names changes nothing when the registry is compiled out. + pub async fn all_connected_tools_for_config(_config: &Config) -> Vec<(String, String, McpTool)> { + Vec::new() + } } From ee4ba908539ce22f6cb475569ab9bc9bd7285849 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:26:41 +0300 Subject: [PATCH 03/13] fix(tools): use config-aware registry entries for diagnostics The `diagnostics_for_config` function was calling `registry_entries()` which reads connected-client tools from the process default workspace, but it should use `registry_entries_for_config(config)` to respect the provided configuration. This change adds a new function that accepts a config parameter and refactors the existing one to delegate to a shared implementation, ensuring diagnostics correctly reflect the tools available in the specified workspace rather than the ambient process default. Auto-committed-on: dragonfly Co-authored-by: Medulla --- src/openhuman/tools/registry/ops.rs | 34 +++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/src/openhuman/tools/registry/ops.rs b/src/openhuman/tools/registry/ops.rs index 1a839973fd..ce8263861b 100644 --- a/src/openhuman/tools/registry/ops.rs +++ b/src/openhuman/tools/registry/ops.rs @@ -51,7 +51,7 @@ pub async fn diagnostics() -> Result, String> pub fn diagnostics_for_config(config: &Config) -> RpcOutcome { log::debug!("[tool_registry] diagnostics_for_config start"); - let tools = registry_entries(); + let tools = registry_entries_for_config(config); let total_tools = tools.len(); let enabled_tools = tools.iter().filter(|entry| entry.enabled).count(); let mcp_stdio_tools = tools @@ -220,7 +220,30 @@ pub fn get_tool(tool_id: &str) -> Result, String> /// 1. MCP stdio server tools (existing `mcp::server` surface) /// 2. Controller-backed tools (existing `tools` namespace) /// 3. Connected MCP client server tools (new `mcp_clients` domain) +/// +/// The connected-client tools come from whichever workspace `mcp::init` claimed +/// as the process default. That is right for the shipped app, which opens one; +/// a caller that holds a `Config` should prefer +/// [`registry_entries_for_config`], which names the workspace it means. pub fn registry_entries() -> Vec { + build_registry_entries(None) +} + +/// The same snapshot, with connected-client tools read from `config`'s +/// workspace rather than the process default. +/// +/// The two differ only when more than one workspace is open in a process. +/// `mcp::host::resolve` returns a lone host but `None` once a second exists, so +/// the ambient form silently reports nothing connected in a test binary where +/// several cases each open their own temporary workspace — which is how +/// `tool_registry_entries_include_connected_mcp_client_tools` came to pass +/// alone and fail beside its neighbours. +pub fn registry_entries_for_config(config: &Config) -> Vec { + build_registry_entries(Some(config)) +} + +/// The shared body. `config` selects the MCP host; everything else is identical. +fn build_registry_entries(config: Option<&Config>) -> Vec { let mut entries = BTreeMap::new(); for spec in crate::openhuman::mcp::server::tool_specs() { @@ -245,7 +268,14 @@ pub fn registry_entries() -> Vec { // (kind = CurrentThread) panics on block_in_place. if handle.runtime_flavor() == tokio::runtime::RuntimeFlavor::MultiThread { tokio::task::block_in_place(|| { - handle.block_on(connections::all_connected_tools()) + handle.block_on(async { + match config { + Some(config) => { + connections::all_connected_tools_for_config(config).await + } + None => connections::all_connected_tools().await, + } + }) }) } else { Vec::new() From f3bc38fe1f1aee889d902dc676eb7db408e91415 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:27:03 +0300 Subject: [PATCH 04/13] fix(tests): use config-scoped registry lookup in MCP client tool test The test `tool_registry_entries_include_connected_mcp_client_tools` was calling the ambient `registry_entries()` function, which resolves through the process default host. When other test cases in the same binary open a second host first, the ambient lookup returns `None` for the connected client tools. The fix switches to `registry_entries_for_config(&config)`, which correctly resolves through the config-scoped host that was used to establish the connection. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../tool_registry_approval_raw_coverage_e2e.rs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs index 44fb50a4f4..c5028977e1 100644 --- a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs +++ b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs @@ -37,7 +37,7 @@ use openhuman_core::openhuman::tools::registry::{ all_tool_registry_controller_schemas, all_tool_registry_registered_controllers, capability_provider_by_id, capability_provider_diagnostics, capability_provider_registry, denials, get_tool, is_capability_provider_trusted_enabled, list_capability_providers, - list_tools, normalize_capability_provider_id, registry_entries, + list_tools, normalize_capability_provider_id, registry_entries, registry_entries_for_config, CapabilityProviderRegistryError, }; @@ -654,7 +654,13 @@ async fn tool_registry_entries_include_connected_mcp_client_tools() { .expect("connect test mcp server"); assert_eq!(tools.first().map(|tool| tool.name.as_str()), Some("echo")); - let entries = registry_entries(); + // Config-scoped, not ambient: this case connects through + // `host::for_config(&config)`, keyed by its own tempdir. `registry_entries()` + // resolves through the process default instead, which returns a lone host + // but `None` once another case in this binary has opened a second one — so + // the ambient form reports nothing connected here purely because of who + // else ran first. + let entries = registry_entries_for_config(&config); let client_entry = entries .iter() .find(|entry| entry.tool_id == format!("mcp-client::{}::echo", server.server_id)) From a045762975c98ff5ff429c6402339a801f94d9b6 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:30:58 +0300 Subject: [PATCH 05/13] chore(mcp): reformat function signature for readability Reformatted the `all_connected_tools_for_config` function signature to split parameters and return type across multiple lines, improving code readability without changing any behavior. Auto-committed-on: dragonfly Co-authored-by: Medulla --- src/openhuman/mcp/registry/stub.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/openhuman/mcp/registry/stub.rs b/src/openhuman/mcp/registry/stub.rs index c176888119..5526694861 100644 --- a/src/openhuman/mcp/registry/stub.rs +++ b/src/openhuman/mcp/registry/stub.rs @@ -127,7 +127,9 @@ pub mod connections { /// Empty, for the same reason as [`all_connected_tools`]. The workspace the /// caller names changes nothing when the registry is compiled out. - pub async fn all_connected_tools_for_config(_config: &Config) -> Vec<(String, String, McpTool)> { + pub async fn all_connected_tools_for_config( + _config: &Config, + ) -> Vec<(String, String, McpTool)> { Vec::new() } } From 41a893b19f2e6578cde1176da88e0058e2067ee9 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:31:11 +0300 Subject: [PATCH 06/13] fix(registry): export missing `registry_entries_for_config` function The `registry_entries_for_config` function was added to the `ops` module but not re-exported from the registry, making it inaccessible to external callers. This change adds the missing re-export so the function can be used as intended. Auto-committed-on: dragonfly Co-authored-by: Medulla --- src/openhuman/tools/registry/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/openhuman/tools/registry/mod.rs b/src/openhuman/tools/registry/mod.rs index 2699beebed..3d94c15195 100644 --- a/src/openhuman/tools/registry/mod.rs +++ b/src/openhuman/tools/registry/mod.rs @@ -6,7 +6,7 @@ mod providers; mod schemas; mod types; -pub use ops::{get_tool, list_tools, registry_entries}; +pub use ops::{get_tool, list_tools, registry_entries, registry_entries_for_config}; pub use providers::{ capability_provider_by_id, capability_provider_diagnostics, capability_provider_registry, is_capability_provider_trusted_enabled, list_capability_providers, From e34226cb0b98b8a4f404ca2339d52b98bdfea7ca Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:35:18 +0300 Subject: [PATCH 07/13] feat(mcp): add disconnect_for_config to connection registry Add a new public function that allows dropping a connection when the caller already holds a Config reference, mirroring the existing pattern used by all_connected_tools_for_config. This avoids the by-server-id form's reliance on the process default host, which stops working once a second workspace is open, ensuring that callers who connected through connect can close over the same workspace. Auto-committed-on: dragonfly Co-authored-by: Medulla --- src/openhuman/mcp/registry/mod.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/openhuman/mcp/registry/mod.rs b/src/openhuman/mcp/registry/mod.rs index e8b7a0ba38..8ca955faa4 100644 --- a/src/openhuman/mcp/registry/mod.rs +++ b/src/openhuman/mcp/registry/mod.rs @@ -201,6 +201,24 @@ pub mod connections { } } + /// Drop a connection held in `config`'s workspace. + /// + /// The counterpart to [`disconnect`] for a caller that holds a `Config`, + /// for the same reason [`all_connected_tools_for_config`] exists: the + /// by-server-id form resolves through the process default, which stops + /// answering once a second workspace is open. A caller that connected + /// through [`connect`] already named a workspace and should close over the + /// same one. + pub async fn disconnect_for_config(config: &Config, server_id: &str) -> bool { + match host::for_config(config) { + Ok(service) => service.dynamic().connections().disconnect(server_id).await, + Err(error) => { + tracing::debug!(?error, "[mcp] no host for workspace; nothing to disconnect"); + false + } + } + } + /// The most recent failure message for a server. pub async fn last_error_for(server_id: &str) -> Option { host::try_service()? From 01b9127bb336d218abd40665136b226c64f3168b Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:35:33 +0300 Subject: [PATCH 08/13] fix(tests): use config-scoped disconnect in MCP client tools test The test was calling the by-id disconnect function, which resolves through the process default connection rather than the config-scoped connection used elsewhere in the test. Changed to use the config-scoped disconnect to match the connection's actual scope and avoid test flakiness. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../raw_coverage/tool_registry_approval_raw_coverage_e2e.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs index c5028977e1..ac4fdf13bf 100644 --- a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs +++ b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs @@ -670,7 +670,10 @@ async fn tool_registry_entries_include_connected_mcp_client_tools() { assert_eq!(client_entry.route["server_id"], json!(server.server_id)); assert!(client_entry.tags.iter().any(|tag| tag == "mcp_client")); - assert!(connections::disconnect(&server.server_id).await); + // Config-scoped for the same reason as the lookup above: this connection + // lives in the host keyed by `config`'s workspace, and the by-id form + // resolves through the process default. + assert!(connections::disconnect_for_config(&config, &server.server_id).await); } #[tokio::test] From ed3e49f3c656fd907f19642406692479773338f2 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 19:40:20 +0300 Subject: [PATCH 09/13] feat(registry): add Config import to connections module The connections module in the MCP registry stub now imports the Config type from the crate's config module, ensuring the stub build has access to the same configuration type used by the enabled build for consistent type handling across builds. Auto-committed-on: dragonfly Co-authored-by: Medulla --- src/openhuman/mcp/registry/stub.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/openhuman/mcp/registry/stub.rs b/src/openhuman/mcp/registry/stub.rs index 5526694861..fe09c328fd 100644 --- a/src/openhuman/mcp/registry/stub.rs +++ b/src/openhuman/mcp/registry/stub.rs @@ -103,6 +103,8 @@ pub mod oauth { /// Global in-process registry of connected MCP servers. pub mod connections { + use crate::openhuman::config::Config; + /// Re-exported from the ungated `types` module — the SAME type the enabled /// build uses, not a mirrored copy, so the orchestrator prompt builder's /// field access can never drift between builds. From 1fdcee920bf48e7517e0b98d9fdbc388f38de392 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 20:34:13 +0300 Subject: [PATCH 10/13] test(raw_coverage): add cross-workspace isolation assertions to MCP tool registry test Add a second workspace and server to the tool registry approval raw coverage e2e test to verify that config-scoped lookups do not leak tools from other workspaces. The new assertions ensure that each workspace's registry entries contain only its own server's tools and that the process default fallback does not incorrectly merge entries across workspaces. Auto-committed-on: dragonfly Co-authored-by: Medulla --- ...tool_registry_approval_raw_coverage_e2e.rs | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs index ac4fdf13bf..912df8f404 100644 --- a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs +++ b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs @@ -654,6 +654,19 @@ async fn tool_registry_entries_include_connected_mcp_client_tools() { .expect("connect test mcp server"); assert_eq!(tools.first().map(|tool| tool.name.as_str()), Some("echo")); + // A second workspace, so that scoping is what the assertions below测 test. + // With one workspace open, `registry_entries()` and the config-scoped form + // agree, and this case would keep passing if the forwarding regressed. + let other_tmp = tempdir().expect("second tempdir"); + let other_config = Config { + workspace_dir: other_tmp.path().to_path_buf(), + ..Config::default() + }; + let other_server = test_mcp_server(); + connections::connect(&other_config, &other_server) + .await + .expect("connect second test mcp server"); + // Config-scoped, not ambient: this case connects through // `host::for_config(&config)`, keyed by its own tempdir. `registry_entries()` // resolves through the process default instead, which returns a lone host @@ -670,10 +683,29 @@ async fn tool_registry_entries_include_connected_mcp_client_tools() { assert_eq!(client_entry.route["server_id"], json!(server.server_id)); assert!(client_entry.tags.iter().any(|tag| tag == "mcp_client")); + // The other workspace's server must NOT leak in. This is the assertion that + // fails if a config-scoped lookup falls back to the process default. + assert!( + !entries.iter().any( + |entry| entry.tool_id == format!("mcp-client::{}::echo", other_server.server_id) + ), + "entries for one workspace must not include another workspace's server" + ); + + // Symmetrically, from the second workspace's side. + let other_entries = registry_entries_for_config(&other_config); + assert!(other_entries + .iter() + .any(|entry| entry.tool_id == format!("mcp-client::{}::echo", other_server.server_id))); + assert!(!other_entries + .iter() + .any(|entry| entry.tool_id == format!("mcp-client::{}::echo", server.server_id))); + // Config-scoped for the same reason as the lookup above: this connection // lives in the host keyed by `config`'s workspace, and the by-id form // resolves through the process default. assert!(connections::disconnect_for_config(&config, &server.server_id).await); + assert!(connections::disconnect_for_config(&other_config, &other_server.server_id).await); } #[tokio::test] From da79730e1092dfbed6399e2f93c9bc9519740062 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 20:34:22 +0300 Subject: [PATCH 11/13] fix(test): correct typo in test comment MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixed a typo in a test comment where "测 test" was corrected to "actually test" to accurately describe the scoping behavior being verified by the assertions below. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../raw_coverage/tool_registry_approval_raw_coverage_e2e.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs index 912df8f404..2fb608c48d 100644 --- a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs +++ b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs @@ -654,9 +654,9 @@ async fn tool_registry_entries_include_connected_mcp_client_tools() { .expect("connect test mcp server"); assert_eq!(tools.first().map(|tool| tool.name.as_str()), Some("echo")); - // A second workspace, so that scoping is what the assertions below测 test. - // With one workspace open, `registry_entries()` and the config-scoped form - // agree, and this case would keep passing if the forwarding regressed. + // A second workspace, so that scoping is what the assertions below actually + // test. With one workspace open, `registry_entries()` and the config-scoped + // form agree, and this case would keep passing if the forwarding regressed. let other_tmp = tempdir().expect("second tempdir"); let other_config = Config { workspace_dir: other_tmp.path().to_path_buf(), From 93da28c39f1a3d2d6ead39ca3e0ee78673efa69c Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 20:41:05 +0300 Subject: [PATCH 12/13] fix(tests): use correct config in tool registry approval e2e test The test `tool_registry_entries_include_connected_mcp_client_tools` was passing the wrong config variable to `registry_entries_for_config`, causing it to check the default config instead of the one with the MCP client connection. This change corrects the argument to use `other_config`, ensuring the test verifies the intended behavior of including connected MCP client tools in the registry entries. Auto-committed-on: dragonfly Co-authored-by: Medulla --- tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs index 2fb608c48d..868d0984aa 100644 --- a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs +++ b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs @@ -673,7 +673,7 @@ async fn tool_registry_entries_include_connected_mcp_client_tools() { // but `None` once another case in this binary has opened a second one — so // the ambient form reports nothing connected here purely because of who // else ran first. - let entries = registry_entries_for_config(&config); + let entries = registry_entries_for_config(&other_config); let client_entry = entries .iter() .find(|entry| entry.tool_id == format!("mcp-client::{}::echo", server.server_id)) From bfcbe35eb0ba8a06f9884207262bd1d34d3a0a37 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sun, 23 Aug 2026 20:41:55 +0300 Subject: [PATCH 13/13] fix(tests): correct config reference in tool registry approval test The test was using `other_config` instead of `config` when calling `registry_entries_for_config`, which meant it was checking the wrong configuration for connected MCP client tools. This change fixes the reference to use the correct config variable so the test verifies the intended configuration. Auto-committed-on: dragonfly Co-authored-by: Medulla --- tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs index 868d0984aa..2fb608c48d 100644 --- a/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs +++ b/tests/raw_coverage/tool_registry_approval_raw_coverage_e2e.rs @@ -673,7 +673,7 @@ async fn tool_registry_entries_include_connected_mcp_client_tools() { // but `None` once another case in this binary has opened a second one — so // the ambient form reports nothing connected here purely because of who // else ran first. - let entries = registry_entries_for_config(&other_config); + let entries = registry_entries_for_config(&config); let client_entry = entries .iter() .find(|entry| entry.tool_id == format!("mcp-client::{}::echo", server.server_id))