Struct RunningService 

pub struct RunningService<R, S>
where
    R: ServiceRole,
    S: Service<R>,
{ /* private fields */ }

Available on crate feature mcp and crate feature tools and (crate features client or server) only.

Implementations

impl<S> RunningService<RoleClient, S>

where S: Service<RoleClient>,

pub async fn call_tool_once( &self, params: CallToolRequestParams, ) -> Result<CallToolResponse, ServiceError>

Send one tools/call request without driving MRTR follow-up rounds.

pub async fn get_prompt_once( &self, params: GetPromptRequestParams, ) -> Result<GetPromptResponse, ServiceError>

Send one prompts/get request without driving MRTR follow-up rounds.

pub async fn read_resource_once( &self, params: ReadResourceRequestParams, ) -> Result<ReadResourceResponse, ServiceError>

Send one resources/read request without driving MRTR follow-up rounds.

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

High-level tools/call helper that automatically fulfils SEP-2322 input_required rounds through the local ClientHandler service.

Errors

Returns ServiceError::InputRequiredRoundsExceeded if the peer does not produce a final CallToolResult within the default MRTR round cap. Other transport, protocol, and local input-handler errors are propagated.

pub async fn call_tool_with_mrtr_max_rounds( &self, params: CallToolRequestParams, max_rounds: usize, ) -> Result<CallToolResult, ServiceError>

Same as Self::call_tool, with an explicit MRTR round cap.

Errors

Returns ServiceError::InputRequiredRoundsExceeded once max_rounds input_required responses have been driven without receiving a final CallToolResult. Other transport, protocol, and local input-handler errors are propagated.

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

High-level prompts/get helper that automatically fulfils SEP-2322 input_required rounds through the local ClientHandler service.

Errors

Returns ServiceError::InputRequiredRoundsExceeded if the peer does not produce a final GetPromptResult within the default MRTR round cap. Other transport, protocol, and local input-handler errors are propagated.

pub async fn get_prompt_with_mrtr_max_rounds( &self, params: GetPromptRequestParams, max_rounds: usize, ) -> Result<GetPromptResult, ServiceError>

Same as Self::get_prompt, with an explicit MRTR round cap.

Errors

Returns ServiceError::InputRequiredRoundsExceeded once max_rounds input_required responses have been driven without receiving a final GetPromptResult. Other transport, protocol, and local input-handler errors are propagated.

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

High-level resources/read helper that automatically fulfils SEP-2322 input_required rounds through the local ClientHandler service.

Errors

Returns ServiceError::InputRequiredRoundsExceeded if the peer does not produce a final ReadResourceResult within the default MRTR round cap. Other transport, protocol, and local input-handler errors are propagated.

pub async fn read_resource_with_mrtr_max_rounds( &self, params: ReadResourceRequestParams, max_rounds: usize, ) -> Result<ReadResourceResult, ServiceError>

Same as Self::read_resource, with an explicit MRTR round cap.

Errors

Returns ServiceError::InputRequiredRoundsExceeded once max_rounds input_required responses have been driven without receiving a final ReadResourceResult. Other transport, protocol, and local input-handler errors are propagated.

impl<R, S> RunningService<R, S>

where R: ServiceRole, S: Service<R>,

pub fn peer(&self) -> &Peer<R>

pub fn service(&self) -> &S

pub fn cancellation_token(&self) -> RunningServiceCancellationToken

pub fn is_closed(&self) -> bool

Returns true if the service has been closed or cancelled.

pub async fn waiting(self) -> Result<QuitReason, JoinError>

Wait for the service to complete.

This will block until the service loop terminates (either due to cancellation, transport closure, or an error).

pub async fn close(&mut self) -> Result<QuitReason, JoinError>

Gracefully close the connection and wait for cleanup to complete.

This method cancels the service, waits for the background task to finish (which includes calling transport.close()), and ensures all cleanup operations complete before returning.

Unlike cancel, this method takes &mut self and can be called without consuming the RunningService. After calling this method, the service is considered closed and subsequent operations will fail.

Example

let mut client = ().serve(transport).await?;
// ... use the client ...
client.close().await?;

pub async fn close_with_timeout( &mut self, timeout: Duration, ) -> Result<Option<QuitReason>, JoinError>

Gracefully close the connection with a timeout.

Similar to close, but returns after the specified timeout if the cleanup doesn’t complete in time. This is useful for ensuring a bounded shutdown time.

Returns Ok(Some(reason)) if shutdown completed within the timeout, Ok(None) if the timeout was reached, or Err if there was a join error.

pub async fn cancel(self) -> Result<QuitReason, JoinError>

Cancel the service and wait for cleanup to complete.

This consumes the RunningService and ensures the connection is properly closed. For a non-consuming alternative, see close.

Methods from Deref<Target = Peer<R>>

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

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

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

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

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

Snapshot of the peer’s handshake info.

pub fn set_peer_info(&self, info: <R as ServiceRole>::PeerInfo)

Stores the peer’s handshake info, overwriting any previous value.

pub fn is_transport_closed(&self) -> bool

Trait Implementations

impl<R, S> Debug for RunningService<R, S>

where R: Debug + ServiceRole, S: Debug + Service<R>,

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

Formats the value using the given formatter.

impl<R, S> Deref for RunningService<R, S>

where R: ServiceRole, S: Service<R>,

type Target = Peer<R>

The resulting type after dereferencing.

fn deref(&self) -> &<RunningService<R, S> as Deref>::Target

Dereferences the value.

impl<R, S> Drop for RunningService<R, S>

where R: ServiceRole, S: Service<R>,

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.