Struct SkillTool 

pub struct SkillTool { /* private fields */ }

Loads skill bodies, and remembers which it has loaded.

Implementations

impl SkillTool

pub fn new(available: Vec<Skill>) -> Self

pub fn loaded(&self) -> Vec<String>

What has been loaded, for a UI or a test.

pub fn available(&self) -> &[Skill]

What this run actually carries — the level-1 set, after config selection and --skill narrowing.

For a UI answering “what does this agent know how to do”. It has to come from here rather than from re-reading the store beside the config, because --skill narrows the run without touching either: mecha skills shipped with exactly that bug, marking every config-selected skill as carried while the run carried one.

pub fn clear(&self)

Forget what is loaded, because the conversation that loaded it ended.

A loaded skill is the agent’s state and a conversation is the scope it belongs to. Where one agent serves one conversation nothing needs to call this; where a front-end starts a fresh one — /clear, the next batch item — it has to, or a tools: narrowing outlives the task that asked for it and silently constrains the next one. There is no unload within a conversation on purpose: a procedure that has been read cannot be un-read, and the narrowing is the fail-closed direction.

Trait Implementations

impl Tool for SkillTool

fn read_only(&self) -> bool

Reading a local file the user wrote, with no side effect anyone can observe. Skipping the approval gate matters more than it looks: a procedure the user authored should not need a click to be read, or every run that follows instructions costs an extra interruption.

fn carried_state(&self) -> Option<CarriedState>

Loaded skills cross a compaction verbatim.

A summariser preserves what is true and drops how far you got — and for a procedure it does something worse, because a paraphrased procedure is a different procedure. The steps would survive as a plausible gist with the specifics gone, which is exactly the failure the user wrote the skill to prevent. rebuild places carried state after the summary, as the part of the rebuilt head known to be current rather than paraphrased.

fn forget_conversation_state(&self)

The union of what the loaded skills declared, or None if none did.

A skill with no tools key is an opinion-free skill and must not drag the surface down to whatever its neighbour declared, so the union is taken over declaring skills only — and if none declares, nothing narrows. See Tool::narrows_surface_to for the composition rule. A conversation ending is the one thing that unloads a skill: loaded skills are its state, and a tools: narrowing that outlived it would silently constrain the next task.

fn name(&self) -> &str

fn description(&self) -> &str

fn input_schema(&self) -> Value

fn capabilities(&self) -> Capabilities

Declared risk surface. The default is the conservative one for a tool nobody has classified: assume it does nothing special.

fn call<'life0, 'life1, 'async_trait>( &'life0 self, input: Value, _ctx: &'life1 ToolCtx, ) -> Pin<Box<dyn Future<Output = Result<ToolOutput>> + Send + 'async_trait>>

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

fn narrows_surface_to(&self) -> Option<Vec<String>>

Tool names this tool is currently restricting the surface to, if it is restricting it at all.

fn denial_remedy(&self) -> Option<String>

How the operator could make a call like the one just refused safe — one sentence appended to a trifecta denial, or None when nothing short of policy would change the answer.

fn fixed_workspace(&self) -> Option<PathBuf>

The root this tool’s relative paths actually resolve against, when the tool was constructed over a fixed directory rather than following the per-run ToolCtx workspace.

fn spec(&self) -> ToolSpec