Struct ActivityEvent 

pub struct ActivityEvent {
    pub workflow_id: WorkflowId,
    pub run_id: RunId,
    pub activity_id: ActivityId,
    pub attempt: u32,
    pub agent_id: Uuid,
    pub agent_role: String,
    pub emitted_at: DateTime<Utc>,
    pub worker_seq: u64,
    pub store_seq: Option<u64>,
    pub ephemeral: bool,
    pub kind: ActivityEventKind,
}

A live transcript event for one (workflow, run, activity, attempt) produced by an agent harness.

Streamed to the ops console in real time and persisted to a durable observability keyspace (except Self::ephemeral events). It is never mixed into workflow replay history — the activity’s single terminal result is the replay-authoritative output, not this transcript.

The run axis is REQUIRED, not optional

A continue-as-new chain reuses one WorkflowId across generations while activity ordinals restart at 0 and attempts restart at 1 in each new run. Without Self::run_id two generations of one chain produce byte-identical stream identities, and their transcripts fuse: generation two’s first event lands on generation one’s stream head. run_id is therefore a plain required field — an Option would let the ambiguity back in through the None arm, and there is no honest value to default it to. The same law already holds one layer over, where the activity idempotency key is run-scoped over the identical triple.

Ordering

Self::emitted_at and Self::worker_seq are best-effort producer-side ordering hints. Self::store_seq is assigned by the server at durable-commit time and is None until the event has been persisted — an unpersisted (e.g. ephemeral, or in-flight) event carries no store sequence.

Fields

workflow_id: WorkflowId

The workflow this activity belongs to.

run_id: RunId

The concrete run of that workflow this event was produced in — the second stream axis.

Required. Two generations of one continue-as-new chain share a workflow_id and restart their ordinals and attempts, so this is the only field that keeps their transcripts apart.

activity_id: ActivityId

The activity within the workflow.

attempt: u32

The attempt number of the activity this event was produced during.

agent_id: Uuid

Sub-identity of the agent that produced this event — REQUIRED for multi-agent attribution (a single activity attempt may run several agents).

agent_role: String

The role/label of the producing agent (e.g. an orchestrator vs a sub-agent).

emitted_at: DateTime<Utc>

Producer-clock instant the event was emitted (best-effort ordering hint).

worker_seq: u64

Worker-local best-effort monotonic sequence.

Exported to TypeScript as number; see the module docs for the accepted 2^53 ceiling.

store_seq: Option<u64>

Server-stamped monotonic sequence assigned at durable-commit time; None until the event is persisted (ephemeral events are never persisted and always carry None).

Exported to TypeScript as number; see the module docs for the accepted 2^53 ceiling.

ephemeral: bool

When true, this event is WS-forward-only and is never persisted (token deltas).

kind: ActivityEventKind

The classified payload of this event.

Trait Implementations

impl Clone for ActivityEvent

fn clone(&self) -> ActivityEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActivityEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActivityEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ActivityEvent

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ActivityEvent

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 ActivityEvent

impl TS for ActivityEvent

type WithoutGenerics = ActivityEvent

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or ().
The only requirement for these dummy types is that EXPORT_TO must be None.

type OptionInnerType = ActivityEvent

If the implementing type is std::option::Option<T>, then this associated type is set to T. All other implementations of TS should set this type to Self instead.

fn ident(cfg: &Config) -> String

Identifier of this type, excluding generic parameters.

fn docs() -> Option<String>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

fn name(cfg: &Config) -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete(cfg: &Config) -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl(cfg: &Config) -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline(cfg: &Config) -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened(cfg: &Config) -> String

Flatten a type declaration. This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<PathBuf>

Returns the output path to where T should be exported, relative to the output directory. The returned path does not include any base directory.

fn visit_dependencies(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all dependency of this type.

fn dependencies(cfg: &Config) -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use TS::export_all.

fn export_all(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies. To export only this type, without its dependencies, use TS::export.

fn export_to_string(cfg: &Config) -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String. This function does not format the output, even if the format feature is enabled.