Enum TextDelta 

#[non_exhaustive]
pub enum TextDelta {
    Text(String),
    Reasoning(String),
    ToolCallStarted {
        index: usize,
        id: String,
        name: String,
    },
    ToolCallArguments {
        index: usize,
        chunk: String,
    },
    ToolCallFinished {
        index: usize,
        call: ToolCall,
    },
    Usage {
        input_tokens: u64,
        output_tokens: u64,
        cached_input_tokens: Option<u64>,
    },
    Finish {
        reason: FinishReason,
        model: String,
    },
}

One incremental piece of a streamed completion (issue #859) — the item type of TextModel::stream.

Semantics a caller (and an overriding adapter) can rely on:

• Self::Usage carries running totals; a stream may send several and the last one wins.
• Self::ToolCallStarted / Self::ToolCallArguments / Self::ToolCallFinished carry one tool call through its life by index. The argument chunks are incremental and only human-readable in sequence; Self::ToolCallFinished carries the fully reassembled ToolCall — exactly what complete would have returned in Completion::tool_calls — so a caller who only cares about finished calls can ignore the first two.
• Exactly one Self::Finish ends a successful stream; it is the last item. An Err item also ends the stream (a failed completion has no Finish).
• Dropping the stream cancels the completion: an overriding adapter MUST abort its upstream exchange on drop, the contract HttpClient::send_streaming carries.

Serialize/Deserialize (adjacently tagged, so every variant round trips) is what lets a route write deltas straight out as SSE or NDJSON: {"type":"text","data":"…"}, {"type":"finish","data":{…}}.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Text(String)

A run of answer text, in stream order.

Reasoning(String)

A run of reasoning the model surfaced alongside its answer. Not part of Completion::text; a caller shows it or drops it.

ToolCallStarted

The model asked to call a tool: the call’s index in the completion’s tool-call order, its provider-assigned id, and the tool name. The arguments have not arrived yet.

Fields

index: usize

Position this call occupies in the completion’s tool calls.

id: String

The provider’s id for the call.

name: String

The tool being called.

ToolCallArguments

One run of the arguments of the call at index. Chunks concatenate to the call’s full arguments JSON; see Self::ToolCallFinished for the reassembled form.

Fields

index: usize

Which call’s arguments are growing.

chunk: String

The next piece of the arguments JSON.

ToolCallFinished

The call at index is complete, arguments and all — the same ToolCall complete would have returned.

Fields

index: usize

Which call finished.

call: ToolCall

The reassembled call.

Usage

Token usage so far. Running totals: a later Self::Usage supersedes it entirely.

Fields

input_tokens: u64

Total prompt tokens processed so far, cached included.

output_tokens: u64

Completion tokens produced so far.

cached_input_tokens: Option<u64>

The cached subset of input_tokens, where the provider reports one — None keeps “no report” and “reported zero” distinct, exactly as Completion::cached_input_tokens does.

Finish

The stream is over, successfully. Always the last item of a successful stream, and the only one.

Fields

reason: FinishReason

Why the completion stopped.

model: String

The provider identifier complete would have reported — the log line’s model, from the stream.

Trait Implementations

impl Clone for TextDelta

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TextDelta

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TextDelta

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TextDelta

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for TextDelta

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 TextDelta