Struct ToolImpl 

pub struct ToolImpl {
    pub def: ToolDef,
    pub exec: Option<AsyncToolExec>,
    pub exec_sync: Option<SyncToolExec>,
    pub sanitize_errors: bool,
}

Complete tool: definition + sync/async exec functions.

Implements Builtin so it can be registered directly in a Bash interpreter or used inside a ScriptedTool.

Example

use bashkit_scripted_tool::{ToolDef, ToolImpl};

let tool = ToolImpl::new(
    ToolDef::new("greet", "Greet a user")
        .with_schema(serde_json::json!({
            "type": "object",
            "properties": { "name": {"type": "string"} }
        })),
)
.with_exec_sync(|args| {
    let name = args.param_str("name").unwrap_or("world");
    Ok(format!("hello {name}\n"))
});

Fields

def: ToolDef

Tool metadata (name, description, schema, tags).

exec: Option<AsyncToolExec>

Async exec (preferred when running in async context).

exec_sync: Option<SyncToolExec>

Sync exec (preferred when running in sync context).

sanitize_errors: bool

Whether callback error strings are sanitized before script-visible stderr.

Implementations

impl ToolImpl

pub fn new(def: ToolDef) -> Self

Create a ToolImpl from a ToolDef with no exec functions.

pub fn with_exec<F, Fut>(self, f: F) -> Self

where F: Fn(ToolArgs) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<String, String>> + Send + 'static,

Set the async exec function.

pub fn with_exec_sync( self, f: impl Fn(&ToolArgs) -> Result<String, String> + Send + Sync + 'static, ) -> Self

Set the sync exec function.

pub fn sanitize_errors(self, sanitize: bool) -> Self

Control whether callback errors are sanitized before reaching stderr.

Default: true, replacing callback Err(String) with "<tool>: callback failed\n" to avoid exposing host-side secrets, paths, connection strings, or stack traces to untrusted scripts. Set to false only when callers are trusted and raw diagnostics are safe.

Trait Implementations

impl Builtin for ToolImpl

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, ctx: Context<'life1>, ) -> Pin<Box<dyn Future<Output = Result<ExecResult>> + Send + 'async_trait>>

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

Execute the builtin command.

fn execution_plan<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 Context<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Option<ExecutionPlan>, Error>> + Send + 'async_trait>>

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

Return an execution plan for sub-command execution.

fn llm_hint(&self) -> Option<&'static str>

Optional short hint for LLM system prompts.

fn reset_session_state(&self)

Clear hidden per-instance state that must not survive snapshot restore.

impl Clone for ToolImpl

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.