Enum Event 

pub enum Event<StateT: AgentState = JsonValue> {
    TextMessageStart(TextMessageStartEvent),
    TextMessageContent(TextMessageContentEvent),
    TextMessageEnd(TextMessageEndEvent),
    TextMessageChunk(TextMessageChunkEvent),
    ThinkingTextMessageStart(ThinkingTextMessageStartEvent),
    ThinkingTextMessageContent(ThinkingTextMessageContentEvent),
    ThinkingTextMessageEnd(ThinkingTextMessageEndEvent),
    ToolCallStart(ToolCallStartEvent),
    ToolCallArgs(ToolCallArgsEvent),
    ToolCallEnd(ToolCallEndEvent),
    ToolCallChunk(ToolCallChunkEvent),
    ToolCallResult(ToolCallResultEvent),
    ThinkingStart(ThinkingStartEvent),
    ThinkingEnd(ThinkingEndEvent),
    StateSnapshot(StateSnapshotEvent<StateT>),
    StateDelta(StateDeltaEvent),
    MessagesSnapshot(MessagesSnapshotEvent),
    ActivitySnapshot(ActivitySnapshotEvent),
    ActivityDelta(ActivityDeltaEvent),
    Raw(RawEvent),
    Custom(CustomEvent),
    RunStarted(RunStartedEvent),
    RunFinished(RunFinishedEvent),
    RunError(RunErrorEvent),
    StepStarted(StepStartedEvent),
    StepFinished(StepFinishedEvent),
}

Union of all possible events in the Agent User Interaction Protocol.

This enum represents any event that can be sent or received in the AG-UI protocol. Events are serialized with a type discriminant in SCREAMING_SNAKE_CASE format.

Type Parameter

• StateT: The type of state for StateSnapshot events, defaults to JsonValue.

Serialization

Events are serialized as JSON objects with a type field indicating the variant:

{"type": "TEXT_MESSAGE_START", "messageId": "...", "role": "assistant"}

Variants

TextMessageStart(TextMessageStartEvent)

Start of a text message from the assistant.

TextMessageContent(TextMessageContentEvent)

Content chunk of a text message (streaming delta).

TextMessageEnd(TextMessageEndEvent)

End of a text message.

TextMessageChunk(TextMessageChunkEvent)

Complete text message chunk (non-streaming alternative).

ThinkingTextMessageStart(ThinkingTextMessageStartEvent)

Start of a thinking text message (extended thinking).

ThinkingTextMessageContent(ThinkingTextMessageContentEvent)

Content chunk of a thinking text message.

ThinkingTextMessageEnd(ThinkingTextMessageEndEvent)

End of a thinking text message.

ToolCallStart(ToolCallStartEvent)

Start of a tool call.

ToolCallArgs(ToolCallArgsEvent)

Arguments chunk for a tool call (streaming).

ToolCallEnd(ToolCallEndEvent)

End of a tool call.

ToolCallChunk(ToolCallChunkEvent)

Complete tool call chunk (non-streaming alternative).

ToolCallResult(ToolCallResultEvent)

Result of a tool call execution.

ThinkingStart(ThinkingStartEvent)

Start of a thinking step (chain-of-thought boundary).

ThinkingEnd(ThinkingEndEvent)

End of a thinking step.

StateSnapshot(StateSnapshotEvent<StateT>)

Complete state snapshot.

StateDelta(StateDeltaEvent)

Incremental state update (JSON Patch).

MessagesSnapshot(MessagesSnapshotEvent)

Complete messages snapshot.

ActivitySnapshot(ActivitySnapshotEvent)

Complete activity snapshot.

ActivityDelta(ActivityDeltaEvent)

Incremental activity update (JSON Patch).

Raw(RawEvent)

Raw event from the underlying provider.

Custom(CustomEvent)

Custom application-specific event.

RunStarted(RunStartedEvent)

Agent run has started.

RunFinished(RunFinishedEvent)

Agent run has finished successfully.

RunError(RunErrorEvent)

Agent run encountered an error.

StepStarted(StepStartedEvent)

A step within a run has started.

StepFinished(StepFinishedEvent)

A step within a run has finished.

Implementations

impl<StateT: AgentState> Event<StateT>

pub fn event_type(&self) -> EventType

Returns the event type for this event.

pub fn timestamp(&self) -> Option<f64>

Returns the timestamp of this event if available.

Trait Implementations

impl<StateT: Clone + AgentState> Clone for Event<StateT>

fn clone(&self) -> Event<StateT>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<StateT: Debug + AgentState> Debug for Event<StateT>

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

Formats the value using the given formatter.

impl<'de, StateT: AgentState> Deserialize<'de> for Event<StateT>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<StateT: PartialEq + AgentState> PartialEq for Event<StateT>

fn eq(&self, other: &Event<StateT>) -> 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<StateT> Serialize for Event<StateT>

where StateT: Serialize + AgentState,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<StateT: AgentState> StructuralPartialEq for Event<StateT>