Struct Shell 

pub struct Shell {
    pub workspace: Arc<dyn Workspace>,
    pub launcher: Launcher,
    pub live: Option<Live>,
    pub spill: Option<Spill>,
    pub cut: Option<OutputLimit>,
    pub confine: bool,
    pub max_timeout: u64,
    pub quiet: Duration,
}

Runs a command with sh -c in its own session and process group, in its Workspace, as its Launcher starts processes. Its stdout and stderr come back interleaved line by line, as each line ends, without terminal escape sequences such as colours; output past the OutputLimit keeps its first and last lines and the first and last errors and failures from between. Publishes how the command ended (ExitStatus) beside its output, and how the output was cut (OutputCut) when it was, and reports the output as it comes to its Live, if it has one.

Fields

workspace: Arc<dyn Workspace>

Where the command runs.

launcher: Launcher

How the command is started: a wrapper, a directory, its variables.

live: Option<Live>

Where each piece of output is reported as it comes, before the command ends.

spill: Option<Spill>

Where output that is cut is kept whole, named in the cut output.

cut: Option<OutputLimit>

How much of the output the result keeps; None keeps all of it, up to the 10 MB the command is killed at, for a host that cuts output itself.

confine: bool

Whether a cwd that resolves outside the launcher’s directory is refused. What the command itself does is not confined: it may still cd anywhere.

max_timeout: u64

The most seconds a call may ask for in timeout_secs; a longer timeout is cut to it.

quiet: Duration

How long a call with the default timeout may print nothing before it is stopped, such as a loop that never ends; one that names its timeout_secs may be quiet as long as that.

Implementations

impl Shell

pub async fn run(&self, args: ShellArgs) -> Result<ShellRun, ToolExecutionError>

Runs args as the tool does, waiting on a thread of its own, and returns the output and how the command ended. Dropping the future stops the command’s process group at once: SIGTERM, then SIGKILL after STOP_GRACE.

Trait Implementations

impl Clone for Shell

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Shell

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Shell

fn default() -> Self

Started on this machine as this process starts it, nothing spilled or reported live, output cut as OutputLimit::default cuts it, timeouts of at most ten minutes, stopped after a minute of printing nothing unless the call names its timeout.

impl Tool for Shell

const NAME: &'static str = "shell"

Unique registration and provider-facing name.

type Args = ShellArgs

Typed JSON arguments.

type Output = String

Output convertible into Rig’s canonical model presentation.

type Error = ToolExecutionError

Typed error returned by direct calls to this tool.

fn description(&self) -> String

Model-facing description.

fn parameters(&self) -> Value

JSON Schema for arguments.

fn annotations(&self) -> ToolAnnotations

What calling the tool does to the world, for the host’s policies (approval, plan mode, which calls run side by side). Nothing is stated by default, which reads as the protocol’s defaults (ToolAnnotations).

async fn call( &self, context: &mut ToolContext, args: ShellArgs, ) -> Result<String, ToolExecutionError>

Execute the tool.

fn footprint(&self, args: &Self::Args) -> Touches

What a call with args may read and change, so a host runs the calls of one reply that touch different things side by side. The default reads it from the annotations: a read-only tool reads anything, any other writes anything.

fn map_error(&self, error: Self::Error) -> ToolExecutionError

Normalize a typed author-facing error for runtime policy and telemetry.