@celljs/ta-web 0.0.0-stage → 4.6.1

package/src/browser/util/message.ts

@@ -0,0 +1,188 @@
+import type { SessionMessage, ToolRun } from '@celljs/ta-client';
+
+export interface ContentBlock {
+    type: string;
+    text?: string;
+    thinking?: string;
+    id?: string;
+    name?: string;
+    arguments?: unknown;
+    data?: string;
+    mimeType?: string;
+}
+
+/** What a tool returned: pi's `AgentToolResult`, live or from the tool result message. */
+export interface ToolOutput {
+    content?: ContentBlock[];
+    details?: Record<string, unknown>;
+    isError?: boolean;
+    /** Milliseconds the call took, on the result message. */
+    durationMs?: number;
+}
+
+/** What the models of a turn took: the context of each request summed, as the run status counts it. */
+export interface TurnUsage {
+    input: number;
+    output: number;
+    /** In dollars; 0 when the price of the model is not known. */
+    cost: number;
+}
+
+/** When a message came: `date` is set for a day before the day before yesterday. */
+export interface MessageTime {
+    day: 'today' | 'yesterday' | 'dayBefore' | 'date';
+    time: string;
+    date?: string;
+}
+
+interface Usage {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    cost?: { total?: number };
+}
+
+interface Entry {
+    id: string;
+    type: string;
+    message?: { role?: string; timestamp?: number };
+}
+
+const SCRIPT_HEADER = /^Script (completed|failed)\nWall time [\d.]+ seconds\nOutput:\n/;
+
+export namespace MessageUtil {
+    export function blocks(message: SessionMessage): ContentBlock[] {
+        const content = (message as { content?: unknown }).content;
+        if (typeof content === 'string') {
+            return [{ type: 'text', text: content }];
+        }
+        return Array.isArray(content) ? (content as ContentBlock[]) : [];
+    }
+
+    export function text(content: ContentBlock[] | string | undefined): string {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return (content ?? [])
+            .filter(block => block.type === 'text')
+            .map(block => block.text ?? '')
+            .join('\n');
+    }
+
+    /** The tool result messages of a conversation by tool call id: shown with their calls. */
+    export function results(messages: SessionMessage[]): Map<string, ToolOutput> {
+        const results = new Map<string, ToolOutput>();
+        for (const message of messages) {
+            const { role, toolCallId } = message as { role: string; toolCallId?: string };
+            if (role === 'toolResult' && toolCallId) {
+                results.set(toolCallId, message as unknown as ToolOutput);
+            }
+        }
+        return results;
+    }
+
+    /** The live run wins over the message: it has the partial results and the diffs of nested calls. */
+    export function output(run: ToolRun | undefined, message: ToolOutput | undefined): ToolOutput | undefined {
+        const live = run?.result as ToolOutput | undefined;
+        if (live && (live.content || live.details)) {
+            return { ...live, isError: run?.status === 'error' };
+        }
+        return message;
+    }
+
+    export function status(run: ToolRun | undefined, output: ToolOutput | undefined): 'running' | 'done' | 'error' {
+        if (run) {
+            return run.status;
+        }
+        if (!output) {
+            return 'running';
+        }
+        return output.isError ? 'error' : 'done';
+    }
+
+    /**
+     * The id of the entry of the session that holds a message: pi's messages carry no id, but each the
+     * time it was made, and entries of other branches have other times.
+     */
+    export function entryId(entries: readonly Entry[], message: SessionMessage): string | undefined {
+        const { role, timestamp } = message as { role?: string; timestamp?: number };
+        if (timestamp === undefined) {
+            return undefined;
+        }
+        for (let index = entries.length - 1; index >= 0; index--) {
+            const entry = entries[index];
+            if (entry.type === 'message' && entry.message?.role === role && entry.message?.timestamp === timestamp) {
+                return entry.id;
+            }
+        }
+        return undefined;
+    }
+
+    export function usage(messages: readonly SessionMessage[]): TurnUsage {
+        const total: TurnUsage = { input: 0, output: 0, cost: 0 };
+        for (const message of messages) {
+            const usage = (message as { role: string; usage?: Usage }).role === 'assistant' ? (message as { usage?: Usage }).usage : undefined;
+            if (usage) {
+                total.input += (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+                total.output += usage.output ?? 0;
+                total.cost += usage.cost?.total ?? 0;
+            }
+        }
+        return total;
+    }
+
+    /** $0.0042 below a cent, else $1.23: enough to tell turns apart. */
+    export function cost(dollars: number): string {
+        return `$${dollars < 0.01 ? dollars.toFixed(4) : dollars.toFixed(2)}`;
+    }
+
+    /**
+     * When a message came, as short as it can be said: the time today, yesterday and the day before with
+     * their word, else the date (with the year only when it is not this one).
+     */
+    export function when(timestamp: number, now = Date.now()): MessageTime {
+        const date = new Date(timestamp);
+        const pad = (value: number) => String(value).padStart(2, '0');
+        const time = `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+        const midnight = (value: Date) => new Date(value.getFullYear(), value.getMonth(), value.getDate()).getTime();
+        const days = Math.round((midnight(new Date(now)) - midnight(date)) / 86_400_000);
+        if (days === 0) {
+            return { day: 'today', time };
+        }
+        if (days === 1 || days === 2) {
+            return { day: days === 1 ? 'yesterday' : 'dayBefore', time };
+        }
+        const day = `${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+        return { day: 'date', date: date.getFullYear() === new Date(now).getFullYear() ? day : `${date.getFullYear()}-${day}`, time };
+    }
+
+    /** The output of a codemode script without the header the model needs and a person does not. */
+    export function scriptOutput(output: string): string {
+        return output.replace(SCRIPT_HEADER, '');
+    }
+
+    export function duration(ms: number | undefined): string {
+        if (ms === undefined) {
+            return '';
+        }
+        return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+    }
+
+    /** The last `count` lines, and how many were left out. */
+    export function tail(text: string, count: number): { text: string; hidden: number } {
+        const lines = text.split('\n');
+        return lines.length <= count ? { text, hidden: 0 } : { text: lines.slice(-count).join('\n'), hidden: lines.length - count };
+    }
+
+    /** The last two parts of a path: enough to recognize a project. */
+    export function shortPath(path: string): string {
+        const parts = path.split(/[\\/]/).filter(Boolean);
+        return parts.length > 2 ? `…/${parts.slice(-2).join('/')}` : path;
+    }
+
+    export function basename(path: string): string {
+        const parts = path.split(/[\\/]/).filter(Boolean);
+        return parts[parts.length - 1] ?? path;
+    }
+}

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

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'bun:test';
+import type { SessionMessage } from '@celljs/ta-client';
+import { ProcessUtil, type TurnItem } from './process';
+
+const messages = (...list: unknown[]) => list as SessionMessage[];
+const user = (text: string) => ({ role: 'user', content: text });
+const call = (id: string, name = 'bash') => ({ type: 'toolCall', id, name, arguments: {} });
+const result = (id: string) => ({ role: 'toolResult', toolCallId: id, content: [{ type: 'text', text: 'ok' }] });
+
+describe('ProcessUtil', () => {
+    it('folds thinking, tool calls and the text on the way into the work of a turn, and keeps the last text as the reply', () => {
+        const items = ProcessUtil.items(
+            messages(
+                user('fix it'),
+                { role: 'assistant', content: [{ type: 'thinking', thinking: 'look first' }, { type: 'text', text: 'Reading.' }, call('c1', 'read')] },
+                result('c1'),
+                { role: 'assistant', content: [call('c2', 'edit')] },
+                result('c2'),
+                {
+                    role: 'assistant',
+                    content: [
+                        { type: 'thinking', thinking: 'done?' },
+                        { type: 'text', text: 'Fixed.' },
+                    ],
+                    stopReason: 'stop',
+                },
+            ),
+            false,
+        );
+        expect(items.map(item => item.kind)).toEqual(['message', 'turn']);
+        const turn = items[1] as TurnItem;
+        expect(turn.steps.map(step => step.kind)).toEqual(['thinking', 'text', 'tool', 'tool', 'thinking']);
+        expect(ProcessUtil.tools(turn.steps).map(block => block.id)).toEqual(['c1', 'c2']);
+        expect(turn.reply).toEqual(['Fixed.']);
+        expect(turn.messages).toHaveLength(5);
+        expect((turn.last as { stopReason?: string }).stopReason).toBe('stop');
+        expect(turn.active).toBe(false);
+    });
+
+    it('has no work for a plain answer, and no reply while the last thing is a tool call', () => {
+        const plain = ProcessUtil.items(messages(user('hi'), { role: 'assistant', content: [{ type: 'text', text: 'Hello' }] }), false)[1] as TurnItem;
+        expect(plain.steps).toEqual([]);
+        expect(plain.reply).toEqual(['Hello']);
+        const running = ProcessUtil.items(
+            messages(user('go'), { role: 'assistant', content: [{ type: 'text', text: 'On it' }, call('c1')] }),
+            true,
+        )[1] as TurnItem;
+        expect(running.reply).toEqual([]);
+        expect(running.steps.map(step => step.kind)).toEqual(['text', 'tool']);
+        expect(running.active).toBe(true);
+    });
+
+    it('is active only for the last turn while the agent works, and a message of the user splits turns', () => {
+        const items = ProcessUtil.items(
+            messages(user('a'), { role: 'assistant', content: [call('c1')] }, result('c1'), user('steer'), { role: 'assistant', content: [] }),
+            true,
+        );
+        expect(items.map(item => (item.kind === 'turn' ? `turn:${item.active}` : 'message'))).toEqual(['message', 'turn:false', 'message', 'turn:true']);
+    });
+
+    it('has the turn of an answer that has not come yet, under the key the answer takes', () => {
+        const asked = messages(user('a'));
+        const waiting = ProcessUtil.items(asked, true);
+        expect(waiting.map(item => item.kind)).toEqual(['message', 'turn']);
+        expect(waiting[1]).toMatchObject({ key: 't1', steps: [], reply: [], active: true });
+        expect(ProcessUtil.items(messages(...asked, { role: 'assistant', content: [] }), true)[1].key).toBe('t1');
+        expect(ProcessUtil.items(asked, false)).toHaveLength(1);
+    });
+
+    it('gives items keys that stay while the conversation grows', () => {
+        const first = messages(user('a'), { role: 'assistant', content: [call('c1')] });
+        const grown = messages(...first, result('c1'), { role: 'assistant', content: [{ type: 'text', text: 'ok' }] }, user('b'));
+        const keys = ProcessUtil.items(first, true).map(item => item.key);
+        expect(
+            ProcessUtil.items(grown, false)
+                .map(item => item.key)
+                .slice(0, keys.length),
+        ).toEqual(keys);
+        expect(ProcessUtil.items(first, true)[1]).toMatchObject({ steps: [{ key: 'c1' }] });
+    });
+
+    it('tells items apart by the identity of their messages, so that unchanged ones are not drawn again', () => {
+        const list = messages(user('a'), { role: 'assistant', content: [call('c1')] }, result('c1'));
+        const before = ProcessUtil.items(list, true);
+        const after = ProcessUtil.items([...list], true);
+        expect(ProcessUtil.same(before[0], after[0])).toBe(true);
+        expect(ProcessUtil.same(before[1], after[1])).toBe(true);
+        const changed = ProcessUtil.items([list[0], { ...(list[1] as object) } as SessionMessage, list[2]], true);
+        expect(ProcessUtil.same(before[1], changed[1])).toBe(false);
+        expect(ProcessUtil.same(before[1], ProcessUtil.items(list, false)[1])).toBe(false);
+    });
+
+    it('shows the latest steps while it works, unless only one or two would fold', () => {
+        const steps = Array.from({ length: 12 }, (_, index) => ({ kind: 'text' as const, key: String(index), text: '' }));
+        expect(ProcessUtil.fold(steps, true, false)).toMatchObject({ hidden: 4 });
+        expect(ProcessUtil.fold(steps, true, false).steps[0].key).toBe('4');
+        expect(ProcessUtil.fold(steps.slice(0, 10), true, false).hidden).toBe(0);
+        expect(ProcessUtil.fold(steps, false, false).hidden).toBe(0);
+        expect(ProcessUtil.fold(steps, true, true).hidden).toBe(0);
+    });
+
+    it('previews a thought in one line without markdown', () => {
+        expect(ProcessUtil.preview('**Plan**\n- read `a.ts`\n- fix')).toBe('Plan - read a.ts - fix');
+        expect(ProcessUtil.preview('x'.repeat(10), 5)).toBe('xxxx…');
+    });
+
+    it('knows whether ta thinks, works or writes', () => {
+        expect(ProcessUtil.phase(messages(user('a')))).toBe('thinking');
+        expect(ProcessUtil.phase(messages({ role: 'assistant', content: [{ type: 'thinking', thinking: '' }] }))).toBe('thinking');
+        expect(ProcessUtil.phase(messages({ role: 'assistant', content: [call('c1')] }))).toBe('working');
+        expect(ProcessUtil.phase(messages({ role: 'assistant', content: [{ type: 'text', text: 'a' }] }))).toBe('writing');
+        expect(ProcessUtil.phase(messages({ role: 'assistant', content: [call('c1')] }, result('c1')))).toBe('thinking');
+    });
+
+    it('shows on the face of ta what a turn did: at work, done, needing you after an error, calm before', () => {
+        const turn = (last: object, active = false) => ({
+            kind: 'turn' as const,
+            key: 't',
+            messages: [last as SessionMessage],
+            steps: [],
+            reply: [],
+            last: last as SessionMessage,
+            active,
+        });
+        expect(ProcessUtil.mood(turn({ role: 'assistant', content: [call('c1')] }, true), true, false)).toBe('working');
+        expect(ProcessUtil.mood(turn({ role: 'assistant', content: [{ type: 'text', text: 'a' }] }, true), true, false)).toBe('speaking');
+        expect(ProcessUtil.mood(turn({ role: 'assistant', content: [] }, true), true, true)).toBe('attention');
+        expect(ProcessUtil.mood(turn({ role: 'assistant', content: [], stopReason: 'stop' }), true, false)).toBe('done');
+        expect(ProcessUtil.mood(turn({ role: 'assistant', content: [], stopReason: 'stop' }), false, false)).toBe('idle');
+        expect(ProcessUtil.mood(turn({ role: 'assistant', content: [], stopReason: 'error' }), false, false)).toBe('attention');
+        expect(ProcessUtil.mood(turn({ role: 'assistant', content: [], stopReason: 'aborted' }), true, false)).toBe('idle');
+    });
+});

package/src/browser/util/process.ts

@@ -0,0 +1,166 @@
+import type { SessionMessage } from '@celljs/ta-client';
+import type { Mood } from '../avatar/dino-avatar';
+import { type ContentBlock, MessageUtil } from './message';
+
+/** One step of the work of ta between two messages of the user. */
+export type ProcessStep =
+    | { kind: 'thinking'; key: string; text: string }
+    | { kind: 'text'; key: string; text: string }
+    | { kind: 'tool'; key: string; call: ContentBlock };
+
+/** A message shown as it is: from the user, a `!command`, a message of an extension, a summary. */
+export interface MessageItem {
+    kind: 'message';
+    key: string;
+    message: SessionMessage;
+}
+
+/**
+ * The assistant and tool result messages in a row: the work (thinking, tool calls, what ta said on
+ * the way) folds into one line, and the text ta ends with is the reply.
+ */
+export interface TurnItem {
+    kind: 'turn';
+    key: string;
+    /** The messages it is made of; the same objects while they do not change. */
+    messages: SessionMessage[];
+    steps: ProcessStep[];
+    /** The text at the end, after the last tool call. */
+    reply: string[];
+    /** The last assistant message: its stop reason and error. */
+    last?: SessionMessage;
+    /** The agent is still at it. */
+    active: boolean;
+}
+
+export type ThreadItem = MessageItem | TurnItem;
+
+/** While the agent works, only the latest steps show; the earlier ones fold into one row. */
+export const VISIBLE_STEPS = 8;
+
+const TURN_ROLES = new Set(['assistant', 'toolResult']);
+
+/**
+ * How the conversation is laid out (thinking and tool calls folded into steps): pure functions over pi's
+ * messages, so that a component only draws what they return.
+ */
+export namespace ProcessUtil {
+    /**
+     * The items of the conversation. While the agent works and has not answered yet, its turn is there
+     * already, empty, with the key the turn will have: the head drawn while it waits is the one its answer
+     * fills, not another put in its place.
+     */
+    export function items(messages: SessionMessage[], working: boolean): ThreadItem[] {
+        const items: ThreadItem[] = [];
+        let index = 0;
+        while (index < messages.length) {
+            const role = (messages[index] as { role: string }).role;
+            if (!TURN_ROLES.has(role)) {
+                items.push({ kind: 'message', key: `m${index}`, message: messages[index] });
+                index++;
+                continue;
+            }
+            const start = index;
+            while (index < messages.length && TURN_ROLES.has((messages[index] as { role: string }).role)) {
+                index++;
+            }
+            items.push(turn(messages.slice(start, index), start, working && index === messages.length));
+        }
+        if (working && items[items.length - 1]?.kind !== 'turn') {
+            items.push({ kind: 'turn', key: `t${messages.length}`, messages: [], steps: [], reply: [], active: true });
+        }
+        return items;
+    }
+
+    function turn(messages: SessionMessage[], start: number, active: boolean): TurnItem {
+        const steps: ProcessStep[] = [];
+        let last: SessionMessage | undefined;
+        messages.forEach((message, offset) => {
+            if ((message as { role: string }).role !== 'assistant') {
+                return;
+            }
+            last = message;
+            MessageUtil.blocks(message).forEach((block, position) => {
+                const key = `${start + offset}.${position}`;
+                if (block.type === 'thinking' && block.thinking?.trim()) {
+                    steps.push({ kind: 'thinking', key, text: block.thinking });
+                } else if (block.type === 'text' && block.text?.trim()) {
+                    steps.push({ kind: 'text', key, text: block.text });
+                } else if (block.type === 'toolCall') {
+                    steps.push({ kind: 'tool', key: block.id || key, call: block });
+                }
+            });
+        });
+        let end = steps.length;
+        while (end > 0 && steps[end - 1].kind === 'text') {
+            end--;
+        }
+        const reply = steps.slice(end).map(step => (step.kind === 'text' ? step.text : ''));
+        return { kind: 'turn', key: `t${start}`, messages, steps: steps.slice(0, end), reply, last, active };
+    }
+
+    /** The tool calls: what "N steps" counts. */
+    export function tools(steps: ProcessStep[]): ContentBlock[] {
+        return steps.flatMap(step => (step.kind === 'tool' ? [step.call] : []));
+    }
+
+    /** The steps shown: all of them, or while it works the latest few when more than two would fold. */
+    export function fold(steps: ProcessStep[], active: boolean, showAll: boolean, visible = VISIBLE_STEPS): { hidden: number; steps: ProcessStep[] } {
+        if (!active || showAll || steps.length <= visible + 2) {
+            return { hidden: 0, steps };
+        }
+        return { hidden: steps.length - visible, steps: steps.slice(-visible) };
+    }
+
+    /** One line of thinking, without markdown: what a folded thought shows. */
+    export function preview(text: string, length = 120): string {
+        const line = text
+            .replace(/\*\*([^*]+)\*\*/g, '$1')
+            .replace(/[`*_#>]+/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        return line.length > length ? `${line.slice(0, length - 1)}…` : line;
+    }
+
+    /** What ta does now, by the last block of the conversation: for its face and the working line. */
+    export function phase(messages: SessionMessage[]): 'thinking' | 'working' | 'writing' {
+        const last = messages[messages.length - 1] as { role?: string } | undefined;
+        if (last?.role !== 'assistant') {
+            // Waiting for the model: after a message of the user or the result of a tool.
+            return 'thinking';
+        }
+        const blocks = MessageUtil.blocks(last as SessionMessage);
+        const block = blocks[blocks.length - 1];
+        if (!block || block.type === 'thinking') {
+            return 'thinking';
+        }
+        return block.type === 'text' ? 'writing' : 'working';
+    }
+
+    /**
+     * The face of ta at the head of a turn: what it does while it works (it needs you while a dialog
+     * waits), then done for the last turn, needing you after an error, and calm for the rest.
+     */
+    export function mood(item: TurnItem, last: boolean, waiting: boolean): Mood {
+        if (item.active) {
+            if (waiting) {
+                return 'attention';
+            }
+            const phase = ProcessUtil.phase(item.messages);
+            return phase === 'thinking' ? 'thinking' : phase === 'writing' ? 'speaking' : 'working';
+        }
+        const { stopReason } = (item.last ?? {}) as { stopReason?: string };
+        if (stopReason === 'error') {
+            return 'attention';
+        }
+        return last && stopReason !== 'aborted' ? 'done' : 'idle';
+    }
+
+    /** The two items show the same: their messages are the same objects, and so is whether it works. */
+    export function same(a: ThreadItem, b: ThreadItem): boolean {
+        if (a.kind === 'message' || b.kind === 'message') {
+            return a.kind === b.kind && (a as MessageItem).message === (b as MessageItem).message;
+        }
+        return a.active === b.active && a.messages.length === b.messages.length && a.messages.every((message, index) => message === b.messages[index]);
+    }
+}

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

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'bun:test';
+import { SessionReducer, type SessionState } from '@celljs/ta-client';
+import { ProgressUtil } from './progress';
+
+const state = (messages: unknown[], change: Partial<SessionState> = {}): SessionState => ({
+    ...SessionReducer.initial(),
+    working: true,
+    messages: messages as never,
+    ...change,
+});
+const user = (text: string) => ({ role: 'user', content: [{ type: 'text', text }] });
+const usage = (input: number, output: number, cacheRead = 0) => ({ input, output, cacheRead, cacheWrite: 0 });
+
+describe('ProgressUtil', () => {
+    it('says what ta does now, from the last block of the conversation', () => {
+        expect(ProgressUtil.phase(state([user('hi')]))).toEqual({ kind: 'waiting' });
+        expect(ProgressUtil.phase(state([user('hi'), { role: 'assistant', content: [] }]))).toEqual({ kind: 'waiting' });
+        expect(ProgressUtil.phase(state([user('hi'), { role: 'assistant', content: [{ type: 'thinking', thinking: 'hm' }] }]))).toEqual({ kind: 'thinking' });
+        expect(ProgressUtil.phase(state([user('hi'), { role: 'assistant', content: [{ type: 'text', text: 'So' }] }]))).toEqual({ kind: 'writing' });
+        expect(ProgressUtil.phase(state([user('hi'), { role: 'assistant', content: [{ type: 'toolCall', name: 'bash', arguments: {} }] }]))).toEqual({
+            kind: 'calling',
+            tool: 'bash',
+        });
+        // A tool has answered: the next request is the model's.
+        expect(ProgressUtil.phase(state([user('hi'), { role: 'assistant', content: [], stopReason: 'toolUse' }, { role: 'toolResult', content: [] }]))).toEqual(
+            {
+                kind: 'waiting',
+            },
+        );
+    });
+
+    it('puts a running tool, a dialog, a compaction and a retry before what the model does', () => {
+        const tools = { c1: { toolName: 'bash', args: { command: 'npm test' }, status: 'running' as const } };
+        expect(ProgressUtil.phase(state([user('hi')], { tools }))).toMatchObject({ kind: 'tool', summary: { verb: 'ta.tool.verb.bash', target: 'npm test' } });
+        expect(ProgressUtil.phase(state([user('hi')], { compacting: 'overflow' })).kind).toBe('compacting');
+        expect(ProgressUtil.phase(state([user('hi')], { retry: { attempt: 2, maxAttempts: 3, delayMs: 4000, errorMessage: 'e' } }))).toEqual({
+            kind: 'retrying',
+            attempt: 2,
+            maxAttempts: 3,
+            seconds: 4,
+        });
+        expect(ProgressUtil.phase(state([user('hi')], { tools, pendingUi: [{ id: 'u', method: 'confirm' } as never] })).kind).toBe('attention');
+    });
+
+    it('counts the tokens of the run: what the model counted, and an estimate for what it has not counted yet', () => {
+        const before = [user('old'), { role: 'assistant', content: [{ type: 'text', text: 'done' }], usage: usage(1000, 100) }];
+        // Sent: the context of the last request, its answer and the new message, which has 8 characters.
+        const sent = state([...before, user('12345678')], { runStart: 2 });
+        expect(ProgressUtil.tokens(sent)).toEqual({ input: 1102, output: 0 });
+        // The model streams 40 characters and has counted nothing yet.
+        const streaming = state([...sent.messages, { role: 'assistant', content: [{ type: 'text', text: 'x'.repeat(40) }], usage: usage(0, 0) }], {
+            runStart: 2,
+        });
+        expect(ProgressUtil.tokens(streaming)).toEqual({ input: 1102, output: 10 });
+        // It has: its count, with the cache, wins; a second request adds its own context.
+        const counted = state(
+            [
+                ...sent.messages,
+                { role: 'assistant', content: [{ type: 'toolCall', name: 'bash', arguments: {} }], usage: usage(100, 30, 1000), stopReason: 'toolUse' },
+                { role: 'toolResult', content: [{ type: 'text', text: 'y'.repeat(400) }] },
+            ],
+            { runStart: 2 },
+        );
+        expect(ProgressUtil.tokens(counted)).toEqual({ input: 1100 + 1130 + 100, output: 30 });
+        // The model has begun its answer to that request, and has said nothing yet: it counts once.
+        const begun = state([...counted.messages, { role: 'assistant', content: [], usage: usage(0, 0) }], { runStart: 2 });
+        expect(ProgressUtil.tokens(begun)).toEqual(ProgressUtil.tokens(counted));
+    });
+
+    it('sends nothing it knows of before the model has counted a request of the session', () => {
+        expect(ProgressUtil.tokens(state([user('hello')], { runStart: 0 }))).toEqual({ input: 0, output: 0 });
+    });
+
+    it('starts the run after the last message of the user when it did not see it start', () => {
+        expect(ProgressUtil.runStart(state([user('a'), { role: 'assistant', content: [] }, user('b')]))).toBe(2);
+        expect(ProgressUtil.runStart(state([user('a'), user('b')], { runStart: 1 }))).toBe(1);
+    });
+
+    it('writes counts short', () => {
+        expect(ProgressUtil.format(999)).toBe('999');
+        expect(ProgressUtil.format(1000)).toBe('1k');
+        expect(ProgressUtil.format(23456)).toBe('23.5k');
+        expect(ProgressUtil.format(123456)).toBe('123k');
+        expect(ProgressUtil.format(1_250_000)).toBe('1.3M');
+    });
+});