Enum DeltaPart 

#[non_exhaustive]
pub enum DeltaPart {
    Text {
        text: String,
    },
    ToolCall {
        partial_json: Value,
    },
    InputJson {
        partial_json: String,
    },
    Thinking {
        text: String,
    },
}

A delta (incremental update) for content within a streaming response.

Each variant represents a different kind of incremental data that the API sends. Consumers should append the payload to the appropriate in-progress part.

#[non_exhaustive] so the framework can add content kinds (e.g. Image/Audio) in a later minor release without breaking downstream matches. Downstream code that matches on DeltaPart MUST include a wildcard arm.

Variants

• Text — Append to the text buffer for text parts.
• ToolCall — Append to the JSON buffer for tool-call parts.
• InputJson — Append to the JSON buffer (raw string form).
• Thinking — Append to the reasoning buffer for separate display; not part of the assistant’s visible text.

Example

use loopctl::stream::DeltaPart;

let delta_content = DeltaPart::Text { text: "hello".to_string() };
let mut buffer = String::new();
let mut json_buf = String::new();
match &delta_content {
    DeltaPart::Text { text } => buffer.push_str(text),
    DeltaPart::InputJson { partial_json } => json_buf.push_str(partial_json),
    DeltaPart::ToolCall { partial_json } => {
        if let Some(s) = partial_json.as_str() {
            json_buf.push_str(s);
        }
    }
    DeltaPart::Thinking { .. } => {
        // Reasoning is delivered via on_thinking_delta; not accumulated here.
    }
    _ => {}
}

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

Text delta — append to the existing text content.

Emitted for text parts. Each delta contains a small fragment of the final text output.

Serialized as "type":"text_delta" with a "text" field.

Fields

text: String

The text fragment to append.

Each fragment is a small piece of the complete text. Concatenate all fragments in order to reconstruct the full text content for this part.

ToolCall

Tool-call input delta — append to the JSON input.

Emitted for tool-call parts. Each delta contains a fragment of the tool’s JSON input, which should be concatenated and parsed once PartStop arrives.

Serialized as "type":"tool_call_delta" with a "partial_json" field.

Fields

partial_json: Value

A JSON value fragment to append to the tool input.

Typically a string that forms part of the final JSON when concatenated with all prior deltas. Use serde_json::from_str on the concatenated result after the part completes.

InputJson

Partial JSON input delta — append to the tool input buffer.

Similar to ToolCall but carries a raw string fragment rather than a JSON value. Concatenate all fragments and parse as JSON when the part ends.

Serialized as "type":"input_json_delta" with a "partial_json" field.

Fields

partial_json: String

A raw JSON string fragment to append.

Concatenate all partial_json strings from consecutive InputJson deltas for the same content part, then parse the combined string as JSON once PartStop is received.

Thinking

Thinking/reasoning delta — append to a reasoning buffer for separate display. NOT part of the assistant’s visible text.

Emitted by reasoning models (Claude extended-thinking, DeepSeek-R1, OpenAI o-series). Stream-only: the StreamAccumulator does NOT carry reasoning into the built Message; consume it via on_thinking_delta. An empty text signals redacted reasoning (e.g. Anthropic redacted_thinking); render a placeholder rather than the empty string.

Serialized as "type":"thinking_delta" with a "text" field.

Fields

text: String

The reasoning text fragment to append.

Concatenate in arrival order per turn to reconstruct the full reasoning trace. Empty string when the reasoning is redacted (the provider withheld the content); consumers should render a placeholder, not the empty string.

Trait Implementations

impl Clone for DeltaPart

fn clone(&self) -> DeltaPart

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeltaPart

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DeltaPart

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DeltaPart

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.