Struct BoundedSessionManager 

pub struct BoundedSessionManager { /* private fields */ }

Wraps LocalSessionManager and limits the number of concurrent sessions.

When the limit is reached, the oldest session (by creation order) is closed before the new one is created. This prevents unbounded memory growth when many clients connect without explicitly closing their sessions.

Optionally, a rate limit can be applied to session creation via BoundedSessionManager::with_rate_limit.

Concurrency note

Under concurrent session creation, the live count may transiently exceed max_sessions by at most the number of concurrent callers. The limit is best-effort under contention; use a semaphore if exact enforcement is required.

Implementations

impl BoundedSessionManager

pub fn new(session_config: SessionConfig, max_sessions: usize) -> Self

Create a new BoundedSessionManager.

• session_config — passed through to the inner LocalSessionManager.
• max_sessions — maximum number of concurrent sessions. When this limit is reached, the oldest session is evicted before creating a new one. Must be at least 1.

Panics

Panics if max_sessions is 0.

pub fn with_rate_limit(self, max_creates: usize, window: Duration) -> Self

Configure a rate limit on session creation.

At most max_creates sessions may be created within any rolling window duration. If exceeded, BoundedSessionError::RateLimited is returned and no eviction is performed.

Panics

Panics if max_creates is 0. Pass no rate limit instead of 0 — a limit of zero would silently block all session creation.

Trait Implementations

impl SessionManager for BoundedSessionManager

type Error = BoundedSessionError

type Transport = WorkerTransport<LocalSessionWorker>

async fn create_session( &self, ) -> Result<(SessionId, Self::Transport), Self::Error>

Create a new session and return its ID together with the transport that will be used to exchange MCP messages within this session.

async fn close_session(&self, id: &SessionId) -> Result<(), Self::Error>

Close and remove the session. Corresponds to an HTTP DELETE request with Mcp-Session-Id.

async fn initialize_session( &self, id: &SessionId, message: ClientJsonRpcMessage, ) -> Result<ServerJsonRpcMessage, Self::Error>

Forward the first message (the initialize request) to the session.

async fn has_session(&self, id: &SessionId) -> Result<bool, Self::Error>

Return true if a session with the given ID exists and is active.

async fn create_stream( &self, id: &SessionId, message: ClientJsonRpcMessage, ) -> Result<impl Stream<Item = ServerSseMessage> + Send + Sync + 'static, Self::Error>

Route a client request into the session and return an SSE stream carrying the server’s response(s).

async fn accept_message( &self, id: &SessionId, message: ClientJsonRpcMessage, ) -> Result<(), Self::Error>

Accept a notification, response, or error message from the client without producing a response stream.

async fn create_standalone_stream( &self, id: &SessionId, ) -> Result<impl Stream<Item = ServerSseMessage> + Send + Sync + 'static, Self::Error>

Create an SSE stream not tied to a specific client request (HTTP GET).

async fn resume( &self, id: &SessionId, last_event_id: String, ) -> Result<impl Stream<Item = ServerSseMessage> + Send + Sync + 'static, Self::Error>

Resume an SSE stream from the given Last-Event-ID, replaying any events the client missed.