Struct RunFinishedEvent 

pub struct RunFinishedEvent {
    pub base: BaseEvent,
    pub thread_id: ThreadId,
    pub run_id: RunId,
    pub outcome: Option<RunFinishedOutcome>,
    pub result: Option<JsonValue>,
    pub interrupt: Option<InterruptInfo>,
}

Event indicating that a run has finished.

This event is sent when an agent run completes, either successfully or with an interrupt requiring human input.

Interrupt Flow

When outcome == Interrupt, the agent indicates that on the next run, a value needs to be provided via RunAgentInput.resume to continue.

Example

use ag_ui_core::{RunFinishedEvent, RunFinishedOutcome, InterruptInfo, ThreadId, RunId};

// Success case
let success = RunFinishedEvent::new(ThreadId::random(), RunId::random())
    .with_result(serde_json::json!({"status": "done"}));

// Interrupt case
let interrupt = RunFinishedEvent::new(ThreadId::random(), RunId::random())
    .with_interrupt(
        InterruptInfo::new()
            .with_reason("human_approval")
            .with_payload(serde_json::json!({"action": "send_email"}))
    );

Fields

base: BaseEvent

Common event fields (timestamp, rawEvent).

thread_id: ThreadId

The thread ID this run belongs to.

run_id: RunId

The run ID that finished.

outcome: Option<RunFinishedOutcome>

Outcome of the run. Optional for backward compatibility. When omitted, outcome is inferred: if interrupt is present, it’s Interrupt; otherwise Success.

result: Option<JsonValue>

Optional result value from the run. Present when outcome is Success (or omitted with no interrupt).

interrupt: Option<InterruptInfo>

Optional interrupt information. Present when outcome is Interrupt (or omitted with interrupt present).

Implementations

impl RunFinishedEvent

pub fn new(thread_id: impl Into<ThreadId>, run_id: impl Into<RunId>) -> Self

Creates a new RunFinishedEvent with Success outcome.

pub fn with_outcome(self, outcome: RunFinishedOutcome) -> Self

Sets the outcome explicitly.

pub fn with_result(self, result: JsonValue) -> Self

Sets the result for this event (implies Success outcome).

pub fn with_interrupt(self, interrupt: InterruptInfo) -> Self

Sets the interrupt info (implies Interrupt outcome).

pub fn with_timestamp(self, timestamp: f64) -> Self

Sets the timestamp for this event.

pub fn effective_outcome(&self) -> RunFinishedOutcome

Returns the effective outcome of this event.

If outcome is explicitly set, returns that. Otherwise:

• If interrupt is present, returns Interrupt
• Otherwise, returns Success

Trait Implementations

impl Clone for RunFinishedEvent

fn clone(&self) -> RunFinishedEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunFinishedEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunFinishedEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RunFinishedEvent

fn eq(&self, other: &RunFinishedEvent) -> 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 RunFinishedEvent

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 RunFinishedEvent