Struct Peer

pub struct Peer<R: ServiceRole> { /* private fields */ }

Available on crate features client or server only.

An interface to fetch the remote client or server

For general purpose, call Peer::send_request or Peer::send_notification to send message to remote peer.

To create a cancellable request, call Peer::send_request_with_option.

Implementations

impl Peer<RoleClient>

pub async fn complete( &self, params: CompleteRequestParam, ) -> Result<CompleteResult, ServiceError>

Available on crate feature client only.

pub async fn set_level( &self, params: SetLevelRequestParam, ) -> Result<(), ServiceError>

Available on crate feature client only.

pub async fn get_prompt( &self, params: GetPromptRequestParam, ) -> Result<GetPromptResult, ServiceError>

Available on crate feature client only.

pub async fn list_prompts( &self, params: Option<PaginatedRequestParam>, ) -> Result<ListPromptsResult, ServiceError>

Available on crate feature client only.

pub async fn list_resources( &self, params: Option<PaginatedRequestParam>, ) -> Result<ListResourcesResult, ServiceError>

Available on crate feature client only.

pub async fn list_resource_templates( &self, params: Option<PaginatedRequestParam>, ) -> Result<ListResourceTemplatesResult, ServiceError>

Available on crate feature client only.

pub async fn read_resource( &self, params: ReadResourceRequestParam, ) -> Result<ReadResourceResult, ServiceError>

Available on crate feature client only.

pub async fn subscribe( &self, params: SubscribeRequestParam, ) -> Result<(), ServiceError>

Available on crate feature client only.

pub async fn unsubscribe( &self, params: UnsubscribeRequestParam, ) -> Result<(), ServiceError>

Available on crate feature client only.

pub async fn call_tool( &self, params: CallToolRequestParam, ) -> Result<CallToolResult, ServiceError>

Available on crate feature client only.

pub async fn list_tools( &self, params: Option<PaginatedRequestParam>, ) -> Result<ListToolsResult, ServiceError>

Available on crate feature client only.

pub async fn notify_cancelled( &self, params: CancelledNotificationParam, ) -> Result<(), ServiceError>

Available on crate feature client only.

pub async fn notify_progress( &self, params: ProgressNotificationParam, ) -> Result<(), ServiceError>

Available on crate feature client only.

pub async fn notify_initialized(&self) -> Result<(), ServiceError>

Available on crate feature client only.

pub async fn notify_roots_list_changed(&self) -> Result<(), ServiceError>

Available on crate feature client only.

impl Peer<RoleClient>

pub async fn list_all_tools(&self) -> Result<Vec<Tool>, ServiceError>

Available on crate feature client only.

A wrapper method for Peer<RoleClient>::list_tools.

This function will call Peer<RoleClient>::list_tools multiple times until all tools are listed.

pub async fn list_all_prompts(&self) -> Result<Vec<Prompt>, ServiceError>

Available on crate feature client only.

A wrapper method for Peer<RoleClient>::list_prompts.

This function will call Peer<RoleClient>::list_prompts multiple times until all prompts are listed.

pub async fn list_all_resources(&self) -> Result<Vec<Resource>, ServiceError>

Available on crate feature client only.

A wrapper method for Peer<RoleClient>::list_resources.

This function will call Peer<RoleClient>::list_resources multiple times until all resources are listed.

pub async fn list_all_resource_templates( &self, ) -> Result<Vec<ResourceTemplate>, ServiceError>

Available on crate feature client only.

A wrapper method for Peer<RoleClient>::list_resource_templates.

This function will call Peer<RoleClient>::list_resource_templates multiple times until all resource templates are listed.

impl Peer<RoleServer>

pub async fn create_message( &self, params: CreateMessageRequestParam, ) -> Result<CreateMessageResult, ServiceError>

Available on crate feature server only.

pub async fn list_roots(&self) -> Result<ListRootsResult, ServiceError>

Available on crate feature server only.

pub async fn create_elicitation( &self, params: CreateElicitationRequestParam, ) -> Result<CreateElicitationResult, ServiceError>

Available on crate feature server only.

pub async fn create_elicitation_with_timeout( &self, params: CreateElicitationRequestParam, timeout: Option<Duration>, ) -> Result<CreateElicitationResult, ServiceError>

Available on crate feature server only.

pub async fn notify_cancelled( &self, params: CancelledNotificationParam, ) -> Result<(), ServiceError>

Available on crate feature server only.

pub async fn notify_progress( &self, params: ProgressNotificationParam, ) -> Result<(), ServiceError>

Available on crate feature server only.

pub async fn notify_logging_message( &self, params: LoggingMessageNotificationParam, ) -> Result<(), ServiceError>

Available on crate feature server only.

pub async fn notify_resource_updated( &self, params: ResourceUpdatedNotificationParam, ) -> Result<(), ServiceError>

Available on crate feature server only.

pub async fn notify_resource_list_changed(&self) -> Result<(), ServiceError>

Available on crate feature server only.

pub async fn notify_tool_list_changed(&self) -> Result<(), ServiceError>

Available on crate feature server only.

pub async fn notify_prompt_list_changed(&self) -> Result<(), ServiceError>

Available on crate feature server only.

impl Peer<RoleServer>

pub fn supports_elicitation(&self) -> bool

Available on crate feature server only.

Check if the client supports elicitation capability

Returns true if the client declared elicitation capability during initialization, false otherwise. According to MCP 2025-06-18 specification, clients that support elicitation MUST declare the capability during initialization.

pub async fn elicit<T>( &self, message: impl Into<String>, ) -> Result<Option<T>, ElicitationError>

where T: ElicitationSafe + for<'de> Deserialize<'de>,

Available on crate feature server only.

Request typed data from the user with automatic schema generation.

This method automatically generates the JSON schema from the Rust type using schemars, eliminating the need to manually create schemas. The response is automatically parsed into the requested type.

Requires the elicitation feature to be enabled.

Type Requirements

The type T must implement:

• schemars::JsonSchema - for automatic schema generation
• serde::Deserialize - for parsing the response

Arguments

• message - The prompt message for the user

Returns

• Ok(Some(data)) if user provided valid data that matches type T
• Err(ElicitationError::UserDeclined) if user explicitly declined the request
• Err(ElicitationError::UserCancelled) if user cancelled/dismissed the request
• Err(ElicitationError::ParseError { .. }) if response data couldn’t be parsed into type T
• Err(ElicitationError::NoContent) if no response content was provided
• Err(ElicitationError::Service(_)) if the underlying service call failed

Example

Add to your Cargo.toml:

[dependencies]
rmcp = { version = "0.3", features = ["elicitation"] }
serde = { version = "1.0", features = ["derive"] }
schemars = "1.0"

#[derive(Debug, Serialize, Deserialize, JsonSchema)]
struct UserProfile {
    #[schemars(description = "Full name")]
    name: String,
    #[schemars(description = "Email address")]
    email: String,
    #[schemars(description = "Age")]
    age: u8,
}

// Mark as safe for elicitation (generates object schema)
rmcp::elicit_safe!(UserProfile);

match peer.elicit::<UserProfile>("Please enter your profile information").await {
    Ok(Some(profile)) => {
        println!("Name: {}, Email: {}, Age: {}", profile.name, profile.email, profile.age);
    }
    Ok(None) => {
        println!("User provided no content");
    }
    Err(ElicitationError::UserDeclined) => {
        println!("User explicitly declined to provide information");
        // Handle explicit decline - perhaps offer alternatives
    }
    Err(ElicitationError::UserCancelled) => {
        println!("User cancelled the request");
        // Handle cancellation - perhaps prompt again later
    }
    Err(ElicitationError::ParseError { error, data }) => {
        println!("Failed to parse response: {}\nData: {}", error, data);
    }
    Err(e) => return Err(e.into()),
}

pub async fn elicit_with_timeout<T>( &self, message: impl Into<String>, timeout: Option<Duration>, ) -> Result<Option<T>, ElicitationError>

where T: ElicitationSafe + for<'de> Deserialize<'de>,

Available on crate feature server only.

Request typed data from the user with custom timeout.

Same as elicit() but allows specifying a custom timeout for the request. If the user doesn’t respond within the timeout, the request will be cancelled.

Arguments

• message - The prompt message for the user
• timeout - Optional timeout duration. If None, uses default timeout behavior

Returns

Same as elicit() but may also return ServiceError::Timeout if timeout expires

Example

#[derive(Debug, Serialize, Deserialize, JsonSchema)]
struct QuickResponse {
    answer: String,
}

// Mark as safe for elicitation
rmcp::elicit_safe!(QuickResponse);

// Give user 30 seconds to respond
let timeout = Some(Duration::from_secs(30));
match peer.elicit_with_timeout::<QuickResponse>(
    "Quick question - what's your answer?",
    timeout
).await {
    Ok(Some(response)) => println!("Got answer: {}", response.answer),
    Ok(None) => println!("User provided no content"),
    Err(ElicitationError::UserDeclined) => {
        println!("User explicitly declined");
        // Handle explicit decline
    }
    Err(ElicitationError::UserCancelled) => {
        println!("User cancelled/dismissed");
        // Handle cancellation
    }
    Err(ElicitationError::Service(ServiceError::Timeout { .. })) => {
        println!("User didn't respond in time");
    }
    Err(e) => return Err(e.into()),
}

impl<R: ServiceRole> Peer<R>

pub async fn send_notification( &self, notification: R::Not, ) -> Result<(), ServiceError>

pub async fn send_request( &self, request: R::Req, ) -> Result<R::PeerResp, ServiceError>

pub async fn send_cancellable_request( &self, request: R::Req, options: PeerRequestOptions, ) -> Result<RequestHandle<R>, ServiceError>

pub async fn send_request_with_option( &self, request: R::Req, options: PeerRequestOptions, ) -> Result<RequestHandle<R>, ServiceError>

pub fn peer_info(&self) -> Option<&R::PeerInfo>

pub fn set_peer_info(&self, info: R::PeerInfo)

pub fn is_transport_closed(&self) -> bool

Trait Implementations

impl<R: Clone + ServiceRole> Clone for Peer<R>

where R::PeerInfo: Clone,

fn clone(&self) -> Peer<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: ServiceRole> Debug for Peer<R>

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

Formats the value using the given formatter.

impl<S> FromToolCallContextPart<S> for Peer<RoleServer>

Available on crate feature server only.

fn from_tool_call_context_part( context: &mut ToolCallContext<'_, S>, ) -> Result<Self, ErrorData>