Struct ToolAdapter 

pub struct ToolAdapter<T> { /* private fields */ }

A Tool as a handler, keyed by its name.

Implementations

impl<T: Tool> ToolAdapter<T>

pub fn new(tool: T) -> Self

Wrap a static tool.

pub fn retrievable(tool: T) -> Result<Self, Error>

where T: ToolEmbedding,

Wraps a tool with embedding descriptions and serialized reconstruction context. Returns an error if context serialization fails.

pub fn tool(&self) -> &T

The wrapped tool.

pub fn embedding(&self) -> Option<&ToolEmbeddingDescriptor>

The retrieval descriptor of a Self::retrievable adapter.

pub async fn run(&self, args: Value) -> Result<ToolOutput, ToolExecutionError>

Runs the tool on JSON args with an empty ToolContext, as Self::run_with does.

pub async fn run_with( &self, context: &mut ToolContext, args: Value, ) -> Result<ToolOutput, ToolExecutionError>

Runs the tool on JSON args as a dispatch of its call runs it: arguments parsed, errors normalized by Tool::map_error, output converted. The tool sees context’s inbound values, and what it publishes with insert_result lands in context. No registry or agent is involved.

use rig_core::{serve::adapters::ToolAdapter, tool::{ContextValue, Tool, ToolContext}};
use serde_json::json;

#[derive(serde::Serialize, serde::Deserialize)]
struct Calls(u32);
impl ContextValue for Calls { const KEY: &'static str = "calls"; }

struct Double;

impl Tool for Double {
    const NAME: &'static str = "double";
    type Args = i64;
    type Output = i64;
    type Error = rig_core::tool::ToolContextError;

    fn description(&self) -> String {
        "Doubles a number.".to_string()
    }

    fn parameters(&self) -> serde_json::Value {
        json!({ "type": "integer" })
    }

    async fn call(&self, context: &mut ToolContext, n: i64) -> Result<i64, Self::Error> {
        context.insert_result(Calls(1))?;
        Ok(n * 2)
    }
}

let double = ToolAdapter::new(Double);
let mut context = ToolContext::new();
let output = futures::executor::block_on(double.run_with(&mut context, json!(21)))?;
assert_eq!(output.as_json(), Some(&json!(42)));
assert_eq!(context.result::<Calls>()?.map(|calls| calls.0), Some(1));
assert!(futures::executor::block_on(double.run(json!("21"))).is_err());

Trait Implementations

impl<T> Serve for ToolAdapter<T>

where T: Tool + 'static,

type Family = Tool

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.

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.

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.

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

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

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.