Struct PythonTool 

pub struct PythonTool { /* private fields */ }

A plugin’s Python tool.

Implementations

impl PythonTool

pub fn new( name: String, plugin: PluginRef, decl: ManifestTool, interpreter: Vec<OsString>, ) -> Option<Self>

decl must be a script tool (ToolKind::Script); None otherwise.

pub fn with_python(self, python: Option<PluginPython>) -> Self

Run with the plugin’s own Python (built on first use if it has requirements).

pub fn with_sandbox(self, sandbox: Option<Sandbox>) -> Self

Run the script in sandbox (see run_script_sandboxed); None: unsandboxed.

pub fn with_timeout(self, timeout: Duration) -> Self

pub fn plugin(&self) -> &PluginRef

pub fn declared(&self) -> &ManifestTool

The tool as the manifest declares it (its name may differ from the name the model sees when that one was taken).

Trait Implementations

impl Tool for PythonTool

fn spec(&self) -> ToolSpec

fn title(&self, args: &Value) -> String

Short human title for the finished call, e.g. “Wrote notes.md”. args is untrusted.

fn access(&self, _args: &Value) -> Access

What this call would do; drives the permission gate. Must not have side effects.

fn run(&self, args: &Value, ctx: &ToolContext<'_>) -> ToolOutput

Do it. args is untrusted model output: validate everything, never panic.

fn pending_title(&self, _args: &Value) -> String

Title for the call before and while it runs, and on approval cards, e.g. “Write notes.md”. Defaults to “Run ”.

fn preview(&self, args: &Value, _workspace: &Path) -> Option<Preview>

A readable account of what the call would do, for approval cards: e.g. a diff for a file write. Reads only, no side effects; bounded. Defaults to the key arguments.

fn always_ask(&self, _args: &Value) -> Option<String>

Some(warning) if this call must be approved by a person every time: no policy, “always allow” grant or --auto-approve lets it run (e.g. installing system-wide). The warning is shown on the approval card.

fn concurrent(&self) -> bool

Calls of this tool start before the other calls of the same round and run side by side, each on a thread of its own (results still go back in call order). For tools that mostly wait, like delegate.