Struct ReasoningHandle 

pub struct ReasoningHandle<'a, S> { /* private fields */ }

One open reasoning block.

Created by RunContext::reasoning. The REASONING_* family nests a message inside a block, so the handle brackets four events rather than two:

REASONING_START          ← on creation
REASONING_MESSAGE_START  ← on creation
REASONING_MESSAGE_CONTENT × n
REASONING_MESSAGE_END    ← on end() or Drop
REASONING_END            ← on end() or Drop

Use it for model reasoning you want the client to render. Reasoning a provider returns only as an opaque blob goes through encrypted_value instead.

Implementations

impl<'a, S> ReasoningHandle<'a, S>

pub fn id(&self) -> &MessageId

The id every event of this block carries.

pub fn delta(&mut self, text: impl Into<String>) -> Result<()>

Appends reasoning text — REASONING_MESSAGE_CONTENT.

pub fn encrypted_value(&mut self, value: impl Into<String>) -> Result<()>

Attaches the provider’s opaque reasoning signature — REASONING_ENCRYPTED_VALUE.

Under zero-data-retention the provider returns no readable reasoning, only a blob that must be replayed on the next request for the model to stay coherent.

pub fn emit(&mut self, event: Event) -> Result<()>

Emits an unrelated event without closing the block. See MessageHandle::emit.

pub fn end(self) -> Result<()>

Emits REASONING_MESSAGE_END then REASONING_END, and consumes the handle.

impl<S: AgentState> ReasoningHandle<'_, S>

The run’s state, reachable while the block is open. See ToolCallHandle, where this matters most.

pub fn state(&self) -> &S

The typed state, as of the last publish.

pub fn state_mut(&mut self) -> &mut S

The typed state, mutably. Nothing is emitted until you call publish_state.

pub fn publish_state(&mut self) -> Result<()>

Publishes whatever state_mut left behind, as a STATE_SNAPSHOT or a STATE_DELTA inside this block’s brackets.

A no-op when nothing changed since the last publish.

Trait Implementations

impl<'a, S: Debug> Debug for ReasoningHandle<'a, S>

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

Formats the value using the given formatter.

impl<S> Drop for ReasoningHandle<'_, S>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.