Struct SessionManager 

pub struct SessionManager { /* private fields */ }

Session manager handles multiple concurrent sessions

Implementations

impl SessionManager

pub fn new( llm_client: Option<Arc<dyn LlmClient>>, tool_executor: Arc<ToolExecutor>, ) -> Self

Create a new session manager without persistence

pub async fn with_persistence<P: AsRef<Path>>( llm_client: Option<Arc<dyn LlmClient>>, tool_executor: Arc<ToolExecutor>, sessions_dir: P, ) -> Result<Self>

Create a session manager with file-based persistence

Sessions will be automatically saved to disk and restored on startup.

pub fn with_store( llm_client: Option<Arc<dyn LlmClient>>, tool_executor: Arc<ToolExecutor>, store: Arc<dyn SessionStore>, backend: StorageBackend, ) -> Self

Create a session manager with a custom store

The backend parameter determines which StorageBackend key the store is registered under. Sessions created with a matching storage_type will use this store.

pub async fn set_default_llm(&self, client: Option<Arc<dyn LlmClient>>)

Hot-swap the default LLM client used by sessions without a per-session client.

Called by SafeClaw when PUT /api/agent/config updates the model config. All subsequent generate / generate_streaming calls will use the new client.

pub async fn set_skill_registry( &self, registry: Arc<SkillRegistry>, skills_dir: PathBuf, )

Set the skill registry for runtime skill management.

Skills registered here will be injected into the system prompt for all subsequent generate / generate_streaming calls. Also registers the manage_skill tool on the ToolExecutor so the Agent can create, list, and remove skills at runtime.

pub async fn skill_registry(&self) -> Option<Arc<SkillRegistry>>

Get the current skill registry, if any.

pub async fn set_memory_store(&self, store: Arc<dyn MemoryStore>)

Set the shared memory store for agent long-term memory.

When set, every generate/generate_streaming call wraps this store in an AgentMemory and injects it into AgentConfig.memory, enabling automatic recall_similar before prompts and remember_success/ remember_failure after tool execution.

pub async fn memory_store(&self) -> Option<Arc<dyn MemoryStore>>

Get the current memory store, if any.

pub async fn restore_session_by_id(&self, session_id: &str) -> Result<()>

Restore a single session by ID from the store

Searches all registered stores for the given session ID and restores it into the in-memory session map. Returns an error if not found.

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

Load all sessions from all registered stores

pub async fn create_session( &self, id: String, config: SessionConfig, ) -> Result<String>

Create a new session

pub async fn destroy_session(&self, id: &str) -> Result<()>

Destroy a session

pub async fn get_session(&self, id: &str) -> Result<Arc<RwLock<Session>>>

Get a session by ID

pub async fn create_child_session( &self, parent_id: &str, child_id: String, config: SessionConfig, ) -> Result<String>

Create a child session for a subagent

Child sessions inherit the parent’s LLM client but have their own permission policy and configuration.

pub async fn get_child_sessions(&self, parent_id: &str) -> Vec<String>

Get all child sessions for a parent session

pub async fn is_child_session(&self, session_id: &str) -> Result<bool>

Check if a session is a child session

pub async fn generate( &self, session_id: &str, prompt: &str, ) -> Result<AgentResult>

Generate response for a prompt

pub async fn generate_streaming( &self, session_id: &str, prompt: &str, ) -> Result<(Receiver<AgentEvent>, JoinHandle<Result<AgentResult>>)>

Generate response with streaming events

pub async fn context_usage(&self, session_id: &str) -> Result<ContextUsage>

Get context usage for a session

pub async fn history(&self, session_id: &str) -> Result<Vec<Message>>

Get conversation history for a session

pub async fn clear(&self, session_id: &str) -> Result<()>

Clear session history

pub async fn compact(&self, session_id: &str) -> Result<()>

Compact session context

pub async fn maybe_auto_compact(&self, session_id: &str) -> Result<bool>

Check if auto-compaction should be triggered and perform it if needed.

Called after generate() / generate_streaming() updates session usage. Triggers compaction when:

• auto_compact is enabled in session config
• context_usage.percent exceeds auto_compact_threshold

pub async fn get_llm_for_session( &self, session_id: &str, ) -> Result<Option<Arc<dyn LlmClient>>>

Resolve the LLM client for a session (session-level -> default fallback)

Returns None if no LLM client is configured at either level.

pub async fn configure( &self, session_id: &str, thinking: Option<bool>, budget: Option<usize>, model_config: Option<LlmConfig>, ) -> Result<()>

Configure session

pub async fn session_count(&self) -> usize

Get session count

pub async fn store_health(&self) -> Vec<(String, Result<()>)>

Check health of all registered stores

pub fn list_tools(&self) -> Vec<ToolDefinition>

List all loaded tools (built-in tools)

pub async fn pause_session(&self, session_id: &str) -> Result<bool>

Pause a session

pub async fn resume_session(&self, session_id: &str) -> Result<bool>

Resume a session

pub async fn cancel_operation(&self, session_id: &str) -> Result<bool>

Cancel an ongoing operation for a session

Returns true if an operation was cancelled, false if no operation was running.

pub async fn get_all_sessions(&self) -> Vec<Arc<RwLock<Session>>>

Get all sessions (returns session locks for iteration)

pub fn tool_executor(&self) -> &Arc<ToolExecutor>

Get tool executor reference

pub async fn confirm_tool( &self, session_id: &str, tool_id: &str, approved: bool, reason: Option<String>, ) -> Result<bool>

Confirm a tool execution (HITL)

pub async fn set_confirmation_policy( &self, session_id: &str, policy: ConfirmationPolicy, ) -> Result<ConfirmationPolicy>

Set confirmation policy for a session (HITL)

pub async fn get_confirmation_policy( &self, session_id: &str, ) -> Result<ConfirmationPolicy>

Get confirmation policy for a session (HITL)

Trait Implementations

impl Clone for SessionManager

fn clone(&self) -> SessionManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.