Struct Runtime 

pub struct Runtime {
    pub bus: EventBus,
    pub registry: ExtensionRegistry,
    /* private fields */
}

Fields

bus: EventBus

registry: ExtensionRegistry

Implementations

impl Runtime

pub async fn force_compact_thread( &self, thread_id: &ThreadId, turn_id: &TurnId, preserve_hint: Option<String>, ) -> Result<ForceCompactOutcome>

impl Runtime

pub async fn fork_thread( &self, request: ForkThreadRequest, ) -> Result<ForkThreadOutcome>

Forks parent_thread_id into a new child thread backed by a fresh workspace fork of the parent workspace.

pub async fn remove_thread_workspace_fork( &self, thread_id: &ThreadId, confirm_path: &str, ) -> Result<WorkspaceFork>

Removes the workspace fork behind a forked thread. Destructive and explicit: confirm_path must match the fork workspace exactly. The thread itself is kept (status flips to Removed) so the conversation stays readable.

impl Runtime

pub fn with_execution_lease(self, lease: Arc<RuntimeExecutionLease>) -> Self

Bind before publishing the runtime or accepting work. Replacing a lost generation requires constructing a new runtime, not resetting this guard.

pub fn uses_execution_lease(&self, lease: &Arc<RuntimeExecutionLease>) -> bool

pub fn ensure_execution_authority(&self) -> Result<()>

impl Runtime

pub async fn pending_external_executions(&self) -> Vec<PendingExternalExecution>

impl Runtime

pub fn fork_providers(&self) -> Vec<ForkProviderDescriptor>

Lists registered fork providers.

pub fn fork_provider(&self, provider_id: &str) -> Result<Arc<dyn ForkProvider>>

Resolves a fork provider with an actionable error naming the available ids.

pub async fn create_workspace_fork( &self, provider_id: &str, request: ForkRequest, ) -> Result<WorkspaceFork>

Creates a workspace fork after host-side validation.

pub async fn list_workspace_forks( &self, provider_id: &str, source_workspace: &Path, ) -> Result<Vec<WorkspaceFork>>

pub async fn resume_workspace_fork( &self, provider_id: &str, id: &ForkId, ) -> Result<WorkspaceFork>

pub async fn remove_workspace_fork( &self, provider_id: &str, id: &ForkId, policy: RemoveForkPolicy, ) -> Result<RemoveForkResult>

Removes a fork; destructive and always path-confirmed by the provider contract.

impl Runtime

pub async fn thread_goal_get( &self, thread_id: &ThreadId, ) -> Result<Option<ThreadGoal>>

pub async fn thread_goal_set( &self, thread_id: &ThreadId, patch: ThreadGoalPatch, ) -> Result<Option<ThreadGoal>>

pub async fn thread_goal_clear(&self, thread_id: &ThreadId) -> Result<bool>

pub async fn apply_external_goal_set_effects( self: &Arc<Self>, previous_goal: Option<ThreadGoal>, goal: Option<ThreadGoal>, ) -> Result<Option<ThreadId>>

pub async fn continue_active_goal_if_idle( self: &Arc<Self>, thread_id: ThreadId, ) -> Result<Option<ThreadId>>

impl Runtime

pub async fn review_config(&self) -> RuntimeReviewConfig

The live [review] settings.

pub async fn publish_review( &self, request: PublishReviewRequest, ) -> Result<ReviewPublishResult, PublishReviewError>

Publishes a completed review’s findings and emits RoderEvent::ReviewPublished.

impl Runtime

pub async fn start_review( self: &Arc<Self>, req: StartReviewRequest, ) -> Result<ReviewHandle>

Starts a review and returns as soon as its turn is admitted. Findings arrive as RoderEvent::ReviewCompleted.

pub async fn run_review( self: &Arc<Self>, req: StartReviewRequest, ) -> Result<ReviewCompletion>

Starts a review and awaits its findings.

pub async fn review_record(&self, review_id: &str) -> Option<ReviewRecord>

Looks up a completed review by id.

pub async fn latest_review_record(&self) -> Option<ReviewRecord>

The most recently completed review, used when a publish request omits the review id.

impl Runtime

pub async fn list_roadmaps(&self) -> Result<Vec<DocumentSummary>>

pub async fn open_roadmap(&self, path: &str) -> Result<Document>

pub async fn focus_roadmap_task(&self, path: &str, task_id: &str) -> Result<()>

pub async fn set_roadmap_task( &self, path: &str, task_id: &str, checked: bool, evidence: &str, ) -> Result<()>

pub async fn validate_roadmap(&self, path: &str) -> Result<ValidationResult>

pub async fn list_roadmap_threads( &self, path: &str, ) -> Result<Vec<ThreadAttachment>>

pub async fn spawn_roadmap_thread( &self, path: &str, task_id: &str, ) -> Result<ThreadAttachment>

pub async fn attach_roadmap_thread( &self, path: &str, task_id: &str, thread_id: &str, title: Option<String>, ) -> Result<ThreadAttachment>

pub async fn enter_roadmap_mode(&self, path: &str) -> Result<()>

impl Runtime

pub async fn seal_idle_owner(&self) -> Result<bool>

Permanently seal an owned runtime only after all admitted turns, tool futures, and terminal cleanup have finished. Busy runtimes keep working; the host must stop new inbound work while polling this operation.

True proves local quiescence, including after lease expiry or revocation. The host must separately confirm loss of the durable generation before reporting a completed handoff. False means work remains. Persistence failures still require reconciliation and cannot be reported as drained.

impl Runtime

pub fn new(registry: ExtensionRegistry, config: RuntimeConfig) -> Result<Self>

pub fn from_engine(engine: Arc<dyn InferenceEngine>) -> Result<Self>

pub fn fake() -> Result<Self>

pub fn subscribe_events(&self) -> Receiver<EventEnvelope>

pub fn lifecycle_metrics(&self) -> LifecycleMetricsSnapshot

Returns process-local, redacted lifecycle health counters. The snapshot intentionally has fixed fields and contains no provider, command, process, thread, or turn identifiers.

pub fn registry(&self) -> &ExtensionRegistry

pub fn media_generation(&self) -> Arc<MediaGenerationService>

pub fn context_artifacts(&self) -> ContextArtifactStore

pub async fn execute_workflow_tool( &self, thread_id: ThreadId, tool_name: &str, arguments: Value, ) -> Result<ToolResult>

pub async fn status(&self) -> RuntimeConfig

pub async fn set_skills(&self, skills: SkillRegistry)

pub async fn skills_snapshot(&self) -> SkillRegistry

pub fn workspace(&self) -> PathBuf

pub fn set_allow_local_workspaces(&self, allowed: bool)

Controls whether native workspace tools may execute without an explicit remote-runner binding. Hosted runtimes disable this after construction; ordinary local runtimes retain the compatible default.

pub fn allows_local_workspaces(&self) -> bool

pub async fn set_remote_runner_destination( &self, destination: Option<RunnerDestination>, )

pub async fn set_file_backed_dynamic_context( &self, enabled: bool, ) -> RuntimeConfig

pub async fn set_command_shell(&self, shell: String) -> RuntimeConfig

pub async fn pending_plan_exit(&self) -> Option<PendingPlanExit>

pub async fn set_policy_mode( &self, mode: PolicyMode, reason: Option<String>, ) -> Result<RuntimeConfig>

pub async fn set_agent_swarm_mode( &self, enabled: bool, trigger: AgentSwarmModeTrigger, ) -> Result<RuntimeConfig>

Toggle agent-swarm mode for the runtime (roadmap 104). When enabled, the swarm reminder is injected into each turn’s developer instructions so every app-server/SDK client gets it, not only the TUI.

pub async fn set_agent_swarm_mode_for_thread( &self, thread_id: &str, enabled: bool, trigger: AgentSwarmModeTrigger, ) -> bool

Toggle agent-swarm mode for a single thread (roadmap 104). The override is stored per thread so toggling swarm mode on one thread does not leak the reminder into other threads sharing the runtime; absent threads fall back to the runtime-global default. The emitted AgentSwarmModeChanged event carries the real thread_id.

pub async fn effective_agent_swarm_mode_for_thread( &self, thread_id: &str, ) -> bool

Resolve whether agent-swarm mode is active for thread_id: the per-thread override when present, otherwise the runtime-global default. The turn loop uses this to decide whether to inject the swarm reminder.

pub async fn set_ultra_mode( &self, enabled: bool, trigger: UltraModeTrigger, ) -> Result<RuntimeConfig>

Toggle ultra mode for the runtime. When enabled, proactive multi-agent policy is injected into each turn’s developer instructions for any model, so every app-server/SDK client gets it (not only the TUI).

pub async fn set_ultra_mode_for_thread( &self, thread_id: &str, enabled: bool, trigger: UltraModeTrigger, ) -> bool

Toggle ultra mode for a single thread. The override is stored per thread so toggling on one thread does not leak proactive multi-agent policy into other threads sharing the runtime; absent threads fall back to the runtime-global default.

pub async fn effective_ultra_mode_for_thread(&self, thread_id: &str) -> bool

Resolve whether ultra mode is active for thread_id: the per-thread override when present, otherwise the runtime-global default. The turn loop uses this (together with Sol/Terra Ultra effort) to decide whether to inject proactive multi-agent policy.

pub async fn set_hosted_web_search( &self, mode: HostedWebSearchMode, ) -> Result<RuntimeConfig>

pub async fn record_pending_plan_exit(&self, pending: PendingPlanExit)

pub async fn resolve_pending_plan_exit( &self, request_id: &str, approved: bool, ) -> Result<Option<PendingPlanExit>>

pub async fn resolve_tool_approval( &self, approval_id: &str, approved: bool, ) -> Result<bool>

pub async fn request_app_server_tool_approval( &self, call: ToolCall, reason: Option<String>, ) -> Result<bool>

pub async fn resolve_external_tool_call( &self, request_id: &str, resolution: ExternalToolResolution, ) -> Result<bool>

Completes a pending host-executed tool call (tools/resolve). Returns false when the request id is unknown, already resolved, timed out, or cancelled by a turn interrupt.

pub async fn resolve_user_input( &self, request_id: &str, answers: Value, ) -> Result<bool>

pub async fn select_provider( &self, provider: String, model: Option<String>, reasoning: Option<String>, ) -> Result<RuntimeConfig>

pub async fn preview_provider_selection( &self, provider: String, model: Option<String>, reasoning: Option<String>, ) -> Result<RuntimeConfig>

pub async fn effective_reasoning(&self) -> String

pub fn effective_reasoning_for_config(cfg: &RuntimeConfig) -> String

pub async fn set_dynamic_workflow_effort( &self, effort_profile: DynamicWorkflowEffortProfile, ) -> RuntimeConfig

pub async fn dynamic_workflow_trigger_decision( &self, message: &str, ) -> WorkflowTriggerDecision

pub async fn create_thread( &self, title: Option<String>, ) -> Result<ThreadMetadata>

pub async fn validate_thread_runner_selection( &self, selection: ThreadRunnerSelection, ) -> Result<()>

Validates a runner selection without creating a thread; the placeholder destination id only appears in error messages.

pub async fn create_thread_with( &self, req: CreateThreadRequest, ) -> Result<ThreadMetadata>

pub async fn list_threads(&self) -> Result<Vec<ThreadMetadata>>

pub async fn list_threads_page( &self, options: ThreadListOptions, ) -> Result<ThreadListPage>

pub async fn load_thread_metadata( &self, thread_id: &str, ) -> Result<Option<ThreadMetadata>>

pub async fn archive_thread(&self, thread_id: &str) -> Result<bool>

pub async fn start_team(&self, req: TeamStartRequest) -> Result<TeamState>

pub async fn list_teams(&self) -> Vec<TeamState>

pub async fn read_team(&self, team_id: &str) -> Option<TeamState>

pub async fn start_team_member( &self, team_id: &str, req: TeamMemberStartRequest, ) -> Result<TeamState>

pub async fn message_team_member( self: &Arc<Self>, team_id: &str, member_id: &str, message: String, ) -> Result<TurnId>

pub async fn set_team_member_policy_mode( &self, team_id: &str, member_id: &str, policy_mode: PolicyMode, ) -> Result<TeamState>

pub async fn interrupt_team_member( &self, team_id: &str, member_id: &str, ) -> Result<Option<TurnId>>

pub async fn close_team_member( &self, team_id: &str, member_id: &str, ) -> Result<TeamMemberDescriptor>

pub async fn cleanup_team(&self, team_id: &str, force: bool) -> Result<bool>

pub async fn effective_policy_mode_for_thread( &self, thread_id: &str, ) -> PolicyMode

pub async fn drain_active_turns(&self, timeout: Duration) -> RuntimeDrainOutcome

Stops accepting new turns, requests interruption for every active turn, and waits for their runtime tasks to reach terminal cleanup up to timeout. Repeated calls are safe and continue draining the same set.

pub fn resume_accepting_turns(&self)

Enables turn submission after a prior drain attempt. This is intended for embedders that keep a runtime alive after a bounded drain timeout.

pub async fn turn_lifecycle_snapshot( &self, thread_id: &ThreadId, ) -> Result<TurnLifecycleSnapshot>

pub async fn load_thread( &self, thread_id: &ThreadId, ) -> Result<Option<ThreadSnapshot>>

pub async fn workspace_for_thread(&self, thread_id: &ThreadId) -> Result<String>

pub async fn set_thread_selection_mode( &self, thread_id: &ThreadId, selection_mode: ModelSelectionMode, ) -> Result<()>

pub async fn pause_thread_runner( &self, thread_id: &ThreadId, ) -> Result<RunnerSessionState>

Pause a runner-bound thread’s session toward standby and persist the post-pause state. Errors if the provider is not pausable.

pub async fn resume_thread_runner( &self, thread_id: &ThreadId, ) -> Result<RunnerSessionState>

Resume (wake) a runner-bound thread’s paused session and persist state.

pub async fn detach_thread_runner( &self, thread_id: &ThreadId, ) -> Result<RunnerSessionState>

Detach a runner-bound thread’s session: persist the durable, rejoinable state and leave the remote sandbox alive. Errors if not detachable.

pub async fn rejoin_thread_runner( &self, thread_id: &ThreadId, sandbox: Option<String>, ) -> Result<RunnerSessionState>

Rejoin a previously created sandbox from a thread’s persisted runner state without provisioning a new one. An optional sandbox overrides the persisted sandbox name (recovery by name). Persists refreshed state.

pub fn start_turn( self: &Arc<Self>, req: StartTurnRequest, ) -> BoxFuture<'_, Result<TurnId>>

pub async fn active_turn_count(&self) -> usize

Number of currently running turns across all threads. Hosted runtime pools use this to avoid evicting tenants with active work.

pub async fn active_turn_for_thread( &self, thread_id: &ThreadId, ) -> Option<TurnId>

pub async fn thread_activity(&self, thread_id: &ThreadId) -> ThreadActivity

pub async fn interrupt_turn( &self, thread_id: ThreadId, turn_id: TurnId, ) -> Result<()>

pub async fn steer_turn( &self, thread_id: ThreadId, turn_id: TurnId, message: String, images: Vec<InputImage>, ) -> Result<()>

pub async fn tool_specs(&self) -> Vec<ToolSpec>

pub fn subagent_definitions(&self) -> Vec<SubagentDefinition>

pub async fn emit(&self, event: RoderEvent) -> EventEnvelope

pub async fn record_thread_item_event_kind( &self, thread_id: &ThreadId, turn_id: &TurnId, timestamp: OffsetDateTime, kind: ThreadItemEventKind, ) -> Result<ThreadItemEvent>

Records a projected thread item event and persists it through the configured thread store.

App-server protocol notification bridges currently call this after translating runtime events into item events. Headless runtime consumers that subscribe to RoderEvent directly must make the same call if they need the derived item event stream persisted.

pub async fn thread_item_exists( &self, thread_id: &ThreadId, turn_id: &TurnId, item_id: &str, ) -> Result<bool>

pub async fn current_reasoning_item_id( &self, thread_id: &ThreadId, turn_id: &TurnId, ) -> Result<Option<String>>

pub async fn latest_transcript_item_index( &self, thread_id: &ThreadId, turn_id: &TurnId, ) -> Result<Option<usize>>