Struct RunStream 

pub struct RunStream {
    pub execution_id: String,
    /* private fields */
}

A live handle to a running workflow execution.

Obtain one from crate::sub::executions::ScopedExecutionsClient::run_stream. The stream yields WorkflowEvent items until the workflow reaches a terminal event (End or Error), at which point it ends. Call output to consume the stream to completion and get the final workflow output (or an error).

Dropping the RunStream cancels the underlying SSE subscription.

Fields

execution_id: String

Implementations

impl RunStream

pub fn on_output<F>(&mut self, cb: F)

where F: Fn(&Value) + Send + 'static,

Register a callback for streaming agent output chunks.

Fires once per WorkflowEvent::AgentChunk. The callback receives the chunk text wrapped in a serde_json::Value::String so the API stays uniform across SDKs (TS/Python use Value-like shapes too).

pub fn on_task_end<F>(&mut self, cb: F)

where F: Fn(&TaskEndPayload) + Send + 'static,

Register a callback for task completion events (WorkflowEvent::TaskEnd).

pub fn on_suspend<F>(&mut self, cb: F)

where F: Fn(&SuspendPayload) + Send + 'static,

Register a callback for workflow suspensions (WorkflowEvent::Checkpoint).

WorkflowEvent::ToolApproval and Breakpoint are not routed here — register on_any if you need to observe every suspend-category event.

pub fn on_error<F>(&mut self, cb: F)

where F: Fn(&EngineErrorPayload) + Send + 'static,

Register a callback for terminal error events (WorkflowEvent::Error).

The stream still terminates on the next poll after an error; the callback fires once, before termination is observed.

pub fn on_any<F>(&mut self, cb: F)

where F: Fn(&WorkflowEvent) + Send + 'static,

Register a catch-all callback that sees every yielded event.

Fires after category-specific callbacks for the same event, in registration order. Use for logging or generic event sinks; prefer the category callbacks for typed access.

pub async fn next(&mut self) -> Option<Result<WorkflowEvent>>

Pull the next typed event. Returns None once the stream terminates.

Error events are yielded as Some(Ok(WorkflowEvent::Error{..})) so the caller can observe them, and they also cause the stream to end immediately after.

pub async fn output(self) -> Result<Value>

Drain the stream and resolve to the final workflow output.

Resolves to Ok(output) when a WorkflowEvent::End was observed (either already, or while draining). If the workflow ended with an Error event, resolves to an AkribesError::Script / ::Transient / ::Fatal depending on the ErrorKind — same classification as crate::sub::executions::ExecutionsClient::await_execution. If the stream closes without a terminal event, resolves to AkribesError::Other.

pub async fn summary(self) -> Result<RunSummary>

Drain the stream to terminal and return a RunSummary aggregated from observed events (#1033 — mirrors TS RunStream.summary()).

Resolves the same way as output: rejects when the workflow ended with an Error event, or when the stream closed without a terminal event. On success, the returned RunSummary rolls up workflow duration, per-task durations, task pass/fail counts, and per-model token totals collected from TaskEnd usage blocks.

Trait Implementations

impl Debug for RunStream

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

Formats the value using the given formatter.

impl Stream for RunStream

type Item = Result<WorkflowEvent, AkribesError>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.