pub struct AsyncRun { /* private fields */ }Methods from Deref<Target = Run>§
Sourcepub async fn amodel_call<F, Fut>(
&mut self,
payload: Value,
options: CallOptions,
handler: F,
) -> Result<Node>
pub async fn amodel_call<F, Fut>( &mut self, payload: Value, options: CallOptions, handler: F, ) -> Result<Node>
Await a model callback only after replay, identity and budget checks. Dropping the future after dispatch settles a conservative unknown-outcome recording, so uncertainty cannot silently become a reusable result.
Sourcepub async fn atool_call<F, Fut>(
&mut self,
name: &str,
args: Value,
options: CallOptions,
handler: F,
) -> Result<Node>
pub async fn atool_call<F, Fut>( &mut self, name: &str, args: Value, options: CallOptions, handler: F, ) -> Result<Node>
Await an unfenced tool. Registered runtimes reject this escape hatch.
Sourcepub fn model_stream<F, I, O>(
&mut self,
payload: Value,
options: CallOptions,
keep_chunks: bool,
handler: F,
on_delta: O,
) -> Result<Node>
pub fn model_stream<F, I, O>( &mut self, payload: Value, options: CallOptions, keep_chunks: bool, handler: F, on_delta: O, ) -> Result<Node>
Consume a native iterator of chunks. Replay reemits retained snapshots.
pub fn tool_stream<F, I, O>( &mut self, name: &str, args: Value, options: CallOptions, keep_chunks: bool, handler: F, on_delta: O, ) -> Result<Node>
Sourcepub async fn amodel_stream<F, Fut, O, OFut>(
&mut self,
payload: Value,
options: CallOptions,
keep_chunks: bool,
next_chunk: F,
on_delta: O,
) -> Result<Node>
pub async fn amodel_stream<F, Fut, O, OFut>( &mut self, payload: Value, options: CallOptions, keep_chunks: bool, next_chunk: F, on_delta: O, ) -> Result<Node>
Pull chunks from an async producer. None ends the stream. The closure
can own a network stream without requiring a particular executor crate.
pub async fn atool_stream<F, Fut, O, OFut>( &mut self, name: &str, args: Value, options: CallOptions, keep_chunks: bool, next_chunk: F, on_delta: O, ) -> Result<Node>
pub fn root_id(&self) -> &str
pub fn cursor_id(&self) -> &str
pub fn cursor(&self) -> Result<Node>
pub fn spent(&self) -> Result<Charges>
pub fn avoided(&self) -> Charges
pub fn report(&self) -> Result<RunReport>
pub fn prune(&mut self) -> Result<()>
pub fn rollback_steps(&mut self, steps: usize) -> Result<Node>
pub fn model_call<F>( &mut self, payload: Value, options: CallOptions, handler: F, ) -> Result<Node>
Sourcepub fn revalidate_model_call<F>(
&mut self,
payload: Value,
contract: &ReplayContract,
options: RevalidationOptions,
handler: F,
) -> Result<RevalidationReport>
pub fn revalidate_model_call<F>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, handler: F, ) -> Result<RevalidationReport>
Compare a stored model result with a separately recorded live observation. The continuation cursor returns to the original recording after comparison.
pub fn revalidate_model_call_with_comparator<F>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, comparator: &dyn RevalidationComparator, handler: F, ) -> Result<RevalidationReport>
pub async fn revalidate_model_call_async<F, Fut>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, handler: F, ) -> Result<RevalidationReport>
pub async fn revalidate_model_call_async_with_comparator<F, Fut>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, comparator: &dyn RevalidationComparator, handler: F, ) -> Result<RevalidationReport>
Sourcepub fn revalidate_model_stream<F, I, O>(
&mut self,
payload: Value,
contract: &ReplayContract,
options: RevalidationOptions,
handler: F,
on_delta: O,
) -> Result<RevalidationReport>
pub fn revalidate_model_stream<F, I, O>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, handler: F, on_delta: O, ) -> Result<RevalidationReport>
Stream a live observation, then compare it without replacing the golden recording.
pub fn revalidate_model_stream_with_comparator<F, I, O>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, comparator: &dyn RevalidationComparator, handler: F, on_delta: O, ) -> Result<RevalidationReport>
Sourcepub async fn revalidate_model_stream_async<F, N, Fut, O, OFut>(
&mut self,
payload: Value,
contract: &ReplayContract,
options: RevalidationOptions,
handler: F,
on_delta: O,
) -> Result<RevalidationReport>
pub async fn revalidate_model_stream_async<F, N, Fut, O, OFut>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, handler: F, on_delta: O, ) -> Result<RevalidationReport>
Construct the asynchronous pull stream only after governance gates pass.
pub async fn revalidate_model_stream_async_with_comparator<F, N, Fut, O, OFut>( &mut self, payload: Value, contract: &ReplayContract, options: RevalidationOptions, comparator: &dyn RevalidationComparator, handler: F, on_delta: O, ) -> Result<RevalidationReport>
Sourcepub fn tool_call<F>(
&mut self,
name: &str,
args: Value,
options: CallOptions,
handler: F,
) -> Result<Node>
pub fn tool_call<F>( &mut self, name: &str, args: Value, options: CallOptions, handler: F, ) -> Result<Node>
Unfenced tool callback. Disallowed when a registry is attached.
pub fn registered_tool_call( &mut self, name: &str, version: Option<&str>, args: Value, options: CallOptions, ) -> Result<Node>
pub async fn registered_tool_call_async( &mut self, name: &str, version: Option<&str>, args: Value, options: CallOptions, ) -> Result<Node>
Sourcepub fn confirm(&mut self, token: &str) -> Result<Node>
pub fn confirm(&mut self, token: &str) -> Result<Node>
Consume a policy-issued token exactly once at its original cursor.
pub async fn confirm_async(&mut self, token: &str) -> Result<Node>
pub fn note(&mut self, payload: Value, attempt: u64) -> Result<Node>
Sourcepub fn branch(&mut self, attempt: u64, budget: Option<Budget>) -> Result<Self>
pub fn branch(&mut self, attempt: u64, budget: Option<Budget>) -> Result<Self>
Branch shares stored charges and budget scopes. Adopt explicitly to move the parent’s cursor; abandoning a branch never refunds dispatched work.