Struct McpToolExecutor 

pub struct McpToolExecutor { /* private fields */ }

MCP tool executor – routes tool calls to the appropriate MCP server.

Servers are held as dyn McpSession, so a stdio subprocess (McpServer) and a remote HTTP connector (car-connectors) coexist in the same routing table.

Implementations

impl McpToolExecutor

pub fn new() -> Self

pub fn with_fallback(self, fallback: Arc<dyn ToolExecutor>) -> Self

pub async fn add_server(&self, server: McpServer) -> Result<Vec<String>, String>

Add an MCP server and discover its tools. Returns the list of discovered tool names (canonical form: mcp_{server}_{tool}).

pub async fn add_session( &self, name: impl Into<String>, session: Arc<Mutex<dyn McpSession>>, )

Register an already-connected session under name without adding any tool routes. Unlike add_server, routes are added explicitly via set_route so the caller can gate exactly which of a server’s tools become callable — the connector manager uses this to keep discovered-but-not-yet-enabled tools invisible and unroutable.

pub async fn set_route( &self, tool: impl Into<String>, server: impl Into<String>, )

Route the canonical tool name tool (the namespaced name the model sees, e.g. mcp_github_create_issue) to server. On dispatch the bare server-side name is recovered by stripping the mcp_{server}_ prefix.

pub async fn remove_server(&self, name: &str)

Drop a session and every route that pointed at it.

pub async fn clear_routes_for_server(&self, name: &str)

Drop only the routes for server (e.g. when disabling its tools) while keeping the underlying connection alive.

pub async fn remove_route(&self, tool: &str)

Drop a single tool route by its canonical (model-visible) name, keeping the connection and the server’s other routes intact. Used when disabling one tool of a connector.

pub async fn handles(&self, tool: &str) -> bool

True if some connected server currently handles tool.

pub async fn session(&self, name: &str) -> Option<Arc<Mutex<dyn McpSession>>>

Retrieve a live MCP session by its server name, if connected.

Returns the same Arc<Mutex<dyn McpSession>> handle stored by add_session/add_server, so a caller (e.g. the daemon binding a connector-driven session to an crate::substrate::McpSubstrate) can wrap the existing connection rather than dialing a second one. The substrate and the mcp_{name}_* routes then share one session.

pub fn share_with_fallback(&self, fallback: Arc<dyn ToolExecutor>) -> Self

Build a view over the same shared server/route state with a per-caller fallback. The daemon keeps one shared executor for all connectors and hands each WS session its own view whose fallback is that session’s WS tool executor.

pub async fn tool_schemas(&self) -> Vec<(String, ToolSchema)>

Get tool schemas from all connected MCP servers.

pub async fn shutdown_all(&self)

Shut down all MCP servers.

Trait Implementations

impl Default for McpToolExecutor

fn default() -> Self

Returns the “default value” for a type.

impl ToolExecutor for McpToolExecutor

fn execute<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tool: &'life1 str, params: &'life2 Value, ) -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn execute_with_action<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tool: &'life1 str, params: &'life2 Value, action_id: &'life3 str, timeout_ms: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Variant that also carries the originating proposal Action.id and its timeout_ms budget.

fn execute_with_action_in_session<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tool: &'life1 str, params: &'life2 Value, action_id: &'life3 str, timeout_ms: Option<u64>, session_id: Option<&'life4 str>, attempt: u32, ) -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Variant that also carries the Runtime execution session and the retry attempt. Executors that retain safety-relevant state across calls (such as a read-before-edit ledger) override this to keep that state isolated by session. Existing executors retain their current behavior through the default delegation.

fn execute_with_action_state_in_session<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>( &'life0 self, tool: &'life1 str, params: &'life2 Value, action_id: &'life3 str, timeout_ms: Option<u64>, session_id: Option<&'life4 str>, attempt: u32, expected_effects: &'life5 HashMap<String, Value>, return_schema: Option<&'life6 Value>, ) -> Pin<Box<dyn Future<Output = Result<ToolExecution, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait, 'life6: 'async_trait,

Execute one action while allowing a transport to return runtime-observed state mutations alongside its ordinary tool output.

fn execute_classified<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>( &'life0 self, tool: &'life1 str, params: &'life2 Value, action_id: &'life3 str, timeout_ms: Option<u64>, session_id: Option<&'life4 str>, attempt: u32, expected_effects: &'life5 HashMap<String, Value>, return_schema: Option<&'life6 Value>, ) -> Pin<Box<dyn Future<Output = Result<ToolExecution, ToolFailure>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait, 'life6: 'async_trait,

Execute one action with typed failure evidence.

fn execute_stream<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tool: &'life1 str, _params: &'life2 Value, _action_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Receiver<ToolStreamChunk>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Streaming entry point for detached invocation modes (C2). Start the tool and return a channel of car_ir::ToolStreamChunks; the runtime drains it into the per-runtime handle registry while the DAG proceeds. End the stream with a terminal chunk (done / error); dropping the sender without one is reported as failure. A cooperative executor should stop work when the receiver returned here is dropped (that’s what cancellation looks like from its side).