Documentation
¶
Overview ¶
Package shell exposes a single LLM-callable shell tool plus a small Executor SPI. The package itself does not pick where commands run — local, sandboxed, or remote backends each implement Executor and plug in via NewTool.
The local executor (NewLocalExecutor) is the reference impl and covers the common case (run on the same host as the agent).
Index ¶
Constants ¶
This section is empty.
Variables ¶
Functions ¶
This section is empty.
Types ¶
type Executor ¶
type Executor interface {
// Run executes exactly one command within the executor's frozen authority.
// It honors ctx and Input.Timeout, returns non-zero exit status as Output
// rather than error, and reserves error for spawn, I/O, or collection failure.
Run(ctx context.Context, in Input) (Output, error)
}
Executor is the authority boundary behind the model-facing shell tool. The concrete implementation owns process creation, working-directory policy, environment exposure, output capture, termination, and platform semantics.
type Input ¶
type Input struct {
// Cmd is the shell command line. Required.
Cmd string
// Timeout bounds the run. 0 = no timeout; ctx cancellation still
// applies.
Timeout time.Duration
}
Input captures everything an executor needs to launch a single command. Only Cmd is required.
type LocalConfig ¶ added in v0.13.0
LocalConfig makes the local process authority visible at construction. The directory controls relative-path resolution but is not a filesystem jail; callers that need confinement must supply an OS sandbox or container.
type LocalExecutor ¶
type LocalExecutor struct {
// contains filtered or unexported fields
}
LocalExecutor runs commands on the local host through one immutable construction-time configuration.
func NewLocalExecutor ¶
func NewLocalExecutor(config LocalConfig) (*LocalExecutor, error)
NewLocalExecutor resolves the working directory to an absolute path and freezes it, so a command cannot relocate the executor by changing process state. The output cap is set here because a command that writes without bound would otherwise be truncated only after the memory was already spent.
type Output ¶
type Output struct {
Stdout []byte
Stderr []byte
ExitCode int
Duration time.Duration
// Killed is true when the process was terminated by ctx or
// Input.Timeout rather than exiting on its own.
Killed bool
}
Output is what every executor returns. A non-zero ExitCode is not an error — only spawn/I/O failures populate the error return.
type Request ¶
type Request struct {
Command string `json:"command" jsonschema:"minLength=1" jsonschema_description:"Shell command line run by /bin/sh -c."`
TimeoutMS int `` /* 169-byte string literal not displayed */
}
Request is the LLM-facing argument shape. It is a strict subset of Input — environment, working directory, and streaming are executor-side concerns, not LLM knobs.
type Response ¶
type Response struct {
Stdout string `json:"stdout"`
Stderr string `json:"stderr"`
ExitCode int `json:"exit_code"`
Killed bool `json:"killed,omitempty"`
Duration string `json:"duration"`
}
Response is the LLM-facing return shape. Stdout/stderr are strings (not []byte) because every consumer is a chat model.
type Tool ¶
type Tool struct {
// contains filtered or unexported fields
}
Tool exposes shell execution to a model. It holds an Executor rather than running commands itself so the dangerous half — where a command runs, under what shell, with what limits — is chosen by the host at construction and cannot be influenced by the model's arguments.
func NewTool ¶
NewTool requires an executor because there is no safe default for running arbitrary commands; a package-level fallback would let a caller obtain shell access without ever stating where it should run.
func (*Tool) Call ¶
func (t *Tool) Call(ctx context.Context, invocation toolcontract.Invocation) (chat.ToolOutput, error)
func (*Tool) Definition ¶
func (t *Tool) Definition() chat.ToolDefinition
Source Files