Struct Client 

pub struct Client { /* private fields */ }

Long-lived protocol-1 WebSocket client.

Implementations

impl Client

pub fn new(url: impl Into<String>) -> Self

Create a client for url.

pub fn with_config(cfg: ClientConfig) -> Self

Create with explicit config.

pub fn url(&self) -> &str

Daemon URL.

pub fn is_connected(&self) -> bool

Whether the socket is connected.

pub fn is_connection_alive(&self) -> bool

Whether the reader task is alive.

pub fn is_handshake_complete(&self) -> bool

Whether the protocol-1 handshake has completed.

pub async fn readiness_state(&self) -> String

Daemon readiness_state from the last connection_ack (empty before handshake).

pub fn inbound_dropped(&self) -> u64

Count of dropped inbound frames under backpressure.

pub fn set_stream_degraded_callback( &self, cb: Option<Arc<dyn Fn(u64, String) + Send + Sync>>, )

Register a hook invoked on the first inbound overflow drop.

pub fn enable_heartbeat_tracking(&self) -> Arc<HeartbeatTracker>

Enable heartbeat tracking with the default 15s alive threshold.

pub fn enable_heartbeat_tracking_with_threshold( &self, threshold: Duration, ) -> Arc<HeartbeatTracker>

Enable heartbeat tracking with a custom alive threshold.

pub fn disable_heartbeat_tracking(&self)

Disable heartbeat tracking.

pub fn heartbeat_tracker(&self) -> Option<Arc<HeartbeatTracker>>

Current heartbeat tracker, if enabled.

pub fn is_daemon_alive(&self) -> bool

Whether the tracked daemon is considered alive (true if tracking disabled).

pub async fn disconnect_cause(&self) -> Option<DisconnectCause>

Disconnect cause if disconnected.

pub async fn wait_disconnected(&self) -> DisconnectCause

Wait until disconnected.

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

Dial + handshake (connection_init / connection_ack ready).

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

Close the connection.

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

Re-dial and re-handshake after a connection drop.

Does not re-establish loop subscriptions; follow with Self::reattach_and_probe to resume a loop session.

pub async fn send_envelope(&self, env: Envelope) -> Result<()>

Send a raw envelope.

pub async fn notify( &self, method: &str, params: Map<String, Value>, ) -> Result<()>

Fire-and-forget notification.

pub async fn request( &self, method: &str, params: Map<String, Value>, req_timeout: Duration, ) -> Result<Map<String, Value>>

RPC request correlated by id.

pub async fn request_response( &self, payload: Map<String, Value>, fallback_method: &str, req_timeout: Duration, ) -> Result<Map<String, Value>>

Request with a payload map that may include a type field as the method name (Go RequestResponse parity).

pub async fn subscribe( &self, method: &str, params: Map<String, Value>, req_timeout: Duration, ) -> Result<String>

Subscribe; returns subscription id.

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

Unsubscribe by id.

pub async fn read_event(&self) -> Result<Option<Value>>

Read next inbound app event (blocks).

pub async fn read_event_with_timeout( &self, dur: Duration, ) -> Result<Option<Value>>

Read with timeout; None on timeout.

pub async fn clear_pending_events(&self)

Clear pending inbound events.

pub async fn peel_stale_pending_control_events(&self) -> Vec<String>

Peel stale pending control frames at turn start.

pub async fn push_pending_event(&self, ev: Value)

Re-queue an event ahead of subsequent Client::read_event calls.

Applies priority-aware drop when the pending buffer is full (Go PushPendingEvent parity).

pub fn set_inbound_max_size(&self, n: usize)

Override the pending-event cap at runtime (Go SetInboundMaxSize parity).

pub fn receive_messages(&self, buffer: usize) -> Receiver<Value>

Spawn a background reader that streams inbound frames on a channel.

The channel closes when the connection ends or the client disconnects. Solicited frames (RPC responses / subscription confirmations) are still routed through the internal mux and are NOT forwarded on this channel; only unsolicited app events are forwarded (Go ReceiveMessages parity).

Heartbeat, ping/pong, and delivery-ack handling are still performed by the internal reader task; this method exposes the already-routed inbound queue as a channel for consumers that prefer pull-style streaming.

pub async fn send_input(&self, text: &str, opts: SendInputOptions) -> Result<()>

Notify loop_input.

pub async fn loop_new( &self, params: Map<String, Value>, ) -> Result<Map<String, Value>>

loop_new RPC.

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

loop_list.

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

loop_get.

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

loop_reattach.

pub async fn loop_subscribe( &self, loop_id: &str, stream_delivery: &str, ) -> Result<String>

Subscribe to loop_events.

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

loop_cards_fetch.

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

loop_history_fetch.

pub async fn loop_messages( &self, loop_id: &str, limit: u32, offset: u32, ) -> Result<Map<String, Value>>

loop_messages.

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

loop_state_get.

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

loop_state_update.

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

loop_tree.

pub async fn loop_prune( &self, loop_id: &str, retention_days: Option<i32>, dry_run: bool, ) -> Result<Map<String, Value>>

loop_prune.

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

loop_delete.

pub async fn loop_detach(&self, subscription_id: &str) -> Result<()>

Detach from a loop by unsubscribing (subscription_id from loop_subscribe).

pub async fn authenticate( &self, access_key: &str, secret_key: &str, ) -> Result<Map<String, Value>>

Authenticate with access/secret keys.

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

Refresh auth token.

pub async fn job_create( &self, goal: &str, workspace: Option<&str>, ) -> Result<Map<String, Value>>

job_create on this long-lived connection.

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

job_status.

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

job_pause.

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

job_resume.

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

job_cancel.

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

job_dag.

pub async fn job_guidance( &self, job_id: &str, content: &str, goal_id: Option<&str>, ) -> Result<Map<String, Value>>

job_guidance.

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

autopilot_status.

pub async fn autopilot_submit( &self, description: &str, priority: i32, workspace: Option<&str>, ) -> Result<Map<String, Value>>

autopilot_submit.

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

autopilot_list_goals.

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

autopilot_get_goal.

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

autopilot_cancel_goal.

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

autopilot_cancel_all.

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

autopilot_wake.

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

autopilot_dream.

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

autopilot_resume.

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

autopilot_list_jobs.

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

autopilot_get_job.

pub async fn autopilot_subscribe(&self) -> Result<String>

Subscribe to autopilot_events (long-lived worker stream).

pub async fn autopilot_unsubscribe(&self, subscription_id: &str) -> Result<()>

Unsubscribe from an autopilot events subscription.

pub async fn cron_add( &self, text: &str, priority: Option<i32>, ) -> Result<Map<String, Value>>

cron_add.

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

cron_list.

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

cron_show.

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

cron_cancel.

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

memory_stats.

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

skills_list.

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

models_list.

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

mcp_status.

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

daemon_status.

pub async fn invoke_skill( &self, skill: &str, args: &str, ) -> Result<Map<String, Value>>

invoke_skill on this connection (stream socket for turn enqueue).

pub async fn reattach_and_probe(&self, loop_id: &str) -> Result<()>

Reattach + subscribe + loop_get probe.

pub async fn command_request( &self, command: &str, loop_id: Option<&str>, params: Option<Map<String, Value>>, ) -> Result<Map<String, Value>>

command_request RPC (structured slash command).

Mirrors Go CommandRequest. Default timeout 30s.

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

/clear — clear loop conversation history.

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

/exit — stop the loop and mark for exit.

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

/quit — alias for /exit.

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

/detach — mark the loop as detached (continues running server-side).

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

/cancel — cancel the running query.

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

/memory — query memory stats.

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

/policy — query the active policy profile.

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

/history — query input history.

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

/config — query daemon configuration.

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

/review — query conversation review.

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

/plan — query current plan.

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

/autopilot_dashboard — show autopilot dashboard.

pub async fn wait_for_daemon_ready( &self, timeout: Duration, ) -> Result<Map<String, Value>>

Wait for the protocol-1 connection_ack handshake to report readiness_state == "ready".

Returns immediately when the handshake already completed during Client::connect; otherwise polls inbound frames for an out-of-band connection_ack. Default timeout 10s (Go WaitForDaemonReady parity).

impl Client

pub async fn send_command(&self, cmd: &str) -> Result<()>

Fire slash_command notification (Go SendCommand parity).

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

Fire disconnect notification (Go SendDetach parity).

pub async fn send_daemon_status(&self, request_id: &[&str]) -> Result<()>

Send daemon_status request envelope (Go SendDaemonStatus parity).

pub async fn send_daemon_shutdown(&self, request_id: &[&str]) -> Result<()>

Send daemon_shutdown request envelope (Go SendDaemonShutdown parity).

pub async fn send_config_get( &self, section: &str, request_id: &[&str], ) -> Result<()>

Send config_get request envelope (Go SendConfigGet parity).

pub async fn send_config_reload(&self, request_id: &[&str]) -> Result<()>

Send config_reload request envelope (Go SendConfigReload parity).

pub async fn send_skills_list(&self, request_id: &[&str]) -> Result<()>

Send skills_list request envelope (Go SendSkillsList parity).

pub async fn send_models_list(&self, request_id: &[&str]) -> Result<()>

Send models_list request envelope (Go SendModelsList parity).

pub async fn send_invoke_skill( &self, skill: &str, args: &str, request_id: &[&str], ) -> Result<()>

Send invoke_skill request envelope (Go SendInvokeSkill parity).

pub async fn send_mcp_status(&self, request_id: &[&str]) -> Result<()>

Send mcp_status request envelope (Go SendMCPStatus parity).

pub async fn send_loop_list( &self, filter: Option<Map<String, Value>>, limit: u32, request_id: &[&str], ) -> Result<()>

Send loop_list request envelope (Go SendLoopList parity).

pub async fn send_loop_get( &self, loop_id: &str, verbose: bool, request_id: &[&str], ) -> Result<()>

Send loop_get request envelope (Go SendLoopGet parity).

pub async fn send_loop_tree( &self, loop_id: &str, format: &str, request_id: &[&str], ) -> Result<()>

Send loop_tree request envelope (Go SendLoopTree parity).

pub async fn send_loop_prune( &self, loop_id: &str, keep_latest: u32, request_id: &[&str], ) -> Result<()>

Send loop_prune request envelope (Go SendLoopPrune parity).

pub async fn send_loop_delete( &self, loop_id: &str, request_id: &[&str], ) -> Result<()>

Send loop_delete request envelope (Go SendLoopDelete parity).

pub async fn send_loop_reattach( &self, loop_id: &str, request_id: &[&str], ) -> Result<()>

Send loop_reattach request envelope (Go SendLoopReattach parity).

pub async fn send_loop_subscribe( &self, loop_id: &str, wire_tier: &str, stream_delivery: &str, request_id: &[&str], ) -> Result<()>

Send loop_events subscribe envelope (Go SendLoopSubscribe parity).

Pass empty wire_tier / stream_delivery to omit those fields.

pub async fn send_loop_detach( &self, loop_id: &str, request_id: &[&str], ) -> Result<()>

Send unsubscribe by subscription id (Go SendLoopDetach parity).

When request_id is empty, loop_id is used as the subscription id.

pub async fn send_loop_new( &self, client_workspace: &str, user_id: &str, client_workspace_id: &str, is_ephemeral: bool, request_id: &[&str], ) -> Result<()>

Send loop_new request envelope (Go SendLoopNew parity).

pub async fn send_loop_input(&self, loop_id: &str, content: &str) -> Result<()>

Send loop_input notification (Go SendLoopInput parity).

pub async fn send_loop_messages( &self, loop_id: &str, limit: u32, offset: u32, include_events: bool, request_id: &[&str], ) -> Result<()>

Send loop_messages request envelope (Go SendLoopMessages parity).

pub async fn send_loop_state_get( &self, loop_id: &str, request_id: &[&str], ) -> Result<()>

Send loop_state_get request envelope (Go SendLoopStateGet parity).

pub async fn send_loop_state_update( &self, loop_id: &str, values: Map<String, Value>, as_node: &str, request_id: &[&str], ) -> Result<()>

Send loop_state_update request envelope (Go SendLoopStateUpdate parity).

pub async fn send_loop_cards_fetch( &self, loop_id: &str, request_id: &[&str], ) -> Result<()>

Send loop_cards_fetch request envelope (Go SendLoopCardsFetch parity).

pub async fn send_loop_history_fetch( &self, loop_id: &str, request_id: &[&str], ) -> Result<()>

Send loop_history_fetch request envelope (Go SendLoopHistoryFetch parity).

pub async fn send_auth( &self, access_key: &str, secret_key: &str, request_id: &[&str], ) -> Result<()>

Send auth request envelope (Go SendAuth parity).

pub async fn send_auth_refresh( &self, refresh_token: &str, request_id: &[&str], ) -> Result<()>

Send auth_refresh request envelope (Go SendAuthRefresh parity).

pub async fn send_cron_add( &self, text: &str, priority: i32, request_id: &[&str], ) -> Result<()>

Send cron_add request envelope (Go SendCronAdd parity).

pub async fn send_cron_list( &self, status: &str, request_id: &[&str], ) -> Result<()>

Send cron_list request envelope (Go SendCronList parity).

pub async fn send_cron_show( &self, job_id: &str, request_id: &[&str], ) -> Result<()>

Send cron_show request envelope (Go SendCronShow parity).

pub async fn send_cron_cancel( &self, job_id: &str, request_id: &[&str], ) -> Result<()>

Send cron_cancel request envelope (Go SendCronCancel parity).

pub async fn send_job_create( &self, goal: &str, workspace: Option<&str>, request_id: &[&str], ) -> Result<()>

Fire-and-forget job_create (Go SendJobCreate parity).

pub async fn send_job_status( &self, job_id: &str, request_id: &[&str], ) -> Result<()>

Fire-and-forget job_status (Go SendJobStatus parity).

pub async fn send_job_pause( &self, job_id: &str, request_id: &[&str], ) -> Result<()>

Fire-and-forget job_pause (Go SendJobPause parity).

pub async fn send_job_resume( &self, job_id: &str, request_id: &[&str], ) -> Result<()>

Fire-and-forget job_resume (Go SendJobResume parity).

pub async fn send_job_cancel( &self, job_id: &str, request_id: &[&str], ) -> Result<()>

Fire-and-forget job_cancel (Go SendJobCancel parity).

pub async fn send_job_dag( &self, job_id: &str, request_id: &[&str], ) -> Result<()>

Fire-and-forget job_dag (Go SendJobDag parity).

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.