Struct ToolRegistry 

pub struct ToolRegistry { /* private fields */ }

A registry that holds multiple tools and implements ToolExecutor.

ToolRegistry provides a convenient way to manage multiple tools and integrate them with the agent loop. It implements ToolExecutor so it can be used directly with AgentLoop.

Example

use everruns_core::tools::{Tool, ToolRegistry};

// Create registry and add tools
let mut registry = ToolRegistry::new();
registry.register(Box::new(GetCurrentTime));
registry.register(Box::new(GetWeather));

// Get tool definitions for agent config
let definitions = registry.tool_definitions();

// Use with agent loop
let agent_loop = AgentLoop::new(config, emitter, store, llm, registry);

Implementations

impl ToolRegistry

pub fn new() -> Self

Create a new empty tool registry

pub fn with_defaults() -> Self

Create a tool registry with default built-in tools.

This includes:

• get_current_time: Returns the current date and time
• echo: Echoes back the provided message
• report_progress: Emits deterministic external progress updates
• TestMath tools: add, subtract, multiply, divide
• TestWeather tools: get_weather, get_forecast
• TaskList tools: write_todos
• FileSystem tools: read_file, write_file, edit_file, list_directory, grep_files, delete_file, stat_file
• WebFetch tools: web_fetch — only when the web-fetch cargo feature is enabled (on by default; absent in provider builds that disable core default features)

pub fn with_monitor_probe_defaults() -> Self

Create a tool registry for autonomous scheduled monitor probes.

Probe execution currently uses a scheduler-local ToolContext instead of the fully populated worker/API executor context. Keep this registry to context-free tools so scheduled probes cannot bypass session-scoped controls such as network ACLs, egress routing, storage, or filesystem mediation.

pub fn register(&mut self, tool: impl Tool + 'static)

Register a tool with the registry.

If a tool with the same name already exists, it will be replaced.

pub fn register_boxed(&mut self, tool: Box<dyn Tool>)

Register a boxed tool

pub fn register_arc(&mut self, tool: Arc<dyn Tool>)

Register an Arc-wrapped tool

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

Get a tool by name

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

Check if a tool is registered

pub fn len(&self) -> usize

Get the number of registered tools

pub fn is_empty(&self) -> bool

Check if the registry is empty

pub fn tool_names(&self) -> Vec<&str>

Get all tool names

pub fn tool_definitions(&self) -> Vec<ToolDefinition>

Get tool definitions for use in RuntimeAgent.

Returns a Vec of ToolDefinition that can be passed to RuntimeAgent::with_tools().

pub fn validate_context_services( &self, services: &ToolContextServices, ) -> Result<()>

Fail configuration before model exposure when a registered tool is missing a runtime service it declares as required.

pub fn unregister(&mut self, name: &str) -> Option<Arc<dyn Tool>>

Remove a tool from the registry

pub fn clear(&mut self)

Clear all tools from the registry

pub fn builder() -> ToolRegistryBuilder

Create a builder for fluent tool registration

Trait Implementations

impl Clone for ToolRegistry

fn clone(&self) -> ToolRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ToolRegistry

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

Formats the value using the given formatter.

impl Default for ToolRegistry

fn default() -> ToolRegistry

Returns the “default value” for a type.

impl ToolExecutor for ToolRegistry

fn execute<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tool_call: &'life1 ToolCall, _tool_def: &'life2 ToolDefinition, ) -> Pin<Box<dyn Future<Output = Result<ToolResult>> + Send + 'async_trait>>

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

Execute a single tool call (without context)

fn execute_with_context<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tool_call: &'life1 ToolCall, _tool_def: &'life2 ToolDefinition, context: &'life3 ToolContext, ) -> Pin<Box<dyn Future<Output = Result<ToolResult>> + Send + 'async_trait>>

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

Execute a single tool call with context

fn execute_batch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tool_calls: &'life1 [ToolCall], tool_defs: &'life2 [ToolDefinition], ) -> Pin<Box<dyn Future<Output = Result<Vec<ToolResult>>> + Send + 'async_trait>>

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

Execute multiple tool calls (default: sequential)

fn execute_parallel<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tool_calls: &'life1 [ToolCall], tool_defs: &'life2 [ToolDefinition], ) -> Pin<Box<dyn Future<Output = Result<Vec<ToolResult>>> + Send + 'async_trait>>

where Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Execute multiple tool calls in parallel