Struct RunManager 

pub struct RunManager {
    pub persistence: Option<Arc<dyn PersistenceLayer>>,
    /* private fields */
}

Fields

persistence: Option<Arc<dyn PersistenceLayer>>

Implementations

impl RunManager

pub async fn new( llm_config: LlmConfig, global_mcp: Arc<McpRegistry>, sessions: SessionStore, skills: Arc<RwLock<SkillRegistry>>, vector_matcher: Arc<VectorMatcher>, persistence: Option<Arc<dyn PersistenceLayer>>, ) -> Self

pub async fn with_classifier_config( llm_config: LlmConfig, global_mcp: Arc<McpRegistry>, sessions: SessionStore, skills: Arc<RwLock<SkillRegistry>>, vector_matcher: Arc<VectorMatcher>, persistence: Option<Arc<dyn PersistenceLayer>>, classifier_config: ClassifierConfig, native_skills: Arc<NativeSkillRegistry>, ) -> Self

Creates a new RunManager with a custom classifier configuration.

pub fn with_agent_graph(self, graph: AgentGraph) -> Self

Attach an agent graph for graph-driven execution.

When set, orchestrator-agent runs execute the graph instead of the simple tool loop. Other agents retain their existing execution path.

pub fn with_message_context_strategy(self, strategy: ContextStrategy) -> Self

Set the message-count based context strategy from global config.

pub fn with_harness_config(self, config: HarnessConfig) -> Self

Set the skill service for coordinated skill management.

pub fn with_world_state_config( self, instructions: ProjectInstructionsConfig, world_state: WorldStateConfig, ) -> Self

Configure host-owned workspace trust and world-state precision.

pub fn with_world_state_clock(self, clock: Arc<dyn Clock>) -> Self

Substitute the host clock without changing assembly or request behavior.

pub fn with_skill_service(self, service: Arc<SkillService>) -> Self

pub fn with_settings_manager( self, settings_manager: Arc<SettingsManager>, ) -> Self

Override the settings manager used to read the Global policy scope.

RunManager::with_classifier_config builds a settings manager from the supplied persistence by default. Embedded hosts that build and seed a single shared SettingsManager (so runtime resolution and the admin surface observe the same cache) pass it here to replace the auto-built instance.

pub fn with_skill_evolution_config(self, cfg: SkillEvolutionConfig) -> Self

Configure the Hermes skill evolution post-run hook.

pub fn with_provider_registry(self, registry: Arc<ProviderRegistry>) -> Self

Set the provider registry for per-agent LLM provider resolution.

pub fn with_llm_driver(self, driver: Arc<dyn LlmDriver>) -> Self

Set a host-supplied primary LLM driver for embedded deployments.

The default service/runtime path still constructs LiterLlmDriver from LlmConfig. This override is intentionally explicit so mobile hosts can register a local provider via ExternalLlmDriver without changing UAR’s default cloud/provider behavior.

pub fn with_destination_preparations( self, preparations: Arc<DestinationRequestPreparations>, ) -> Self

Install exact model/template/settings contracts resolved by the trusted host. The manager supplies unreduced canonical history to this registry for ordinary, graph and checkpoint-resume execution.

pub fn with_failover_config(self, config: FailoverConfig) -> Self

Set the runtime model failover configuration (CH-03). When enabled, each run’s Orchestrator receives every configured healthy fallback in declared order plus the shared provider-health monitor.

pub fn with_resilience_policy(self, policy: ResiliencePolicy) -> Self

Configure bounded provider retry and stream-start behavior for runs.

pub async fn with_global_cost_budget( self, budget: Option<&LlmBudgetConfig>, ) -> Self

Configure the global spend ceiling (CH-06) from LlmConfig.budget. A no-op when budget is None (global scope is left unlimited — CostBudgetTracker’s default BudgetLimit is f64::INFINITY).

pub fn with_provider_service(self, service: Arc<ProviderService>) -> Self

Attach the multi-tenant credential service. When set, start_run resolves a per-user/session/agent provider key and overrides the run’s api_key. When unset, the env/config key is used (single-tenant).

pub fn with_governance_engine(self, engine: Arc<GovernanceEngine>) -> Self

Attach the Cedar governance engine consulted at the tool-approval gate.

pub fn with_governance_gate(self, gate: GovernanceGateHandle) -> Self

Attach the coherent boot-effective governance master gate.

pub fn with_native_skills(self, registry: Arc<NativeSkillRegistry>) -> Self

Set a shared native skill registry for in-process tool execution.

pub fn with_sandbox_runner(self, runner: Arc<dyn SandboxRunner>) -> Self

Bind an isolation backend resolved by the trusted embedding/server host. Required tools still check the backend’s isolation contract at execution.

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

Join sandbox operations, including scopes whose run future unwound.

Errors

Retains and reports unconfirmed backend outcomes instead of replaying them.

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

Cancel and join directly launched terminal processes retained by runs.

Errors

Reports unconfirmed process cleanup without forgetting its owned handle.

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

Cancel and join graph root workers before closing shared transports.

Errors

Retains failed workers and unresolved persistence/cleanup receipts.

pub async fn sandbox_operations(&self) -> Vec<SandboxOperationSnapshot>

Content-free host diagnostics for retained sandbox operations.

pub fn with_a2ui_backbone(self, backbone: Arc<InMemoryReplayBackbone>) -> Self

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

Resolve a pending tool-call approval for the given run. Returns true if an approval was pending and the decision was delivered, false if no pending approval was found for that run_id.

pub async fn resolve_approval_request( &self, run_id: &str, approval_id: Option<&str>, approved: bool, ) -> bool

Resolve an exact approval request after authenticating the root owner. Child requests require an ID; run-only decisions serve legacy roots.

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

Cancel an in-flight run.

Cancels the run’s cancellation token (which aborts the in-flight LLM stream and tool execution at the next await point) and resolves any pending tool approval as aborted so a run parked on the approval gate unblocks promptly. Returns true if a live run was found and cancelled, false for an unknown or already-terminal run (idempotent).

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

Cancel an in-flight run only when it belongs to the authenticated owner.

pub async fn cancel_run_for_context( &self, user: &UserContext, run_id: &str, ) -> bool

Cancel only when the complete middleware-verified identity owns the run.

pub async fn cancel_session_run(&self, session_id: &str) -> bool

Cancel the current in-flight run associated with a conversation session.

Service clients receive a stable session identifier before the first streamed event reveals UAR’s internal run id. Resolving the mapping in the runtime keeps cancellation reliable without asking clients to parse transport-specific event payloads.

pub async fn cancel_session_run_for_user( &self, owner_id: &str, session_id: &str, ) -> bool

Cancel the current run for an owner-scoped conversation session.

pub async fn cancel_session_run_for_context( &self, user: &UserContext, session_id: &str, ) -> bool

Cancel a session’s current run only for the complete verified identity.

pub fn root_cancellation_token(&self) -> CancellationToken

A clone of the root cancellation token.

Cancelling it aborts ALL in-flight runs at once; used to wire run cancellation into the server’s graceful-shutdown path.

pub async fn effective_config(&self, conversation_id: &str) -> EffectiveConfig

Compute the effective configuration for a conversation, mirroring the service path’s GET /conversations/{id}/effective-config: it resolves the agent named by the stored conversation policy (or the default agent), resolves the effective run policy for that agent + conversation (Global → Agent → Conversation → Turn), and backfills the model route from the registry default so the reported model is the one that will execute.

Returns the resolved agent, the stored requested policy (if any), and the effective policy — the pieces an embedded admin surface needs without a service.

pub async fn start_run( &self, artifact: AgentArtifact, input: String, session_id: Option<String>, user_id: Option<String>, memory_hits: Vec<MemoryItem>, ) -> String

pub async fn start_run_with_skill_attachments( &self, artifact: AgentArtifact, input: String, session_id: Option<String>, user_id: Option<String>, memory_hits: Vec<MemoryItem>, skill_attachments: Vec<String>, ) -> String

Start a run with explicit skill attachments admitted before matching.

pub async fn start_run_with_history( &self, artifact: AgentArtifact, input: String, session_id: Option<String>, user_id: Option<String>, memory_hits: Vec<MemoryItem>, seed_history: Vec<SeedMessage>, ) -> String

Self::start_run plus a seed_history of prior turns used to repopulate an empty (cold-started) session. See Self::start_run_with_policy_and_history.

pub async fn continue_with_interaction( &self, run_id: &str, interaction: Value, user: &UserContext, ) -> Result<String, String>

Continue an existing run after a user responds to an interactive A2UI surface. A continuation is a real agent run in the same conversation, not a synthetic event injected into a completed stream.

pub async fn prepare_interaction_request( &self, run_id: &str, interaction: Value, user: &UserContext, inline_artifact: Option<AgentArtifact>, ) -> Result<RunExecutionRequest, String>

Assemble a continuation request without retaining or resolving any host secret. The API adapter reattaches and compares request-scoped resources before it calls execute_request.

pub async fn start_run_with_policy( &self, artifact: AgentArtifact, input: String, session_id: Option<String>, user_id: Option<String>, memory_hits: Vec<MemoryItem>, resolved_policy: Option<EffectiveRunPolicy>, ) -> String

Start a run using an immutable policy already resolved by UAR’s control plane. When omitted, a backward-compatible policy is resolved from the artifact, persisted conversation policy, and currently available resources.

pub async fn start_run_with_policy_and_history( &self, artifact: AgentArtifact, input: String, session_id: Option<String>, user_id: Option<String>, memory_hits: Vec<MemoryItem>, resolved_policy: Option<EffectiveRunPolicy>, seed_history: Vec<SeedMessage>, ) -> String

Self::start_run_with_policy plus a seed_history of prior turns used to repopulate an empty session (a cold-started conversation whose durable history lives in the host, not the in-process store). A session that already holds messages is never re-seeded, so this is idempotent across warm turns.

pub async fn start_run_from_checkpoint( &self, artifact: AgentArtifact, input: Option<String>, session_id: Option<String>, user_id: Option<String>, memory_hits: Vec<MemoryItem>, restored_history: Vec<Message>, restored_state: GraphState, checkpoint_authorization_digest: String, ) -> String

Start a run from a checkpoint’s exact graph state and conversation history. Unlike an ordinary run, an absent input does not append an empty user turn to the restored history.

pub async fn execute_request(&self, request: RunExecutionRequest) -> String

Execute the shared request type; compatibility entry points adapt here.

pub async fn capture_thread_kernel( &self, owner: &ActorOwner, root: &PersistedAgentThread, persistence: Arc<dyn PersistenceLayer>, ) -> Result<CapturedThreadKernel>

Capture a live root’s executable resources for its trusted thread host. This neither admits a child nor creates a second thread scheduler.

Errors

Rejects unverified owners, completed roots and unavailable MCP bindings.

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

pub async fn subscriber_count(&self, run_id: &str) -> usize

Number of active subscribers to a run’s event stream (SSE clients).

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

Cancel a run only if it currently has no subscribers.

Used by the SSE disconnect guard to implement last-subscriber-drop semantics: a run is abandoned only when the final viewer leaves, so a multi-viewer stream (or a client reconnecting via history replay) is not cancelled when one of several subscribers disconnects. Returns true if the run was cancelled.

pub async fn emit_to_run(&self, run_id: &str, event: NormalizedEvent)

Emit an event into an existing run’s broadcast channel.

This is used by external callers (e.g. post-stream auto-capture) that need to inject events after start_run returns. The event is also appended to the run’s history buffer so late-connecting SSE clients can replay it. Silently no-ops if the run has already been cleaned up.

pub async fn history_since( &self, run_id: &str, last_event_id: Option<u64>, ) -> Option<Vec<StreamEvent>>

pub async fn get_run(&self, run_id: &str) -> Option<Run>

pub async fn get_run_for_user( &self, owner_id: &str, run_id: &str, ) -> Option<Run>

Return a run only when it belongs to the authenticated subject.

pub async fn get_run_for_owner( &self, owner: &ActorOwner, run_id: &str, ) -> Option<Run>

Return a run only for the exact verified subject and tenant identity.

pub async fn get_run_by_session_id(&self, session_id: &str) -> Option<Run>

pub async fn get_run_by_session_id_for_user( &self, owner_id: &str, session_id: &str, ) -> Option<Run>

Return the current run for an owner-scoped conversation session.

pub async fn resolve_default_model(&self) -> Option<(String, String)>

Return the resolved default model (provider_id, model_id) if one is available, or None if neither a provider registry entry nor a global llm_config.model is configured.

Trait Implementations

impl Clone for RunManager

fn clone(&self) -> RunManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunManager

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

Formats the value using the given formatter.