Enum SessionEvent 

#[non_exhaustive]
pub enum SessionEvent {
    Thinking,
    ToolCallStart {
        name: String,
        arguments: String,
    },
    ToolCallComplete {
        name: String,
        output: String,
        success: bool,
        duration_ms: u64,
    },
    TextChunk(String),
    TextComplete(String),
    ThinkingComplete(String),
    UsageReport {
        prompt_tokens: usize,
        completion_tokens: usize,
        duration_ms: u64,
        model: String,
    },
    SessionSync(Box<Session>),
    Done,
    Error(String),
    TokenEstimate(TokenEstimate),
    TokenUsage(TokenDelta),
    RlmProgress(RlmProgressEvent),
    RlmComplete(RlmCompletion),
    CompactionStarted(CompactionStart),
    CompactionCompleted(CompactionOutcome),
    CompactionFailed(CompactionFailure),
    ContextTruncated(ContextTruncation),
    RlmSubcallFallback(RlmSubcallFallback),
}

Events emitted during session processing for real-time UI updates and durable telemetry.

Stability

This enum is #[non_exhaustive]. match expressions must include a wildcard arm; new variants may be added without breaking consumers.

Examples

use codetether_agent::session::SessionEvent;

let ev = SessionEvent::Thinking;
assert!(!ev.is_durable());
assert!(matches!(ev, SessionEvent::Thinking));

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.

Thinking

The agent is thinking / waiting on the model.

ToolCallStart

A tool call has started.

Fields

name: String

Tool name.

arguments: String

Tool arguments (JSON-encoded).

ToolCallComplete

A tool call has completed.

Fields

name: String

Tool name.

output: String

Rendered tool output.

success: bool

Whether the tool reported success.

duration_ms: u64

End-to-end execution duration in milliseconds.

TextChunk(String)

Partial assistant text output for streaming UIs.

TextComplete(String)

Final (per-step) assistant text output.

ThinkingComplete(String)

Model thinking/reasoning output (for reasoning-capable models).

UsageReport

Token usage and timing for one LLM round-trip (legacy aggregate).

Prefer SessionEvent::TokenUsage for new code — it carries a TokenSource so RLM sub-calls and tool-embedded LLM calls are attributed separately.

Fields

prompt_tokens: usize

Prompt tokens consumed.

completion_tokens: usize

Completion tokens produced.

duration_ms: u64

Round-trip duration in milliseconds.

model: String

Model ID that served the request.

SessionSync(Box<Session>)

Updated session state so the caller can sync its in-memory copy.

Done

Processing is complete.

Error(String)

An error occurred during processing.

TokenEstimate(TokenEstimate)

Pre-flight estimate of the next request’s token footprint. Ephemeral.

TokenUsage(TokenDelta)

Observed token consumption for one LLM round-trip, attributed by TokenSource. Durable.

RlmProgress(RlmProgressEvent)

Per-iteration progress tick from an in-flight RLM loop. Ephemeral.

RlmComplete(RlmCompletion)

Terminal record for an RLM invocation. Durable.

CompactionStarted(CompactionStart)

A context-compaction pass has begun. Durable.

CompactionCompleted(CompactionOutcome)

A context-compaction pass has finished successfully. Durable.

CompactionFailed(CompactionFailure)

Every compaction strategy failed to fit under budget. Durable.

ContextTruncated(ContextTruncation)

The terminal truncation fallback dropped part of the transcript. Durable; emitted in addition to SessionEvent::CompactionCompleted when the final strategy is FallbackStrategy::Truncate.

RlmSubcallFallback(RlmSubcallFallback)

A configured subcall_model could not be resolved so the router fell back to the root model. Durable — this is a cost signal.

Implementations

impl SessionEvent

pub fn is_durable(&self) -> bool

Returns true if this variant carries data that must reach the durable sink (see the module docs for the full split).

Examples

use codetether_agent::session::{SessionEvent, TokenDelta, TokenSource};

let delta = TokenDelta {
    source: TokenSource::Root,
    model: "m".into(),
    prompt_tokens: 1, completion_tokens: 1, duration_ms: 0,
};
assert!(SessionEvent::TokenUsage(delta).is_durable());
assert!(!SessionEvent::Thinking.is_durable());
assert!(!SessionEvent::TextChunk("x".into()).is_durable());

Trait Implementations

impl Clone for SessionEvent

fn clone(&self) -> SessionEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SessionEvent

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

Formats the value using the given formatter.