Struct SessionLoop 

pub struct SessionLoop { /* private fields */ }

Supervised session loop — one per active session.

Runs as a background tokio::spawned task. Receives user events via an mpsc channel, processes each turn through the real Runner, and broadcasts session events via a tokio::broadcast channel.

Example

use std::sync::Arc;
use std::time::Duration;
use tokio::sync::{broadcast, mpsc, Mutex, Notify};
use tokio_util::sync::CancellationToken;
use adk_managed::session_loop::SessionLoop;
use adk_managed::parking::ToolParkingLot;

let (event_tx, event_rx) = mpsc::channel(64);
let (broadcast_tx, _) = broadcast::channel(256);
let cancel = CancellationToken::new();
let parking = Arc::new(ToolParkingLot::new(Duration::from_secs(300)));

let loop_handle = SessionLoop::new(
    "session_001".to_string(),
    event_rx,
    broadcast_tx,
    parking,
    cancel.clone(),
    agent,
    session_service,
);

let handle = tokio::spawn(loop_handle.run());
// Send events via event_tx...

Implementations

impl SessionLoop

pub fn new( session_id: String, event_rx: Receiver<UserEvent>, event_tx: Sender<SessionEvent>, parking: Arc<ToolParkingLot>, cancel_token: CancellationToken, agent: Arc<dyn Agent>, session_service: Arc<dyn SessionService>, ) -> Self

Create a new session loop.

Arguments

• session_id - The session this loop operates on.
• event_rx - Receiver for incoming user events.
• event_tx - Broadcast sender for outgoing session events.
• parking - Shared parking lot for custom tool calls.
• cancel_token - Token to signal interrupt/shutdown.
• agent - The built agent to drive through the Runner.
• session_service - Session persistence for the Runner.

pub fn with_pause_controls( session_id: String, event_rx: Receiver<UserEvent>, event_tx: Sender<SessionEvent>, parking: Arc<ToolParkingLot>, cancel_token: CancellationToken, pause_flag: Arc<Mutex<bool>>, pause_notify: Arc<Notify>, checkpoint: Arc<RwLock<CheckpointManager>>, agent: Arc<dyn Agent>, session_service: Arc<dyn SessionService>, ) -> Self

Create a session loop with custom pause controls (for external pause/resume).

See the memory-enabled variant for full documentation.

pub fn with_owner( self, app_name: impl Into<String>, user_id: impl Into<String>, ) -> Self

Makes this loop’s Runner calls under owner.

Without this the loop used the constants managed / managed_user, so every managed session shared one logical namespace and no session could be attributed to a caller.

Example

let session_loop = SessionLoop::with_pause_controls(/* ... */)
    .with_owner(owner.app_name(), owner.user_id());

pub fn with_shared_status(self, status: Arc<RwLock<SessionStatus>>) -> Self

Reports status into the handle the caller already holds.

The runtime’s ActiveSession owns the status a caller observes through ManagedAgentRuntime::status. Installing it here is what makes normal queued → running → idle transitions visible; without it the loop wrote to its own field and the public handle stayed Queued through an entire session.

Example

let session_loop = SessionLoop::with_pause_controls(/* ... */)
    .with_shared_status(Arc::clone(&active.status));

pub fn pause_flag(&self) -> Arc<Mutex<bool>>

Get a clone of the pause flag for external control.

pub fn pause_notify(&self) -> Arc<Notify>

Get a clone of the pause notify for external control.

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

Run the session loop (consumes self).

This is the main loop body, designed to be tokio::spawned. It runs until the input channel is closed or the cancellation token is triggered.

Returns

Returns Ok(()) on graceful shutdown, or Err(RuntimeError) if an unrecoverable error occurs.