Struct ConnectionRefresher 

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

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));

// Operations automatically retry on connection failure
let tools = refresher.list_tools().await?;
let result = refresher.call_tool(params).await?;

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>) -> Self

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>) -> Self

Create a new connection refresher without an initial connection.

The first operation will trigger a connection.

pub fn with_config(self, config: RefreshConfig) -> Self

Set the refresh configuration.

pub fn with_max_attempts(self, attempts: u32) -> Self

Set the maximum number of reconnection attempts.

pub async fn list_tools(&self) -> Result<RetryResult<Vec<McpTool>>, 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<CallToolResult>, String>

Call a tool on the MCP server with automatic reconnection.

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.