Struct ToolCallView 

pub struct ToolCallView<'a> {
    pub call: &'a ToolCall,
    pub result: Option<&'a ToolResult>,
    pub state: CallState,
    pub theme: Theme,
    pub facts: Option<&'a ToolResultContext>,
    pub took: Option<Duration>,
    pub output: Option<&'a str>,
    pub children: &'a [ChildCall],
}

A tool call and its result, if it has one yet, as a renderer sees them.

Fields

call: &'a ToolCall

The call. While it streams, its arguments are what has come of them, and its id is not the final one.

result: Option<&'a ToolResult>

Its result, once it is in the conversation.

state: CallState

Where the call stands.

theme: Theme

The transcript’s colors.

facts: Option<&'a ToolResultContext>

What the call published, such as rig-core’s ExitStatus and FilesChanged, once it settled: in this run, or in an earlier one of a resumed session whose effect log was kept.

took: Option<Duration>

How long it ran, once it settled, as for facts.

output: Option<&'a str>

The output so far of a running call whose tool reports it as it runs (CallOutput), such as a command’s: cut as tool output is cut, its last lines after a line that counts the earlier ones. None once the call answered, and before it printed anything.

children: &'a [ChildCall]

The tool and model calls the call started, and those they started, in order, each after the one that started it, through any effect between that is no call: such as a subagent’s calls under the call that spawned it, through the spawn and the brief it was sent. Also after a resume, from the session’s effect log (PastEffects).

Implementations

impl<'a> ToolCallView<'a>

pub fn new( call: &'a ToolCall, result: Option<&'a ToolResult>, state: CallState, ) -> Self

call, answered by result if it was, standing as state, with no facts or output known, in the default colors.

pub fn name(&self) -> &str

The tool’s name.

pub fn argument(&self, key: &str) -> Option<&str>

The string argument key, if the call has one.

pub fn result_text(&self) -> Option<String>

The result’s text, joined, if the tool answered.

pub fn failed(&self) -> bool

Whether the call failed: the tool answered with an error, or the process it ran did not exit with 0 (ExitStatus).

pub fn header( &self, title: impl Into<String>, detail: impl Into<String>, ) -> Line<'static>

The header line: title in bold and detail dimmed on a band tinted by where the call stands (Theme’s call_* colors), with the state in words too when it is running, held or failed (how its process ended, when it ran one).

pub fn header_spans( &self, title: impl Into<String>, detail: Vec<Span<'static>>, ) -> Line<'static>

header with detail in spans styled by the look, such as a highlighted command; the state’s words still end it.

pub fn result_lines(&self) -> Vec<Line<'static>>

The whole result, indented under the header, red for an error. A unified diff is coloured. The line that says the tool cut its output (OutputCut), naming the file with all of it, is on its side. Before the result, a running call’s progress.

pub fn progress_lines(&self) -> Vec<Line<'static>>

A running call’s progress, indented under the header, where its result goes once it answers; none without one.

pub fn default_lines(&self) -> Vec<Line<'static>>

The look of a tool with no renderer: the name, the arguments and the result.