Enum Msg 

pub enum Msg {
    Key(Key),
    Paste(Paste),
    SubmitPrompt {
        text: String,
        attachment_ids: Vec<u64>,
    },
    Slash(SlashCmd),
    CancelTurn,
    ConfirmAccepted,
    ConfirmDeclined,
    Quit,
    RuntimeSignal(RuntimeSignal),
    StreamText {
        turn: TurnId,
        chunk: String,
    },
    StreamReasoning {
        turn: TurnId,
        chunk: ReasoningChunk,
    },
    StreamToolCall {
        turn: TurnId,
        call: ToolCall,
    },
    ContextUsageEstimated {
        turn: TurnId,
        snapshot: ContextUsageSnapshot,
    },
    ProviderContextResolved {
        model_id: String,
        model_max: Option<usize>,
        effective: Option<usize>,
        source: Option<NumCtxSource>,
    },
    OllamaPlacementResolved {
        model_id: String,
        size_vram_bytes: u64,
        total_bytes: u64,
        suggested_num_ctx: Option<u32>,
    },
    BuiltinToolSchemaTokens(usize),
    CompactionFinished {
        turn: TurnId,
        result: CompactionResult,
    },
    CompactionFailed {
        turn: TurnId,
        trigger: CompactionTrigger,
        message: String,
        kind: StatusKind,
    },
    StreamDone {
        turn: TurnId,
        usage: Option<TokenUsage>,
        thinking_signature: Option<String>,
        stop_reason: Option<FinishReason>,
    },
    UpstreamError {
        turn: TurnId,
        error: UserFacingError,
    },
    TurnCancelled(TurnId),
    ToolStarted {
        turn: TurnId,
        call_id: ToolCallId,
    },
    ToolProgress {
        turn: TurnId,
        call_id: ToolCallId,
        event: ProgressEvent,
    },
    ToolFinished {
        turn: TurnId,
        call_id: ToolCallId,
        outcome: ToolOutcome,
    },
    ApprovalRequested {
        turn: TurnId,
        call_id: ToolCallId,
        tool: String,
        risk: String,
        kind: ApprovalKind,
        prompt: String,
        allowlist_scope: String,
    },
    McpServerReady {
        name: String,
        tools: Vec<McpToolSpec>,
    },
    McpServerErrored {
        name: String,
        reason: String,
    },
    McpServerStopped {
        name: String,
    },
    InstructionsChanged(Option<LoadedInstructions>),
    MemoryChanged(Option<LoadedMemory>),
    SessionSaved,
    ConversationLoaded(ConversationHistory),
    ConversationsListed(Vec<ConversationSummary>),
    RuntimeTasksListed(Vec<TaskRecord>),
    RuntimeTaskLoaded {
        task: Option<TaskRecord>,
        events: Vec<TaskTimelineEvent>,
    },
    RuntimeProcessesListed(Vec<ProcessRecord>),
    RuntimeText(String),
    RuntimeApprovalsListed(Vec<ApprovalRecord>),
    RuntimeCheckpointsListed(Vec<CheckpointRecord>),
    RuntimePluginsListed(Vec<PluginInstallRecord>),
    ModelPullFinished {
        model: String,
    },
    ModelPullProgress(String),
    Tick,
    Resize {
        width: u16,
        height: u16,
    },
    TransientStatus {
        text: String,
    },
    MouseScroll {
        delta: i16,
    },
    OpenImageAt {
        message_index: usize,
        image_index: usize,
    },
    CopySelection(String),
}

Single reducer input. Non-exhaustive is intentional: adding a new variant is a deliberate act that forces every reducer arm to consider it at compile time (the reducer’s match is NOT _ => — see reducer.rs).

Serde derives exist for --record / --replay: every Msg the driver feeds the reducer is serialized to one JSONL line, and replay folds the deserialized stream back through update(). New variants round-trip automatically via the externally-tagged representation — no per-variant recording code to keep in sync.

Variants

Key(Key)

Raw key event from crossterm, after the event source has stripped mouse/resize/paste.

Paste(Paste)

A full paste (text OR image) from the terminal.

SubmitPrompt

User hit Enter on a non-empty input. The event source has already stripped the slash-command routing.

Fields

text: String

attachment_ids: Vec<u64>

Attachment IDs the reducer should consume from state.

Slash(SlashCmd)

User ran a slash command (post-routing from app::event_source).

CancelTurn

Esc or another explicit cancellation source during an active turn.

ConfirmAccepted

Confirmation modal answer.

ConfirmDeclined

Quit

User wants to exit cleanly (Ctrl+D with empty input, or /quit).

RuntimeSignal(RuntimeSignal)

External process lifecycle signal. In raw-mode TUI sessions a typed Ctrl+C still arrives as Msg::Key; this variant covers OS-level SIGINT/SIGTERM/SIGHUP delivered from outside.

StreamText

Chunk of assistant text. Append to partial_text.

Fields

turn: TurnId

chunk: String

StreamReasoning

Chunk of reasoning / thinking content.

Fields

turn: TurnId

chunk: ReasoningChunk

StreamToolCall

Model emitted a tool call. Append to the outgoing call list; actual execution dispatches on StreamDone.

Fields

turn: TurnId

call: ToolCall

ContextUsageEstimated

Effect runner estimated the fully-enriched request context after built-in and MCP tool schemas were attached.

Fields

turn: TurnId

snapshot: ContextUsageSnapshot

ProviderContextResolved

Effect runner resolved the provider’s context window. For Ollama, model_max is the probed architectural window and effective is the auto-fitted/overridden num_ctx. Model-level metadata (not turn-scoped); model_id is carried so a probe that lands after a /model switch can be dropped instead of overwriting the new model’s window. Drives the /context display + quick-fix.

Fields

model_id: String

model_max: Option<usize>

effective: Option<usize>

source: Option<NumCtxSource>

OllamaPlacementResolved

Effect runner verified the loaded model’s memory placement after a turn (Ollama /api/ps). size_vram_bytes < total_bytes ⇒ the model spilled to CPU/RAM (slow). Model-level metadata (not turn-scoped); model_id is carried so a probe that lands after a /model switch can be dropped. Drives the offload warning + /context placement line.

Fields

model_id: String

size_vram_bytes: u64

total_bytes: u64

suggested_num_ctx: Option<u32>

Auto-converge target: largest num_ctx that would fit when the model spilled, or None if it fits / can’t be helped by shrinking.

BuiltinToolSchemaTokens(usize)

The effect runner’s estimate of the built-in tool-schema token cost it appends to every request during dispatch. Not turn-scoped — the reducer stores it on runtime so /context can fold it into its MCP-only estimate and agree with what dispatch actually decides.

CompactionFinished

Context compaction completed and produced a replacement model-visible history.

Fields

turn: TurnId

result: CompactionResult

CompactionFailed

Context compaction failed or no-oped. Manual failures end the compaction turn; auto failures may leave generation running.

Fields

turn: TurnId

trigger: CompactionTrigger

message: String

kind: StatusKind

StreamDone

Stream complete. Carries final token count (0 if unknown) and, for Anthropic, the thinking signature that must round-trip on the next request.

Fields

turn: TurnId

usage: Option<TokenUsage>

thinking_signature: Option<String>

stop_reason: Option<FinishReason>

Why the model stopped (truncation / content block / normal), when the provider reported it. Drives the truncation status note.

UpstreamError

Upstream returned a recoverable or terminal error. Reducer commits an error line and returns to Idle (or surfaces a retry affordance, if recoverable).

Fields

turn: TurnId

error: UserFacingError

TurnCancelled(TurnId)

Terminal event for a cancelled turn. Emitted by the effect runner’s drop_scope once every child task in the turn’s TurnScope has unwound. Reducer transitions Cancelling(id) → Idle when it arrives.

Without this, the reducer relies on the (wrong) side-channel of UpstreamError arriving from a cancelled provider call to exit Cancelling. If the provider task is aborted before it can emit an error, the state would stick in Cancelling forever.

ToolStarted

Tool was picked up by the executor — useful for “spinner started” UI transitions.

Fields

turn: TurnId

call_id: ToolCallId

ToolProgress

Mid-flight progress (streaming subprocess output, byte-count updates, multimodal artifacts, nested subagent activity). Reducer pattern-matches the variant and routes accordingly: text variants update the status line; Artifact with an image/* mime attaches to the in-flight assistant message; Subagent* variants render as indented status.

Fields

turn: TurnId

call_id: ToolCallId

event: ProgressEvent

ToolFinished

Tool finished (one of Finished / Error / Cancelled).

Fields

turn: TurnId

call_id: ToolCallId

outcome: ToolOutcome

ApprovalRequested

A gated tool is awaiting the user’s inline approval (interactive ask mode / Auto-mode escalation). The reducer enqueues a modal; the answer flows back as Cmd::ResolveApproval. The tool task is parked until then, so the turn naturally pauses (its outcome slot stays None).

Fields

turn: TurnId

call_id: ToolCallId

tool: String

risk: String

kind: ApprovalKind

prompt: String

allowlist_scope: String

McpServerReady

initialize succeeded; server is ready to dispatch tools.

Fields

name: String

tools: Vec<McpToolSpec>

McpServerErrored

Server startup failed OR the child exited with non-zero.

Fields

name: String

reason: String

McpServerStopped

Fields

name: String

InstructionsChanged(Option<LoadedInstructions>)

MERMAID.md loaded / changed / removed since last check.

MemoryChanged(Option<LoadedMemory>)

Memory files loaded / changed / removed since last check.

SessionSaved

save_conversation finished.

ConversationLoaded(ConversationHistory)

/load <id> — a saved conversation has been read off disk.

ConversationsListed(Vec<ConversationSummary>)

Response to Cmd::ListConversations. Populates the /load picker’s candidate list.

RuntimeTasksListed(Vec<TaskRecord>)

Response to /tasks.

RuntimeTaskLoaded

Response to /task <id>.

Fields

task: Option<TaskRecord>

events: Vec<TaskTimelineEvent>

RuntimeProcessesListed(Vec<ProcessRecord>)

Response to /processes.

RuntimeText(String)

Generic daemon/runtime text response.

RuntimeApprovalsListed(Vec<ApprovalRecord>)

RuntimeCheckpointsListed(Vec<CheckpointRecord>)

RuntimePluginsListed(Vec<PluginInstallRecord>)

ModelPullFinished

/model <name> finished pulling (Ollama only).

Fields

model: String

ModelPullProgress(String)

Streaming stdout line from an ollama pull subprocess. Reducer forwards to the status line for the user to watch.

Tick

1/60s timer tick. Used for spinner animation + elapsed-time display. Reducer only advances derived fields.

Resize

Terminal was resized. Reducer normally no-ops; render consumes.

Fields

width: u16

height: u16

TransientStatus

Generic user-visible feedback from an async effect handler, routed into the chat transcript. Lets effects surface a result (clipboard read, config saved, plugin install, …) without a bespoke Msg per effect.

Fields

text: String

MouseScroll

Mouse-wheel scroll in the chat pane. Positive delta = scroll toward older messages (up), negative = toward newer (down). The reducer accumulates into ui.mouse_scroll_accum; the render layer diffs it and applies the delta to the ChatWidget’s scroll offset.

Fields

delta: i16

OpenImageAt

Ctrl+Click on an image thumbnail in the chat pane. The coordinates are absolute screen row/col; the render cache’s ChatState::find_image_at_screen_pos maps them to a (message_index, image_index) pair. The main loop handles the lookup before forwarding this message to the reducer, so by the time the reducer sees it, the target has already been resolved into a base64 payload and this Msg carries the already-decoded image. The reducer just emits Cmd::WriteImageToTemp + Cmd::OpenInSystem.

Fields

message_index: usize

image_index: usize

CopySelection(String)

Copy the current chat text selection to the system clipboard. The main loop reads the selected text from the render layer (rstate.chat) and emits this, so the side effect flows through update() — and is recorded for replay — instead of being dispatched out-of-band (#18).

Implementations

impl Msg

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

Extract the TurnId for effect-result variants. Returns None for variants that aren’t turn-scoped (user intent, housekeeping, MCP lifecycle). The reducer uses this to short-circuit stale events.

pub fn kind(&self) -> MsgKind

Classification for telemetry / replay tooling. Cheaper than a full Debug string and stable across refactors.

Trait Implementations

impl Clone for Msg

fn clone(&self) -> Msg

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Msg

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Msg

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Msg

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.