Struct SessionState 

pub struct SessionState { /* private fields */ }

Shared session state that can be cloned across requests.

Uses atomic operations for thread-safe state transitions. Includes a type-safe extensions map for storing session-scoped data like authentication claims.

Example

use tower_mcp::SessionState;

#[derive(Debug, Clone)]
struct UserClaims {
    user_id: String,
    role: String,
}

let session = SessionState::new();

// Store auth claims in the session
session.insert(UserClaims {
    user_id: "user123".to_string(),
    role: "admin".to_string(),
});

// Retrieve claims later
if let Some(claims) = session.get::<UserClaims>() {
    assert_eq!(claims.role, "admin");
}

Implementations

impl SessionState

pub fn new() -> Self

Create a new session in the Uninitialized phase

pub fn insert<T: Send + Sync + Clone + 'static>(&self, val: T)

Insert a value into the session extensions.

This is typically used by auth middleware to store claims that can be checked by capability filters.

Example

use tower_mcp::SessionState;

let session = SessionState::new();
session.insert(42u32);
assert_eq!(session.get::<u32>(), Some(42));

pub fn get<T: Send + Sync + Clone + 'static>(&self) -> Option<T>

Get a cloned value from the session extensions.

Returns None if no value of the given type has been inserted or if the lock cannot be acquired.

Example

use tower_mcp::SessionState;

let session = SessionState::new();
session.insert("hello".to_string());
assert_eq!(session.get::<String>(), Some("hello".to_string()));
assert_eq!(session.get::<u32>(), None);

pub fn phase(&self) -> SessionPhase

Get the current session phase

pub fn is_initialized(&self) -> bool

Check if the session is initialized (operation phase)

pub fn mark_initializing(&self) -> bool

Transition from Uninitialized to Initializing. Called after responding to an initialize request. Returns true if the transition was successful.

pub fn mark_initialized(&self) -> bool

Transition to Initialized phase. Called when receiving an initialized notification.

Accepts transitions from both Initializing and Uninitialized states. The Uninitialized → Initialized path handles a race condition in HTTP transports where the client sends the initialized notification before the server has finished processing the initialize request (the session is stored in Uninitialized state before the request is dispatched).

Returns true if the transition was successful.

pub fn is_request_allowed(&self, method: &str) -> bool

Check if a request method is allowed in the current phase. Per spec:

• Before initialization: only initialize and ping are valid
• During all phases: ping is always valid

Trait Implementations

impl Clone for SessionState

fn clone(&self) -> SessionState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for SessionState

fn default() -> Self

Returns the “default value” for a type.