Struct McpPool 

pub struct McpPool { /* private fields */ }

A shared MCP connection pool over one executor, caching each connected server’s advertised tool defs by config signature.

Implementations

impl McpPool

pub fn new(shared: Arc<Mutex<ToolExecutor>>, reserved: HashSet<String>) -> Self

Build a pool over shared, reserving reserved names from advertisement.

pub fn with_env_allowlist(self, allow: Vec<String>) -> Self

Allow these credential-shaped variables in MCP ${VAR} headers.

pub fn with_credential_store(self, kind: CredentialStoreKind) -> Self

Read and write MCP grants through kind’s backend.

pub fn for_daemon( shared_mcp: Arc<Mutex<ToolExecutor>>, config_servers: &[MCPServerConfig], ) -> Arc<Self>

Build the daemon’s shared pool over shared_mcp: reserve built-in and sub-agent tool names (so a server tool can’t shadow a core one) and seed the already-connected global config_servers with empty defs, so a blueprint that re-declares one doesn’t open a duplicate connection.

pub fn for_daemon_with( shared_mcp: Arc<Mutex<ToolExecutor>>, config_servers: &[MCPServerConfig], credential_store: CredentialStoreKind, allow_env_vars: Vec<String>, ) -> Arc<Self>

for_daemon reading and writing MCP OAuth grants through credential_store’s backend.

The pool refreshes lapsed tokens and writes them back, so it has to write them where the user asked for them to be kept - otherwise the first refresh after a keychain migration would put a fresh refresh token back on disk.

pub fn seed(&self, config: &MCPServerConfig, defs: Vec<Tool>)

Seed the cache with an already-connected server’s defs (used at startup for the global config servers, connected once by ToolRegistry::build).

pub async fn ensure(&self, config: &MCPServerConfig) -> Vec<Tool>

Ensure config is connected (idempotent by signature) and return its advertised tool defs. A connection failure logs and returns no defs (the agent simply doesn’t get that server’s tools); it is not cached, so a later spawn retries.

pub async fn ensure_all(self: Arc<Self>, servers: Vec<MCPServerConfig>)

Connect every server in servers (idempotent). Takes Arc<Self> + owned servers so it can be tokio::spawned directly as a detached warm task (e.g. by the fan-out spawner) without a wrapping closure.

pub async fn warm_recovered(&self, runs_dir: &Path)

Warm the per-agent [[mcp_servers]] of every non-terminal persisted run in runs_dir, so a run reloaded on daemon restart can still execute its blueprint MCP tools (their advertisement is restored from the snapshot; only the shared connection is lost across a restart). Blueprint paths are collected synchronously, then connected - no fs iterator is held across an .await.

pub fn cached_defs_for(&self, configs: &[MCPServerConfig]) -> Vec<Tool>

The cached defs for every config in configs (pool must already be warm for them - call Self::ensure first). Unknown/unconnected configs contribute nothing. This is the sync read the spawner uses.