Enum TurnState 

pub enum TurnState {
    Idle,
    Generating {
        id: TurnId,
        started: SystemTime,
        partial_text: String,
        partial_reasoning: String,
        tokens: usize,
        phase: GenPhase,
        provider_continuation: Option<ProviderContinuation>,
        pending_tool_calls: Vec<ToolCall>,
        continuation: bool,
    },
    ExecutingTools {
        id: TurnId,
        started: SystemTime,
        calls: Vec<PendingToolCall>,
        outcomes: Vec<Option<ToolOutcome>>,
    },
    Compacting {
        id: TurnId,
        started: SystemTime,
        trigger: CompactionTrigger,
        resume_continuation: bool,
    },
    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).

provider_continuation: Option<ProviderContinuation>

Opaque provider state carried until the assistant message commits.

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.

continuation: bool

True when this turn resumes a reply cut by the per-response output cap (auto-continue). The commit stamps the resulting message ChatMessageKind::Continuation so the transcript can stitch it into the previous bubble. Survives an intervening empty-retry or truncation-recovery compaction so a chain never loses the marker mid-way.

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

resume_continuation: bool

True when the turn that led into this compaction was itself a continuation (see Generating::continuation): a TruncationRecovery resume must re-enter Generating with the flag intact or a continuation chain interrupted by a genuine context-full compaction would commit its remaining text unmarked.

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.