@adecore/agents-react 0.23.1 → 0.24.0

package/dist/chat/logic/embedded-code.js

@@ -0,0 +1,371 @@
+export const SHELL_LANGUAGE = 'shellscript';
+// Past this a command is drawn without looking for code inside it; the scan is linear, the highlighting is not.
+export const EMBEDDED_CODE_LIMIT = 20_000;
+const MAX_DEPTH = 3;
+const SHELL = {
+    language: SHELL_LANGUAGE,
+    script: (flag) => /^-[a-zA-Z]*c[a-zA-Z]*$/.test(flag),
+    takesValue: new Set(['-o', '-O', '--rcfile', '--init-file'])
+};
+const PYTHON = { language: 'python', script: (flag) => flag === '-c', takesValue: new Set(['-W', '-X']) };
+const NODE = {
+    language: 'javascript',
+    script: (flag) => ['-e', '--eval', '-p', '--print'].includes(flag),
+    takesValue: new Set(['-r', '--require', '--import', '--input-type', '--conditions', '-C'])
+};
+const BUN = { language: 'typescript', script: (flag) => ['-e', '--eval', '-p', '--print'].includes(flag), takesValue: NODE.takesValue };
+const MYSQL = {
+    language: 'sql',
+    client: true,
+    script: (flag) => flag === '-e' || flag === '--execute',
+    takesValue: new Set(['-u', '-h', '-P', '-D', '-S', '--user', '--host', '--port', '--database'])
+};
+const INTERPRETERS = {
+    bash: SHELL,
+    sh: SHELL,
+    zsh: SHELL,
+    dash: SHELL,
+    ksh: SHELL,
+    python: PYTHON,
+    node: NODE,
+    bun: BUN,
+    psql: {
+        language: 'sql',
+        client: true,
+        script: (flag) => flag === '-c' || flag === '--command',
+        takesValue: new Set(['-d', '-h', '-p', '-U', '-f', '-v', '-o', '--dbname', '--host', '--port', '--username', '--file', '--set'])
+    },
+    mysql: MYSQL,
+    mariadb: MYSQL,
+    sqlite3: { language: 'sql', client: true, script: () => false, takesValue: new Set(['-cmd', '-separator', '-newline', '-nullvalue']), positional: 1 }
+};
+// Programs that run the next word as the command; their own options are skipped along with them.
+const WRAPPERS = new Set(['sudo', 'env', 'exec', 'nohup', 'time', 'command', 'nice']);
+// Tools that run a program of a project's environment as `<tool> run <program>`.
+const RUNNERS = new Set(['uv', 'poetry', 'pipenv']);
+// Where a heredoc written to a file goes, by the file's extension.
+const EXTENSIONS = {
+    py: 'python',
+    js: 'javascript',
+    mjs: 'javascript',
+    cjs: 'javascript',
+    jsx: 'jsx',
+    ts: 'typescript',
+    mts: 'typescript',
+    tsx: 'tsx',
+    json: 'json',
+    sql: 'sql',
+    sh: SHELL_LANGUAGE,
+    bash: SHELL_LANGUAGE,
+    zsh: SHELL_LANGUAGE,
+    yml: 'yaml',
+    yaml: 'yaml',
+    md: 'markdown',
+    css: 'css',
+    html: 'html',
+    php: 'php',
+    xml: 'xml'
+};
+const SEPARATORS = ';&|()';
+const BLANKS = ' \t\r';
+/* The program a command name runs, as the table above knows it: `/usr/bin/python3.12` is `python`. */
+function programOf(word) {
+    const name = word.slice(word.lastIndexOf('/') + 1);
+    return /^python\d*(\.\d+)?$/.test(name) ? 'python' : name;
+}
+/* Splits `source[from, to)` into simple commands the way a shell would, enough to find the code in them. */
+function parseCommands(source, from, to) {
+    const commands = [];
+    let current = { words: [], redirects: [], heredocs: [] };
+    const pending = [];
+    const finish = () => {
+        if (current.words.length > 0 || current.redirects.length > 0) {
+            commands.push(current);
+        }
+        current = { words: [], redirects: [], heredocs: [] };
+    };
+    const skipBlanks = (index) => {
+        while (index < to && BLANKS.includes(source[index])) {
+            index++;
+        }
+        return index;
+    };
+    const readWord = (start) => {
+        let index = start;
+        let text = '';
+        let quoted = null;
+        let parts = 0;
+        let bare = true;
+        while (index < to) {
+            const char = source[index];
+            if (BLANKS.includes(char) || char === '\n' || SEPARATORS.includes(char) || char === '<' || char === '>') {
+                break;
+            }
+            parts++;
+            if (char === "'") {
+                const close = source.indexOf("'", index + 1);
+                const end = close === -1 || close >= to ? to : close;
+                text += source.slice(index + 1, end);
+                quoted = { start: index + 1, end };
+                bare = false;
+                index = Math.min(end + 1, to);
+            }
+            else if (char === '"') {
+                let end = index + 1;
+                while (end < to && source[end] !== '"') {
+                    if (source[end] === '\\' && end + 1 < to && '$`"\\\n'.includes(source[end + 1])) {
+                        text += source[end + 1];
+                        end += 2;
+                    }
+                    else {
+                        text += source[end];
+                        end++;
+                    }
+                }
+                quoted = { start: index + 1, end };
+                bare = false;
+                index = Math.min(end + 1, to);
+            }
+            else if (char === '\\') {
+                text += source[index + 1] ?? '';
+                bare = false;
+                index += 2;
+            }
+            else if (char === '$' && source[index + 1] === '(') {
+                const end = closingParen(source, index + 1, to);
+                text += source.slice(index, end);
+                index = end;
+            }
+            else {
+                text += char;
+                index++;
+            }
+        }
+        const end = Math.min(index, to);
+        const body = bare ? { start, end } : parts === 1 && quoted !== null ? quoted : null;
+        return { start, end, text, body };
+    };
+    const readHeredoc = (start, delimiter, strip) => {
+        let index = start;
+        while (index < to) {
+            const newline = source.indexOf('\n', index);
+            const lineEnd = newline === -1 || newline >= to ? to : newline;
+            let line = source.slice(index, lineEnd).replace(/\r$/, '');
+            if (strip) {
+                line = line.replace(/^\t+/, '');
+            }
+            if (line === delimiter) {
+                return { body: { start, end: index }, next: Math.min(lineEnd + 1, to) };
+            }
+            index = lineEnd + 1;
+        }
+        return { body: { start, end: to }, next: to };
+    };
+    let index = from;
+    while (index < to) {
+        const char = source[index];
+        if (char === '\n') {
+            index++;
+            for (const heredoc of pending) {
+                const { body, next } = readHeredoc(index, heredoc.delimiter, heredoc.strip);
+                heredoc.command.heredocs.push(body);
+                index = next;
+            }
+            pending.length = 0;
+            finish();
+        }
+        else if (BLANKS.includes(char)) {
+            index++;
+        }
+        else if (char === '\\' && source[index + 1] === '\n') {
+            index += 2;
+        }
+        else if (char === '#') {
+            const newline = source.indexOf('\n', index);
+            index = newline === -1 || newline >= to ? to : newline;
+        }
+        else if (source.startsWith('<<<', index)) {
+            index = readWord(skipBlanks(index + 3)).end;
+        }
+        else if (source.startsWith('<<', index)) {
+            index += 2;
+            const strip = source[index] === '-';
+            const word = readWord(skipBlanks(strip ? index + 1 : index));
+            if (word.text !== '') {
+                pending.push({ command: current, delimiter: word.text, strip });
+            }
+            index = word.end;
+        }
+        else if (char === '<' || char === '>' || (char === '&' && source[index + 1] === '>')) {
+            let end = index + 1;
+            while (end < to && '<>&|'.includes(source[end])) {
+                end++;
+            }
+            const op = source.slice(index, end);
+            const target = readWord(skipBlanks(end));
+            current.redirects.push({ op, target });
+            index = Math.max(target.end, end);
+        }
+        else if (SEPARATORS.includes(char)) {
+            index++;
+            finish();
+        }
+        else {
+            const word = readWord(index);
+            // The `2` of `2>&1` is a file descriptor, not an argument.
+            const descriptor = /^\d+$/.test(word.text) && (source[word.end] === '>' || source[word.end] === '<');
+            if (!descriptor) {
+                current.words.push(word);
+            }
+            index = Math.max(word.end, index + 1);
+        }
+    }
+    finish();
+    return commands;
+}
+/* Where the `)` that closes the `(` at `open` is, past it; quotes inside do not count. */
+function closingParen(source, open, to) {
+    let depth = 0;
+    let quote = null;
+    for (let index = open; index < to; index++) {
+        const char = source[index];
+        if (quote !== null) {
+            if (char === quote) {
+                quote = null;
+            }
+            else if (char === '\\' && quote === '"') {
+                index++;
+            }
+        }
+        else if (char === "'" || char === '"') {
+            quote = char;
+        }
+        else if (char === '(') {
+            depth++;
+        }
+        else if (char === ')') {
+            depth--;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+    }
+    return to;
+}
+/* The index of the word a command runs, past variable assignments, wrappers and runners; -1 for none. */
+function programIndex(words) {
+    let index = 0;
+    while (index < words.length) {
+        const text = words[index].text;
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(text)) {
+            index++;
+        }
+        else if (WRAPPERS.has(programOf(text))) {
+            index++;
+            while (index < words.length && words[index].text.startsWith('-')) {
+                index++;
+            }
+        }
+        else if (RUNNERS.has(programOf(text)) && words[index + 1]?.text === 'run') {
+            index += 2;
+        }
+        else {
+            return index;
+        }
+    }
+    return -1;
+}
+/* The code of one simple command: an inline script, or a heredoc fed to an interpreter or written to a file. */
+function codeOf(command) {
+    const found = [];
+    const at = programIndex(command.words);
+    const program = at === -1 ? '' : programOf(command.words[at].text);
+    const interpreter = INTERPRETERS[program];
+    let readsFile = false;
+    if (interpreter !== undefined) {
+        let positional = 0;
+        for (let index = at + 1; index < command.words.length; index++) {
+            const word = command.words[index];
+            if (word.text.startsWith('-') && word.text !== '-') {
+                if (interpreter.script(word.text)) {
+                    const script = command.words[index + 1];
+                    if (script?.body) {
+                        found.push({ ...script.body, language: interpreter.language });
+                    }
+                    readsFile = true;
+                    index++;
+                }
+                else if (interpreter.takesValue?.has(word.text)) {
+                    index++;
+                }
+                else if (interpreter === PYTHON && word.text === '-m') {
+                    readsFile = true;
+                    break;
+                }
+                continue;
+            }
+            if (interpreter.client !== true) {
+                // A script file; whatever follows is its own arguments.
+                readsFile = word.text !== '-';
+                break;
+            }
+            if (positional === interpreter.positional && word.body !== null) {
+                found.push({ ...word.body, language: interpreter.language });
+            }
+            positional++;
+        }
+    }
+    const heredocLanguage = interpreter !== undefined && (!readsFile || interpreter.client === true) ? interpreter.language : writtenLanguage(command, program);
+    if (heredocLanguage !== null) {
+        for (const body of command.heredocs) {
+            found.push({ ...body, language: heredocLanguage });
+        }
+    }
+    return found;
+}
+/* The language of the file a `cat > file` or `tee file` writes, by its extension; null when nothing says. */
+function writtenLanguage(command, program) {
+    const targets = command.redirects.filter(({ op }) => op === '>' || op === '>>' || op === '>|').map(({ target }) => target.text);
+    if (program === 'tee') {
+        targets.push(...command.words
+            .slice(programIndex(command.words) + 1)
+            .map(({ text }) => text)
+            .filter((text) => !text.startsWith('-')));
+    }
+    for (const target of targets) {
+        const dot = target.lastIndexOf('.');
+        const language = dot === -1 ? undefined : EXTENSIONS[target.slice(dot + 1).toLowerCase()];
+        if (language !== undefined) {
+            return language;
+        }
+    }
+    return null;
+}
+function collect(source, from, to, depth, into) {
+    for (const command of parseCommands(source, from, to)) {
+        for (const code of codeOf(command)) {
+            if (code.end <= code.start) {
+                continue;
+            }
+            into.push(code);
+            if (code.language === SHELL_LANGUAGE && depth < MAX_DEPTH) {
+                collect(source, code.start, code.end, depth + 1, into);
+            }
+        }
+    }
+}
+/*
+ * The code inside a shell command that is in another language, or a shell script of its own: the
+ * script of `bash -lc '…'`, `python3 -c '…'`, `node -e '…'`, `psql -c '…'`, and a heredoc fed to an
+ * interpreter or written to a file of a known kind. Sorted by start, a stretch before the ones inside
+ * it, so drawing them in order leaves the innermost language on top. A heuristic over a small shell
+ * grammar, not a parser: what it does not recognize stays plain shell.
+ */
+export function embeddedCode(command) {
+    if (command.length > EMBEDDED_CODE_LIMIT) {
+        return [];
+    }
+    const found = [];
+    collect(command, 0, command.length, 0, found);
+    return found.sort((left, right) => left.start - right.start || right.end - left.end);
+}

package/dist/chat/logic/fork.js

@@ -108,6 +108,7 @@ export function turnIdOfRow(row) {
         case 'user':
         case 'assistant':
         case 'thinking':
+        case 'live-thought':
         case 'subagent':
         case 'approval':
         case 'question':

package/dist/chat/logic/goal.d.ts

@@ -0,0 +1,6 @@
+import type { ChatGoal, ChatGoalAction, ChatInfo, ProviderCapabilities } from '@adecore/agent-contracts';
+export interface GoalView {
+    goal: ChatGoal;
+    actions: ChatGoalAction[];
+}
+export declare function goalView(info: Pick<ChatInfo, 'goal' | 'activeTurnId'>, goals: ProviderCapabilities['goals'], canAct: boolean): GoalView | null;

package/dist/chat/logic/goal.js

@@ -0,0 +1,26 @@
+/*
+ * The row above the composer while the chat has a goal. A CLI with calls for goals pauses, resumes and
+ * clears it at any time; one that only reads `/goal` clears it with a turn of its own, so only between
+ * turns, and a goal it already met clears itself.
+ */
+export function goalView(info, goals, canAct) {
+    const goal = info.goal;
+    if (goal === undefined) {
+        return null;
+    }
+    if (!canAct || goals === undefined) {
+        return { goal, actions: [] };
+    }
+    if (goals === 'command') {
+        return { goal, actions: goal.status === 'complete' || info.activeTurnId !== null ? [] : ['clear'] };
+    }
+    const actions = [];
+    if (goal.status === 'active') {
+        actions.push('pause');
+    }
+    else if (goal.status !== 'complete') {
+        actions.push('resume');
+    }
+    actions.push('clear');
+    return { goal, actions };
+}

package/dist/chat/logic/scrubber.d.ts

@@ -48,4 +48,4 @@ export interface MessageRange {
 export declare function messagesInView({ starts, scrollTop, visibleHeight }: ReadingPosition): MessageRange | null;
 export declare function slotInView(slot: TickSlot, range: MessageRange | null): boolean;
 export declare function stepMessage(starts: readonly number[], eligible: (index: number) => boolean, scrollTop: number, direction: -1 | 1): number | null;
-export declare function threadPaddingLeft(width: number, strip: boolean): number;
+export declare function threadPaddingLeft(width: number, strip: boolean, measure?: number): number;

package/dist/chat/logic/scrubber.js

@@ -1,10 +1,10 @@
+import { DEFAULT_READING_WIDTH, readingMeasure } from '../reading-width.js';
 /* With fewer messages than this the thread is short enough to scroll through, and the strip is noise. */
 export const SCRUBBER_MIN_TICKS = 3;
 export const TICK_HEIGHT_PX = 2;
 const PITCH_PX = 8;
 const MIN_PITCH_PX = 4;
-/* The thread's content column in a view of its own (`.chat-column-content`) and the scroller's padding around it (`px-4`). */
-const CONTENT_MAX_WIDTH_PX = 768;
+/* The scroller's padding around the thread's content column (`px-4`). */
 const THREAD_PADDING_PX = 16;
 export const STRIP_WIDTH_PX = 24;
 /* The strip's distance from the view's left edge, and the air it keeps between itself and the thread's text. */
@@ -199,13 +199,14 @@ export function stepMessage(starts, eligible, scrollTop, direction) {
 /*
  * The left padding of the thread in a view that draws the strip at its left edge. A wide view keeps
  * the usual padding, since its centered column already clears the strip; a narrower one pads until
- * the column's text starts clear of it, so nothing is ever drawn under the strip.
+ * the column's text starts clear of it, so nothing is ever drawn under the strip. `measure` is the
+ * widest the content column runs (`readingMeasure`).
  */
-export function threadPaddingLeft(width, strip) {
+export function threadPaddingLeft(width, strip, measure = readingMeasure(DEFAULT_READING_WIDTH)) {
     if (!strip) {
         return THREAD_PADDING_PX;
     }
     // The column's margin is half of what the padding leaves, so the padding counts the clearance twice.
-    const padding = 2 * STRIP_CLEARANCE_PX + CONTENT_MAX_WIDTH_PX + THREAD_PADDING_PX - Math.floor(width);
+    const padding = 2 * STRIP_CLEARANCE_PX + measure + THREAD_PADDING_PX - Math.floor(width);
     return Math.min(STRIP_CLEARANCE_PX, Math.max(THREAD_PADDING_PX, padding));
 }

package/dist/chat/logic/thought.d.ts

@@ -0,0 +1,3 @@
+export declare function flattenThought(text: string): string;
+export declare function thoughtPreview(text: string): string;
+export declare function thoughtLine(text: string): string;

package/dist/chat/logic/thought.js

@@ -0,0 +1,35 @@
+import { stripMarkdown } from './timeline-copy.js';
+// A line that is nothing but bold, the way a model titles a stretch of its reasoning.
+const HEADING_LINE = /^[ \t]*\*\*([^*\n]+?)\*\*[ \t]*$/;
+const LIST_MARKER = /^[ \t]*(?:[-*+]|\d+[.)])[ \t]+/gm;
+// A sentence ends on a stop with white space after it, so `a.ts` and `1.5` stay whole.
+const SENTENCE_END = /[.!?]["'”’)\]]*(?=\s)/;
+/* The thought as one line of plain text: the marks gone and every run of white space one space. */
+export function flattenThought(text) {
+    return stripMarkdown(text.replace(LIST_MARKER, '')).replace(/\s+/g, ' ').trim();
+}
+function headingOf(line) {
+    return HEADING_LINE.exec(line)?.[1] ?? null;
+}
+/* What a folded thought shows on its one line: the heading it opens with, or the whole thought flattened for the row to cut off. */
+export function thoughtPreview(text) {
+    const heading = headingOf(text.trimStart().split('\n', 1)[0] ?? '');
+    return flattenThought(heading ?? text);
+}
+/*
+ * What the model is thinking about now, in a line: the heading of the last stretch it titled, which
+ * is the one it is on, or the first sentence of a thought that titles nothing.
+ */
+export function thoughtLine(text) {
+    const headings = text
+        .split('\n')
+        .map(headingOf)
+        .filter((heading) => heading !== null);
+    const last = headings.at(-1);
+    if (last !== undefined) {
+        return flattenThought(last);
+    }
+    const flat = flattenThought(text);
+    const end = SENTENCE_END.exec(flat);
+    return end === null ? flat : flat.slice(0, end.index + end[0].length);
+}

package/dist/chat/logic/thread-cards.js

@@ -21,6 +21,8 @@ function rowTime(row) {
             return row.tool.createdAt;
         case 'work-group':
             return row.tools[0]?.createdAt ?? null;
+        case 'live-thought':
+            return row.at;
         case 'working':
             return Number.POSITIVE_INFINITY;
         default:

package/dist/chat/logic/timeline.d.ts

@@ -42,6 +42,11 @@ export type TimelineRow = {
     kind: 'work-live';
     id: string;
     tool: ChatToolItem;
+} | {
+    kind: 'live-thought';
+    id: string;
+    item: ChatThinkingItem;
+    at: number;
 } | {
     kind: 'workflow';
     id: string;

package/dist/chat/logic/timeline.js

@@ -276,6 +276,26 @@ function lastAssistantRow(rows) {
     }
     return null;
 }
+/*
+ * The rows of a running turn with its latest thought over the call it led to, so what the model
+ * found does not scroll away behind the next tool line. Nothing when that call follows the thought
+ * directly, where the thought's own row already shows it, or when a newer thought came after the call.
+ */
+function withLiveThought(rows, items) {
+    const thoughtAt = items.findLastIndex((item) => item.kind === 'thinking' && parentOf(item) === null);
+    const thought = items[thoughtAt];
+    if (thought?.kind !== 'thinking' || thought.text === '') {
+        return rows;
+    }
+    const after = new Set(items.slice(thoughtAt + 1).map((item) => item.id));
+    const index = rows.findIndex((row) => row.kind === 'work-live' && after.has(row.tool.id));
+    const call = rows[index];
+    const previous = rows[index - 1];
+    if (call?.kind !== 'work-live' || (previous?.kind === 'thinking' && previous.id === thought.id)) {
+        return rows;
+    }
+    return [...rows.slice(0, index), { kind: 'live-thought', id: `live-thought-${thought.id}`, item: thought, at: call.tool.createdAt }, ...rows.slice(index)];
+}
 /* Items grouped by turn, in order of first appearance; runs of turnless items keep their place. */
 function chunksByTurn(items) {
     const chunks = [];
@@ -319,7 +339,8 @@ export function deriveTimelineRows(items, options) {
         }
         const active = turnId === options.activeTurnId || turn?.state === 'running';
         if (!turn || active) {
-            rows.push(...rowsForItems(conversation, options, children));
+            const live = rowsForItems(conversation, options, children);
+            rows.push(...(active ? withLiveThought(live, conversation) : live));
             if (active) {
                 rows.push({ kind: 'working', id: `working-${turnId}`, startedAt: turn?.createdAt ?? Date.now() });
             }

package/dist/chat/logic/tool-catalog.d.ts

@@ -5,6 +5,7 @@ export interface ToolEntry {
     grouped: boolean;
     changesFiles: boolean;
     readsImage: boolean;
+    shell: boolean;
 }
 export declare const TOOL_CATALOG: Record<string, ToolEntry>;
 export declare function toolEntry(name: string): ToolEntry | undefined;

package/dist/chat/logic/tool-catalog.js

@@ -6,6 +6,7 @@ function entry(icon, summary, rest = {}) {
         grouped: true,
         changesFiles: false,
         readsImage: false,
+        shell: false,
         ...rest
     };
 }
@@ -25,7 +26,8 @@ export const TOOL_CATALOG = {
     NotebookEdit: entry(SquarePen, ['file_path', 'notebook_path']),
     // Codex reports a patch as the paths it touches; its own input carries no path of its own.
     ApplyPatch: entry(SquarePen, ['summary'], { grouped: false, changesFiles: true }),
-    Bash: entry(Terminal, ['description', 'command']),
+    // Codex's command executions arrive under this name too.
+    Bash: entry(Terminal, ['description', 'command'], { shell: true }),
     Grep: entry(Search, ['pattern']),
     Glob: entry(FolderSearch, ['pattern']),
     WebFetch: entry(Globe, ['url', 'query']),

package/dist/chat/logic/tools.d.ts

@@ -5,6 +5,20 @@ export interface FileChange {
     after: string;
 }
 export declare function toolSummary(name: string, input: unknown): string;
+export declare function toolSummaryIsPath(name: string, input: unknown): boolean;
+export declare function shellCommand(name: string, input: unknown): string | null;
+export interface ToolCallLines {
+    readonly command: string | null;
+    readonly args: ReadonlyArray<readonly [key: string, value: string]>;
+    readonly text: string | null;
+}
+export declare function toolCallLines(name: string, input: unknown): ToolCallLines;
+export declare function exitCodeOf(output: string): {
+    code: number | null;
+    rest: string;
+};
+export declare function hasOutput(output: string | null): output is string;
+export declare function hasToolBody(tool: ChatToolItem): boolean;
 export declare function readImagePath(name: string, input: unknown): string | null;
 export declare function fileChanges(name: string, input: unknown): FileChange[];
 export declare function isFileChange(name: string): boolean;

package/dist/chat/logic/tools.js

@@ -22,6 +22,63 @@ export function toolSummary(name, input) {
     }
     return '';
 }
+// The input keys whose value is a file a call is about.
+const PATH_KEYS = new Set(['file_path', 'notebook_path']);
+/* Whether the one line of a call is the path of a file, which a row cuts in the middle so the name stays. */
+export function toolSummaryIsPath(name, input) {
+    const known = toolEntry(name);
+    if (known === undefined || !isRecord(input)) {
+        return false;
+    }
+    const key = known.summary.find((candidate) => str(input[candidate]) !== null);
+    return key !== undefined && PATH_KEYS.has(key);
+}
+/* The command of a shell call, as it was run; null for any other call or one without a command. */
+export function shellCommand(name, input) {
+    if (toolEntry(name)?.shell !== true || !isRecord(input)) {
+        return null;
+    }
+    const command = str(input.command);
+    return command === null || command.trim() === '' ? null : command;
+}
+// A shell call's description is already the detail of its row.
+const SHELL_SHOWN = new Set(['command', 'description']);
+function valueText(value) {
+    // An empty string can be the point of a call (clearing a field), so it shows as one.
+    return typeof value === 'string' && value !== '' ? value : (JSON.stringify(value) ?? String(value));
+}
+/* The input of a call as lines: a shell command as itself, every other key as `key value`, null included. */
+export function toolCallLines(name, input) {
+    if (!isRecord(input)) {
+        const text = input === null || input === undefined || input === '' ? null : valueText(input);
+        return { command: null, args: [], text };
+    }
+    const command = shellCommand(name, input);
+    const args = Object.entries(input)
+        .filter(([key, value]) => value !== undefined && !(command !== null && SHELL_SHOWN.has(key)))
+        .map(([key, value]) => [key, valueText(value)]);
+    return { command, args, text: null };
+}
+/* A failed call's output with the exit code its tool put on the first line ("Exit code 1"), as Claude Code's shell does. */
+export function exitCodeOf(output) {
+    const match = /^Exit code (-?\d+)[ \t]*(?:\r?\n|$)/.exec(output);
+    if (match === null || Number(match[1]) === 0) {
+        return { code: null, rest: output };
+    }
+    return { code: Number(match[1]), rest: output.slice(match[0].length) };
+}
+/* Whether an output says anything; whitespace alone does not. */
+export function hasOutput(output) {
+    return output !== null && output.trim() !== '';
+}
+/* Whether opening a call shows anything: a diff, the input it was given or what it answered. */
+export function hasToolBody(tool) {
+    if (hasFileChanges(tool) || hasOutput(tool.output)) {
+        return true;
+    }
+    const lines = toolCallLines(tool.name, tool.input);
+    return lines.command !== null || lines.args.length > 0 || lines.text !== null;
+}
 // What `GET /fs/file` will serve; a path with another suffix is not worth asking the host about.
 const IMAGE_SUFFIXES = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'];
 /* The image file a tool call looked at, so the row can draw it; null for every other call. */