Enum ClientMessage 

pub enum ClientMessage {
    Request(ClientJsonrpcRequest),
    Notification(ClientJsonrpcNotification),
    Response(ClientJsonrpcResponse),
    Error(JsonrpcErrorResponse),
}

“Similar to JsonrpcMessage, but with the variants restricted to client-side messages.” ClientMessage represents a message sent by an MCP Client and received by an MCP Server.

Variants

Request(ClientJsonrpcRequest)

Notification(ClientJsonrpcNotification)

Response(ClientJsonrpcResponse)

Error(JsonrpcErrorResponse)

Implementations

impl ClientMessage

pub fn as_response(self) -> Result<ClientJsonrpcResponse, RpcError>

Converts the current message into a ClientJsonrpcResponse if it’s of the correct type.

This function checks if the current message is of type Response. If so, it returns the ClientJsonrpcResponse wrapped in a Result::Ok. If the message is not a Response, it returns an error with a descriptive message indicating the mismatch in expected message types.

Returns

• Ok(ClientJsonrpcResponse) if the message is a valid Response.
• Err(RpcError) if the message type is invalid

pub fn as_request(self) -> Result<ClientJsonrpcRequest, RpcError>

Converts the current message into a ClientJsonrpcRequest if it’s of the correct type.

This function checks if the current message is of type Request. If so, it returns the ClientJsonrpcRequest wrapped in a Result::Ok. If the message is not a Request, it returns an error with a descriptive message indicating the mismatch in expected message types.

Returns

• Ok(ClientJsonrpcRequest) if the message is a valid Request.
• Err(RpcError) if the message type is invalid

pub fn as_notification(self) -> Result<ClientJsonrpcNotification, RpcError>

Converts the current message into a ClientJsonrpcNotification if it’s of the correct type.

This function checks if the current message is of type Notification. If so, it returns the ClientJsonrpcNotification wrapped in a Result::Ok. If the message is not a Notification, it returns an error with a descriptive message indicating the mismatch in expected message types.

Returns

• Ok(ClientJsonrpcNotification) if the message is a valid Notification.
• Err(RpcError) if the message type is invalid

pub fn as_error(self) -> Result<JsonrpcErrorResponse, RpcError>

Converts the current message into a JsonrpcErrorResponse if it’s of the correct type.

This function checks if the current message is of type Error. If so, it returns the JsonrpcErrorResponse wrapped in a Result::Ok. If the message is not a Error, it returns an error with a descriptive message indicating the mismatch in expected message types.

Returns

• Ok(JsonrpcErrorResponse) if the message is a valid Error.
• Err(RpcError) if the message type is invalid

pub fn is_initialize_request(&self) -> bool

Returns true if message is an InitializeRequest.

pub fn is_initialized_notification(&self) -> bool

Returns true if the message is an InitializedNotification

Trait Implementations

impl Clone for ClientMessage

fn clone(&self) -> ClientMessage

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClientMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClientMessage

fn deserialize<__D>( __deserializer: __D, ) -> Result<ClientMessage, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ClientMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<ClientJsonrpcNotification> for ClientMessage

fn from(value: ClientJsonrpcNotification) -> ClientMessage

Converts to this type from the input type.

impl From<ClientJsonrpcRequest> for ClientMessage

fn from(value: ClientJsonrpcRequest) -> ClientMessage

Converts to this type from the input type.

impl From<ClientJsonrpcResponse> for ClientMessage

fn from(value: ClientJsonrpcResponse) -> ClientMessage

Converts to this type from the input type.

impl From<ClientMessage> for ClientMessages

fn from(value: ClientMessage) -> ClientMessages

Converts to this type from the input type.

impl FromMessage<MessageFromClient> for ClientMessage

fn from_message( message: MessageFromClient, request_id: Option<RequestId>, ) -> Result<ClientMessage, RpcError>

impl FromStr for ClientMessage

type Err = RpcError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<ClientMessage, <ClientMessage as FromStr>::Err>

Parses a string s to return a value of this type.

impl McpDispatch<ClientMessages, ServerMessages, ClientMessage, ServerMessage> for MessageDispatcher<ClientMessage>

fn send_message<'life0, 'async_trait>( &'life0 self, messages: ServerMessages, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MessageDispatcher<ClientMessage>: 'async_trait,

Sends a message from the server to the client and awaits a response if applicable.

Serializes the ServerMessages to JSON, writes it to the transport, and waits for a ClientMessages response if the message is a request. Notifications and responses return Ok(None).

Arguments

• messages - The client message to send, coulld be a single message or batch.

Returns

A TransportResult containing Some(ClientMessages) for requests with a response, or None for notifications/responses, or an error if the operation fails.

Errors

Returns a TransportError if serialization, writing, or timeout occurs.

fn write_str<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, skip_store: bool, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MessageDispatcher<ClientMessage>: 'async_trait,

Writes a string payload to the underlying asynchronous writable stream, appending a newline character and flushing the stream afterward.

fn send<'life0, 'async_trait>( &'life0 self, message: ServerMessage, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientMessage>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MessageDispatcher<ClientMessage>: 'async_trait,

fn send_batch<'life0, 'async_trait>( &'life0 self, message: Vec<ServerMessage>, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ClientMessage>>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MessageDispatcher<ClientMessage>: 'async_trait,

impl McpDispatch<ClientMessages, ServerMessages, ClientMessage, ServerMessage> for SseTransport<ClientMessage>

fn send_message<'life0, 'async_trait>( &'life0 self, message: ServerMessages, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

Sends a raw message represented by type S and optionally includes a request_id. The request_id is used when sending a message in response to an MCP request. It should match the request_id of the original request.

fn send<'life0, 'async_trait>( &'life0 self, message: ServerMessage, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientMessage>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

fn send_batch<'life0, 'async_trait>( &'life0 self, message: Vec<ServerMessage>, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ClientMessage>>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

fn write_str<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, skip_store: bool, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

Writes a string payload to the underlying asynchronous writable stream, appending a newline character and flushing the stream afterward.

impl McpDispatch<ClientMessages, ServerMessages, ClientMessage, ServerMessage> for StdioTransport<ClientMessage>

fn send_message<'life0, 'async_trait>( &'life0 self, message: ServerMessages, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, StdioTransport<ClientMessage>: 'async_trait,

Sends a raw message represented by type S and optionally includes a request_id. The request_id is used when sending a message in response to an MCP request. It should match the request_id of the original request.

fn send<'life0, 'async_trait>( &'life0 self, message: ServerMessage, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientMessage>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, StdioTransport<ClientMessage>: 'async_trait,

fn send_batch<'life0, 'async_trait>( &'life0 self, message: Vec<ServerMessage>, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ClientMessage>>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, StdioTransport<ClientMessage>: 'async_trait,

fn write_str<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, skip_store: bool, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, StdioTransport<ClientMessage>: 'async_trait,

Writes a string payload to the underlying asynchronous writable stream, appending a newline character and flushing the stream afterward.

impl McpDispatch<ServerMessages, ClientMessages, ServerMessage, ClientMessage> for ClientSseTransport<ServerMessage>

fn send_message<'life0, 'async_trait>( &'life0 self, message: ClientMessages, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ClientSseTransport<ServerMessage>: 'async_trait,

Sends a raw message represented by type S and optionally includes a request_id. The request_id is used when sending a message in response to an MCP request. It should match the request_id of the original request.

fn send<'life0, 'async_trait>( &'life0 self, message: ClientMessage, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessage>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ClientSseTransport<ServerMessage>: 'async_trait,

fn send_batch<'life0, 'async_trait>( &'life0 self, message: Vec<ClientMessage>, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ServerMessage>>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ClientSseTransport<ServerMessage>: 'async_trait,

fn write_str<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, skip_store: bool, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ClientSseTransport<ServerMessage>: 'async_trait,

Writes a string payload to the underlying asynchronous writable stream, appending a newline character and flushing the stream afterward.

impl McpDispatch<ServerMessages, ClientMessages, ServerMessage, ClientMessage> for ClientStreamableTransport<ServerMessage>

fn send_message<'life0, 'async_trait>( &'life0 self, message: ClientMessages, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ClientStreamableTransport<ServerMessage>: 'async_trait,

Sends a raw message represented by type S and optionally includes a request_id. The request_id is used when sending a message in response to an MCP request. It should match the request_id of the original request.

fn send<'life0, 'async_trait>( &'life0 self, message: ClientMessage, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessage>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ClientStreamableTransport<ServerMessage>: 'async_trait,

fn send_batch<'life0, 'async_trait>( &'life0 self, message: Vec<ClientMessage>, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ServerMessage>>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ClientStreamableTransport<ServerMessage>: 'async_trait,

fn write_str<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, skip_store: bool, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ClientStreamableTransport<ServerMessage>: 'async_trait,

Writes a string payload to the underlying asynchronous writable stream, appending a newline character and flushing the stream afterward.

impl McpDispatch<ServerMessages, ClientMessages, ServerMessage, ClientMessage> for MessageDispatcher<ServerMessage>

fn send_message<'life0, 'async_trait>( &'life0 self, messages: ClientMessages, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MessageDispatcher<ServerMessage>: 'async_trait,

Sends a message from the client to the server and awaits a response if applicable.

Serializes the ClientMessages to JSON, writes it to the transport, and waits for a ServerMessages response if the message is a request. Notifications and responses return Ok(None).

Arguments

• messages - The client message to send, coulld be a single message or batch.

Returns

A TransportResult containing Some(ServerMessages) for requests with a response, or None for notifications/responses, or an error if the operation fails.

Errors

Returns a TransportError if serialization, writing, or timeout occurs.

fn write_str<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, _skip_store: bool, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MessageDispatcher<ServerMessage>: 'async_trait,

Writes a string payload to the underlying asynchronous writable stream, appending a newline character and flushing the stream afterward.

fn send<'life0, 'async_trait>( &'life0 self, message: ClientMessage, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessage>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MessageDispatcher<ServerMessage>: 'async_trait,

fn send_batch<'life0, 'async_trait>( &'life0 self, message: Vec<ClientMessage>, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ServerMessage>>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MessageDispatcher<ServerMessage>: 'async_trait,

impl McpDispatch<ServerMessages, ClientMessages, ServerMessage, ClientMessage> for StdioTransport<ServerMessage>

fn send_message<'life0, 'async_trait>( &'life0 self, message: ClientMessages, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, StdioTransport<ServerMessage>: 'async_trait,

Sends a raw message represented by type S and optionally includes a request_id. The request_id is used when sending a message in response to an MCP request. It should match the request_id of the original request.

fn send<'life0, 'async_trait>( &'life0 self, message: ClientMessage, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<ServerMessage>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, StdioTransport<ServerMessage>: 'async_trait,

fn send_batch<'life0, 'async_trait>( &'life0 self, message: Vec<ClientMessage>, request_timeout: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ServerMessage>>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, StdioTransport<ServerMessage>: 'async_trait,

fn write_str<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, skip_store: bool, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, StdioTransport<ServerMessage>: 'async_trait,

Writes a string payload to the underlying asynchronous writable stream, appending a newline character and flushing the stream afterward.

impl McpMessage for ClientMessage

fn message_type(&self) -> MessageTypes

Determines the type of the message and returns the corresponding MessageTypes variant.

fn is_response(&self) -> bool

fn is_request(&self) -> bool

fn is_notification(&self) -> bool

fn is_error(&self) -> bool

impl RpcMessage for ClientMessage

fn request_id(&self) -> Option<&RequestId>

fn jsonrpc(&self) -> &str

fn method(&self) -> Option<&str>

impl Serialize for ClientMessage

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Transport<ClientMessages, MessageFromServer, ClientMessage, ServerMessages, ServerMessage> for SseTransport<ClientMessage>

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ReceiverStream<ClientMessages>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MessageDispatcher<ClientMessage>: McpDispatch<ClientMessages, ServerMessages, ClientMessage, ServerMessage>, SseTransport<ClientMessage>: 'async_trait,

Starts the transport, initializing streams and message dispatcher

Sets up the MCP stream and dispatcher using the provided duplex streams.

Returns

• TransportResult<(Pin<Box<dyn Stream<Item = R> + Send>>, MessageDispatcher<R>, IoStream)>
  • The message stream, dispatcher, and error stream

Errors

• Returns TransportError if streams are already taken or not initialized

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

where 'life0: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

Checks if the transport has been shut down

Returns

• bool - True if the transport is shut down, false otherwise

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

where 'life0: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

Shuts down the transport, terminating tasks and signaling closure

Cancels any running tasks and clears the cancellation source.

Returns

• TransportResult<()> - Ok if shutdown is successful, Err if cancellation fails

fn message_sender( &self, ) -> Arc<RwLock<Option<MessageDispatcher<ClientMessage>>>>

fn error_stream(&self) -> &RwLock<Option<IoStream>>

fn consume_string_payload<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

fn keep_alive<'life0, 'async_trait>( &'life0 self, interval: Duration, disconnect_tx: Sender<()>, ) -> Pin<Box<dyn Future<Output = Result<JoinHandle<()>, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

fn pending_request_tx<'life0, 'life1, 'async_trait>( &'life0 self, request_id: &'life1 RequestId, ) -> Pin<Box<dyn Future<Output = Option<Sender<ClientMessage>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SseTransport<ClientMessage>: 'async_trait,

fn session_id<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<String>> + Send + 'async_trait>>

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

impl TransportDispatcher<ClientMessages, MessageFromServer, ClientMessage, ServerMessages, ServerMessage> for SseTransport<ClientMessage>

impl TransportDispatcher<ClientMessages, MessageFromServer, ClientMessage, ServerMessages, ServerMessage> for StdioTransport<ClientMessage>

impl TransportDispatcher<ServerMessages, MessageFromClient, ServerMessage, ClientMessages, ClientMessage> for ClientSseTransport<ServerMessage>

impl TransportDispatcher<ServerMessages, MessageFromClient, ServerMessage, ClientMessages, ClientMessage> for ClientStreamableTransport<ServerMessage>

impl TransportDispatcher<ServerMessages, MessageFromClient, ServerMessage, ClientMessages, ClientMessage> for StdioTransport<ServerMessage>