Struct McpServer 

pub struct McpServer { /* private fields */ }

A running MCP server connection.

A background reader task owns stdout and demultiplexes responses by id into per-request oneshot channels. send_request writes to stdin and then awaits its channel — never read_line directly. So a request timeout (or any cancellation of the caller’s future) only drops a receiver; the reader keeps consuming the stream and discards the now-orphaned response. This makes the transport cancel-safe by construction: there is no read to interrupt mid-line, hence no desync and no poison/recovery dance.

Implementations

impl McpServer

pub async fn start(config: McpServerConfig) -> Result<Self, String>

Start an MCP server and initialize the connection.

pub async fn list_tools(&mut self) -> Result<Vec<McpToolInfo>, String>

Discover tools from this MCP server.

pub async fn call_tool( &mut self, name: &str, arguments: Value, ) -> Result<Value, String>

Call a tool on this MCP server.

pub async fn call_tool_with_timeout( &mut self, name: &str, arguments: Value, timeout: Option<Duration>, ) -> Result<Value, String>

Call a tool, bounding the response await by timeout (else the backstop). Callers that know a tool can run long (e.g. the substrate’s run_command carrying its own timeout) pass it here so CAR doesn’t abandon a call that is still executing server-side.

pub async fn shutdown(self)

Shut down the MCP server gracefully.

pub fn name(&self) -> &str

Get the server name.

Trait Implementations

impl Drop for McpServer

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl McpSession for McpServer

fn list_tools<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Vec<McpToolInfo>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Discover the tools this server exposes.

fn call_tool<'life0, 'life1, 'async_trait>( &'life0 mut self, name: &'life1 str, arguments: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send + 'async_trait>>

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

Invoke a tool by its bare (server-side) name.

fn call_tool_with_timeout<'life0, 'life1, 'async_trait>( &'life0 mut self, name: &'life1 str, arguments: Value, timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send + 'async_trait>>

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

Invoke a tool, bounding the response await by timeout (else the session’s backstop). Default ignores timeout (back-compat for sessions where calls are short); the stdio McpServer honors it so a long-running run_command isn’t cut off mid-execution.

fn name(&self) -> &str

The server’s registered name (the routing key).