Struct TurnDriver 

pub struct TurnDriver { /* private fields */ }

A pumpable, non-blocking driver for one agentic turn at a time.

Owns the running transcript and at most one in-flight turn. The external event loop submits input (or submit_observations shell activity), polls for completion every frame, and may cancel the in-flight turn.

Implementations

impl TurnDriver

pub fn new(config: TurnDriverConfig) -> Self

Build a driver with an empty transcript.

pub fn with_transcript( config: TurnDriverConfig, transcript: Vec<MemMessage>, ) -> Self

Build a driver seeded with an existing transcript (e.g. a system prompt plus prior turns the consumer already assembled).

pub fn transcript(&self) -> &[MemMessage]

The current transcript — every message the model has seen plus the replies it produced. Feed it to transcript_lines for renderer-agnostic, width-wrapped rows, or render it however the consumer likes.

pub fn is_running(&self) -> bool

Whether a turn is currently in flight.

pub fn submit_observation(&mut self, obs: ShellObservation)

Append a ShellObservation to the transcript so it becomes part of the next turn’s context. The observation is redacted and framed by ShellObservation::into_mem_message — credentials in shell output are scrubbed before they enter the transcript. This does not start a turn on its own; a real human message (submit) drives the loop, with the accumulated observations already in context.

pub fn submit( &mut self, input: impl Into<String>, ) -> Result<(), TurnDriverError>

Submit a human message and start a turn.

Appends the message as a User turn, snapshots the transcript, and spawns a task that runs one chat_complete against the configured backend. Returns an error (without starting anything) if a turn is already in flight — the driver runs one turn at a time. Poll poll for the result.

pub fn poll(&mut self) -> TurnStatus

Non-blocking poll for the in-flight turn’s status.

• TurnStatus::Idle — nothing in flight.
• TurnStatus::Running — in flight, not done.
• TurnStatus::Completed — done; the reply has been appended to the transcript as an assistant message. Returned exactly once.
• TurnStatus::Failed — errored; nothing appended. Returned once.

pub fn cancel(&mut self)

Cancel the in-flight turn, if any. Signals the worker thread to abandon the turn (winning the select! race against chat_complete) and joins it so the runtime tears down before returning. The user message that started the turn stays in the transcript — the consumer can pop it for a clean retry. No-op when idle.

A turn already blocked deep inside a single HTTP dispatch returns when that dispatch resolves (or times out); the cancel signal is honored at the next select! poll point, which in practice is between dispatches.