Struct CheckpointManager 

pub struct CheckpointManager { /* private fields */ }

Manages in-process checkpoint state for resumable sessions.

Each checkpoint atomically stores an event and the updated run-state so that a crash cannot leave an event emitted but un-checkpointed (or vice versa).

Example

use adk_managed::checkpoint::{CheckpointManager, RunState};
use adk_managed::types::{SessionEvent, SessionStatus, ContentBlock};

let mut mgr = CheckpointManager::new("session_001".to_string());

let event = SessionEvent::StatusRunning { seq: 0 };
let state = RunState { seq: 1, pending_tool_ids: vec![], status: SessionStatus::Running };
mgr.checkpoint(event, state.clone());

assert_eq!(mgr.events().len(), 1);
assert_eq!(mgr.run_state(), &state);

Implementations

impl CheckpointManager

pub fn new(session_id: String) -> Self

Create a new checkpoint manager for the given session.

Initializes with an empty event log and the initial run state (seq=0, no pending tools, queued status).

pub fn with_store(self, store: Arc<dyn ManagedStateStore>) -> Self

Writes flushed checkpoints to store.

Check ManagedStateStore::durability to learn whether those writes survive process loss. With the shipped InMemoryManagedStateStore they do not.

Example

use adk_managed::{CheckpointManager, InMemoryManagedStateStore};
use std::sync::Arc;

let manager = CheckpointManager::new("session-1".to_string())
    .with_store(Arc::new(InMemoryManagedStateStore::new()));
assert!(manager.store().is_some());

pub fn store(&self) -> Option<&Arc<dyn ManagedStateStore>>

The configured store, if any.

pub async fn flush(&self) -> Result<(), RuntimeError>

Writes the current snapshot to the configured store.

A no-op without a store. Separate from CheckpointManager::checkpoint because that method is synchronous and a store write is not; a caller that needs the snapshot externally visible must flush.

Errors

Returns RuntimeError when the store rejects the write.

pub async fn restore( session_id: String, store: Arc<dyn ManagedStateStore>, ) -> Result<Self, RuntimeError>

Rebuilds a manager for session_id from store.

Returns a manager with the stored snapshot when one exists, and an empty one otherwise. Whether anything is found across a restart depends entirely on the store’s durability — with the in-memory backend a new process finds nothing.

Errors

Returns RuntimeError when the store cannot be read.

pub fn checkpoint(&mut self, event: SessionEvent, run_state: RunState)

Records an event and the updated run state together.

The pair is applied in one call, so replay never sees an event without its state. This is a write to this manager’s own fields, not a transaction with a persistent store: it says nothing about surviving a crash. Call CheckpointManager::flush to write the snapshot out, and check the store’s durability to learn what that write guarantees.

pub fn load_checkpoint(&self) -> (Vec<SessionEvent>, RunState)

The events and run state this manager holds, for resume within the process.

Reconstructing a session in a different process requires a crash-durable ManagedStateStore and CheckpointManager::restore; this method reads local fields only.

pub fn events(&self) -> &[SessionEvent]

Get all events stored in the checkpoint log.

pub fn run_state(&self) -> &RunState

Get current run state.

pub fn session_id(&self) -> &str

Get the session ID this manager is checkpointing for.