Enum AssistantBlock 

#[non_exhaustive]
pub enum AssistantBlock {
    Text {
        text: String,
        cache_control: Option<CacheControl>,
    },
    ToolCall {
        id: String,
        name: String,
        args: Value,
        cache_control: Option<CacheControl>,
    },
    Reasoning {
        text: String,
        signature: Option<String>,
    },
    RedactedReasoning {
        data: String,
    },
}

One block inside a Message::Assistant turn.

Block ordering is preserved on replay because some providers (Anthropic extended thinking) require the original sequence on every subsequent request.

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

Visible model-authored text.

Fields

text: String

Text content.

cache_control: Option<CacheControl>

See UserBlock::Text::cache_control.

ToolCall

A tool invocation request from the model. Pair with a UserBlock::ToolResult in the next user turn that matches id to call_id.

Fields

id: String

Provider-assigned id; mirrors back as call_id on the matching UserBlock::ToolResult.

name: String

Tool name as registered in the crate::ChatRequest::tools list.

args: Value

JSON arguments. Adapters serialize this through to the provider verbatim; the engine does not validate the schema.

cache_control: Option<CacheControl>

See UserBlock::Text::cache_control.

Reasoning

Visible reasoning emitted by the model. signature is provider-issued material that must be replayed verbatim on subsequent turns when tools are involved (Anthropic extended thinking). Providers without a signature concept (e.g. OpenAI reasoning) leave it None.

Reasoning blocks intentionally have no cache_control slot: Anthropic does not accept the field on thinking / redacted_thinking blocks. Place breakpoints on adjacent text or tool blocks instead.

Fields

text: String

Visible reasoning text.

signature: Option<String>

Provider signature (Anthropic extended thinking). Replay verbatim on subsequent turns when tools are involved; None for providers without a signature concept.

RedactedReasoning

Opaque reasoning block whose content the provider chose to hide. data is verbatim provider material — store it untouched and replay it back when the next request continues a tool-use chain.

Fields

data: String

Verbatim provider payload; treat as opaque bytes.

Implementations

impl AssistantBlock

pub fn text(text: impl Into<String>) -> Self

Build an AssistantBlock::Text with no cache breakpoint.

pub fn tool_call( id: impl Into<String>, name: impl Into<String>, args: Value, ) -> Self

Build an AssistantBlock::ToolCall with no cache breakpoint.

pub fn with_cache_control(self, cache_control: Option<CacheControl>) -> Self

Builder-style helper: set or replace the cache breakpoint on this block. No-op for reasoning variants (they do not carry cache breakpoints on the wire).

pub fn cache_control(&self) -> Option<&CacheControl>

Read the current cache breakpoint. Always None for the reasoning variants (they do not carry breakpoints on the wire).

Trait Implementations

impl Clone for AssistantBlock

fn clone(&self) -> AssistantBlock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AssistantBlock

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AssistantBlock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AssistantBlock

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

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 AssistantBlock