Struct AgentRuntime 

pub struct AgentRuntime {
    pub state: AgentSessionState,
    /* private fields */
}

Orchestrates a single agent turn: manages steering, lifecycle events, and the LLM call.

Fields

state: AgentSessionState

Mutable session state including conversation history and statistics.

Implementations

impl AgentRuntime

pub fn new( state: AgentSessionState, event_sink: Option<EventSink>, steering_receiver: Option<UnboundedReceiver<SteeringMessage>>, ) -> Self

Create a new runtime with the given session state, optional event sink, and steering receiver.

pub fn set_event_handler(&mut self, sink: Option<EventSink>)

Replace the structured event sink used for lifecycle event emission.

pub fn set_steering_receiver( &mut self, receiver: Option<UnboundedReceiver<SteeringMessage>>, )

Replace the steering message receiver channel for this runtime.

pub fn take_steering_receiver( &mut self, ) -> Option<UnboundedReceiver<SteeringMessage>>

Take ownership of the steering receiver, leaving None in its place.

pub fn split_mut(&mut self) -> (&mut AgentSessionState, &mut RuntimeSteering)

Borrow the session state and steering controller mutably at the same time.

pub fn has_pending_follow_up_inputs(&self) -> bool

Returns true if there are queued follow-up user inputs waiting to be consumed.

pub fn run_until_idle(&mut self) -> Option<String>

Pop the next queued follow-up input, add a tagged user message, and retain the intent until the enclosing history checkpoint succeeds.

pub fn queue_follow_up_input(&mut self, input: String)

Queue a follow-up input to be consumed by run_until_idle on the next iteration, causing the session loop to start a new turn with this input without waiting for the user to type anything.

pub fn try_queue_follow_up_input( &mut self, input: String, ) -> Result<(), FollowUpQueueFull>

Queue a follow-up input while exposing FIFO overflow to the caller.

pub fn restore_follow_up_state( &mut self, pending_intents: impl IntoIterator<Item = QueuedFollowUpIntent>, applied_intent_ids: impl IntoIterator<Item = String>, ) -> Result<(), FollowUpQueueFull>

Restore the durable steering snapshot after loading session history. Pending intents already represented by a tagged user message, or already in the applied-ID window, are skipped; identical text with a different ID is intentionally retained.

pub fn applied_follow_up_intent_ids(&self) -> &VecDeque<String>

Access the intent IDs acknowledged by this runtime for checkpointing.

pub fn clear_pending_follow_up_inputs(&mut self)

Drop follow-up inputs belonging to the discarded execution context.

pub async fn poll_turn_control(&mut self) -> RuntimeControl

Poll the steering channel for control signals during the current turn.

pub async fn poll_tool_control(&mut self) -> RuntimeControl

Poll the steering channel for control signals during tool execution.

pub fn take_emitted_events(&mut self) -> Vec<ThreadEvent>

Take all emitted lifecycle events, leaving the internal buffer empty.

pub fn tool_call_item_id(&self, call_id: &str) -> Option<String>

Look up the lifecycle item ID for a given tool call identifier.

pub fn complete_tool_call( &mut self, call_id: &str, status: ToolCallStatus, outcome: Option<ToolOutcome>, )

Mark a specific tool call as completed with the given status and emit lifecycle events.

pub fn complete_open_tool_calls(&mut self, status: ToolCallStatus)

Mark all still-open tool calls as completed with the given status and emit lifecycle events.

pub async fn run_turn_once( &mut self, provider: &mut Box<dyn LLMProvider>, request: LLMRequest, timeout: Option<Duration>, ) -> Result<TurnExecution>

Execute a single LLM turn: stream the response, update session state, and return the result.