Enum AgentEvent 

#[non_exhaustive]
pub enum AgentEvent {
    RunStarted {
        session_id: SessionId,
    },
    TurnStarted {
        session_id: SessionId,
        turn_id: TurnId,
    },
    InputAccepted {
        session_id: SessionId,
        items: Vec<Item>,
    },
    ContentDelta(Delta),
    ToolCallRequested(ToolCallPart),
    ToolExecutionStarted(ToolCallPart),
    ToolExecutionProgress(ToolResultPart),
    ToolResultReceived(ToolResultPart),
    ApprovalRequired(ApprovalRequest),
    ApprovalResolved {
        approved: bool,
    },
    ToolCatalogChanged(ToolCatalogEvent),
    MutationStarted {
        session_id: SessionId,
        turn_id: Option<TurnId>,
        mutator: String,
        point: MutationPoint,
    },
    MutationFinished {
        session_id: SessionId,
        turn_id: Option<TurnId>,
        mutator: String,
        dirty: bool,
        metadata: MetadataMap,
    },
    UsageUpdated(Usage),
    Warning {
        message: String,
    },
    RunFailed {
        message: String,
    },
    TurnFinished(TurnResult),
}

Lifecycle and streaming events emitted by the LoopDriver.

Observers (see LoopObserver) receive these events in the order they occur. They are useful for building UIs, logging, or telemetry.

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.

RunStarted

The agent run has been initialised.

Fields

session_id: SessionId

TurnStarted

A new model turn is starting.

Fields

session_id: SessionId

turn_id: TurnId

InputAccepted

User input has been accepted into the pending queue.

Fields

session_id: SessionId

items: Vec<Item>

ContentDelta(Delta)

Incremental content delta from the model.

ToolCallRequested(ToolCallPart)

The model has requested a tool call.

ToolExecutionStarted(ToolCallPart)

A tool call is about to execute after policy and approval checks.

ToolExecutionProgress(ToolResultPart)

A tool call has non-terminal progress to report.

Used for updates such as background detachment. Unlike AgentEvent::ToolResultReceived, this does not mean the call has reached a terminal result.

ToolResultReceived(ToolResultPart)

A tool call’s result has landed in the transcript.

Fires once per terminal Part::ToolResult that’s appended. Cancellation/denial paths (auth cancelled, approval denied) also emit this with is_error = true.

Correlate with the matching AgentEvent::ToolCallRequested via call_id.

ApprovalRequired(ApprovalRequest)

A tool call requires explicit user approval before execution.

ApprovalResolved

An approval interrupt has been resolved.

Fields

approved: bool

ToolCatalogChanged(ToolCatalogEvent)

The available tool catalog changed and will be reflected on the next model request.

MutationStarted

A LoopMutator is about to run at one of the mutation points. mutator is a stable label the implementation chooses for itself.

Fields

session_id: SessionId

turn_id: Option<TurnId>

mutator: String

point: MutationPoint

MutationFinished

A LoopMutator has finished running. dirty indicates whether the transcript was modified; metadata carries mutator-specific extras (e.g. compaction reason, replaced item count).

Fields

session_id: SessionId

turn_id: Option<TurnId>

mutator: String

dirty: bool

metadata: MetadataMap

UsageUpdated(Usage)

Updated token usage statistics.

Warning

Non-fatal warning (e.g. a tool failure that was recovered from).

Fields

message: String

RunFailed

The agent run has failed with an unrecoverable error.

Fields

message: String

TurnFinished(TurnResult)

A turn has finished (successfully, via cancellation, etc.).

Trait Implementations

impl Clone for AgentEvent

fn clone(&self) -> AgentEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AgentEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AgentEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AgentEvent

fn eq(&self, other: &AgentEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AgentEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AgentEvent