Struct DynModel 

pub struct DynModel<Op: Operation> { /* private fields */ }

A model of one operation with its wire and transport erased. Clones share the model. Built with Model::erase or From<Model<W, T>>, so a consumer takes impl Into<DynModel<Op>> and accepts either.

Every call runs the driver the concrete model runs: spans, request ids, the operation’s fold and error enrichment are the same.

A model used by one consumer is passed as is; a model shared by several is erased once and the handle is cloned. A model the bus serves is a ModelHandle in the agent runtime instead: its calls are dispatched, recorded and observed by the bus.

use rig_core::embeddings::EmbeddingsBuilder;
use rig_core::vector_store::in_memory_store::InMemoryVectorStore;
use rig_core::{Model, providers::openai::{self, OpenAI}};

let model = OpenAI::from_env()?.with_http(http).embedding(openai::TEXT_EMBEDDING_3_SMALL, None).erase();
let embeddings = EmbeddingsBuilder::new(model.clone())
    .documents(["a document".to_owned()])?
    .build()
    .await?;
let index = InMemoryVectorStore::from_documents(embeddings).index(model);

Implementations

impl<Op: Operation> DynModel<Op>

pub fn name(&self) -> &str

The wire’s provider descriptor name ("anthropic").

pub fn id(&self) -> Option<&str>

The model id the wire addresses, when the operation addresses one.

pub fn capabilities(&self) -> Capabilities

What a runtime accounts for about this model.

pub fn call( &self, request: impl Into<Op::Request>, ) -> impl Future<Output = Result<Op::Response, ProviderError>> + WasmCompatSend + 'static

Send request and fold the whole reply into the operation’s response; Model::call with the model erased. The call owns what it sends, so it can be spawned.

pub fn call_observed( &self, request: impl Into<Op::Request>, observation: AdapterContext, ) -> impl Future<Output = Result<Op::Response, ProviderError>> + WasmCompatSend + 'static

Self::call, with the attempt observed under observation.

pub fn stream( &self, request: impl Into<Op::Request>, ) -> Result<Streamed<Op>, ProviderError>

Open a streamed reply; Model::stream with the model erased.

pub fn stream_observed( &self, request: impl Into<Op::Request>, observation: AdapterContext, ) -> Result<Streamed<Op>, ProviderError>

Self::stream, with the attempt observed under observation.

impl DynModel<Embedding>

pub async fn embed_text(&self, text: &str) -> Result<Embedding, ProviderError>

Embed one text, returning the last vector or an error if none is returned.

Trait Implementations

impl<Op: Operation> Clone for DynModel<Op>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Op: Operation> Debug for DynModel<Op>

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

Formats the value using the given formatter.

impl<W, T> From<Model<W, T>> for DynModel<W::Op>

where W: Wire, T: Transport<W>,

fn from(model: Model<W, T>) -> Self

Converts to this type from the input type.