Crate turbomcp_transport 

TurboMCP Transport

Transport layer implementations for the Model Context Protocol with runtime selection, fault tolerance, and multiple protocol support.

Supported Transports

• STDIO: Standard input/output for command-line MCP servers (always available)
• TCP: Direct TCP socket communication for network deployments
• Unix Sockets: Fast local inter-process communication
• HTTP/SSE: HTTP with Server-Sent Events for server push
• WebSocket Bidirectional: Full-duplex communication for elicitation

Reliability Features

• Circuit Breakers: Automatic fault detection and recovery mechanisms
• Retry Logic: Configurable exponential backoff with jitter
• Health Monitoring: Real-time transport health status tracking
• Connection Pooling: Efficient connection reuse and management
• Message Deduplication: Prevention of duplicate message processing
• Graceful Degradation: Maintained service availability during failures

Module Organization

turbomcp-transport/
├── core            # Core transport traits and error types (re-exports from turbomcp-transport-traits)
├── resilience/     # Circuit breakers, retry logic, health checks
├── security/       # Origin validation, rate limiting, session security
├── stdio           # STDIO transport (re-exports from turbomcp-stdio)
├── streamable_http # HTTP transport configuration (server impl in turbomcp-server)
├── streamable_http_client # Streamable HTTP client (re-exports from turbomcp-http)
├── websocket_bidirectional # WebSocket transport (re-exports from turbomcp-websocket)
├── tcp             # TCP transport (re-exports from turbomcp-tcp)
├── unix            # Unix socket transport (re-exports from turbomcp-unix)
├── child_process   # Child-process stdio transport
├── compression     # Message compression support
└── metrics         # Transport performance metrics

Usage Examples

WebSocket Bidirectional Transport

use turbomcp_transport::{WebSocketBidirectionalTransport, WebSocketBidirectionalConfig};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = WebSocketBidirectionalConfig {
        url: Some("ws://localhost:8080".to_string()),
        max_concurrent_elicitations: 10,
        elicitation_timeout: Duration::from_secs(60),
        keep_alive_interval: Duration::from_secs(30),
        reconnect: Default::default(),
        ..Default::default()
    };

    let transport = WebSocketBidirectionalTransport::new(config).await?;
     
    // Transport is ready for bidirectional communication
    println!("WebSocket transport established");
    Ok(())
}

MCP 2025-11-25 Streamable HTTP (Client)

use turbomcp_transport::streamable_http_client::{StreamableHttpClientConfig, StreamableHttpClientTransport};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = StreamableHttpClientConfig {
        base_url: "http://localhost:8080".to_string(),
        endpoint_path: "/mcp".to_string(),
        timeout: Duration::from_secs(30),
        ..Default::default()
    };

    let mut transport = StreamableHttpClientTransport::new(config);
    // Full MCP 2025-11-25 compliance with SSE support
    Ok(())
}

Runtime Transport Selection

use turbomcp_transport::Features;

// Check available transports at runtime
if Features::has_websocket() {
    println!("WebSocket transport available");
}

if Features::has_http() {
    println!("HTTP transport available");
}

// Always available
assert!(Features::has_stdio());

// Get list of all available transports
let available = Features::available_transports();
println!("Available transports: {:?}", available);

Re-exports

pub use bidirectional::BidirectionalTransportWrapper;

pub use bidirectional::MessageRouter;

pub use bidirectional::ProtocolDirectionValidator;

pub use bidirectional::RouteAction;

pub use server::ServerTransportConfig;

pub use server::ServerTransportConfigBuilder;

pub use server::ServerTransportDispatcher;

pub use server::ServerTransportEvent;

pub use server::ServerTransportManager;

pub use server::ServerTransportWrapper;

pub use tower::SessionInfo;

pub use tower::SessionManager;

pub use tower::TowerTransportAdapter;

pub use child_process::ChildProcessConfig;

pub use child_process::ChildProcessTransport;

pub use config::TransportConfigBuilder;

pub use resilience::CircuitBreakerConfig;

pub use resilience::CircuitBreakerStats;

pub use resilience::CircuitState;

pub use resilience::HealthCheckConfig;

pub use resilience::HealthInfo;

pub use resilience::HealthStatus;

pub use resilience::RetryConfig;

pub use resilience::TurboTransport;

pub use security::AuthConfig;

pub use security::AuthMethod;

pub use security::EnhancedSecurityConfigBuilder;

pub use security::OriginConfig;

pub use security::RateLimitConfig;

pub use security::RateLimiter;

pub use security::SecureSessionInfo;

pub use security::SecurityConfigBuilder;

pub use security::SecurityError;

pub use security::SecurityValidator;

pub use security::SessionSecurityConfig;

pub use security::SessionSecurityManager;

pub use security::validate_message_size;

pub use shared::SharedTransport;

Modules

bidirectional

Bidirectional transport wrappers and utilities. Bidirectional transport implementation with server-initiated request support

child_process

Transport for managing child processes. Child Process Transport for TurboMCP

config

Transport configuration builders and types. Transport configuration utilities.

core

Core transport traits, types, and errors. Core transport traits, types, and errors.

metrics

Metrics and performance monitoring for transports. Transport metrics collection and reporting.

resilience

Resilience patterns like circuit breakers and retries. Transport resilience features for fault tolerance and reliability

security

Security features for transports, including authentication and rate limiting. Security module for transport layer

server

Server-side transport management and dispatch. Server-specific transport functionality for bidirectional MCP communication

shared

Utilities for shared transport instances. Shared transport wrappers for concurrent access

stdiostdio

Standard I/O (stdio) transport for command-line applications.

tower

Integration with the Tower service abstraction. Tower Service integration for TurboMCP Transport layer

Structs

ConnectionState

Connection state for bidirectional communication

CorrelationContext

Correlation context for request-response patterns

Features

Transport feature detection

LimitsConfig

Configuration for request and response size limits.

StdioTransportstdio

Standard I/O transport implementation

TransportCapabilities

Describes the capabilities of a transport implementation.

TransportConfig

Configuration for a transport instance.

TransportMessage

A wrapper for a message being sent or received over a transport.

TransportMetrics

A serializable snapshot of a transport’s performance metrics.

Enums

MessageDirection

Message direction in the transport layer

TransportError

Represents errors that can occur during transport operations.

TransportEvent

Represents events that occur within a transport’s lifecycle.

TransportState

Represents the current state of a transport connection.

TransportType

Enumerates the types of transports supported by the system.

Traits

BidirectionalTransport

A trait for transports that support full-duplex, bidirectional communication.

Transport

The core trait for all transport implementations.

Functions

validate_request_size

Validates that a request message size does not exceed the configured limit.

validate_response_size

Validates that a response message size does not exceed the configured limit.

Type Aliases

TransportResult

A specialized Result type for transport operations.