Struct MessageHandle 

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

One open text message.

Created by RunContext::assistant_message. TEXT_MESSAGE_START has already gone out by the time you hold one; Drop emits TEXT_MESSAGE_END if end was not called.

let mut message = ctx.assistant_message()?;
for word in ["Hello", ", ", "world"] {
    message.delta(word)?;
}
message.end()?;
assert_eq!(events.drain().len(), 5);

Implementations

impl<'a, S> MessageHandle<'a, S>

pub fn id(&self) -> &MessageId

The id every event of this message carries.

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

Appends text — TEXT_MESSAGE_CONTENT.

No .await: see the module docs for why the emit path is synchronous.

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

Emits an unrelated event without closing the message.

For the unordered families — STATE_*, ACTIVITY_*, CUSTOM, RAW — which may legally interleave with a message. Opening a second message through here is a protocol violation the verifier will reject.

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

Emits TEXT_MESSAGE_END and consumes the handle.

Only worth calling over letting the handle drop when you want to see the error: Drop cannot report one.

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

The run’s state, reachable while the message is open — an agent that narrates what it is doing changes both in the same breath. 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 message’s brackets.

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

Trait Implementations

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

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

Formats the value using the given formatter.

impl<S> Drop for MessageHandle<'_, 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.