Struct ContextScope 

pub struct ContextScope { /* private fields */ }

One conversation’s working context: append to it, read it back bounded, or render the prompt-ready block. Build it with Laser::context.

Implementations

impl ContextScope

pub async fn append( &self, topic: AgentTopic<'_>, payload: impl Into<Vec<u8>>, ) -> Result<(), LaserError>

Append payload to topic within this conversation. The provenance is pinned to the conversation, so a later fetch reads it back in order.

pub async fn fetch( &self, topics: Vec<AgentTopic<'static>>, n: usize, token_budget: Option<usize>, ) -> Result<Vec<ContextMessage>, LaserError>

Read this conversation’s history from topics, bounded to the last n messages. token_budget trims the selected messages to an estimated token count after n, so the read is bounded by turns and by prompt size at once. The bound is required: an unbounded read of a long-lived conversation is a replay nobody asked for, so the full walk has its own deliberate spelling (fetch_with).

pub async fn fetch_with( &self, topics: Vec<AgentTopic<'static>>, policy: Box<dyn ContextPolicy>, ) -> Result<Vec<ContextMessage>, LaserError>

Read this conversation’s history from topics under an explicit ContextPolicy, the deep form behind fetch.

pub async fn block( &self, topics: Vec<AgentTopic<'static>>, n: usize, token_budget: Option<usize>, ) -> Result<String, LaserError>

The last n messages rendered as one newline-joined text block, the prompt-ready form (each payload as UTF-8, lossy). token_budget trims the selected messages to an estimated token count after n, so the block is bounded by turns and by prompt size at once.

pub async fn state<S, F>( &self, topics: Vec<AgentTopic<'static>>, bound: ReplayBound, init: S, fold: F, ) -> Result<S, LaserError>

where F: FnMut(S, &ContextMessage) -> S,

Rebuild in-memory state by folding this conversation’s log under the explicit bound (the ReplayBound vocabulary: offsets, last-n, or the deliberately spelled full walk).

pub async fn state_with<Store, S, F>( &self, store: &Store, topics: Vec<AgentTopic<'static>>, init: S, fold: F, ) -> Result<S, LaserError>

where Store: SnapshotStore + Sync, S: DeserializeOwned, F: FnMut(S, &ContextMessage) -> S,

Like state but seeded through a SnapshotStore: the newest snapshot’s state (JSON-decoded into S) plus a replay of only the tail past it.

pub fn memory(&self, namespace: impl Into<String>) -> ScopedMemory

This conversation’s memory in namespace, pre-scoped so recall and remember never repeat the conversation id: the same session the messages belong to, seen as memory. Durable facts and the knowledge graph stay deliberately cross-conversation (a fact learned in one session is worth recalling in the next), so they are reached through Laser::memory/Laser::graph and not narrowed here.

pub fn memory_with( &self, namespace: impl Into<String>, backend: MemoryBackend, ) -> ScopedMemory

memory on an explicit MemoryBackend.

pub fn graph(&self, name: impl Into<String>) -> GraphHandle<'_>

The knowledge graph name, reached from this scope for the common flow where a task streams messages, keeps session memory, and resolves the dependencies between them. The graph is returned unnarrowed on purpose: a dependency or knowledge graph is shared across conversations (a service-to-component edge holds no matter which task asked), so scoping it to one conversation would hide the very relationships the caller wants. Identical to Laser::graph, offered here so one scope reaches every primitive. Feature graph.

pub async fn checkpoint( &self, topics: &[AgentTopic<'static>], ) -> Result<Checkpoint, LaserError>

The current tail of topics as a Checkpoint: fold up to it with ReplayBound::At or resume after it with ReplayBound::FromCheckpoint. Offsets are per topic partition, not per conversation.

pub fn conversation(&self) -> ConversationId

This context’s conversation id.

pub fn laser(&self) -> &Laser

The Laser this scope reads and writes through.

Trait Implementations

impl Clone for ContextScope

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.