Enum ThreadEvent 

#[non_exhaustive]
pub enum ThreadEvent {
    ThreadStarted {
        thread_id: String,
    },
    TurnStarted {
        turn_number: usize,
    },
    TurnCompleted {
        turn_number: usize,
        usage: TokenUsage,
    },
    ItemStarted {
        item: Item,
    },
    ItemCompleted {
        item: Item,
    },
    ContentDelta {
        delta: String,
    },
    ThinkingDelta {
        thinking: String,
    },
    WaitingForInput {
        prompt: String,
    },
    Error {
        message: String,
        recoverable: bool,
    },
    ThreadCompleted {
        usage: TokenUsage,
    },
    ThreadCancelled,
    GoalVerificationStarted {
        goals: Vec<String>,
        method: String,
    },
    GoalVerificationResult {
        goal: String,
        score: f64,
        target: f64,
        passed: bool,
        duration_ms: u64,
    },
    GoalVerificationCompleted {
        all_passed: bool,
        passed_count: usize,
        total_count: usize,
    },
    RalphIterationStarted {
        iteration: u32,
        max_iterations: u32,
        prompt: String,
    },
    RalphContinuation {
        reason: String,
        confidence: u32,
        details: String,
    },
    RalphCircuitBreak {
        reason: String,
        iteration: u32,
    },
    BackgroundTaskSpawned {
        task_id: String,
        description: String,
        agent: String,
    },
    BackgroundTaskProgress {
        task_id: String,
        status: String,
        message: Option<String>,
    },
    BackgroundTaskCompleted {
        task_id: String,
        success: bool,
        result_preview: Option<String>,
        duration_secs: f64,
    },
    SubagentStarted {
        task_id: String,
        agent_name: String,
        model: String,
        session_id: String,
    },
    SubagentCompleted {
        task_id: String,
        session_id: String,
        success: bool,
        duration_secs: f64,
    },
    ModelSwitched {
        model: String,
        provider: String,
    },
    PermissionEvaluated {
        permission: String,
        path: String,
        action: String,
        rule_matched: Option<String>,
    },
    ApprovalCached {
        tool_name: String,
        pattern: String,
        decision: String,
    },
    CompactionStarted {
        strategy: String,
        token_count_before: usize,
    },
    CompactionCompleted {
        token_count_before: usize,
        token_count_after: usize,
        messages_removed: usize,
    },
    TodoUpdated {
        todos: Vec<TodoItem>,
    },
}

Top-level event for JSONL streaming

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ThreadStarted

Thread has started

Fields

thread_id: String

TurnStarted

A new turn has started

Fields

turn_number: usize

TurnCompleted

A turn has completed

Fields

turn_number: usize

usage: TokenUsage

ItemStarted

An item has started processing

Fields

item: Item

ItemCompleted

An item has completed

Fields

item: Item

ContentDelta

Content is being streamed

Fields

delta: String

ThinkingDelta

Thinking/reasoning content is being streamed

Fields

thinking: String

WaitingForInput

Waiting for user input

Fields

prompt: String

Error

Error occurred

Fields

message: String

recoverable: bool

ThreadCompleted

Thread has completed

Fields

usage: TokenUsage

ThreadCancelled

Thread was cancelled

GoalVerificationStarted

Goal verification has started

Fields

goals: Vec<String>

method: String

GoalVerificationResult

Result of a single goal verification

Fields

goal: String

score: f64

target: f64

passed: bool

duration_ms: u64

GoalVerificationCompleted

All goal verifications completed

Fields

all_passed: bool

passed_count: usize

total_count: usize

RalphIterationStarted

Ralph iteration has started

Fields

iteration: u32

max_iterations: u32

prompt: String

RalphContinuation

Ralph is continuing (verification failed)

Fields

reason: String

confidence: u32

details: String

RalphCircuitBreak

Ralph circuit breaker tripped

Fields

reason: String

iteration: u32

BackgroundTaskSpawned

Background task has been spawned

Fields

task_id: String

description: String

agent: String

BackgroundTaskProgress

Background task progress update

Fields

task_id: String

status: String

message: Option<String>

BackgroundTaskCompleted

Background task has completed

Fields

task_id: String

success: bool

result_preview: Option<String>

duration_secs: f64

SubagentStarted

Subagent has been started

Fields

task_id: String

agent_name: String

model: String

session_id: String

SubagentCompleted

Subagent has completed

Fields

task_id: String

session_id: String

success: bool

duration_secs: f64

ModelSwitched

Model was switched at runtime

Fields

model: String

provider: String

PermissionEvaluated

Permission was evaluated for a tool

Fields

permission: String

path: String

action: String

rule_matched: Option<String>

ApprovalCached

Approval decision was cached

Fields

tool_name: String

pattern: String

decision: String

CompactionStarted

Context compaction started

Fields

strategy: String

token_count_before: usize

CompactionCompleted

Context compaction completed

Fields

token_count_before: usize

token_count_after: usize

messages_removed: usize

TodoUpdated

Todo list was updated

Fields

todos: Vec<TodoItem>

Trait Implementations

impl Clone for ThreadEvent

fn clone(&self) -> ThreadEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ThreadEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ThreadEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ThreadEvent> for Event

fn from(thread_event: ThreadEvent) -> Self

Converts to this type from the input type.

impl Serialize for ThreadEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.