Struct RuntimeSteering 

pub struct RuntimeSteering { /* private fields */ }

Manages steering messages (stop, pause, resume, follow-up inputs) for a running agent turn.

Implementations

impl RuntimeSteering

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

Replace the steering message receiver channel.

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

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

pub fn has_pending_follow_up_inputs(&self) -> bool

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

Dequeue the next follow-up user input, if any are pending.

pub fn pop_follow_up_intent(&mut self) -> Option<QueuedFollowUpIntent>

Dequeue the next identified follow-up intent.

Refills the primary FIFO from overflow first so an empty primary with parked overflow still yields (has_pending_follow_up_inputs staying true must not race a None pop).

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

Queue a follow-up user input. The boolean is false when the FIFO is full; callers that need the error detail should use the try_ variant.

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

Queue a follow-up user input and return an explicit overflow error.

pub fn try_queue_follow_up_intent( &mut self, intent: QueuedFollowUpIntent, ) -> Result<(), FollowUpQueueFull>

Queue a recovered intent without changing its stable identity.

Primary FIFO first; when it is full the intent parks in a bounded overflow buffer so rapid influx is preserved rather than dropped. Only when both buffers are full does the call fail.

pub fn acknowledge_follow_up_intent(&mut self, intent_id: impl Into<String>)

Mark an intent as applied after its tagged user message is stored.

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

pub fn pending_follow_up_intents(&self) -> &VecDeque<QueuedFollowUpIntent>

Primary-FIFO view of pending follow-ups (excludes overflow park and in-flight). Prefer Self::pending_follow_up_intents_snapshot when the complete unwritten set matters.

pub fn pending_follow_up_intents_snapshot(&self) -> Vec<QueuedFollowUpIntent>

Return all accepted intents that are not yet represented by durable session history, including the intent currently being processed and any parked in the overflow buffer.

pub fn drain_follow_up_intents_to_in_flight( &mut self, ) -> Vec<QueuedFollowUpIntent>

Pop every queued follow-up intent and move it to the in-flight queue, returning the intents for immediate application to live history (mid-turn steering). Until the post-turn history checkpoint succeeds, the moved intents stay in the pending snapshot exactly like turn-boundary delivery.

pub fn acknowledge_durable_follow_up_intents(&mut self)

Mark intents whose tagged user messages have been durably checkpointed as applied. Until this is called, the intents remain in the pending snapshot so a crash cannot lose them between history and envelope IO.

pub fn release_in_flight_follow_up_intents_without_persistence(&mut self)

Release intents after their tagged messages have been applied when no history archive exists. This frees FIFO capacity for the in-process session without adding applied IDs that could falsely imply crash durability.

pub fn clear_pending_follow_up_inputs(&mut self)

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.

Trait Implementations

impl Default for RuntimeSteering

fn default() -> Self

Returns the “default value” for a type.