Struct AgentOs 

pub struct AgentOs { /* private fields */ }

Implementations

impl AgentOs

pub fn builder() -> AgentOsBuilder

pub fn client(&self) -> Client

pub fn skill_list(&self) -> Option<Vec<Arc<dyn Skill>>>

pub fn agent(&self, agent_id: &str) -> Option<AgentDefinition>

pub fn agent_ids(&self) -> Vec<String>

Return all registered agent ids in stable order.

pub fn tools(&self) -> HashMap<String, Arc<dyn Tool>>

pub fn validate_agent(&self, agent_id: &str) -> Result<(), AgentOsResolveError>

Check whether an agent with the given ID is registered.

pub fn resolve( &self, agent_id: &str, ) -> Result<ResolvedRun, AgentOsResolveError>

Resolve an agent’s static wiring: config, tools, and run policy.

impl AgentOs

pub fn agent_state_store(&self) -> Option<&Arc<dyn ThreadStore>>

pub async fn load_thread( &self, id: &str, ) -> Result<Option<ThreadHead>, AgentOsRunError>

Load a thread from storage. Returns the thread and its version. If the thread does not exist, returns None.

pub async fn current_run_id_for_thread( &self, agent_id: &str, thread_id: &str, ) -> Result<Option<String>, AgentOsRunError>

pub async fn start_active_run_with_persistence( &self, owner_agent_id: &str, run_request: RunRequest, resolved: ResolvedRun, persist_run: bool, strip_lineage: bool, ) -> Result<RunStream, AgentOsRunError>

pub async fn prepare_run( &self, request: RunRequest, resolved: ResolvedRun, ) -> Result<PreparedRun, AgentOsRunError>

Prepare a resolved run for execution.

This handles all deterministic pre-run logic:

1. Thread loading/creation from storage
2. Message deduplication and appending
3. Persisting pre-run state
4. Run-context creation

Callers resolve first, optionally customize, then prepare:

let mut resolved = os.resolve("my-agent")?;
resolved.tools.insert("extra".into(), tool);
let prepared = os.prepare_run(request, resolved).await?;

pub async fn prepare_run_with_persistence( &self, request: RunRequest, resolved: ResolvedRun, persist_run: bool, ) -> Result<PreparedRun, AgentOsRunError>

Prepare a resolved run and control whether the run should be persisted.

This powers dialog-style runs where short-lived execution state is needed but we intentionally do not keep durable run records.

pub fn execute_prepared( prepared: PreparedRun, ) -> Result<RunStream, AgentOsRunError>

Execute a previously prepared run.

pub async fn run_stream( &self, request: RunRequest, ) -> Result<RunStream, AgentOsRunError>

Resolve, prepare, and execute an agent run.

This is the primary entry point. Callers that need to customize the resolved wiring should use [resolve] + mutation + [prepare_run]

• [execute_prepared] instead.

impl AgentOs

pub async fn bind_thread_run_stream_fanout( &self, run_id: &str, fanout: Sender<Bytes>, ) -> bool

pub async fn subscribe_thread_run_stream( &self, run_id: &str, ) -> Option<Receiver<Bytes>>

pub async fn active_run_id_for_thread( &self, agent_id: &str, thread_id: &str, ) -> Option<String>

pub async fn forward_decisions_by_thread( &self, agent_id: &str, thread_id: &str, decisions: &[ToolCallDecision], ) -> Option<ForwardedDecision>

pub async fn forward_decisions_by_run_id( &self, run_id: &str, decisions: &[ToolCallDecision], ) -> Option<ForwardedDecision>

pub async fn cancel_active_run_by_id(&self, run_id: &str) -> bool

pub async fn cancel_active_run_by_thread( &self, thread_id: &str, ) -> Option<String>

Trait Implementations

impl Clone for AgentOs

fn clone(&self) -> AgentOs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AgentOs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.