Crate turbomcp_transport 

TurboMCP Transport

Transport layer implementations for the Model Context Protocol with runtime selection, comprehensive 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 (New in 1.0.3)
• WebSocket Bidirectional: Full-duplex communication for elicitation (New in 1.0.3)

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
├── robustness/     # Circuit breakers, retry logic, health checks
├── stdio/          # Standard I/O transport implementation
├── http/           # HTTP/SSE transport implementation
├── websocket/      # WebSocket transport implementation
├── tcp/            # TCP socket transport implementation
├── unix/           # Unix domain socket implementation
├── compression/    # Message compression support
└── metrics/        # Transport performance metrics

Usage Examples

WebSocket Bidirectional Transport (New in 1.0.3)

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(())
}

HTTP Server-Sent Events (New in 1.0.3)

use turbomcp_transport::http_sse::HttpSseConfig;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = HttpSseConfig {
        bind_addr: "127.0.0.1:3000".to_string(),
        sse_path: "/events".to_string(),
        post_path: "/mcp".to_string(),
        keep_alive_interval: Duration::from_secs(30),
        max_sessions: 100,
        ..Default::default()
    };

    // HTTP/SSE transport configuration ready
    println!("HTTP SSE transport configured on {}", config.bind_addr);
    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::ConnectionState;

pub use bidirectional::CorrelationContext;

pub use bidirectional::MessageDirection;

pub use bidirectional::MessageRouter;

pub use bidirectional::ProtocolDirectionValidator;

pub use bidirectional::RouteAction;

pub use core::BidirectionalTransport;

pub use core::StreamingTransport;

pub use core::Transport;

pub use core::TransportCapabilities;

pub use core::TransportConfig;

pub use core::TransportError;

pub use core::TransportEvent;

pub use core::TransportMessage;

pub use core::TransportMetrics;

pub use core::TransportResult;

pub use core::TransportState;

pub use core::TransportType;

pub use server::ServerTransportConfig;

pub use server::ServerTransportConfigBuilder;

pub use server::ServerTransportDispatcher;

pub use server::ServerTransportEvent;

pub use server::ServerTransportEventListener;

pub use server::ServerTransportManager;

pub use server::ServerTransportWrapper;

pub use stdio::StdioTransport;

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 robustness::CircuitBreakerConfig;

pub use robustness::CircuitBreakerStats;

pub use robustness::CircuitState;

pub use robustness::HealthCheckConfig;

pub use robustness::HealthInfo;

pub use robustness::HealthStatus;

pub use robustness::RetryConfig;

pub use robustness::RobustTransport;

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 implementation with server-initiated request support

child_process

Child Process Transport for TurboMCP

config

Transport configuration utilities.

core

Core transport traits and types.

metrics

Transport metrics collection and reporting.

robustness

Transport robustness features

security

Security module for transport layer

server

Server-specific transport functionality for bidirectional MCP communication

shared

Shared transport wrappers for concurrent access

stdio

Standard I/O transport implementation.

tower

Tower Service integration for TurboMCP Transport layer

Structs

Features

Transport feature detection