Enum TurnState 

pub enum TurnState {
    Idle,
    Generating {
        id: TurnId,
        started: SystemTime,
        partial_text: String,
        partial_reasoning: String,
        tokens: usize,
        phase: GenPhase,
        thinking_signature: Option<String>,
        pending_tool_calls: Vec<ToolCall>,
    },
    ExecutingTools {
        id: TurnId,
        started: SystemTime,
        calls: Vec<PendingToolCall>,
        outcomes: Vec<Option<ToolOutcome>>,
    },
    Compacting {
        id: TurnId,
        started: SystemTime,
        trigger: CompactionTrigger,
    },
    Cancelling {
        id: TurnId,
        since: SystemTime,
    },
}

The turn state machine. Each variant carries its own TurnId so the reducer can cheaply check “is this effect result for the current turn?” without threading the ID through every match arm.

The ExecutingTools::outcomes: Vec<Option<ToolOutcome>> field is the architectural payoff: every slot starts None, flips to Some(outcome) as each tool finishes, and the transition to the follow-up Generating state requires outcomes to be fully populated. Statically impossible to “lose” a tool result.

Variants

Idle

Generating

Fields

id: TurnId

started: SystemTime

partial_text: String

partial_reasoning: String

tokens: usize

Running token estimate — updated by StreamText events.

phase: GenPhase

Sub-phase for richer status display (see GenPhase).

thinking_signature: Option<String>

Anthropic-only: carries forward across the turn so we can attach it to the committed assistant message. None until the Anthropic adapter emits a signature event.

pending_tool_calls: Vec<ToolCall>

Tool calls the model has streamed so far this turn. StreamToolCall messages push here; StreamDone drains the vec, allocates PendingToolCall entries, and transitions to ExecutingTools. When the vec is empty at stream end, the turn returns to Idle.

ExecutingTools

Fields

id: TurnId

started: SystemTime

When tool execution started, so the status line can show elapsed time (a long-running command — npm run dev, a slow build — would otherwise look frozen at 0s).

calls: Vec<PendingToolCall>

outcomes: Vec<Option<ToolOutcome>>

Compacting

Summarizing history as a step of its own: a manual /compact (trigger: Manual, ends the turn afterwards) or a truncation recovery (trigger: TruncationRecovery, resumes the run afterwards). Pre-turn auto compaction instead runs while Generating because it is preflight for the same user turn. trigger is what the finished/failed handlers key off.

Fields

id: TurnId

started: SystemTime

trigger: CompactionTrigger

Cancelling

CancelTurn was dispatched. The reducer has already emitted a Cmd::CancelScope — now we wait for the final Cancelled / StreamDone that the effect runner sends back when the scope’s JoinSet drains. Only then do we transition to Idle.

Stuck in Cancelling too long = effect runner has a bug. UI surfaces a “cleanup taking a while…” hint after 2s.

Fields

id: TurnId

since: SystemTime

Implementations

impl TurnState

pub fn id(&self) -> Option<TurnId>

pub fn accepts(&self, event_turn: TurnId) -> bool

True when a Msg tagged with the given TurnId should be accepted. Events from prior turns return false — the reducer’s first line on every effect-result arm.

Trait Implementations

impl Clone for TurnState

fn clone(&self) -> TurnState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TurnState

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

Formats the value using the given formatter.