Struct DaemonSession 

pub struct DaemonSession {
    pub turn_event_stats: Mutex<TurnEventStats>,
    pub last_turn_end_state: Mutex<String>,
    pub last_turn_cancel_seen: Mutex<bool>,
    pub last_turn_error_message: Mutex<String>,
    /* private fields */
}

Dual-socket session: stream + lazy RPC sidecar.

Fields

turn_event_stats: Mutex<TurnEventStats>

Per-turn stream filtering counters.

last_turn_end_state: Mutex<String>

Last turn end state label.

last_turn_cancel_seen: Mutex<bool>

Whether cancel was observed for the last turn.

last_turn_error_message: Mutex<String>

Last turn error message.

Implementations

impl DaemonSession

pub fn new( ws_url: impl Into<String>, opts: Option<DaemonSessionOptions>, ) -> Self

Create a session for ws_url.

pub fn stream_client(&self) -> &Client

Stream socket.

pub fn rpc_client(&self) -> &Client

RPC sidecar socket (lazy-connected for list/cards/history).

pub async fn loop_id(&self) -> String

Active loop id.

pub async fn connect( &self, resume_loop_id: Option<&str>, ) -> Result<Map<String, Value>>

Connect and bootstrap a loop (or resume).

pub async fn new_loop(&self) -> Result<Map<String, Value>>

Start a fresh loop on the stream socket.

pub async fn switch_loop(&self, loop_id: &str) -> Result<Map<String, Value>>

Switch to an existing loop.

pub async fn ensure_connected(&self) -> Result<()>

Reconnect + reattach, or fresh bootstrap if stale.

pub async fn close(&self) -> Result<()>

Close both sockets.

pub async fn detach(&self) -> Result<()>

Notify disconnect (loops keep running server-side).

pub async fn send_turn( &self, text: &str, opts: Option<SendTurnOptions>, ) -> Result<()>

Send a user turn on the stream socket.

pub async fn cancel_active_turn(&self) -> Result<()>

Cancel active turn via /cancel.

pub async fn list_loops(&self, limit: u32) -> Result<Map<String, Value>>

List loops via RPC sidecar.

pub async fn fetch_loop_cards( &self, loop_id: &str, ) -> Result<Map<String, Value>>

Fetch cards via RPC sidecar.

pub async fn fetch_loop_history( &self, loop_id: &str, ) -> Result<Map<String, Value>>

Fetch history via RPC sidecar.

pub async fn iter_turn_chunks( &self, max_wait: Option<Duration>, ) -> Result<Vec<TurnChunk>>

Stream turn chunks until idle / stream.end.

max_wait of None means no absolute deadline.