Struct WorldObserver 

pub struct WorldObserver {
    pub adapter: Option<AdapterContext>,
    pub published: Option<Arc<PublishedContext>>,
    pub id: EffectId,
    pub recording: Option<Recording>,
    pub observed: Arc<ObservedState>,
    pub witness: Option<(Witnessing, Subject)>,
}

Records original answers, stream items, and layer patches or discards for a task-served dispatch. Once observation closes, worker callbacks cannot mutate the recording.

Fields

adapter: Option<AdapterContext>

Explicit host operation, already bound to this dispatch’s subject.

published: Option<Arc<PublishedContext>>

Tool output shared with the caller, read without consuming it.

id: EffectId

The dispatch.

recording: Option<Recording>

The world’s recorder, if any.

observed: Arc<ObservedState>

The shared slots.

witness: Option<(Witnessing, Subject)>

The world’s witness with the current dispatch subject.

Trait Implementations

impl Observe for WorldObserver

fn adapter_context(&self) -> Option<AdapterContext>

Provider witness associated with this dispatch, independently of recording.

fn outcome(&mut self, outcome: &Result<Outcome, ErrorReport>)

The completed handler response, or the fold of a streaming handler’s events. A resolved response retains content that has no stream block, such as images emitted as unknown events.

fn keep_events(&self) -> bool

Whether streamed items are wanted verbatim (Self::event).

fn stream_item( &mut self, item: &Result<Relayed, ErrorReport>, outcome: Option<&Result<Outcome, ErrorReport>>, )

Observe one stream item together with its first folded outcome, if any. Drivers that snapshot recording concurrently with cancellation can override this operation to make the item and its answer one observation boundary.

fn origin(&mut self, origin: &Origin)

Who a streamed reply is from, before its first item. Required, so a recording observer cannot drop it: a replayed stream cut short needs it to know its origin.

fn event(&mut self, item: &Item<StreamEvent>)

One item pulled from the original handler stream. This is recording evidence, not acknowledgement that a consumer received the item.

fn stream_error(&mut self, error: &ErrorReport)

An error item in a kept stream.

fn discard(&mut self, layer: &str)

The dispatch was decided before any handler served it, by the layer named: the record it opened is forgotten.

fn patch(&mut self, kind: &EffectKind)

The layer named serves kind in place of the effect that began (same family): the record’s request is what the innermost handler served.