Struct StdioTransport

pub struct StdioTransport { /* private fields */ }

A transport implementation that uses standard input/output for communication.

This transport is suitable for scenarios where the client and server communicate through stdin/stdout, such as command-line applications or local development.

Thread Safety

The implementation is thread-safe, using Arc and Mutex to protect shared access to stdin/stdout. This allows the transport to be used safely across multiple threads in an async context.

Message Flow

• Input: Messages are read line by line from stdin, parsed as JSON-RPC messages
• Output: Messages are serialized to JSON and written to stdout

Example

use mcp_sdk_rs::transport::stdio::StdioTransport;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let transport = StdioTransport::new();
    Ok(())
}

Implementations

impl StdioTransport

pub fn new() -> (Self, Sender<Result<Message, Error>>)

Creates a new stdio transport instance using actual stdin/stdout.

Trait Implementations

impl Transport for StdioTransport

fn send<'life0, 'async_trait>( &'life0 self, message: Message, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Sends a message by writing it to stdout.

Arguments

• message - The message to send

Returns

Returns Ok(()) if the message was successfully written to stdout, or an error if the write failed or stdout was locked.

Errors

This function will return an error if:

• Failed to acquire the stdout lock
• Failed to serialize the message to JSON
• Failed to write to stdout
• Failed to flush stdout

fn receive(&self) -> Pin<Box<dyn Stream<Item = Result<Message, Error>> + Send>>

Creates a stream of messages received from stdin.

Returns

Returns a pinned box containing a stream that yields Result<Message, Error>. The stream will continue until stdin is closed or an error occurs.

Message Flow

1. Messages are read from stdin in the background task created in new()
2. Each message is sent through the broadcast channel
3. This stream receives messages from the broadcast channel

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Closes the transport.

For stdio transport, this is a no-op as we don’t own stdin/stdout.

Returns

Always returns Ok(()).