Struct FunctionTool 

pub struct FunctionTool<T, F> { /* private fields */ }

A Tool built from an async function, without writing a struct and a trait impl.

The function takes any serde type: the arguments the model sends are deserialized into it. parameters is the JSON schema advertised to the model; it should describe that type.

#[derive(serde::Deserialize)]
struct AddInput { a: f64, b: f64 }

let adder = FunctionTool::new(
    "adder",
    "Adds two numbers together",
    json!({
        "type": "object",
        "properties": { "a": {"type": "number"}, "b": {"type": "number"} },
        "required": ["a", "b"]
    }),
    |input: AddInput| async move {
        Ok::<_, String>(format!("The sum of {} and {} is {}", input.a, input.b, input.a + input.b))
    },
);
let tools: Vec<Arc<dyn Tool>> = vec![Arc::new(adder)];

For a tool that takes a single string, FunctionTool::text fills in the schema.

Input that doesn’t deserialize comes back to the model as a tool error naming the expected schema, so it can retry; the function isn’t called.

Implementations

impl<T, F> FunctionTool<T, F>

pub fn new<N: Into<String>, D: Into<String>>( name: N, description: D, parameters: Value, func: F, ) -> Self

impl<F> FunctionTool<String, F>

pub fn text<N: Into<String>, D: Into<String>>( name: N, description: D, func: F, ) -> Self

A tool whose function takes the model’s input as one string. The advertised schema is {"input": string}, described by description.

Trait Implementations

impl<T, F, Fut, O, E> Tool for FunctionTool<T, F>

where T: DeserializeOwned + Send + 'static, F: Fn(T) -> Fut + Send + Sync, Fut: Future<Output = Result<O, E>> + Send, O: ToString, E: Into<Box<dyn Error>>,

fn parse_input<'life0, 'life1, 'async_trait>( &'life0 self, input: &'life1 str, ) -> Pin<Box<dyn Future<Output = Value> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Keeps the arguments as JSON (the default turns objects into a string); anything that isn’t JSON is passed on as a string.

fn name(&self) -> String

Returns the name of the tool.

fn description(&self) -> String

Provides a description of what the tool does and when to use it.

fn parameters(&self) -> Value

This are the parametters for OpenAi-like function call. You should return a jsnon like this one

fn run<'life0, 'async_trait>( &'life0 self, input: Value, ) -> Pin<Box<dyn Future<Output = Result<String, Box<dyn Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Executes the core functionality of the tool.

fn call<'life0, 'life1, 'async_trait>( &'life0 self, input: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, Box<dyn Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Processes an input string and executes the tool’s functionality, returning a Result.