Struct ObservingEventStore 

pub struct ObservingEventStore<S, F> { /* private fields */ }

An EventStore decorator that invokes a callback on every appended envelope, then delegates all storage to an inner store.

This is the reusable, blessed way to “stream to stdout” (or to any live observer) with the SDK: the agent loop writes every AgentEventEnvelope through the configured event store, so wrapping a store lets you watch events as they happen — printing TextDeltas, forwarding to a UI channel — without hand-rolling the full five-method EventStore surface or wiring an in-process channel. The callback runs before the inner store records the envelope.

Example

use agent_sdk_tools::stores::{InMemoryEventStore, ObservingEventStore};
use agent_sdk_foundation::events::AgentEvent;

let _store = ObservingEventStore::new(InMemoryEventStore::new(), |envelope| {
    if let AgentEvent::TextDelta { delta, .. } = &envelope.event {
        print!("{delta}");
    }
});

Implementations

impl<S, F> ObservingEventStore<S, F>

where S: EventStore, F: Fn(&AgentEventEnvelope) + Send + Sync,

pub const fn new(inner: S, observer: F) -> Self

Wrap inner, calling observer on every appended envelope before it is persisted.

pub const fn inner(&self) -> &S

Borrow the wrapped inner store (e.g. to read back persisted history).

Trait Implementations

impl<S, F> EventStore for ObservingEventStore<S, F>

where S: EventStore, F: Fn(&AgentEventEnvelope) + Send + Sync,

fn append<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, turn: usize, envelope: AgentEventEnvelope, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append an event envelope for the given thread and turn.

fn finish_turn<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, turn: usize, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark the given turn as finished and flush any buffered writes.

fn get_turn<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, turn: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<StoredTurnEvents>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve the stored data for a single turn.

fn get_turns<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StoredTurnEvents>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve all stored turns for the given thread in ascending turn order.

fn get_events<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, ) -> Pin<Box<dyn Future<Output = Result<Vec<AgentEventEnvelope>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve all event envelopes for the given thread across every stored turn.

fn event_count<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the stored events for thread_id without materializing them.

fn get_events_since<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, offset: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<AgentEventEnvelope>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve event envelopes for thread_id from offset onward, in overall append order, skipping the earlier ones.

fn clear<'life0, 'life1, 'async_trait>( &'life0 self, thread_id: &'life1 ThreadId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Clear all events for the given thread.