Struct BasicToolExecutor 

pub struct BasicToolExecutor { /* private fields */ }

The default ToolExecutor that walks one or more ToolSources, checks permissions via Tool::proposed_requests, and invokes the tool.

Compose static native tools (a frozen ToolRegistry) alongside dynamic sources (a CatalogReader minted by dynamic_catalog and owned by an MCP manager, skill watcher, plugin loader, etc.) without merging into a single mutable registry.

Example

use std::sync::Arc;
use agentkit_tools_core::{BasicToolExecutor, ToolRegistry, ToolSource};

let static_registry: Arc<dyn ToolSource> = Arc::new(ToolRegistry::new());
let executor = BasicToolExecutor::new([static_registry]);
// Pass `executor` to the agent loop.

Implementations

impl BasicToolExecutor

pub fn new(sources: impl IntoIterator<Item = Arc<dyn ToolSource>>) -> Self

Creates an executor that walks sources in order on every lookup.

pub fn from_registry(registry: ToolRegistry) -> Self

Back-compat shorthand: wrap a single ToolRegistry as the only source.

pub fn with_collision_policy(self, policy: CollisionPolicy) -> Self

Sets the collision policy applied when the same tool name appears in multiple sources.

pub fn with_output_truncation_strategy( self, strategy: impl ToolOutputTruncationStrategy + 'static, ) -> Self

Installs a central tool-output truncation strategy. The strategy runs after every successful tool invocation and before the result is returned to the agent loop.

pub fn with_output_truncation_strategy_arc( self, strategy: Arc<dyn ToolOutputTruncationStrategy>, ) -> Self

Installs a pre-wrapped central tool-output truncation strategy.

pub fn specs(&self) -> Vec<ToolSpec>

Returns the ToolSpec for every tool across all sources, deduped by CollisionPolicy.

Trait Implementations

impl ToolExecutor for BasicToolExecutor

fn specs(&self) -> Vec<ToolSpec>

Returns the current specification for every available tool.

fn drain_catalog_events(&self) -> Vec<ToolCatalogEvent>

Drains any pending dynamic catalog events.

fn execute<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, request: ToolRequest, ctx: &'life1 mut ToolContext<'life2>, ) -> Pin<Box<dyn Future<Output = ToolExecutionOutcome> + Send + 'async_trait>>

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

Looks up the tool, evaluates permissions, and invokes it.

fn execute_approved<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, request: ToolRequest, approved_request: &'life1 ApprovalRequest, ctx: &'life2 mut ToolContext<'life3>, ) -> Pin<Box<dyn Future<Output = ToolExecutionOutcome> + Send + 'async_trait>>

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

Re-executes a tool call that was previously interrupted for approval.

fn execute_owned<'life0, 'async_trait>( &'life0 self, request: ToolRequest, ctx: OwnedToolContext, ) -> Pin<Box<dyn Future<Output = ToolExecutionOutcome> + Send + 'async_trait>>

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

Looks up the tool, evaluates permissions, and invokes it using an owned execution context.

fn execute_approved_owned<'life0, 'life1, 'async_trait>( &'life0 self, request: ToolRequest, approved_request: &'life1 ApprovalRequest, ctx: OwnedToolContext, ) -> Pin<Box<dyn Future<Output = ToolExecutionOutcome> + Send + 'async_trait>>

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

Re-executes a tool call that was previously interrupted for approval using an owned execution context.