Struct ErasedHandler 

pub struct ErasedHandler { /* private fields */ }

Shared, type-erased handler. Clones retain the same handler allocation. Implements Send + Sync on native targets, but not on WASM.

Implementations

impl ErasedHandler

pub fn new(handler: impl Serve + 'static) -> Self

Erase handler.

pub fn unavailable( descriptor: HandlerDescriptor, why: impl Into<String>, ) -> Self

A handler that serves nothing: it is descriptor, and every effect it gets is answered ErrorKind::HandlerUnavailable with why. For a model whose calls a plugin answers itself, such as from a batch, so a call that reaches the handler by mistake fails plainly while records still name the model.

use rig_core::completion::ModelRef;
use rig_core::effect::{FamilyDescriptor, HandlerDescriptor, model_key};
use rig_core::serve::ErasedHandler;

let descriptor = HandlerDescriptor {
    key: model_key("batch/claude"),
    family: FamilyDescriptor::Completion {
        model: ModelRef::from("batch/claude"),
        capabilities: Default::default(),
    },
    layers: Vec::new(),
};
let handler = ErasedHandler::unavailable(descriptor, "answered from the batch API");
assert_eq!(handler.key(), &model_key("batch/claude"));

pub fn layered(self, intercept: impl Intercept) -> Self

Wrap this handler in a Layer: intercept sees every dispatch before this handler does and every answer after. handler.layered(a).layered(b) calls b.before first and a.after first.

pub fn map_stream<M, F>(self, name: impl Into<String>, make: M) -> Self

where M: Fn(Arc<PublishedContext>) -> F + WasmCompatSend + WasmCompatSync + 'static, F: FnMut(Relayed) -> Vec<Relayed> + WasmCompatSend + 'static,

Rewrite this handler’s completion streams: every item of each reply passes through a fresh make(published) in order, and the items it returns go on in its place. It sees the Relayed::Done too, so a rewrite of the events also rewrites the response the reply ends with. A unary completion is rewritten as its events, so both delivery modes answer alike; other outcomes and errors pass as they are. name joins the descriptor’s layers.

published is the dispatch’s PublishedContext: a fact the rewrite inserts there before it passes the Done on, such as that it split reasoning out of this reply, comes back to the driver beside the reply and is recorded with it.

Unlike a Layer, the rewrite is recorded: the record of a dispatch is the reply the consumer receives, so a replay of it does not rewrite twice.

pub fn descriptor(&self) -> HandlerDescriptor

What the erased handler is.

pub fn key(&self) -> &HandlerKey

The key of its descriptor, without building one.

pub fn handle(&self, kind: EffectKind, dispatch: Dispatch) -> HandlerFuture<'_>

Serve one effect: the driver’s call, straight to the boxed handler.

pub fn footprint(&self, kind: &EffectKind) -> Option<Touches>

What dispatching kind to this handler may read and change (Serve::footprint).

pub fn check(&self, kind: &EffectKind) -> Vec<UnsupportedOption>

The options of kind this handler would leave out (Serve::check).

pub fn ptr_eq(&self, other: &Self) -> bool

Whether two erased handlers are the same allocation.

Trait Implementations

impl Clone for ErasedHandler

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErasedHandler

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

Formats the value using the given formatter.

impl Serve for ErasedHandler

Forwards serving to the wrapped handler; re-erasure adds another boxed future.

type Family = Dynamic

The family this handler serves, or Dynamic.

fn descriptor(&self) -> HandlerDescriptor

What this handler is: the family-keyed description a typed view checks at bind time and a scene serializes.

async fn serve(&self, kind: EffectKind, dispatch: Dispatch) -> Reply

Prepare an outcome or an owned stream for the driver to consume.

fn footprint(&self, kind: &EffectKind) -> Option<Touches>

What dispatching kind may read and change, for a tool’s handler (Tool::footprint); None when it cannot say, such as for arguments that do not parse.

fn check(&self, kind: &EffectKind) -> Vec<UnsupportedOption>

The options of kind this handler would leave out when it serves it, with nothing sent: for a model’s handler, what its wire or model cannot honour (DynModel::check). Empty when it leaves nothing out or cannot say, as by default.

fn key(&self) -> HandlerKey

The descriptor’s key. A handler whose descriptor is costly to build, such as a tool’s argument schema, says it without building one.