Struct SessionManager 

pub struct SessionManager { /* private fields */ }

AI-optimized session manager for creating and managing multiple terminal sessions.

The SessionManager provides a centralized way to create, track, and manage AI-enhanced terminal sessions. It includes automatic cleanup, session restoration, and efficient resource management.

Features

• Session Pooling: Efficient management of multiple concurrent sessions
• Automatic Cleanup: Garbage collection of terminated sessions
• Session Restoration: Restore sessions from persistent storage
• Resource Management: Automatic cleanup and memory management

Examples

Basic Session Management

use ai_session::{SessionManager, SessionConfig};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = SessionManager::new();
     
    // Create multiple sessions
    let session1 = manager.create_session().await?;
    let session2 = manager.create_session().await?;
     
    session1.start().await?;
    session2.start().await?;
     
    // List all active sessions
    let session_ids = manager.list_sessions();
    println!("Active sessions: {}", session_ids.len());
     
    // Clean up
    manager.remove_session(&session1.id).await?;
    manager.remove_session(&session2.id).await?;
     
    Ok(())
}

Custom Configuration

use ai_session::{SessionManager, SessionConfig, ContextConfig};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = SessionManager::new();
     
    // Configure for AI development agent
    let mut config = SessionConfig::default();
    config.enable_ai_features = true;
    config.agent_role = Some("backend-developer".to_string());
    config.working_directory = "/project/backend".into();
    config.context_config = ContextConfig {
        max_tokens: 8192,
        compression_threshold: 0.8,
    };
     
    let session = manager.create_session_with_config(config).await?;
    session.start().await?;
     
    // Session is optimized for AI backend development
    Ok(())
}

Session Persistence

use ai_session::{SessionManager, SessionConfig, SessionId};
use chrono::Utc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = SessionManager::new();
     
    // Create session
    let config = SessionConfig::default();
    let session = manager.create_session_with_config(config.clone()).await?;
    let session_id = session.id.clone();
    let created_at = session.created_at;
     
    // Later, restore the session
    let restored = manager.restore_session(session_id, config, created_at).await?;
    restored.start().await?;
     
    Ok(())
}

Implementations

impl SessionManager

pub fn new() -> Self

Create a new session manager

pub async fn create_session(&self) -> Result<Arc<AISession>>

Create a new session with default config

pub async fn create_session_with_config( &self, config: SessionConfig, ) -> Result<Arc<AISession>>

Create a new session with custom config

pub async fn restore_session( &self, id: SessionId, config: SessionConfig, created_at: DateTime<Utc>, ) -> Result<Arc<AISession>>

Restore a session with a specific ID (for persistence)

pub fn get_session(&self, id: &SessionId) -> Option<Arc<AISession>>

Get a session by ID

pub fn list_sessions(&self) -> Vec<SessionId>

List all active sessions

pub fn list_session_refs(&self) -> Vec<Arc<AISession>>

List all active session references

pub async fn remove_session(&self, id: &SessionId) -> Result<()>

Remove a session

pub async fn cleanup_terminated(&self) -> Result<usize>

Clean up terminated sessions

Trait Implementations

impl Default for SessionManager

fn default() -> Self

Returns the “default value” for a type.