Struct ConnectionRefresher 

pub struct ConnectionRefresher<S, F>
where
    S: Service<RoleClient> + Send + Sync + 'static,
    F: ConnectionFactory<S>,
{ /* private fields */ }

Available on crate features mcp and tools only.

Connection refresher that wraps an MCP client and handles automatic reconnection.

This is similar to adk-go’s connectionRefresher struct. It transparently retries operations after reconnecting when the underlying session fails.

Type Parameters

• S - The service type for the MCP client
• F - The factory type for creating new connections

Example

use adk_tool::mcp::{ConnectionRefresher, ConnectionFactory};

struct MyFactory { /* ... */ }

#[async_trait::async_trait]
impl ConnectionFactory<MyService> for MyFactory {
    async fn create_connection(&self) -> Result<RunningService<RoleClient, MyService>, String> {
        // Create and return a new connection
    }
}

let refresher = ConnectionRefresher::new(initial_client, Arc::new(factory));

// Read-only discovery automatically retries on connection failure.
let tools = refresher.list_tools().await?;

// Tool calls are not replayed unless the caller explicitly opts in.
// The server chooses whether to answer inline or with a task, so the
// caller reads the response to find out which happened.
let response = refresher
    .with_tool_call_retries()
    .call_tool(params)
    .await?
    .value;
match response {
    CallToolResponse::Complete(result) => println!("{result:?}"),
    other => println!("not a plain result: {other:?}"),
}

Implementations

impl<S, F> ConnectionRefresher<S, F>

where S: Service<RoleClient> + Send + Sync + 'static, F: ConnectionFactory<S>,

pub fn new( client: RunningService<RoleClient, S>, factory: Arc<F>, ) -> ConnectionRefresher<S, F>

Create a new connection refresher with an initial client and factory.

Arguments

• client - The initial MCP client connection
• factory - Factory for creating new connections when needed

pub fn lazy(factory: Arc<F>) -> ConnectionRefresher<S, F>

Create a new connection refresher without an initial connection.

The first operation will trigger a connection.

pub fn with_config(self, config: RefreshConfig) -> ConnectionRefresher<S, F>

Set the refresh configuration.

pub fn with_max_attempts(self, attempts: u32) -> ConnectionRefresher<S, F>

Set the maximum number of reconnection attempts.

pub fn with_tool_call_retries(self) -> ConnectionRefresher<S, F>

Allow tools/call to be replayed after reconnecting.

A transport failure after request transmission is an ambiguous outcome: a mutating tool may have completed its external effect before the response was lost. Enable this only for read-only tools or operations protected by a stable provider idempotency guarantee.

Example

let refresher = ConnectionRefresher::new(client, Arc::new(factory))
    .with_tool_call_retries();

pub async fn list_tools(&self) -> Result<RetryResult<Vec<Tool>>, String>

List all tools from the MCP server with automatic reconnection.

Handles pagination internally and restarts from scratch if reconnection occurs (per MCP spec, cursors don’t persist across sessions).

pub async fn call_tool( &self, params: CallToolRequestParams, ) -> Result<RetryResult<CallToolResponse>, String>

Call a tool on the MCP server.

Tool calls are not replayed by default after an ambiguous connection failure. Use Self::with_tool_call_retries only when the operation is known to be replay-safe.

pub async fn cancellation_token( &self, ) -> Option<RunningServiceCancellationToken>

Get the cancellation token for the current connection.

pub async fn is_connected(&self) -> bool

Check if currently connected.

pub async fn reconnect(&self) -> Result<(), String>

Force a reconnection.

pub async fn close(&self)

Close the connection.