Enum Event 

pub enum Event {
    RunStarted {
        run: RunId,
        task: String,
        agent: String,
    },
    RouteSelected {
        run: RunId,
        chain: Vec<String>,
        context_window: u64,
    },
    ModelSwitched {
        run: RunId,
        from: String,
        to: String,
        reason: String,
    },
    ThinkingDelta {
        run: RunId,
        text: String,
    },
    ReasoningDelta {
        run: RunId,
        text: String,
    },
    Message {
        run: RunId,
        role: String,
        text: String,
    },
    ToolUseProposed {
        run: RunId,
        id: String,
        name: String,
        args: Value,
        risk: RiskLevel,
    },
    ApprovalRequested {
        run: RunId,
        id: String,
        summary: String,
        tool: Option<String>,
        risk: Option<String>,
    },
    ApprovalResolved {
        run: RunId,
        id: String,
        decision: Decision,
    },
    ToolUseStarted {
        run: RunId,
        id: String,
    },
    ToolOutput {
        run: RunId,
        id: String,
        blocks: Vec<Block>,
        is_error: bool,
    },
    DiffProposed {
        run: RunId,
        file: String,
        patch: String,
        plus: u32,
        minus: u32,
    },
    DiffApplied {
        run: RunId,
        file: String,
    },
    TestResult {
        run: RunId,
        passed: u32,
        failed: u32,
        detail: String,
    },
    AgentSpawned {
        run: RunId,
        role: String,
        model: String,
    },
    AgentStatus {
        run: RunId,
        role: String,
        status: AgentStatus,
        note: String,
    },
    CheckpointCreated {
        run: RunId,
        id: CheckpointId,
        label: String,
    },
    SkillLearned {
        run: RunId,
        name: String,
    },
    CostUpdate {
        run: RunId,
        usd: f64,
    },
    TokenUsage {
        run: RunId,
        input: u64,
        output: u64,
    },
    TokenUsageEstimated {
        run: RunId,
        input: u64,
        output: u64,
        reason: String,
    },
    AutonomyChanged {
        run: RunId,
        level: AutonomyLevel,
    },
    RunFinished {
        run: RunId,
        outcome: OutcomeSummary,
    },
    Error {
        run: RunId,
        message: String,
    },
    Compacted {
        run: RunId,
        before_chars: usize,
        after_chars: usize,
        handoff_path: Option<String>,
    },
    UpdateAvailable {
        current: String,
        latest: String,
        download_url: Option<String>,
        crate_url: String,
        release_url: String,
        install_cmd: String,
    },
}

Every surface renders from this stream; replay records from it. This enum is the contract that connects runtime ↔ surfaces ↔ replay.

Variants

RunStarted

Fields

run: RunId

task: String

agent: String

RouteSelected

Fields

run: RunId

chain: Vec<String>

context_window: u64

ModelSwitched

Fields

run: RunId

from: String

to: String

reason: String

ThinkingDelta

Fields

run: RunId

text: String

ReasoningDelta

Opaque provider reasoning state. Surfaces should not render this as assistant-visible text, but session persistence must keep it so reasoning-mode providers can receive reasoning_content on the next turn when they require it.

Fields

run: RunId

text: String

Message

Fields

run: RunId

role: String

text: String

ToolUseProposed

Fields

run: RunId

id: String

name: String

args: Value

risk: RiskLevel

ApprovalRequested

Fields

run: RunId

id: String

summary: String

tool: Option<String>

risk: Option<String>

ApprovalResolved

Fields

run: RunId

id: String

decision: Decision

ToolUseStarted

Fields

run: RunId

id: String

ToolOutput

Fields

run: RunId

id: String

blocks: Vec<Block>

is_error: bool

True when the tool reported a failure (ToolResult::is_error). Additive + defaulted so old recordings/replays still deserialize.

DiffProposed

Fields

run: RunId

file: String

patch: String

plus: u32

minus: u32

DiffApplied

Fields

run: RunId

file: String

TestResult

Fields

run: RunId

passed: u32

failed: u32

detail: String

AgentSpawned

Fields

run: RunId

role: String

model: String

AgentStatus

Fields

run: RunId

role: String

status: AgentStatus

note: String

CheckpointCreated

Fields

run: RunId

id: CheckpointId

label: String

SkillLearned

Fields

run: RunId

name: String

CostUpdate

Fields

run: RunId

usd: f64

TokenUsage

Fields

run: RunId

input: u64

output: u64

TokenUsageEstimated

Fields

run: RunId

input: u64

output: u64

reason: String

AutonomyChanged

Fields

run: RunId

level: AutonomyLevel

RunFinished

Fields

run: RunId

outcome: OutcomeSummary

Error

Fields

run: RunId

message: String

Compacted

A compaction pass has just completed. Surfaces the before/after sizes (in chars) and the path of the handoff doc, if any.

Fields

run: RunId

before_chars: usize

after_chars: usize

handoff_path: Option<String>

UpdateAvailable

A newer version of Sparrow is available. Surfaces should show a non-intrusive notification with update instructions.

Fields

current: String

latest: String

download_url: Option<String>

crate_url: String

release_url: String

install_cmd: String

Implementations

impl Event

pub fn is_public(&self) -> bool

Returns true for events that may be streamed to user-facing feeds.

ReasoningDelta is provider-internal continuity state: the engine and session stores consume it so reasoning-mode providers can receive the required reasoning_content on the next turn, but exposing every delta as NDJSON/WebSocket output floods users with opaque token fragments.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Event

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

where __S: Serializer,

Serialize this value into the given Serde serializer.