Enum AssistantBlock 

pub enum AssistantBlock {
    Text(TextContent),
    Thinking(TextContent),
    Reasoning(TextContent),
    ReasoningDetails(ReasoningDetailsContent),
    ToolCall(ToolCall),
}

Blocks an assistant message can carry.

Channel separation contract

Thinking and Reasoning are two independent channels and the loop must never mix them:

• Thinking is prompt-elicited tag-text. The model wraps reasoning inside <thought>...</thought> (or one of the synonym tags handled by crate::ThinkingTagStreamFilter) inside its visible text stream. The bridge parses those tags out of the visible-text channel and stores the captured content here. On the next provider request it is rewoven into the content field as a <thought>...</thought> tag — never as the wire reasoning field.

• Reasoning and ReasoningDetails are provider-native reasoning. They arrive on a dedicated sideband (delta.reasoning / delta.reasoning_details on the OpenRouter wire) and represent the provider’s own chain-of-thought tokens. On the next provider request they are replayed verbatim through the typed reasoning / reasoning_details fields — never wrapped in a <thought>...</thought> tag in the content field.

The two processes are not interchangeable: tag-elicited scratch is the model writing into its visible output by convention, and the loop strips it before the user sees anything. Provider-native reasoning is the upstream API delivering structured thinking alongside the message. Conflating them risks (a) shipping the model’s hidden scratch as if it were native reasoning (some providers reject unknown content there or refuse to bill it as cached input) and (b) leaking native reasoning into visible text by way of <thought> rewrap (would round-trip native tokens through the visible channel and double-count them).

The invariants are pinned by tests in openrouter_request_tests.rs::channel_separation_invariants and openrouter_stream::tests::stream_chunk_routing_invariants.

Variants

Text(TextContent)

Thinking(TextContent)

Prompt-elicited hidden scratchpad. Captured from <thought>...</thought> tags the model writes inside its visible text stream; rewoven into the wire content field as <thought>...</thought> on the next request. Never flows into the wire reasoning field — see the type-level docs for the channel-separation contract.

Reasoning(TextContent)

Provider-native reasoning (xAI Grok, OpenAI o-series, Anthropic native thinking). Arrives on the dedicated delta.reasoning sideband and replayed via the wire reasoning field. Never wrapped in a <thought>...</thought> tag inside the content field — see the type-level docs.

ReasoningDetails(ReasoningDetailsContent)

Native provider reasoning detail blocks (xAI’s reasoning.encrypted envelopes, etc.). Replayed unmodified on tool-continuation requests for reasoning models that rely on signed/encrypted thinking continuity. Same channel contract as Reasoning.

ToolCall(ToolCall)

Tool call request. Loop dispatches via the registry.

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