Struct ReasoningState 

pub struct ReasoningState { /* private fields */ }

Reasoning state that a provider requires to be handed back unmodified.

Current models do not treat their own reasoning as throwaway. Anthropic requires thinking blocks to be replayed “complete and unmodified” across a tool-use turn, OpenAI’s stateless flow needs the encrypted reasoning item echoed back into the next request, and Gemini attaches a thought signature to each function call. Dropping any of them degrades multi-turn tool use quietly: the model loses the reasoning that produced the very call it is being handed a result for.

The payload is provider-encoded and deliberately opaque. Core never parses it, and neither should anything else — the encoding belongs to the provider, the meaning belongs to the provider, and the only correct operation is to give it back. Encoding the whole block rather than its parts is what lets one type carry Anthropic’s thinking and redacted_thinking blocks, whose shapes differ, without core knowing either.

Provider tagging

State is tied to the model that produced it. Anthropic documents that thinking blocks must be stripped when switching models, and cross-provider replay is at best ignored and at worst rejected. Every value therefore records its origin, and providers read it back with payload_for rather than trusting whatever the conversation happens to carry.

Implementations

impl ReasoningState

pub fn new(provider: impl Into<String>, payload: impl Into<String>) -> Self

Creates reasoning state tagged with the provider that produced it.

provider should be the stable short name the provider crate uses for itself ("claude", "openai", "gemini"), and payload its own encoding of the block, which it alone will decode.

pub fn provider(&self) -> &str

The provider that produced this state.

pub fn payload(&self) -> &str

The opaque payload, without checking its origin.

Prefer payload_for when about to put the value on the wire; this accessor is for logging and inspection.

pub fn payload_for(&self, provider: &str) -> Option<&str>

The payload, but only if this state came from provider.

Returns None for foreign state so callers drop it instead of replaying it into an API that cannot verify it.

Trait Implementations

impl Clone for ReasoningState

fn clone(&self) -> ReasoningState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReasoningState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReasoningState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReasoningState

impl PartialEq for ReasoningState

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ReasoningState

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 ReasoningState