Enum ReasoningItem 

pub enum ReasoningItem {
    Text {
        id: Option<String>,
        format: ReasoningFormat,
        index: Option<u32>,
        text: String,
        signature: Option<String>,
    },
    Summary {
        id: Option<String>,
        format: ReasoningFormat,
        index: Option<u32>,
        summary: String,
    },
    Encrypted {
        id: Option<String>,
        format: ReasoningFormat,
        index: Option<u32>,
        data: String,
    },
}

One provider-emitted reasoning element.

Three variants cover every shape known across the major providers: readable reasoning text (with optional Anthropic-style signature), summary blurbs (OpenAI/Anthropic summaries), and fully-encrypted blobs (Gemini thoughtSignature, OpenAI encrypted_content, Anthropic redacted_thinking). Round-trip identity is the contract: every byte the provider emitted must come back unchanged on the next assistant message.

Variants

Text

reasoning.text — visible reasoning content. The signature field is opaque and mandatory round-trip on providers that emit it (Anthropic).

Fields

id: Option<String>

format: ReasoningFormat

index: Option<u32>

text: String

signature: Option<String>

Summary

reasoning.summary — provider-emitted summary of internal reasoning; carries no signature, but still must replay verbatim to preserve token-cache continuity on some providers.

Fields

id: Option<String>

format: ReasoningFormat

index: Option<u32>

summary: String

Encrypted

reasoning.encrypted — opaque base64 blob. Gemini’s thoughtSignature is delivered in this shape via OpenRouter; OpenAI’s encrypted_content and Anthropic’s redacted_thinking.data likewise. The bridge stores data byte-for-byte and the codec attaches it back to the right wire location for the originating provider.

Fields

id: Option<String>

format: ReasoningFormat

index: Option<u32>

data: String

Implementations

impl ReasoningItem

pub fn format(&self) -> ReasoningFormat

Originating-provider tag.

pub fn index(&self) -> Option<u32>

index if the provider supplied one. OpenRouter uses this to preserve order across heterogeneous variants when the provider emits text and encrypted blobs interleaved.

pub fn carries_signed_payload(&self) -> bool

True iff this item carries a signature/encrypted payload the provider will reject if missing on replay. Used by ReasoningCodec to validate “did we receive what we need for the next turn?” without having to inspect the inner fields.

pub fn from_openrouter_value(value: &Value) -> Option<Self>

Round-trip from a Value shaped exactly as OpenRouter’s reasoning_details[] item. Returns None if the input is not an object with a recognized type discriminator.

pub fn to_openrouter_value(&self) -> Value

Serialize back to the OpenRouter wire shape. Round-trip fidelity: from_openrouter_value(v).unwrap().to_openrouter_value() == v for any well-formed input.

Trait Implementations

impl Clone for ReasoningItem

fn clone(&self) -> ReasoningItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReasoningItem

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReasoningItem

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ReasoningItem

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

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 ReasoningItem