@celljs/ta-web 0.0.0-stage → 4.6.0

package/src/browser/util/progress.ts

@@ -0,0 +1,170 @@
+import type { SessionMessage, SessionState } from '@celljs/ta-client';
+import { MessageUtil } from './message';
+import { type ToolSummary, ToolUtil } from './tool';
+
+/** What ta does now, in a word or a line: what the loading line says. */
+export type Phase =
+    | { kind: 'waiting' }
+    | { kind: 'thinking' }
+    | { kind: 'writing' }
+    /** The model writes a tool call: its arguments are not whole yet. */
+    | { kind: 'calling'; tool: string }
+    | { kind: 'tool'; summary: ToolSummary }
+    | { kind: 'clientTool'; tool: string }
+    | { kind: 'attention' }
+    | { kind: 'compacting' }
+    | { kind: 'retrying'; attempt: number; maxAttempts: number; seconds: number };
+
+/** Tokens of the run of now: sent to the model (each request counts its whole context) and received from it. */
+export interface RunTokens {
+    input: number;
+    output: number;
+}
+
+interface Usage {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}
+
+/** pi's estimate, for what a model has not counted yet: four characters a token. */
+const CHARS_PER_TOKEN = 4;
+
+function usageOf(message: SessionMessage): Usage | undefined {
+    return (message as { role: string; usage?: Usage }).role === 'assistant' ? (message as { usage?: Usage }).usage : undefined;
+}
+
+function contextOf(usage: Usage | undefined): number {
+    return usage ? (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) : 0;
+}
+
+function role(message: SessionMessage | undefined): string | undefined {
+    return (message as { role?: string } | undefined)?.role;
+}
+
+export namespace ProgressUtil {
+    /** What ta does now, the most pressing first: a question for the user, then pi's own work, then the model's. */
+    export function phase(state: SessionState): Phase {
+        if (state.pendingUi.length > 0) {
+            return { kind: 'attention' };
+        }
+        if (state.compacting) {
+            return { kind: 'compacting' };
+        }
+        if (state.retry) {
+            const { attempt, maxAttempts, delayMs } = state.retry;
+            return { kind: 'retrying', attempt, maxAttempts, seconds: Math.max(1, Math.round(delayMs / 1000)) };
+        }
+        const [request] = state.pendingClientTools;
+        if (request) {
+            return { kind: 'clientTool', tool: request.toolName };
+        }
+        const run = ToolUtil.current(state.tools);
+        if (run) {
+            return { kind: 'tool', summary: ToolUtil.summary(run.toolName, (run.args as Record<string, unknown>) ?? {}) };
+        }
+        const last = state.messages[state.messages.length - 1];
+        if (role(last) !== 'assistant' || (last as { stopReason?: string }).stopReason === 'toolUse') {
+            // Sent, or a tool has answered: the model has not begun.
+            return { kind: 'waiting' };
+        }
+        const blocks = MessageUtil.blocks(last);
+        const block = blocks[blocks.length - 1];
+        switch (block?.type) {
+            case 'thinking':
+                return { kind: 'thinking' };
+            case 'text':
+                return { kind: 'writing' };
+            case 'toolCall':
+                return { kind: 'calling', tool: block.name ?? '' };
+            default:
+                return { kind: 'waiting' };
+        }
+    }
+
+    /** Where the run of now starts: as the store saw it start, else after the last message of the user. */
+    export function runStart(state: SessionState): number {
+        if (state.runStart !== undefined && state.runStart <= state.messages.length) {
+            return state.runStart;
+        }
+        for (let index = state.messages.length - 1; index >= 0; index--) {
+            if (role(state.messages[index]) === 'user') {
+                return index;
+            }
+        }
+        return 0;
+    }
+
+    /**
+     * The tokens of the run so far. A request the model has answered counts what it says; one it has not
+     * counted yet is estimated as pi does: the context of the last counted request and the characters
+     * since. While the model has not answered the latest request, it counts as sent. Before the model has
+     * counted any request of the session, the system prompt and the tools are unknown: nothing is sent yet.
+     */
+    export function tokens(state: SessionState): RunTokens {
+        const { messages } = state;
+        const start = runStart(state);
+        let input = 0;
+        let output = 0;
+        // The context of the latest counted request, and the index after its answer.
+        let known = 0;
+        let knownAt = 0;
+        const estimateSince = (end: number) => (known ? known + Math.ceil(chars(messages.slice(knownAt, end)) / CHARS_PER_TOKEN) : 0);
+        for (let index = 0; index < messages.length; index++) {
+            const usage = usageOf(messages[index]);
+            if (!usage) {
+                continue;
+            }
+            const counted = contextOf(usage);
+            if (index >= start) {
+                input += counted || estimateSince(index);
+                const estimate = Math.ceil(chars([messages[index]]) / CHARS_PER_TOKEN);
+                const streaming = state.working && index === messages.length - 1;
+                output += streaming ? Math.max(usage.output ?? 0, estimate) : usage.output || estimate;
+            }
+            if (counted) {
+                known = counted + (usage.output ?? 0);
+                knownAt = index + 1;
+            }
+        }
+        // Sent, and the model has not begun its answer: the loop above has not counted this request.
+        if (state.working && messages.length > start && role(messages[messages.length - 1]) !== 'assistant' && phase(state).kind === 'waiting') {
+            input += estimateSince(messages.length);
+        }
+        return { input, output };
+    }
+
+    /** 1234 is 1.2k, 23456 is 23.5k, 123456 is 123k: short enough for one line. */
+    export function format(count: number): string {
+        if (count < 1000) {
+            return String(count);
+        }
+        if (count < 100_000) {
+            return `${trim((count / 1000).toFixed(1))}k`;
+        }
+        if (count < 1_000_000) {
+            return `${Math.round(count / 1000)}k`;
+        }
+        return `${trim((count / 1_000_000).toFixed(1))}M`;
+    }
+
+    function trim(value: string): string {
+        return value.replace(/\.0$/, '');
+    }
+
+    /** The characters a model reads or writes of these messages: text, thoughts, tool calls and results. */
+    function chars(messages: SessionMessage[]): number {
+        let count = 0;
+        for (const message of messages) {
+            for (const block of MessageUtil.blocks(message)) {
+                const { text, thinking, arguments: args, partialJson } = block as typeof block & { partialJson?: string };
+                count += (text?.length ?? 0) + (thinking?.length ?? 0);
+                if (block.type === 'toolCall') {
+                    count += partialJson?.length ?? JSON.stringify(args ?? {}).length;
+                }
+            }
+        }
+        return count;
+    }
+}

package/src/browser/util/qr-code.spec.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'bun:test';
+import { QrCode } from './qr-code';
+
+/** The 7×7 finder pattern at a corner: a dark ring, a light ring, a dark 3×3 middle. */
+function hasFinder(code: QrCode, left: number, top: number): boolean {
+    for (let dy = 0; dy < 7; dy++) {
+        for (let dx = 0; dx < 7; dx++) {
+            const ring = Math.max(Math.abs(dx - 3), Math.abs(dy - 3));
+            if (code.isDark(left + dx, top + dy) !== (ring !== 2)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+describe('QrCode', () => {
+    it('takes the smallest version that holds the text', () => {
+        expect(QrCode.encode('hi').version).toBe(1);
+        expect(QrCode.encode('x'.repeat(60)).version).toBe(4);
+        // A pairing link of ta pair.
+        expect(QrCode.encode(`https://relay.cellbang.com/pair#v=1&h=${'h'.repeat(22)}&d=${'d'.repeat(22)}&k=${'k'.repeat(43)}&n=MacBook`).version).toBe(8);
+        expect(() => QrCode.encode('z'.repeat(3000))).toThrow();
+    });
+
+    it('has the finder patterns and the timing lines in place', () => {
+        const code = QrCode.encode('https://example.com');
+        expect(code.size).toBe(code.version * 4 + 17);
+        expect(hasFinder(code, 0, 0)).toBe(true);
+        expect(hasFinder(code, code.size - 7, 0)).toBe(true);
+        expect(hasFinder(code, 0, code.size - 7)).toBe(true);
+        for (let i = 8; i < code.size - 8; i++) {
+            expect(code.isDark(i, 6)).toBe(i % 2 === 0);
+        }
+        // The dark module beside the lower finder.
+        expect(code.isDark(8, code.size - 8)).toBe(true);
+    });
+
+    it('draws each dark module once in its path', () => {
+        const code = QrCode.encode('ta');
+        let dark = 0;
+        for (let y = 0; y < code.size; y++) {
+            for (let x = 0; x < code.size; x++) {
+                dark += code.isDark(x, y) ? 1 : 0;
+            }
+        }
+        expect(code.path().split('M').length - 1).toBe(dark);
+    });
+});

package/src/browser/util/qr-code.ts

@@ -0,0 +1,371 @@
+/**
+ * A QR code (ISO/IEC 18004) of a text, in byte mode with the error correction level M, in the smallest
+ * version that holds it. Enough for a link a phone scans; written here rather than taken from a package.
+ * The steps and tables follow the standard, as does the well-known reference implementation by Nayuki.
+ */
+export class QrCode {
+    /** Codewords for error correction per block, and blocks, at level M, by version (index 0 unused). */
+    protected static readonly ECC_PER_BLOCK = [
+        -1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+        28, 28, 28,
+    ];
+    protected static readonly BLOCKS = [
+        -1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49,
+    ];
+    /** Level M in the format bits. */
+    protected static readonly ECC_FORMAT = 0;
+
+    readonly size: number;
+    protected readonly modules: boolean[][];
+    protected readonly reserved: boolean[][];
+
+    protected constructor(
+        readonly version: number,
+        data: number[],
+    ) {
+        this.size = version * 4 + 17;
+        this.modules = Array.from({ length: this.size }, () => new Array<boolean>(this.size).fill(false));
+        this.reserved = Array.from({ length: this.size }, () => new Array<boolean>(this.size).fill(false));
+        this.drawPatterns();
+        this.drawCodewords(this.withEcc(data));
+        let best = 0;
+        let lowest = Number.POSITIVE_INFINITY;
+        for (let mask = 0; mask < 8; mask++) {
+            this.applyMask(mask);
+            this.drawFormat(mask);
+            const penalty = this.penalty();
+            if (penalty < lowest) {
+                best = mask;
+                lowest = penalty;
+            }
+            this.applyMask(mask);
+        }
+        this.applyMask(best);
+        this.drawFormat(best);
+    }
+
+    /** Throws when the text is too long for any version. */
+    static encode(text: string): QrCode {
+        const bytes = [...new TextEncoder().encode(text)];
+        for (let version = 1; version <= 40; version++) {
+            const capacity = QrCode.dataCodewords(version) * 8;
+            const countBits = version <= 9 ? 8 : 16;
+            const used = 4 + countBits + bytes.length * 8;
+            if (used <= capacity) {
+                const bits: number[] = [];
+                const push = (value: number, length: number) => {
+                    for (let i = length - 1; i >= 0; i--) {
+                        bits.push((value >>> i) & 1);
+                    }
+                };
+                push(0b0100, 4);
+                push(bytes.length, countBits);
+                for (const byte of bytes) {
+                    push(byte, 8);
+                }
+                push(0, Math.min(4, capacity - bits.length));
+                push(0, (8 - (bits.length % 8)) % 8);
+                for (let pad = 0xec; bits.length < capacity; pad ^= 0xec ^ 0x11) {
+                    push(pad, 8);
+                }
+                const data: number[] = [];
+                for (let i = 0; i < bits.length; i += 8) {
+                    data.push(bits.slice(i, i + 8).reduce((byte, bit) => (byte << 1) | bit, 0));
+                }
+                return new QrCode(version, data);
+            }
+        }
+        throw new Error('The text is too long for a QR code.');
+    }
+
+    isDark(x: number, y: number): boolean {
+        return this.modules[y][x];
+    }
+
+    /** The code as an SVG path of its dark modules, one unit each, without the quiet zone. */
+    path(): string {
+        let d = '';
+        for (let y = 0; y < this.size; y++) {
+            for (let x = 0; x < this.size; x++) {
+                if (this.modules[y][x]) {
+                    d += `M${x} ${y}h1v1h-1z`;
+                }
+            }
+        }
+        return d;
+    }
+
+    protected static rawModules(version: number): number {
+        let result = (16 * version + 128) * version + 64;
+        if (version >= 2) {
+            const align = Math.floor(version / 7) + 2;
+            result -= (25 * align - 10) * align - 55;
+            if (version >= 7) {
+                result -= 36;
+            }
+        }
+        return result;
+    }
+
+    protected static dataCodewords(version: number): number {
+        return Math.floor(QrCode.rawModules(version) / 8) - QrCode.ECC_PER_BLOCK[version] * QrCode.BLOCKS[version];
+    }
+
+    protected alignmentPositions(): number[] {
+        if (this.version === 1) {
+            return [];
+        }
+        const count = Math.floor(this.version / 7) + 2;
+        const step = this.version === 32 ? 26 : Math.ceil((this.version * 4 + 4) / (count * 2 - 2)) * 2;
+        const result = [6];
+        for (let position = this.size - 7; result.length < count; position -= step) {
+            result.splice(1, 0, position);
+        }
+        return result;
+    }
+
+    protected set(x: number, y: number, dark: boolean): void {
+        this.modules[y][x] = dark;
+        this.reserved[y][x] = true;
+    }
+
+    protected drawPatterns(): void {
+        for (let i = 0; i < this.size; i++) {
+            this.set(6, i, i % 2 === 0);
+            this.set(i, 6, i % 2 === 0);
+        }
+        const finder = (cx: number, cy: number) => {
+            for (let dy = -4; dy <= 4; dy++) {
+                for (let dx = -4; dx <= 4; dx++) {
+                    const x = cx + dx;
+                    const y = cy + dy;
+                    if (x >= 0 && x < this.size && y >= 0 && y < this.size) {
+                        const distance = Math.max(Math.abs(dx), Math.abs(dy));
+                        this.set(x, y, distance !== 2 && distance !== 4);
+                    }
+                }
+            }
+        };
+        finder(3, 3);
+        finder(this.size - 4, 3);
+        finder(3, this.size - 4);
+        const positions = this.alignmentPositions();
+        for (let i = 0; i < positions.length; i++) {
+            for (let j = 0; j < positions.length; j++) {
+                const corner = (i === 0 && j === 0) || (i === 0 && j === positions.length - 1) || (i === positions.length - 1 && j === 0);
+                if (!corner) {
+                    for (let dy = -2; dy <= 2; dy++) {
+                        for (let dx = -2; dx <= 2; dx++) {
+                            this.set(positions[i] + dx, positions[j] + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+                        }
+                    }
+                }
+            }
+        }
+        // Reserved now, drawn with each mask.
+        this.drawFormat(0);
+        if (this.version >= 7) {
+            let rem = this.version;
+            for (let i = 0; i < 12; i++) {
+                rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
+            }
+            const bits = (this.version << 12) | rem;
+            for (let i = 0; i < 18; i++) {
+                const dark = ((bits >>> i) & 1) !== 0;
+                const a = this.size - 11 + (i % 3);
+                const b = Math.floor(i / 3);
+                this.set(a, b, dark);
+                this.set(b, a, dark);
+            }
+        }
+    }
+
+    protected drawFormat(mask: number): void {
+        const data = (QrCode.ECC_FORMAT << 3) | mask;
+        let rem = data;
+        for (let i = 0; i < 10; i++) {
+            rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+        }
+        const bits = ((data << 10) | rem) ^ 0x5412;
+        const bit = (i: number) => ((bits >>> i) & 1) !== 0;
+        for (let i = 0; i <= 5; i++) {
+            this.set(8, i, bit(i));
+        }
+        this.set(8, 7, bit(6));
+        this.set(8, 8, bit(7));
+        this.set(7, 8, bit(8));
+        for (let i = 9; i < 15; i++) {
+            this.set(14 - i, 8, bit(i));
+        }
+        for (let i = 0; i < 8; i++) {
+            this.set(this.size - 1 - i, 8, bit(i));
+        }
+        for (let i = 8; i < 15; i++) {
+            this.set(8, this.size - 15 + i, bit(i));
+        }
+        this.set(8, this.size - 8, true);
+    }
+
+    /** The data split into blocks, each with its Reed-Solomon codewords, interleaved. */
+    protected withEcc(data: number[]): number[] {
+        const blocks = QrCode.BLOCKS[this.version];
+        const eccLength = QrCode.ECC_PER_BLOCK[this.version];
+        const raw = Math.floor(QrCode.rawModules(this.version) / 8);
+        const shortBlocks = blocks - (raw % blocks);
+        const shortLength = Math.floor(raw / blocks);
+        const divisor = QrCode.reedSolomonDivisor(eccLength);
+        const all: number[][] = [];
+        for (let i = 0, k = 0; i < blocks; i++) {
+            const dataLength = shortLength - eccLength + (i < shortBlocks ? 0 : 1);
+            const block = data.slice(k, k + dataLength);
+            k += dataLength;
+            const ecc = QrCode.reedSolomonRemainder(block, divisor);
+            if (i < shortBlocks) {
+                block.push(0);
+            }
+            all.push([...block, ...ecc]);
+        }
+        const result: number[] = [];
+        for (let i = 0; i < all[0].length; i++) {
+            for (let j = 0; j < all.length; j++) {
+                // The padding byte of a short block is not sent.
+                if (i !== shortLength - eccLength || j >= shortBlocks) {
+                    result.push(all[j][i]);
+                }
+            }
+        }
+        return result;
+    }
+
+    protected drawCodewords(codewords: number[]): void {
+        let i = 0;
+        for (let right = this.size - 1; right >= 1; right -= 2) {
+            if (right === 6) {
+                right = 5;
+            }
+            for (let vertical = 0; vertical < this.size; vertical++) {
+                for (let j = 0; j < 2; j++) {
+                    const x = right - j;
+                    const upward = ((right + 1) & 2) === 0;
+                    const y = upward ? this.size - 1 - vertical : vertical;
+                    if (!this.reserved[y][x] && i < codewords.length * 8) {
+                        this.modules[y][x] = ((codewords[i >>> 3] >>> (7 - (i & 7))) & 1) !== 0;
+                        i++;
+                    }
+                }
+            }
+        }
+    }
+
+    protected applyMask(mask: number): void {
+        for (let y = 0; y < this.size; y++) {
+            for (let x = 0; x < this.size; x++) {
+                if (this.reserved[y][x]) {
+                    continue;
+                }
+                const flip = [
+                    (x + y) % 2,
+                    y % 2,
+                    x % 3,
+                    (x + y) % 3,
+                    (Math.floor(x / 3) + Math.floor(y / 2)) % 2,
+                    ((x * y) % 2) + ((x * y) % 3),
+                    (((x * y) % 2) + ((x * y) % 3)) % 2,
+                    (((x + y) % 2) + ((x * y) % 3)) % 2,
+                ][mask];
+                if (flip === 0) {
+                    this.modules[y][x] = !this.modules[y][x];
+                }
+            }
+        }
+    }
+
+    /** How hard the code is to read with a mask: long runs, blocks, finder-like patterns, imbalance. */
+    protected penalty(): number {
+        let result = 0;
+        const line = (get: (i: number, j: number) => boolean) => {
+            for (let i = 0; i < this.size; i++) {
+                let run = 1;
+                const seen: boolean[] = [];
+                for (let j = 0; j < this.size; j++) {
+                    const dark = get(i, j);
+                    if (j > 0 && dark === get(i, j - 1)) {
+                        run++;
+                        if (run === 5) {
+                            result += 3;
+                        } else if (run > 5) {
+                            result++;
+                        }
+                    } else {
+                        run = 1;
+                    }
+                    seen.push(dark);
+                }
+                const text = seen.map(dark => (dark ? '1' : '0')).join('');
+                for (const pattern of ['10111010000', '00001011101']) {
+                    for (let at = text.indexOf(pattern); at >= 0; at = text.indexOf(pattern, at + 1)) {
+                        result += 40;
+                    }
+                }
+            }
+        };
+        line((i, j) => this.modules[i][j]);
+        line((i, j) => this.modules[j][i]);
+        let dark = 0;
+        for (let y = 0; y < this.size; y++) {
+            for (let x = 0; x < this.size; x++) {
+                const value = this.modules[y][x];
+                dark += value ? 1 : 0;
+                if (
+                    x < this.size - 1 &&
+                    y < this.size - 1 &&
+                    value === this.modules[y][x + 1] &&
+                    value === this.modules[y + 1][x] &&
+                    value === this.modules[y + 1][x + 1]
+                ) {
+                    result += 3;
+                }
+            }
+        }
+        const total = this.size * this.size;
+        result += Math.floor(Math.abs(dark * 20 - total * 10) / total) * 10;
+        return result;
+    }
+
+    protected static multiply(x: number, y: number): number {
+        let z = 0;
+        for (let i = 7; i >= 0; i--) {
+            z = (z << 1) ^ ((z >>> 7) * 0x11d);
+            z ^= ((y >>> i) & 1) * x;
+        }
+        return z & 0xff;
+    }
+
+    protected static reedSolomonDivisor(degree: number): number[] {
+        const result = new Array<number>(degree).fill(0);
+        result[degree - 1] = 1;
+        let root = 1;
+        for (let i = 0; i < degree; i++) {
+            for (let j = 0; j < result.length; j++) {
+                result[j] = QrCode.multiply(result[j], root);
+                if (j + 1 < result.length) {
+                    result[j] ^= result[j + 1];
+                }
+            }
+            root = QrCode.multiply(root, 0x02);
+        }
+        return result;
+    }
+
+    protected static reedSolomonRemainder(data: number[], divisor: number[]): number[] {
+        const result = new Array<number>(divisor.length).fill(0);
+        for (const byte of data) {
+            const factor = byte ^ (result.shift() as number);
+            result.push(0);
+            divisor.forEach((coefficient, i) => {
+                result[i] ^= QrCode.multiply(coefficient, factor);
+            });
+        }
+        return result;
+    }
+}

package/src/browser/util/tool.spec.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'bun:test';
+import type { ToolRun } from '@celljs/ta-client';
+import { ToolUtil } from './tool';
+
+describe('ToolUtil', () => {
+    it('says what a call does in one line', () => {
+        expect(ToolUtil.summary('bash', { command: 'npm test\nnpm run lint' })).toEqual({
+            verb: 'ta.tool.verb.bash',
+            name: 'bash',
+            target: 'npm test',
+            code: true,
+        });
+        expect(ToolUtil.summary('read', { path: 'a.ts', offset: 10, limit: 5 }).target).toBe('a.ts:10-14');
+        expect(ToolUtil.summary('start_task', { title: 'Fix the build', instructions: 'long' }).target).toBe('Fix the build');
+        expect(ToolUtil.summary('mcp_search', { limit: 3, query: 'cats' })).toEqual({ verb: undefined, name: 'mcp_search', target: 'cats', code: false });
+        expect(ToolUtil.scriptTitle('// @options: {}\n// read the config\nawait tools.read({})')).toBe('read the config');
+        expect(ToolUtil.scriptTitle('const a = 1;\nreturn a')).toBe('const a = 1;');
+    });
+
+    it('joins the record of a script with its live runs, and falls back to the record on the result message', () => {
+        const runs: Record<string, ToolRun> = {
+            'c1/1': { toolName: 'read', args: { path: 'a.ts' }, status: 'done', parentToolCallId: 'c1' },
+            'c1/2': { toolName: 'bash', args: { command: 'ls' }, status: 'running', parentToolCallId: 'c1' },
+        };
+        const details = {
+            calls: [
+                { id: 'c1/1', name: 'read', args: '{"path":"a.ts"}', status: 'ok', durationMs: 3 },
+                { id: 'c1/?', name: 'bash', args: '{"command":"ls"}', status: 'running' },
+            ],
+        };
+        const calls = ToolUtil.nestedCalls('c1', { details }, runs);
+        expect(calls.map(call => [call.key, call.status, call.run === runs[call.key]])).toEqual([
+            ['c1/1', 'done', true],
+            ['c1#1', 'running', false],
+        ]);
+        expect(calls[1].run).toBe(runs['c1/2']);
+        const kept = ToolUtil.nestedCalls(
+            'c1',
+            { nestedCalls: { calls: [{ id: 'c1/1', name: 'edit', arguments: { path: 'b.ts' }, status: 'error', error: 'no match' }] } } as never,
+            {},
+        );
+        expect(kept).toEqual([{ key: 'c1/1', name: 'edit', args: { path: 'b.ts' }, status: 'error', durationMs: undefined, error: 'no match' }]);
+    });
+
+    it('counts the calls of a script as steps, and a script that failed on its own as a failed one', () => {
+        const results = new Map([
+            [
+                's1',
+                {
+                    details: {
+                        calls: [
+                            { name: 'read', status: 'ok' },
+                            { name: 'edit', status: 'error' },
+                        ],
+                    },
+                },
+            ],
+            ['s2', { isError: true, details: { calls: [{ name: 'read', status: 'ok' }] } }],
+            ['b1', { content: [] }],
+        ]);
+        const calls = [
+            { type: 'toolCall', id: 's1', name: 'codemode' },
+            { type: 'toolCall', id: 's2', name: 'codemode' },
+            { type: 'toolCall', id: 'b1', name: 'bash' },
+        ];
+        expect(ToolUtil.count(calls, results, {})).toEqual({ steps: 4, failed: 2 });
+    });
+
+    it('finds the call a session runs now: the latest started', () => {
+        const runs: Record<string, ToolRun> = {
+            c1: { toolName: 'codemode', args: {}, status: 'running' },
+            'c1/1': { toolName: 'bash', args: {}, status: 'running', parentToolCallId: 'c1' },
+            c0: { toolName: 'read', args: {}, status: 'done' },
+        };
+        expect(ToolUtil.current(runs)?.toolName).toBe('bash');
+        expect(ToolUtil.current({})).toBeUndefined();
+    });
+});