Struct Connection 

pub struct Connection<S> { /* private fields */ }

A typestate connection that tracks lifecycle state at the type level.

The state parameter S ensures that only valid operations are available for each connection state.

Example

use mcpkit_server::state::{Connection, markers};
use mcpkit_core::capability::{ServerInfo, ServerCapabilities};

// Start disconnected
let conn: Connection<markers::Disconnected> = Connection::new(
    ServerInfo::new("my-server", "1.0.0"),
    ServerCapabilities::new().with_tools(),
);

// The typestate pattern ensures compile-time safety:
// - A Disconnected connection can only call connect()
// - A Connected connection can only call initialize() or close()
// - A Ready connection can access capabilities

Implementations

impl Connection<Disconnected>

pub fn new( server_info: ServerInfo, server_capabilities: ServerCapabilities, ) -> Self

Create a new disconnected connection.

pub async fn connect(self) -> Result<Connection<Connected>, McpError>

Connect to establish a transport connection.

This transitions from Disconnected to Connected state.

impl Connection<Connected>

pub async fn initialize( self, _protocol_version: ProtocolVersion, ) -> Result<Connection<Initializing>, McpError>

Start the initialization handshake.

This transitions from Connected to Initializing state.

pub async fn close(self) -> Result<(), McpError>

Close the connection before initialization.

impl Connection<Initializing>

pub async fn complete( self, client_capabilities: ClientCapabilities, protocol_version: ProtocolVersion, ) -> Result<Connection<Ready>, McpError>

Complete the initialization handshake.

This transitions from Initializing to Ready state.

pub async fn abort(self) -> Result<Connection<Disconnected>, McpError>

Abort initialization.

impl Connection<Ready>

pub fn client_capabilities(&self) -> &ClientCapabilities

Get the client capabilities.

Panics

This should never panic if the connection was properly initialized through the typestate transitions. Use try_client_capabilities() for a fallible version.

pub fn try_client_capabilities(&self) -> Option<&ClientCapabilities>

Try to get the client capabilities.

Returns None if capabilities were not set (should not happen in normal use).

pub fn server_capabilities(&self) -> &ServerCapabilities

Get the server capabilities.

pub fn server_info(&self) -> &ServerInfo

Get the server info.

pub fn protocol_version(&self) -> ProtocolVersion

Get the negotiated protocol version.

Panics

This should never panic if the connection was properly initialized through the typestate transitions. Use try_protocol_version() for a fallible version.

pub fn try_protocol_version(&self) -> Option<ProtocolVersion>

Try to get the negotiated protocol version.

Returns None if version was not set (should not happen in normal use).

pub async fn shutdown(self) -> Result<Connection<Closing>, McpError>

Start graceful shutdown.

This transitions from Ready to Closing state.

impl Connection<Closing>

pub async fn disconnect(self) -> Result<(), McpError>

Complete the shutdown and disconnect.

Trait Implementations

impl<S> Clone for Connection<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for Connection<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.