Struct ToolRegistry

Source

pub struct ToolRegistry<Ctx> { /* private fields */ }

Expand description

Registry of available tools.

Tools are stored with their names erased to allow different Name types in the same registry. The registry uses string-based lookup for LLM compatibility.

Supports both synchronous Tools and asynchronous AsyncTools.

Implementations§

Source §

impl<Ctx> ToolRegistry<Ctx>
where Ctx: Send + Sync + 'static,

Source

pub fn new() -> ToolRegistry<Ctx>

Source

pub fn register<T>(&mut self, tool: T) -> &mut ToolRegistry<Ctx>
where T: Tool<Ctx> + 'static,

Register a synchronous tool in the registry.

The tool’s name is converted to a string via serde serialization and used as the lookup key.

Source

pub fn register_simple<T>(&mut self, tool: T) -> &mut ToolRegistry<Ctx>
where T: SimpleTool<Ctx> + 'static,

Register a SimpleTool — a tool whose name is a plain &str and which needs no ToolName type.

The tool is wrapped in a SimpleToolAdapter (giving it Name = DynamicToolName) and registered like any other Tool. This is the lowest-ceremony way to add a first custom tool.

Source

pub fn register_typed<T>(&mut self, tool: T) -> &mut ToolRegistry<Ctx>
where T: TypedTool<Ctx> + 'static,

Register a TypedTool — a tool whose model-emitted arguments are deserialized into a typed TypedTool::Input and validated before execute runs.

The tool is wrapped in a TypedToolAdapter (giving it Name = DynamicToolName) and registered like any other Tool. A malformed tool call is turned into a structured validation-error ToolResult at the dispatch boundary so the model can self-correct; execute is never reached with invalid arguments.

Source

pub fn register_async<T>(&mut self, tool: T) -> &mut ToolRegistry<Ctx>
where T: AsyncTool<Ctx> + 'static,

Register an async tool in the registry.

Async tools have two phases: execute (lightweight, starts operation) and check_status (streams progress until completion).

Source

pub fn register_listen<T>(&mut self, tool: T) -> &mut ToolRegistry<Ctx>
where T: ListenExecuteTool<Ctx> + 'static,

Register a listen/execute tool in the registry.

Listen/execute tools start by streaming updates via listen(), then run final execution with execute() once confirmed.

Source

pub fn get(&self, name: &str) -> Option<&Arc<dyn ErasedTool<Ctx>>>

Get a synchronous tool by name.

Source

pub fn get_async(&self, name: &str) -> Option<&Arc<dyn ErasedAsyncTool<Ctx>>>

Get an async tool by name.

Source

pub fn get_listen(&self, name: &str) -> Option<&Arc<dyn ErasedListenTool<Ctx>>>

Get a listen/execute tool by name.

Source

pub fn is_async(&self, name: &str) -> bool

Check if a tool name refers to an async tool.

Source

pub fn is_listen(&self, name: &str) -> bool

Check if a tool name refers to a listen/execute tool.

Source

pub fn all(&self) -> impl Iterator<Item = &Arc<dyn ErasedTool<Ctx>>>

Get all registered synchronous tools.

Source

pub fn all_async(&self) -> impl Iterator<Item = &Arc<dyn ErasedAsyncTool<Ctx>>>

Get all registered async tools.

Source

pub fn all_listen( &self, ) -> impl Iterator<Item = &Arc<dyn ErasedListenTool<Ctx>>>

Get all registered listen/execute tools.

Source

pub fn len(&self) -> usize

Get the number of registered tools (sync + async).

Source

pub fn is_empty(&self) -> bool

Check if the registry is empty.

Source

pub fn filter<F>(&mut self, predicate: F)
where F: Fn(&str) -> bool,

Filter tools by a predicate.

Removes tools for which the predicate returns false. The predicate receives the tool name. Applies to both sync and async tools.

§Example

registry.filter(|name| name != "bash");

Source

pub fn to_llm_tools(&self) -> Vec<Tool>

Convert all tools (sync + async + listen) to LLM tool definitions. The output is sorted by tool name so the order is deterministic across builds and across calls.

Determinism matters for prompt caching. Anthropic’s cache_control: ephemeral keys on the byte content of the system + tool list. Anything that perturbs the order of the tool list invalidates the cache. The three backing maps are HashMaps, whose values() order is randomized (DoS-safe RandomState by default), so two consecutive turns with the same registered tool set were producing different orderings and silently zeroing the cache hit rate.

Sorting by name is the cheapest fix that holds across insertion order, internal map type changes, and concurrent builds. The tool count is small (tens, not thousands) so the sort cost is negligible compared to a single LLM call.