Struct Step 

pub struct Step {

    pub id: String,
    pub step_index: u32,
    pub kind: StepType,
    pub source: StepSource,
    pub target: StepTarget,
    pub status: StepStatus,
    pub content: String,
    pub content_delta: String,
    pub thinking: String,
    pub thinking_delta: String,
    pub tool_calls: Vec<ToolCall>,
    pub tool_results: Vec<ToolResult>,
    pub error: String,
    pub is_complete_response: Option<bool>,
    pub structured_output: Option<Value>,
    pub usage_metadata: Option<UsageMetadata>,
}

One event in the agent’s response stream.

Fields

id: String

Backend-assigned step identifier.

step_index: u32

Zero-based index within the current turn.

kind: StepType

What kind of event this step represents.

source: StepSource

Who produced this step.

target: StepTarget

Intended audience.

status: StepStatus

Lifecycle state.

content: String

Accumulated text content.

content_delta: String

Incremental text delta since the last step.

thinking: String

Accumulated thinking (reasoning) text.

thinking_delta: String

Incremental thinking delta.

tool_calls: Vec<ToolCall>

Tool calls the model is requesting.

tool_results: Vec<ToolResult>

Dispatched tool RESULTS (a Step::tool_result observability step). Stream consumers (ChatResponse::chunks → StreamChunk::ToolResult) read these to flip a tool block from “running” to ok/err and render inline result cards. Empty on every other step kind; omitted from the wire when empty (old-shape compatible).

error: String

Error message, if any.

is_complete_response: Option<bool>

Explicit flag that this step ends the turn.

structured_output: Option<Value>

Structured JSON output from the finish tool.

usage_metadata: Option<UsageMetadata>

Token usage for this step.

Implementations

impl Step

pub fn text_delta(trajectory_id: &str, step_index: u32, delta: &str) -> Self

A streamed text delta (model → user, Active, non-terminal).

pub fn thought_delta(trajectory_id: &str, step_index: u32, delta: &str) -> Self

A streamed thinking (reasoning) delta (model → user, Active, non-terminal).

pub fn tool_call(step_index: u32, call: ToolCall, status: StepStatus) -> Self

A tool-call step (model → environment, non-terminal) surfacing call on the stream. status is StepStatus::Active when emitted ahead of dispatch (the live backends) or StepStatus::Done when the call was already dispatched inline and the step is observability-only (the mock backend — the Agent’s step dispatcher skips Done steps).

pub fn tool_result(step_index: u32, result: ToolResult) -> Self

A resolved-tool-result step (model → environment, Done, non-terminal, NO tool_calls) carrying the full dispatched ToolResult in tool_results — ChatResponse::chunks surfaces it as StreamChunk::ToolResult so a UI can flip the tool block from “running” to ok/err and render the inline result card. Done + Model→Environment so it is observability-only: the step dispatcher skips Done steps, and it never trips the System+Error turn-failure translation in subscribe_steps (a tool error must not abort the turn — it also rides in error for step-level consumers).

pub fn turn_complete( trajectory_id: impl Into<String>, step_index: u32, status: StepStatus, content: impl Into<String>, error: impl Into<String>, finished: bool, structured_output: Option<Value>, usage_metadata: Option<UsageMetadata>, ) -> Self

The turn-terminating step (model → user, terminal). kind is StepType::Finish when the model called the finish tool (finished == true) OR carried structured output (a bare finish with no output arg still flags Finish), else StepType::TextResponse. The Finish kind is the canonical “the model said it’s done” signal — consumers (the in-tab loop) read it to stop auto-continuing and to suppress an empty-response bubble on a pure-tool/finish turn.

pub fn turn_error(step_index: u32, message: impl Into<String>) -> Self

A System-sourced turn-failure step (terminal, status Error) carrying message. Backends whose subscribe_steps translates turn failures convert exactly this shape into a stream Err.

pub fn is_terminal_response(&self) -> bool

A turn-terminating step: model-sourced, user-facing, status DONE, with content. Mirrors is_complete_response semantics in the Python SDK.

Trait Implementations

impl Clone for Step

fn clone(&self) -> Step

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Step

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Step

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Step

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

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 Step