Module client 

MCP client implementation

This module provides the main client implementation for the Model Context Protocol.

Architecture

The client module consists of:

• McpClient: Main client struct for protocol communication
• McpClientBuilder: Fluent API for client configuration
• ClientSession: Session management and state tracking
• ClientRequestHandler: Interface for handling server requests

Usage Patterns

Simple Client

use prism_mcp_rs::client::McpClient;

let client = McpClient::new("my-client".to_string(), "1.0.0".to_string());

// Connect and initialize
// client.connect_stdio().await?;
// client.initialize().await?;

// EXAMPLE_END

Using ClientBuilder

use prism_mcp_rs::client::{McpClientBuilder, ConnectionConfig, RetryConfig};
use std::time::Duration;

let client = McpClientBuilder::new()
    .name("my-client")
    .version("2.0.0")
    .timeout(Duration::from_secs(30))
    .max_retries(3)
    .validate_requests(true)
    .validate_responses(true)
    .build();

Request Handlers

Clients can handle requests from servers using request handlers:

use prism_mcp_rs::client::{ClientRequestHandler, DefaultClientRequestHandler};
use prism_mcp_rs::core::error::{McpError, McpResult};
use prism_mcp_rs::protocol::messages::{CreateMessageParams, ListRootsParams, ListRootsResult, ElicitParams, ElicitResult, PingParams, PingResult};
use prism_mcp_rs::protocol::types::{CreateMessageResult, Role, SamplingContent, StopReason, ElicitationAction};
use prism_mcp_rs::protocol::{JsonRpcRequest, JsonRpcResponse};
use async_trait::async_trait;
use serde_json;
use std::collections::HashMap;

struct MyHandler;

#[async_trait]
impl ClientRequestHandler for MyHandler {
    async fn handle_create_message(
        &self,
        params: CreateMessageParams,
    ) -> McpResult<CreateMessageResult> {
        // Handle server's request to create a message
        Ok(CreateMessageResult {
            model: "test-model".to_string(),
            stop_reason: Some(StopReason::EndTurn),
            role: Role::Assistant,
            content: SamplingContent::Text {
                text: "Hello!".to_string(),
                annotations: None,
                meta: None,
            },
            meta: None,
        })
    }

    async fn handle_list_roots(&self, _params: ListRootsParams) -> McpResult<ListRootsResult> {
        Ok(ListRootsResult {
            roots: vec![],
            meta: None,
        })
    }

    async fn handle_elicit(&self, _params: ElicitParams) -> McpResult<ElicitResult> {
        Ok(ElicitResult {
            action: ElicitationAction::Accept,
            content: Some(HashMap::new()),
            meta: None,
        })
    }

    async fn handle_ping(&self, _params: PingParams) -> McpResult<PingResult> {
        Ok(PingResult {
            meta: None,
        })
    }
}

Session Management

The client maintains session state throughout the connection lifecycle:

use prism_mcp_rs::client::{ClientSession, SessionState};

// Session state is managed internally
// You can check connection status after connecting
// let connected = client.is_connected();
println!("Client configured and ready to connect");

Features

• Auto-reconnection: Configurable retry with exponential backoff
• Request Handling: Bidirectional communication support
• Session Tracking: Automatic state management
• Multiple Transports: STDIO, HTTP, WebSocket support
• Type Safety: Strongly typed requests and responses

Re-exports

pub use enhanced_builder::ConnectionConfig;

pub use enhanced_builder::McpClientBuilder;

pub use enhanced_builder::RetryConfig;

pub use mcp_client::ClientConfig;

pub use mcp_client::McpClient;

pub use mcp_client::TransportInfo;

pub use mcp_client::TransportUseCase;

pub use request_handler::AutomatedClientRequestHandler;

pub use request_handler::ClientRequestHandler;

pub use request_handler::DefaultClientRequestHandler;

pub use request_handler::InteractiveClientRequestHandler;

pub use session::ClientSession;

pub use session::SessionConfig;

pub use session::SessionState;

Modules

enhanced_builder

Enhanced client builder with fluent interface Consolidates all client creation into single builder pattern

enhanced_traits

Enhanced trait implementations for better ergonomics

fluent_interfaces

Fluent interfaces for resources and prompts

fluent_tools

Fluent interface for tool operations

mcp_client

MCP client implementation

request_handler

Client-side request handling for server-initiated requests

session

Client session management

Type Aliases

ClientBuilder