> For the complete documentation index, see [llms.txt](https://docs.talus.network/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.talus.network/reference/sdk/events.md).

# Event Ingestion

**Audience:** Nexus SDK integrators building event consumers (Rust).

**Area:** Event ingestion and Nexus event queries.

**Generated from:** Nexus SDK event API at tag `v2.1.1` commit `08bfe76e726922ce512d623fbc1d2e1bd786bcd4`; the generated inventory is preserved and replay/live additions are source-verified.

Complete generic Sui event ingestion and Nexus event query, classification, replay, checkpoint, cancellation, and error surfaces.

> **Before consuming typed events:** Verify event type origins against the selected network package graph and SDK bindings. The generated enum retains historical variants for compatibility; do not map historical ToolPayment variants onto Invocation accounting.

The Invocation surface emits `InvocationLockedEvent` and `InvocationSettledEvent`. Consumers should correlate execution, runtime vertex, Tool, cashier, policy, source IDs, amount, and Invocation ID from those events, then re-read the authoritative Execution/Task state before retrying. A stream notification is an invalidation, not a replacement for the exact object read.

### Live and replay page sources

Each `EventPage` carries `EventPageSource::Live` or `EventPageSource::Replay`. A live subscription reads the configured subscription RPC; replay uses the configured archival endpoint and bounded concurrency to scan checkpoint ranges. `first_matching_checkpoint` returns the first matching replay checkpoint when one exists, and replay resumes a bounded range without treating a missing page as an empty result.

Callers that construct or destructure an `EventPage` must preserve the `source` field. A replay page is historical evidence and a live page is a subscription observation; neither replaces an authoritative transaction-output or object-version read.

### Generic Sui event ingestion

#### `EventIngestor` methods

**`new`**

> Creates an ingestor for `query`.

```rust
pub fn new(rpc_url: impl Into<String>, query: Q) -> Self
```

**`with_channel_capacity`**

> Sets the number of pages that may wait for the consumer.

```rust
pub fn with_channel_capacity(self, capacity: usize) -> Self
```

**`with_cancellation_token`**

> Sets the token used to stop ingestion.

```rust
pub fn with_cancellation_token(self, cancellation_token: CancellationToken) -> Self
```

**`with_replay_gap_recovery`**

> Resumes at the live cursor when Sui no longer retains replay history.
>
> The ingestor reports \[`EventIngestionError::ReplayGap`] before it resumes. Leave this disabled when the consumer requires every event from the requested checkpoint.

```rust
pub fn with_replay_gap_recovery(self) -> Self
```

**`start`**

> Starts ingestion from an inclusive checkpoint.
>
> Passing \[`None`] starts at the current stream position.
>
> \# Errors
>
> Returns \[`EventIngestionError::Configuration`] when the endpoint or requested fields are invalid.

```rust
pub fn start(self, from_checkpoint: Option<u64>) -> Result<EventPageReceiver<Q::Output>, EventIngestionError>
```

**`RawEventQuery` methods**

**`new`**

> Creates a query from a server filter and requested fields.

```rust
pub fn new(filter: sui::grpc::EventFilter, read_mask: sui::grpc::FieldMask) -> Self
```

#### Nexus event queries and classification

#### Invocation event contract

Subscribe to `InvocationLockedEvent` for admission and exact lock identity, and `InvocationSettledEvent` for charge/refund outcome. If a hosted projection omits them, use matching SDK bindings and on-chain effects; do not map historical ToolPayment events onto them.

#### Historical compatibility event variants

**`ProtocolActivation`**

> Canonical wake signal emitted after a protocol version is activated.

```rust
pub struct ProtocolActivation {
    /// Transaction digest and event index that uniquely identify this notification.
    pub id: (sui::types::Digest, u64),
    /// Exact primitives package that emitted this notification.
    pub emitting_package: sui::types::Address,
    /// Decoded protocol activation payload.
    pub event: crate::move_bindings::primitives::protocol::ProtocolVersionActivatedV1Event,
}
```

**`ProtocolActivationQuery`**

> Event query for the \[`ProtocolVersionActivatedV1Event`] datatype.

```rust
pub struct ProtocolActivationQuery {
    /* private fields */
}
```

**`ProtocolActivationIngestor`**

> \[`EventIngestor`] configured for protocol activation notifications.

```rust
pub type ProtocolActivationIngestor = crate::sui::events::EventIngestor<ProtocolActivationQuery>;
```

**`NexusEventKind` methods**

**`name`**

> Returns the name of the event kind as a string.

```rust
pub fn name(&self) -> String
```

**`NexusEventCandidate` methods**

**`source_package`**

> Returns the package recorded by Sui as the Move command source.

```rust
pub fn source_package(&self) -> sui::types::Address
```

**`into_supported`**

> Converts \[`Self::Supported`] into its decoded event.
>
> \# Errors
>
> Returns \[`UnsupportedNexusEvent`] for \[`Self::Unsupported`].

```rust
pub fn into_supported(self) -> Result<NexusEvent, UnsupportedNexusEvent>
```

### Source-derived public API inventory

#### `re-export pub, use, query`

```rust
pub use query::*;
```

#### `UnsupportedNexusEvent`

```rust
pub struct UnsupportedNexusEvent {
    /// Transaction digest and event sequence that identify the event.
    pub id: (sui::types::Digest, u64),
    /// Package recorded by Sui as the source of the Move command.
    pub source_package: sui::types::Address,
    /// Full inner event type. Its address identifies the definition package.
    pub event_type: Box<sui::types::StructTag>,
}
```

#### `NexusEventDecodeError`

```rust
pub enum NexusEventDecodeError {
    /// Required event identity is missing or invalid.
    #[error("Nexus event identity is invalid: {0}")]
    Identity(String),
    /// A required Sui event field is missing.
    #[error("Required Nexus event field is missing: {0}")]
    MissingField(&'static str),
    /// The Sui event type is invalid.
    #[error("Nexus event type is invalid: {0}")]
    EventType(#[from] sui::types::TypeParseError),
    /// The immutable package graph selected by the emitter is invalid.
    #[error("Could not resolve Nexus event emitter package '{package}': {source}")]
    EmitterPackage {
        /// Package recorded as the event emitter.
        package: sui::types::Address,
        /// Resolver failure for that package.
        #[source]
        source: crate::nexus::error::NexusError,
    },
    /// The inner datatype belongs to Nexus but is absent from the SDK contract.
    #[error(transparent)]
    UnsupportedEvent(#[from] UnsupportedNexusEvent),
    /// The Nexus event contents are invalid.
    #[error("Nexus event contents are invalid: {0}")]
    Contents(#[source] anyhow::Error),
}
```

#### `DistributedEventMetadata`

```rust
pub struct DistributedEventMetadata {
    /// The execution window duration.
    #[serde(
        rename = "deadline_ms",
        deserialize_with = "deserialize_u64_to_duration",
        serialize_with = "serialize_duration_to_u64"
    )]
    pub deadline: chrono::Duration,
    /// The timestamp by which the event was requested.
    #[serde(
        rename = "requested_at_ms",
        deserialize_with = "deserialize_u64_to_datetime",
        serialize_with = "serialize_datetime_to_u64"
    )]
    pub requested_at: chrono::DateTime<chrono::Utc>,
    /// The priority list of leader addresses.
    pub leaders: Vec<sui::types::Address>,
    /// The task ID.
    pub task_id: sui::types::Address,
}
```

#### `NexusEvent`

```rust
pub struct NexusEvent {
    /// The event transaction digest and event sequence.
    pub id: (sui::types::Digest, u64),
    /// Package containing the top level Move function that emitted the event.
    ///
    /// This identifies runtime code and is intentionally distinct from the
    /// event datatype origin encoded in its type tag.
    pub emitting_package: sui::types::Address,
    /// If the `T in NexusEvent<T>` is also a generic, this field holds the
    /// generic type. Note that this can be nested indefinitely.
    pub generics: Vec<sui::types::TypeTag>,
    /// The event data.
    pub data: NexusEventKind,
    /// If the event is a distributed event, this field holds the distribution
    /// metadata.
    pub distribution: Option<DistributedEventMetadata>,
}
```

#### `NexusEvent::was_emitted_by`

```rust
pub fn was_emitted_by(&self, context: &crate::types::NexusContext) -> bool {
```

#### `NexusEventCandidate`

```rust
pub enum NexusEventCandidate {
    /// Event represented by [`NexusEventKind`].
    Supported(Box<NexusEvent>),
    /// Event absent from [`NexusEventKind`].
    Unsupported(UnsupportedNexusEvent),
}
```

#### `NexusEventCandidate::source_package`

```rust
pub fn source_package(&self) -> sui::types::Address {
```

#### `NexusEventCandidate::into_supported`

```rust
pub fn into_supported(self) -> Result<NexusEvent, UnsupportedNexusEvent> {
```

#### `NexusEventKind::name`

```rust
pub fn name(&self) -> String {
```

#### `NexusEventDecoder`

```rust
pub struct NexusEventDecoder {
    resolver: StateResolver,
    objects: Arc<NexusObjects>,
}
```

#### `NexusEventDecoder::new`

```rust
pub fn new(resolver: StateResolver, objects: Arc<NexusObjects>) -> Self {
```

#### `NexusEventDecoder::decode_sui_event`

```rust
pub async fn decode_sui_event(
        &self,
        index: u64,
        digest: sui::types::Digest,
        event: &sui::types::Event,
    ) -> Result<Option<NexusEvent>, NexusEventDecodeError> {
```

#### `NexusEventQuery`

```rust
pub struct NexusEventQuery {
    filter_context: Arc<NexusContext>,
    decoder: NexusEventDecoder,
    supported_event_filter: Option<fn(&str) -> bool>,
}
```

#### `NexusEventQuery::new`

```rust
pub fn new(filter_context: Arc<NexusContext>, decoder: NexusEventDecoder) -> Self {
```

#### `NexusEventQuery::with_supported_event_filter`

```rust
pub fn with_supported_event_filter(mut self, filter: fn(&str) -> bool) -> Self {
```

#### `NexusEventQuery::decode_sui_event`

```rust
pub async fn decode_sui_event(
        &self,
        index: u64,
        digest: sui::types::Digest,
        event: &sui::types::Event,
    ) -> Result<Option<NexusEvent>, NexusEventDecodeError> {
```

#### `NexusEventIngestor`

```rust
pub type NexusEventIngestor = EventIngestor<NexusEventQuery>;
```

#### `EventIngestionError`

```rust
pub enum EventIngestionError {
    /// The endpoint or requested fields are invalid.
    #[error("Event ingestion configuration is invalid: {0}")]
    Configuration(String),
    /// A Sui RPC request or response failed.
    #[error("Sui event RPC failed while {operation}: {status}")]
    Rpc {
        /// Operation that failed.
        operation: &'static str,
        /// Status returned by Sui.
        #[source]
        status: tonic::Status,
    },
    /// Sui no longer retains the requested replay checkpoint.
    #[error(
        "Sui cannot replay events from checkpoint {start_checkpoint} while {operation}: {status}"
    )]
    ReplayGap {
        /// Inclusive checkpoint requested from Sui.
        start_checkpoint: u64,
        /// Replay operation that failed.
        operation: &'static str,
        /// Status returned by Sui.
        #[source]
        status: tonic::Status,
    },
    /// A Sui response violated the event stream contract.
    #[error("Sui event stream protocol failed: {0}")]
    Protocol(String),
    /// An event accepted by the query could not be decoded.
    #[error(
        "Event at checkpoint {checkpoint}, transaction {transaction_digest}, \
         index {event_index} could not be decoded: {source}"
    )]
    Decode {
        /// Checkpoint containing the event.
        checkpoint: u64,
        /// Transaction that emitted the event.
        transaction_digest: String,
        /// Position of the event in the transaction.
        event_index: u32,
        /// Query conversion failure.
        #[source]
        source: anyhow::Error,
    },
}
```

#### `EventPageSource`

```rust
pub enum EventPageSource {
    /// Historical events requested from the Ledger service.
    Replay,
    /// Events received from the live subscription.
    Live,
}
```

#### `EventPage`

```rust
pub struct EventPage<T> {
    /// Events emitted for this page.
    pub events: Vec<T>,
    /// Checkpoint observed for this page.
    pub checkpoint: u64,
    /// Whether this progress came from replay or the live subscription.
    pub source: EventPageSource,
}
```

#### `EventPageReceiver`

```rust
pub type EventPageReceiver<T> = mpsc::Receiver<Result<EventPage<T>, EventIngestionError>>;
```

#### `EventIngestor`

```rust
pub struct EventIngestor<Q: EventQuery> {
    pub(super) subscription_rpc_url: String,
    pub(super) replay_rpc_url: Option<String>,
    pub(super) query: Q,
    pub(super) filter: sui::grpc::EventFilter,
    pub(super) read_mask: sui::grpc::FieldMask,
    pub(super) channel_capacity: usize,
    pub(super) replay_concurrency: NonZeroUsize,
    pub(super) cancellation_token: CancellationToken,
    pub(super) recover_replay_gap: bool,
}
```

#### `EventIngestor::new`

```rust
pub fn new(subscription_rpc_url: impl Into<String>, query: Q) -> Self {
```

#### `EventIngestor::with_subscription_rpc_url`

```rust
pub fn with_subscription_rpc_url(mut self, rpc_url: impl Into<String>) -> Self {
```

#### `EventIngestor::with_replay_rpc_url`

```rust
pub fn with_replay_rpc_url(mut self, rpc_url: impl Into<String>) -> Self {
```

#### `EventIngestor::with_channel_capacity`

```rust
pub fn with_channel_capacity(mut self, capacity: usize) -> Self {
```

#### `EventIngestor::with_replay_concurrency`

```rust
pub fn with_replay_concurrency(mut self, concurrency: NonZeroUsize) -> Self {
```

#### `EventIngestor::with_cancellation_token`

```rust
pub fn with_cancellation_token(mut self, cancellation_token: CancellationToken) -> Self {
```

#### `EventIngestor::with_replay_gap_recovery`

```rust
pub fn with_replay_gap_recovery(mut self) -> Self {
```

#### `EventIngestor::first_matching_checkpoint`

```rust
pub async fn first_matching_checkpoint(&self) -> Result<Option<u64>, EventIngestionError> {
```

#### `EventIngestor::start`

```rust
pub fn start(
        self,
        from_checkpoint: Option<u64>,
    ) -> Result<EventPageReceiver<Q::Output>, EventIngestionError> {
```

#### `re-export EventIngestionError, EventIngestor, EventPage, EventPageReceiver, EventPageSource, query, EventQuery, RawEventQuery`

```rust
pub use {
    ingestor::{EventIngestionError, EventIngestor, EventPage, EventPageReceiver, EventPageSource},
    query::{EventQuery, RawEventQuery},
};
```

#### `EventQuery`

```rust
pub trait EventQuery: Send + Sync + 'static {
    /// Event type emitted by the query.
    type Output: Send + 'static;
    /// Error returned while converting a Sui event.
    type Error: Error + Send + Sync + 'static;

    /// Returns the server filter for this query.
    fn filter(&self) -> sui::grpc::EventFilter;

    /// Returns the fields requested by this query.
    fn read_mask(&self) -> sui::grpc::FieldMask;

    /// Converts one Sui event into an optional query result.
    ///
    /// Returning [`None`] intentionally excludes an event accepted by the
    /// server filter.
    fn decode(
        &self,
        event: sui::grpc::Event,
    ) -> impl std::future::Future<Output = Result<Option<Self::Output>, Self::Error>> + Send;
}
```

#### `RawEventQuery`

```rust
pub struct RawEventQuery {
    filter: sui::grpc::EventFilter,
    read_mask: sui::grpc::FieldMask,
}
```

#### `RawEventQuery::new`

```rust
pub fn new(filter: sui::grpc::EventFilter, read_mask: sui::grpc::FieldMask) -> Self {
```

#### `NexusEventKind`

```rust
pub enum NexusEventKind {
    AgentCreated(crate::move_bindings::interface::agent::AgentCreatedEvent),
    DAGCreated(crate::move_bindings::interface::dag::DAGCreatedEvent),
    DAGDefaultValueAdded(crate::move_bindings::interface::dag::DAGDefaultValueAddedEvent),
    DAGEdgeAdded(crate::move_bindings::interface::dag::DAGEdgeAddedEvent),
    DAGEntryVertexInputPortAdded(crate::move_bindings::interface::dag::DAGEntryVertexInputPortAddedEvent),
    DAGFinalized(crate::move_bindings::interface::dag::DAGFinalizedEvent),
    DAGOutputAdded(crate::move_bindings::interface::dag::DAGOutputAddedEvent),
    DAGVertexAdded(crate::move_bindings::interface::dag::DAGVertexAddedEvent),
    AgentSkillPaymentCreated(crate::move_bindings::interface::payment::AgentSkillPaymentCreatedEvent),
    ExecutionAccomplished(crate::move_bindings::interface::payment::ExecutionAccomplishedEvent),
    ExecutionPaymentFeesRecorded(crate::move_bindings::interface::payment::ExecutionPaymentFeesRecordedEvent),
    ExecutionPaymentToolCostSnapshotted(crate::move_bindings::interface::payment::ExecutionPaymentToolCostSnapshottedEvent),
    ExecutionRefunded(crate::move_bindings::interface::payment::ExecutionRefundedEvent),
    GasPaymentConsumed(crate::move_bindings::interface::payment::GasPaymentConsumedEvent),
    TaskExecutionPaymentCreated(crate::move_bindings::interface::payment::TaskExecutionPaymentCreatedEvent),
    TaskExecutionPaymentFinalized(crate::move_bindings::interface::payment::TaskExecutionPaymentFinalizedEvent),
    TaskPaymentReserveCanceled(crate::move_bindings::interface::payment::TaskPaymentReserveCanceledEvent),
    TaskPaymentReserveRefilled(crate::move_bindings::interface::payment::TaskPaymentReserveRefilledEvent),
    DefaultDagExecutorUpdated(crate::move_bindings::registry::agent_registry::DefaultDagExecutorUpdatedEvent),
    SkillContractRevisioned(crate::move_bindings::registry::agent_registry::SkillContractRevisionedEvent),
    SkillRegistered(crate::move_bindings::registry::agent_registry::SkillRegisteredEvent),
    LeaderCapIssued(crate::move_bindings::registry::leader::LeaderCapIssuedEvent),
    LeaderClaimed(crate::move_bindings::registry::leader::LeaderClaimedEvent),
    LeaderRegistryCreated(crate::move_bindings::registry::leader::LeaderRegistryCreatedEvent),
    LeaderStatusChanged(crate::move_bindings::registry::leader::LeaderStatusChangedEvent),
    LeaderSuspensionSkipped(crate::move_bindings::registry::leader::LeaderSuspensionSkippedEvent),
    LeaderUpserted(crate::move_bindings::registry::leader::LeaderUpsertedEvent),
    MaxTransactionBudgetUpdated(crate::move_bindings::registry::leader::MaxTransactionBudgetUpdatedEvent),
    MinStakeUsUpdated(crate::move_bindings::registry::leader::MinStakeUsUpdatedEvent),
    StakeDeposited(crate::move_bindings::registry::leader::StakeDepositedEvent),
    StakeSlashed(crate::move_bindings::registry::leader::StakeSlashedEvent),
    UnbondingDurationUpdated(crate::move_bindings::registry::leader::UnbondingDurationUpdatedEvent),
    UnstakeClaimed(crate::move_bindings::registry::leader::UnstakeClaimedEvent),
    UnstakeRequested(crate::move_bindings::registry::leader::UnstakeRequestedEvent),
    FoundingLeaderCapCreated(crate::move_bindings::registry::leader_cap::FoundingLeaderCapCreatedEvent),
    ActiveKeyUpdated(crate::move_bindings::registry::network_auth::ActiveKeyUpdatedEvent),
    KeyBindingCreated(crate::move_bindings::registry::network_auth::KeyBindingCreatedEvent),
    KeyRegistered(crate::move_bindings::registry::network_auth::KeyRegisteredEvent),
    KeyRevoked(crate::move_bindings::registry::network_auth::KeyRevokedEvent),
    NetworkAuthCreated(crate::move_bindings::registry::network_auth::NetworkAuthCreatedEvent),
    PriorityFeeDepositCreated(crate::move_bindings::registry::priority_fee_vault::PriorityFeeDepositCreatedEvent),
    PriorityFeeSharesCollected(crate::move_bindings::registry::priority_fee_vault::PriorityFeeSharesCollectedEvent),
    PriorityFeeSwap(crate::move_bindings::registry::priority_fee_vault::PriorityFeeSwapEvent),
    PriorityFeeVaultConfigured(crate::move_bindings::registry::priority_fee_vault::PriorityFeeVaultConfiguredEvent),
    PriorityFeeWithdrawn(crate::move_bindings::registry::priority_fee_vault::PriorityFeeWithdrawnEvent),
    OccurrenceAdvertised(crate::move_bindings::scheduler::scheduler::OccurrenceAdvertisedEvent),
    OccurrenceDispatched(crate::move_bindings::scheduler::scheduler::OccurrenceDispatchedEvent),
    OccurrenceMissed(crate::move_bindings::scheduler::scheduler::OccurrenceMissedEvent),
    OccurrenceScheduled(crate::move_bindings::scheduler::scheduler::OccurrenceScheduledEvent),
    OccurrenceSettled(crate::move_bindings::scheduler::scheduler::OccurrenceSettledEvent),
    OccurrenceWithdrawn(crate::move_bindings::scheduler::scheduler::OccurrenceWithdrawnEvent),
    TaskCanceled(crate::move_bindings::scheduler::scheduler::TaskCanceledEvent),
    TaskClosed(crate::move_bindings::scheduler::scheduler::TaskClosedEvent),
    TaskCreated(crate::move_bindings::scheduler::scheduler::TaskCreatedEvent),
    TaskPaused(crate::move_bindings::scheduler::scheduler::TaskPausedEvent),
    TaskRejected(crate::move_bindings::scheduler::scheduler::TaskRejectedEvent),
    TaskResumed(crate::move_bindings::scheduler::scheduler::TaskResumedEvent),
    CreditOfferChanged(crate::move_bindings::tool::finite_credits::CreditOfferChangedEvent),
    CreditsCreated(crate::move_bindings::tool::finite_credits::CreditsCreatedEvent),
    TimePassCreated(crate::move_bindings::tool::time_pass::TimePassCreatedEvent),
    TimePassOfferChanged(crate::move_bindings::tool::time_pass::TimePassOfferChangedEvent),
    CashierDepositCreated(crate::move_bindings::tool::tool_cashier::CashierDepositCreatedEvent),
    PolicyAdded(crate::move_bindings::tool::tool_cashier::PolicyAddedEvent),
    PolicyRemoved(crate::move_bindings::tool::tool_cashier::PolicyRemovedEvent),
    ExternalVerifierRegistered(crate::move_bindings::tool::tool_registry::ExternalVerifierRegisteredEvent),
    ToolRegistered(crate::move_bindings::tool::tool_registry::ToolRegisteredEvent),
    ToolRegistryCreated(crate::move_bindings::tool::tool_registry::ToolRegistryCreatedEvent),
    ToolSlashed(crate::move_bindings::tool::tool_registry::ToolSlashedEvent),
    ToolUnregistered(crate::move_bindings::tool::tool_registry::ToolUnregisteredEvent),
    ToolUpdated(crate::move_bindings::tool::tool_registry::ToolUpdatedEvent),
    ToolVerificationStatusChanged(crate::move_bindings::tool::tool_registry::ToolVerificationStatusChangedEvent),
    AgentSkillExecutionRequested(crate::move_bindings::workflow::execution_events::AgentSkillExecutionRequestedEvent),
    AgentVertexAuthorizationRequired(crate::move_bindings::workflow::execution_events::AgentVertexAuthorizationRequiredEvent),
    CommittedToolResult(crate::move_bindings::workflow::execution_events::CommittedToolResultEvent),
    EndStateReached(crate::move_bindings::workflow::execution_events::EndStateReachedEvent),
    ExecutionFinished(crate::move_bindings::workflow::execution_events::ExecutionFinishedEvent),
    ExecutionPaymentInsufficientSettlement(crate::move_bindings::workflow::execution_events::ExecutionPaymentInsufficientSettlementEvent),
    ExecutionPaymentRefilled(crate::move_bindings::workflow::execution_events::ExecutionPaymentRefilledEvent),
    InvocationAuthorizationRequired(crate::move_bindings::workflow::execution_events::InvocationAuthorizationRequiredEvent),
    RequestWalkExecution(crate::move_bindings::workflow::execution_events::RequestWalkExecutionEvent),
    SubmissionFailureEvidenceRecorded(crate::move_bindings::workflow::execution_events::SubmissionFailureEvidenceRecordedEvent),
    TerminalErrEvalRecorded(crate::move_bindings::workflow::execution_events::TerminalErrEvalRecordedEvent),
    ToolVerificationResolved(crate::move_bindings::workflow::execution_events::ToolVerificationResolvedEvent),
    WalkAborted(crate::move_bindings::workflow::execution_events::WalkAbortedEvent),
    WalkAdvanced(crate::move_bindings::workflow::execution_events::WalkAdvancedEvent),
    WalkCancelled(crate::move_bindings::workflow::execution_events::WalkCancelledEvent),
    WalkFailed(crate::move_bindings::workflow::execution_events::WalkFailedEvent),
    WalkPendingAbort(crate::move_bindings::workflow::execution_events::WalkPendingAbortEvent),
    InvocationLocked(crate::move_bindings::workflow::invocation_adapter::InvocationLockedEvent),
    InvocationSettled(crate::move_bindings::workflow::invocation_adapter::InvocationSettledEvent),
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.talus.network/reference/sdk/events.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `build a script that syncs our docs to a CMS` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.