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,
    },
    CompactionFinished {
        turn: TurnId,
        result: CompactionResult,
    },
    CompactionFailed {
        turn: TurnId,
        trigger: CompactionTrigger,
        message: String,
        kind: StatusKind,
    },
    StreamDone {
        turn: TurnId,
        usage: Option<TokenUsage>,
        thinking_signature: Option<String>,
    },
    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,
    StatusDismiss,
    Resize {
        width: u16,
        height: u16,
    },
    TransientStatus {
        text: String,
        kind: StatusKind,
        dismiss_ms: u64,
    },
    MouseScroll {
        delta: i16,
    },
    OpenImageAt {
        message_index: usize,
        image_index: usize,
    },
}

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).

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

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>

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.

StatusDismiss

Status line expired (self-clear) or user dismissed.

Resize

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

Fields

width: u16

height: u16

TransientStatus

Set state.status to (text, kind) and schedule automatic dismissal after dismiss_ms. Used by effect handlers that need to surface user-visible feedback without a bespoke Msg per effect — today that’s clipboard-read success / failure (F14), but the variant is general and other effects will reuse it. Reducer handles this arm by setting state.status and pushing Cmd::DismissStatusAfter { ms: dismiss_ms }.

Fields

text: String

kind: StatusKind

dismiss_ms: u64

MouseScroll

Mouse-wheel scroll in the chat pane. Positive delta = scroll toward older messages (up), negative = toward newer (down). The reducer tracks the scroll offset on ui.chat_scroll; the ChatWidget reads it during render.

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

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.