Struct Event 

pub struct Event {
    pub id: EventId,
    pub event_type: String,
    pub ts: DateTime<Utc>,
    pub session_id: SessionId,
    pub context: EventContext,
    pub data: EventData,
    pub metadata: Option<Value>,
    pub tags: Option<Vec<String>>,
    pub sequence: Option<i32>,
}

Standard event following the Everruns event protocol.

All events have a consistent structure:

• id: Unique event identifier (format: event_{32-hex})
• type: Event type in dot notation (e.g., “input.message”, “reason.started”)
• ts: ISO 8601 timestamp with millisecond precision
• session_id: Session this event belongs to (format: session_{32-hex})
• context: Correlation context for tracing
• data: Event-specific payload (typed via EventData enum)
• metadata: Optional arbitrary metadata
• tags: Optional list of tags for filtering

Fields

id: EventId

Unique event identifier (format: event_{32-hex})

event_type: String

Event type in dot notation

ts: DateTime<Utc>

Event timestamp

session_id: SessionId

Session this event belongs to (format: session_{32-hex})

context: EventContext

Correlation context

data: EventData

Event-specific payload. The schema depends on the event type. See EventData documentation for the mapping of type to data schema.

metadata: Option<Value>

Arbitrary metadata for the event

tags: Option<Vec<String>>

Tags for filtering and categorization

sequence: Option<i32>

Sequence number within session (for ordering)

Implementations

impl Event

pub fn new( session_id: SessionId, context: EventContext, data: impl Into<EventData>, ) -> Self

Create a new event with the given session_id, context, and typed data

The event type is automatically inferred from the data type.

pub fn with_id( id: EventId, session_id: SessionId, context: EventContext, data: impl Into<EventData>, ) -> Self

Create an event with a specific ID (for testing or replay)

pub fn with_sequence(self, sequence: i32) -> Self

Set the sequence number

pub fn with_metadata(self, metadata: Value) -> Self

Set metadata

pub fn with_tags(self, tags: Vec<String>) -> Self

Set tags

pub fn session_uuid(&self) -> Uuid

Get the session_id as raw UUID

pub fn is_message_event(&self) -> bool

Check if this is an input or output message event

pub fn is_ephemeral(&self) -> bool

Whether this event is ephemeral. Delta events may be delivered to listeners without ever being inserted into the events table, so any downstream storage that holds an FK to events.id must treat the reference as best-effort and skip it for ephemeral sources.

Mirror of EventRequest::is_ephemeral; both delegate to is_ephemeral_event_type so the match set stays in lockstep.

pub fn is_input_event(&self) -> bool

Check if this is an input event

pub fn is_output_event(&self) -> bool

Check if this is an output event

pub fn is_atom_event(&self) -> bool

Check if this is an atom lifecycle event

pub fn is_turn_event(&self) -> bool

Check if this is a turn lifecycle event

pub fn is_session_event(&self) -> bool

Check if this is a session lifecycle event

pub fn is_unsupported(&self) -> bool

Check if this event has unsupported data. Unsupported events should be filtered before API responses.

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.