Something went wrong. Try again.
small gleam coding and persistent agent daemon with a detachable cli and a canvas ui forked from okami.mom/albedo
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676import { getShellCommand, readEntryContent, readHistory, readRequests, sendMessage, uuidv7, type ContentPart, type HistoryEntry, type Phase, type SkillLoad, type ShellCommand } from './api';import type { Trace } from './burst';import type { Attached } from './chat/attachments';import type { Usage } from './context';import { follow, type Batch } from './stream';import { formatGap, outcome, type Mood } from './moods';
// One session's transcript as the chat shows it. Entries arrive as history// pages; blocks are what the chat draws. Content a page only referenced is// fetched when needed: messages and shell receipts at once, tool output on opening.
/** Why a turn failed: the error's own words, and all it said. */type Failure = { text: string; detail: string };
export type Block = | { kind: 'user'; key: string; text: string; images: Picture[]; from: string | null; gap: string | null; at: number; state: 'sending' | 'sent' | 'seen' | 'failed'; error?: string; skill?: string } | { kind: 'assistant'; key: string; text: string; plate: boolean } | { kind: 'thinking'; key: string; text: string; ms: number | null } | { kind: 'tool'; key: string; name: string; entry: HistoryEntry; done: boolean; trace?: Trace; failed: boolean } | { kind: 'note'; key: string; text: string } | { kind: 'compaction'; key: string; text: string } | ({ kind: 'failure'; key: string } & Failure) | { kind: 'end'; key: string; turnId: string | null; from: number; mood: Mood; seed: number; elapsedMs: number; tools: number; text: string; changed: { files: number; added: number; removed: number } } | { kind: 'progress'; key: string; name: string; title?: string | null; preview: string } | { kind: 'shell'; key: string; command: ShellCommand };
/** An artifact a cell made or revised: its id, the version, and its title. */export interface Made { id: string; version: number; title: string;}
/** The artifacts a trace says its cell made or revised. */export function madeIn(trace: Trace | undefined): Made[] { return (trace?.activities ?? []).flatMap((activity) => activity.kind === 'artifact' && activity.artifact ? [{ id: activity.artifact.id, version: activity.artifact.version, title: activity.target }] : [], );}
/** The skills a trace says its cell loaded, by name. */export function loadedIn(trace: Trace | undefined): string[] { return (trace?.activities ?? []).flatMap((activity) => (activity.kind === 'skill' ? [activity.target] : []));}
/** Output the session is writing now, before it commits: one message of thinking or reply. */interface Live { id: string; kind: 'text' | 'thinking'; text: string;}
/** A tool call running now, as its progress reports it. */interface Progress { id: string; /** The model's id for the call, which its tool_call entry carries too. */ call: string; name: string; title?: string | null; preview: string;}
interface Turn { id: string | null; /** The turn's first history position, where a review starts reading. */ from: number; start: number; last: number; tools: number; answered: boolean; files: Set<string>; added: number; removed: number; /** The turn's last reply, which its copy action copies. */ text: string;}
/** The pause before your message that earns a "later" note, as in the TUI. */const AWAY_MS = 30 * 60_000;
/** A turn's run of thinking and tool use, drawn as one collapsible step list. */export type Group = { kind: 'work'; key: string; steps: Block[] } | Block;
/** An image in a message: where to load it, and its size when known. */export interface Picture { src: string; width?: number; height?: number;}
interface Pending { id: string; text: string; images: Attached[]; at: number; /** The daemon has it, waiting for the loop to take it into the conversation. */ accepted?: boolean; error?: string;}
/** The images a user entry carries; the daemon serves each under its reference. */function picturesOf(entry: HistoryEntry): Picture[] { return entry.content.flatMap((part) => (part.kind === 'image' && part.image.reference ? [{ src: `/api${part.image.reference.url}`, width: part.image.width, height: part.image.height }] : []));}
function textOf(content: ContentPart[]): string { return content.map((part) => (part.kind === 'text' ? part.text : '')).join('');}
/** The value of a JSON field of an entry, if the page carried it inline. */export function jsonField(entry: HistoryEntry, field: string): unknown { for (const part of entry.content) if (part.kind === 'json' && part.field === field) return part.value; return undefined;}
function traceOf(entry: HistoryEntry): Trace | undefined { for (const part of entry.content) if (part.kind === 'trace') return part.trace; return undefined;}
/** A python cell that raised, read from its result envelope. */export function failedTool(entry: HistoryEntry): boolean { const result = jsonField(entry, 'result'); if (typeof result !== 'string') return false; try { return JSON.parse(result)?.status === 'error'; } catch { return false; }}
function progressOf(progress: any): Progress { return { id: progress?.call_id ?? '', call: progress?.tool_call_id ?? '', name: progress?.name ?? 'tool', title: progress?.title ?? undefined, preview: progress?.preview?.text ?? '' };}
/** An error as one line: the message inside the provider's JSON body when it carries one. */function failureLine(detail: string): string { const body = detail.slice(detail.indexOf('{'), detail.lastIndexOf('}') + 1); // The stream's error quotes the body inside the transport's own words. for (const candidate of [body, body.replaceAll('\\"', '"')]) { try { const parsed = JSON.parse(candidate); const message = parsed?.error?.message ?? parsed?.message; if (typeof message === 'string' && message.trim()) return message.trim(); } catch {} } return detail.trim().split('\n')[0];}
const failureOf = (detail: string): Failure => ({ text: failureLine(detail), detail: detail.trim() });
const at = (entry: HistoryEntry) => (entry.created_at ? Date.parse(entry.created_at) : 0);
function shellCommandOf(value: unknown): ShellCommand | null { if (!value || typeof value !== 'object') return null; const command = value as Record<string, unknown>; if ( typeof command.id !== 'string' || typeof command.command !== 'string' || !['running', 'completed', 'cancelled', 'interrupted', 'failed'].includes(String(command.status)) || (command.exit_code !== null && typeof command.exit_code !== 'number') || typeof command.output !== 'string' || typeof command.output_bytes !== 'number' || typeof command.truncated !== 'boolean' || (command.error !== null && typeof command.error !== 'string') || (command.history_seq !== null && typeof command.history_seq !== 'number') || (command.delivery !== undefined && !['unknown', 'pending', 'delivered', 'detached'].includes(String(command.delivery))) ) return null; return { ...value as ShellCommand, delivery: command.delivery as ShellCommand['delivery'] ?? 'unknown' };}
/** HTTP admission replies can lag behind completion/ACK events. Neither may undo an acknowledgment. */function mergeShell(previous: ShellCommand, next: ShellCommand): ShellCommand { const stale = next.delivery !== 'detached' && ( previous.delivery === 'detached' || (previous.delivery === 'delivered' && next.delivery !== 'delivered') || (previous.status !== 'running' && next.status === 'running') || (previous.history_seq !== null && next.history_seq === null) || previous.output_bytes > next.output_bytes ); const latest = stale ? previous : next; // Reset/events carry a smaller head than hydrated history; keep the richer preview. const output = previous.output.length > next.output.length ? previous.output : next.output; return latest.output === output ? latest : { ...latest, output };}
function referenced(entry: HistoryEntry): boolean { return entry.content.some((part) => part.kind === 'reference' && !part.reference.field.startsWith('image-'));}
/** What a tool result that just arrived made, reading its trace if the page only referenced it. */async function madeBy(entry: HistoryEntry): Promise<Made[]> { if (entry.kind !== 'tool_result') return []; const traced = entry.content.some((part) => part.kind === 'reference' && part.reference.field === 'trace') ? await hydrate(entry) : entry; return madeIn(traceOf(traced));}
/** Replaces an entry's references with the content they name. */export async function hydrate(entry: HistoryEntry): Promise<HistoryEntry> { if (!referenced(entry)) return { ...entry, content_complete: true }; const urls = new Set(entry.content.flatMap((part) => (part.kind === 'reference' ? [part.reference.url] : []))); const loaded = new Map<string, Record<string, string>>(); await Promise.all([...urls].map(async (url) => loaded.set(url, await readEntryContent(url)))); const content = entry.content.map((part): ContentPart => { if (part.kind !== 'reference' || part.reference.field.startsWith('image-')) return part; const { url, field } = part.reference; const raw = loaded.get(url)?.[field] ?? ''; if (field === 'text') return { kind: 'text', text: raw }; if (field === 'trace') return { kind: 'trace', trace: JSON.parse(raw) }; return { kind: 'json', field, value: JSON.parse(raw) }; }); return { ...entry, content, content_complete: true };}
export class Transcript { entries = $state.raw<HistoryEntry[]>([]); pending = $state.raw<Pending[]>([]); loading = $state(true); /** Whether the session is busy, so its newest turn is not signed off yet. */ running = $state(false); /** The phase the stream last reported, fresher than the session list's. */ phase = $state<Phase | null>(null); streaming = $state(false); live = $state.raw<Live[]>([]); progress = $state.raw<Progress[]>([]); shellCommands = $state.raw<ShellCommand[]>([]); #stop: (() => void) | null = null; #settle: ReturnType<typeof setTimeout> | undefined; #replacing: 'all' | string[] = []; more = $state(false); error = $state<string | null>(null); /** * Artifacts made or revised since the chat opened, oldest first, so the * chat can open them as they arrive; history read on opening never adds. */ made = $state.raw<Made[]>([]);
/** Why turns failed, by run id: the stream's error, then the failed model call's own record. */ failures = $state.raw<Record<string, Failure>>({}); /** * Whether each run's last model call read so far failed. A later call * clears only a failure a call set: one the stream reported after a call * that succeeded stays. */ #calls = new Map<string, boolean>(); /** The first and last model calls read. */ #requestsFrom = Infinity; #requestsAfter = 0;
/** The newest request's usage, from the stream's snapshot and its usage events; null before the first. */ usage = $state.raw<Usage | null>(null);
blocks = $derived(this.#blocks()); groups = $derived(group(this.blocks)); /** Your newest message, until a reply follows it, so the chat can say whether the model has it. */ receipt = $derived(this.#receipt());
#expanding = new Set<string>(); #polling = false; #shellRefresh: AbortController | undefined;
constructor(readonly sessionId: string) {}
trackShell(command: ShellCommand) { const previous = this.shellCommands.find((item) => item.id === command.id); this.shellCommands = [...this.shellCommands.filter((item) => item.id !== command.id), previous ? mergeShell(previous, command) : command]; }
async load() { try { const page = await readHistory(this.sessionId); this.#merge(await this.#hydrateText(page.items)); this.more = page.older !== null; this.error = null; } catch (error) { this.error = String((error as Error).message ?? error); } finally { this.loading = false; } this.#readFailures().catch(() => {}); }
async loadOlder() { const first = this.entries[0]; if (!first || !this.more) return; const page = await readHistory(this.sessionId, { before: first.position }); const known = new Set(this.entries.map((entry) => entry.id)); this.#merge(await this.#hydrateText(page.items.filter((entry) => !known.has(entry.id)))); this.more = page.older !== null; this.#readFailures(true).catch(() => {}); }
/** * Adds the entries the chat does not have yet, in history order, and * returns them. Reads overlap (a poll racing the first load, or a load * after a reconnect), so an entry may arrive twice; a duplicate key would * stop the whole chat from updating. */ #merge(arrived: HistoryEntry[]): HistoryEntry[] { const known = new Set(this.entries.map((entry) => entry.id)); const added = arrived.filter((entry) => !known.has(entry.id)); if (added.length) this.entries = [...this.entries, ...added].sort((a, b) => a.position - b.position); // Initial hydration may finish after a reset that had no loaded rows yet. if (this.#stop && added.some((entry) => entry.kind === 'shell_command')) void this.#refreshShells(); return added; }
/** Reads everything after the newest entry. One poll runs at a time. */ async poll() { if (this.#polling) return; this.#polling = true; // A read racing the first load may return history from before the chat // opened; only what follows that load counts as arriving. const opened = !this.loading; try { for (;;) { const last = this.entries.at(-1); const page = await readHistory(this.sessionId, last ? { after: last.position } : {}); const known = new Set(this.entries.map((entry) => entry.id)); const fresh = page.items.filter((entry) => !known.has(entry.id)); if (fresh.length) { const hydrated = await this.#hydrateText(fresh); const made = opened ? (await Promise.all(hydrated.map(madeBy))).flat() : []; const arrived = this.#merge(hydrated); if (made.length) this.made = [...this.made, ...made]; const answered = new Set(arrived.map((entry) => entry.input_id)); this.pending = this.pending.filter((send) => !answered.has(send.id)); if (arrived.some((entry) => ['thinking', 'assistant', 'tool_call'].includes(entry.kind))) this.#clearReplaced(); } if (!page.newer || !fresh.length) return; } } finally { this.#polling = false; } }
/** Follows the session's stream: live output as it is written, and history as it commits. */ attach() { this.#stop ??= follow(this.sessionId, (batch) => this.#apply(batch), (connected) => (this.streaming = connected)); }
detach() { this.#stop?.(); this.#stop = null; clearTimeout(this.#settle); this.#shellRefresh?.abort(); }
/** A reset may have missed an ACK for an older, already loaded history row. */ async #refreshShells() { this.#shellRefresh?.abort(); const abort = (this.#shellRefresh = new AbortController()); const pending = new Set(this.entries.flatMap((entry) => { if (entry.kind !== 'shell_command') return []; const part = entry.content.find((part) => part.kind === 'json' && part.field === 'shell_command'); const command = part?.kind === 'json' ? shellCommandOf(part.value) : null; return command?.delivery === 'pending' ? [command.id] : []; })); // Serial reads bound in-flight work even when many idle receipts were loaded. for (const id of pending) { if (abort.signal.aborted) return; try { const command = await getShellCommand(this.sessionId, id, abort.signal); if (abort.signal.aborted) return; this.trackShell(command); } catch { /* Preserve the last observation; the next reconnect or event can refresh it. */ } } }
#apply(batch: Batch) { for (const event of batch.events) { const data = event.data ?? {}; switch (event.type) { case 'reset': { const snapshot = batch.snapshot ?? {}; this.phase = snapshot.status?.phase ?? null; if (snapshot.usage) this.usage = snapshot.usage.observed_at ? snapshot.usage : null; this.live = (snapshot.active_output ?? []).flatMap((output: any) => output.kind === 'text' || output.kind === 'thinking' ? [{ id: output.message_id, kind: output.kind, text: output.text ?? '…' }] : [], ); this.progress = (snapshot.current_progress ?? []).map(progressOf); this.shellCommands = (snapshot.shell_commands ?? []).flatMap((command: unknown) => { const checked = shellCommandOf(command); return checked ? [checked] : []; }); void this.#refreshShells(); this.#commit(null); break; } case 'status': this.phase = data.phase ?? null; if (this.phase === 'idle') this.#commit(null); break; case 'usage': this.usage = data; break; case 'error': if (data.run_id) this.failures = { ...this.failures, [data.run_id]: failureOf(data.message ?? '') }; break; case 'text': case 'thinking': { const at = this.live.findIndex((item) => item.id === data.message_id); if (at < 0) this.live = [...this.live, { id: data.message_id, kind: event.type, text: data.text }]; else this.live = this.live.map((item, index) => (index === at ? { ...item, text: item.text + data.text } : item)); break; } case 'shell_command': { const shell = shellCommandOf(data.shell_command); if (shell) this.trackShell(shell); break; } case 'tool_progress': { const next = progressOf(data.progress); this.progress = [...this.progress.filter((item) => item.id !== next.id), next]; break; } case 'tool': this.progress = this.progress.filter((item) => item.id !== data.progress_call_id); this.#commit(null); break; case 'committed': this.#commit(data.replaces_all_live ? 'all' : (data.replaces_live_ids ?? [])); break; case 'message': case 'note': this.#commit(null); break; } } }
/** * Reads what committed, then drops the live output it replaces, so a reply * never blinks out between its last delta and its history entry. */ #commit(replaces: 'all' | string[] | null) { // Events arrive in bursts (a commit, then its tool, then a status), so // one read serves them all; what each burst replaces adds up rather than // the last event's list winning. if (replaces === 'all') this.#replacing = 'all'; else if (replaces && this.#replacing !== 'all') this.#replacing = [...this.#replacing, ...replaces]; clearTimeout(this.#settle); this.#settle = setTimeout(async () => { await this.poll().catch(() => {}); this.#clearReplaced(); if (this.phase === 'idle') { [this.live, this.progress] = [[], []]; await this.#readFailures().catch(() => {}); } }, 60); }
/** * Reads which turns failed from the session's model calls since the oldest * loaded entry: a turn whose last call failed. The stream says so as it * happens; this is what a chat opened later has. Reads on from the last * call read, or, for an `older` page, the calls before the first one read. */ async #readFailures(older = false) { const since = this.entries[0]?.created_at; if (this.loading || !since) return; const last = new Map<string, string | null>(); const until = this.#requestsFrom; let after = older ? 0 : this.#requestsAfter; reading: for (;;) { const page = await readRequests(this.sessionId, after, 200, undefined, after ? undefined : Date.parse(since)); for (const request of page.items) { if (older && request.sequence >= until) break reading; if (request.run_id) last.set(request.run_id, request.outcome === 'failed' ? (request.failure?.detail ?? '') : null); this.#requestsFrom = Math.min(this.#requestsFrom, request.sequence); after = request.sequence; } if (!page.next || !page.items.length) break; } if (!older) this.#requestsAfter = Math.max(this.#requestsAfter, after); if (!last.size) return; const failures = { ...this.failures }; for (const [run, detail] of last) { // A later page already read how an older run ended. if (older && this.#calls.has(run)) continue; if (detail !== null) failures[run] = failureOf(detail); else if (this.#calls.get(run)) delete failures[run]; this.#calls.set(run, detail !== null); } this.failures = failures; }
#clearReplaced() { const replacing = this.#replacing; this.#replacing = []; if (replacing === 'all') this.live = []; else if (replacing.length) this.live = this.live.filter((item) => !replacing.includes(item.id)); }
async send(text: string, images: Attached[] = []) { const send = { id: uuidv7(), text, images, at: Date.now() }; this.pending = [...this.pending, send]; await this.#deliver(send); }
async retry(id: string) { const send = this.pending.find((candidate) => candidate.id === id); if (!send) return; this.pending = this.pending.map((candidate) => (candidate.id === id ? { ...send, error: undefined } : candidate)); await this.#deliver(send); }
discard(id: string) { this.pending = this.pending.filter((send) => send.id !== id); }
/** Removes the sends the daemon cancelled and returns them in the order they were sent. */ take(ids: string[]): { text: string; images: Attached[] }[] { const taken = this.pending.filter((send) => ids.includes(send.id)); this.pending = this.pending.filter((send) => !ids.includes(send.id)); return taken; }
#receipt(): string | null { for (const block of this.blocks.toReversed()) { if (block.kind === 'assistant' || block.kind === 'failure') return null; if (block.kind === 'user' && !block.from) return block.key; } return null; }
/** Where a turn starts among the loaded entries, for a review of it. */ turnStart(turnId: string): number | null { return this.entries.find((entry) => entry.turn_id === turnId)?.position ?? null; }
/** Puts tool entries' full arguments and output in place of their references. */ async expand(...entries: HistoryEntry[]) { const waiting = entries.filter((entry) => !entry.content_complete && !this.#expanding.has(entry.id) && referenced(entry)); if (!waiting.length) return; for (const entry of waiting) this.#expanding.add(entry.id); try { const full = new Map((await Promise.all(waiting.map(hydrate))).map((entry) => [entry.id, entry])); this.entries = this.entries.map((candidate) => full.get(candidate.id) ?? candidate); } finally { for (const entry of waiting) this.#expanding.delete(entry.id); } }
async #deliver(send: Pending) { try { await sendMessage(this.sessionId, send.id, send.text, send.images.map(({ mime_type, data }) => ({ mime_type, data }))); this.pending = this.pending.map((candidate) => (candidate.id === send.id ? { ...candidate, accepted: true } : candidate)); } catch (error) { const message = String((error as Error).message ?? error); this.pending = this.pending.map((candidate) => (candidate.id === send.id ? { ...candidate, error: message } : candidate)); } }
// Fetch visible messages and bounded shell receipts up front; tool content waits. #hydrateText(entries: HistoryEntry[]) { return Promise.all(entries.map((entry) => (['user', 'assistant', 'thinking', 'note', 'compaction', 'shell_command'].includes(entry.kind) ? hydrate(entry) : entry))); }
#blocks(): Block[] { const results = new Set(this.entries.flatMap((entry) => (entry.kind === 'tool_result' && entry.tool ? [entry.tool.tool_call_id] : []))); const blocks: Block[] = []; let turn = null as Turn | null; let previous = 0; let speaker = '';
// A turn signs off with a face once the next one starts or the session rests. const signOff = () => { const id = turn?.id; const failed = id ? this.failures[id] : undefined; if (failed) blocks.push({ kind: 'failure', key: `failure:${id}`, ...failed }); if (!turn || (!turn.answered && !turn.tools)) return; const elapsedMs = Math.max(0, turn.last - turn.start); const changed = { files: turn.files.size, added: turn.added, removed: turn.removed }; blocks.push({ kind: 'end', key: `end:${turn.id}:${turn.from}`, turnId: turn.id, from: turn.from, mood: outcome(false, false, elapsedMs), seed: turn.last, elapsedMs, tools: turn.tools, text: turn.text, changed }); };
const liveShells = new Map(this.shellCommands.map((command) => [command.id, command])); for (const entry of this.entries) { // Mid-turn receipts belong to the surrounding turn. Loose idle receipts // still sign it off before shell time starts. if (entry.kind === 'shell_command') { if (!turn || entry.turn_id === null || entry.turn_id !== turn.id) { signOff(); turn = null; } speaker = 'you'; const part = entry.content.find((item) => item.kind === 'json' && item.field === 'shell_command'); const recorded = part?.kind === 'json' ? shellCommandOf(part.value) : null; const live = recorded ? liveShells.get(recorded.id) : undefined; const command = recorded && live ? mergeShell(recorded, live) : recorded; if (command) blocks.push({ kind: 'shell', key: `shell:${command.id}`, command }); if (at(entry)) previous = at(entry); continue; } const text = textOf(entry.content); // An entry outside any turn (a system or scheduled note) shows where it landed but // does not end the turn around it; that turn would sign off twice. const loose = entry.turn_id === null && entry.kind !== 'user'; if (!turn || (entry.turn_id !== turn.id && !loose)) { signOff(); turn = { id: entry.turn_id, from: entry.position, start: at(entry), last: at(entry), tools: 0, answered: false, files: new Set(), added: 0, removed: 0, text: '' }; } turn.last = Math.max(turn.last, at(entry)); switch (entry.kind) { case 'user': { const gap = previous && at(entry) - previous >= AWAY_MS ? formatGap(at(entry) - previous) : null; const from = entry.mail?.sender_label?.toLowerCase() ?? (entry.turn_type && !['user', 'chat'].includes(entry.turn_type) ? entry.turn_type : null); const skill = jsonField(entry, 'skill') as SkillLoad | undefined; blocks.push({ kind: 'user', key: entry.id, text, images: picturesOf(entry), from, gap, at: at(entry), state: 'seen', skill: skill?.name }); speaker = 'you'; break; } case 'assistant': if (!text.trim()) break; blocks.push({ kind: 'assistant', key: entry.id, text, plate: speaker !== 'albedo' }); speaker = 'albedo'; turn.answered = true; turn.text = text; break; case 'thinking': if (text.trim()) blocks.push({ kind: 'thinking', key: entry.id, text, ms: entry.thinking_duration_ms ?? null }); break; case 'tool_call': // A call shows until its result replaces it. if (entry.tool && !results.has(entry.tool.tool_call_id)) blocks.push({ kind: 'tool', key: entry.id, name: entry.tool.name, entry, done: false, failed: false }); break; case 'tool_result': if (!entry.tool) break; turn.tools++; for (const change of traceOf(entry)?.changes ?? []) { turn.files.add(change.path); if (change.kind === 'diff') { turn.added += change.added; turn.removed += change.removed; } } blocks.push({ kind: 'tool', key: entry.id, name: entry.tool.name, entry, done: true, trace: traceOf(entry), failed: failedTool(entry) }); break; case 'note': case 'image_fit': if (text.trim()) blocks.push({ kind: 'note', key: entry.id, text }); break; case 'compaction': blocks.push({ kind: 'compaction', key: entry.id, text }); break; } if (at(entry)) previous = at(entry); } if (!this.running && !this.pending.length) signOff(); for (const item of this.live) { if (!item.text.trim()) continue; if (item.kind === 'thinking') blocks.push({ kind: 'thinking', key: `live:${item.id}`, text: item.text, ms: null }); else blocks.push({ kind: 'assistant', key: `live:${item.id}`, text: item.text, plate: speaker !== 'albedo' }); } // A call whose entry has committed already shows as that entry. const called = new Set(this.entries.flatMap((entry) => (entry.kind === 'tool_call' && entry.tool ? [entry.tool.tool_call_id] : []))); for (const item of this.progress) { if (!called.has(item.call)) blocks.push({ kind: 'progress', key: `progress:${item.id}`, name: item.name, title: item.title, preview: item.preview }); } const durableShells = new Set(blocks.flatMap((block) => block.kind === 'shell' ? [block.command.id] : [])); for (const command of this.shellCommands) if (!durableShells.has(command.id)) blocks.push({ kind: 'shell', key: `shell:${command.id}`, command }); for (const send of this.pending) { const images = send.images.map((image) => ({ src: image.preview })); blocks.push({ kind: 'user', key: `pending:${send.id}`, text: send.text, images, from: null, gap: null, at: send.at, state: send.error ? 'failed' : send.accepted ? 'sent' : 'sending', error: send.error }); } return blocks; }}
function group(blocks: Block[]): Group[] { const groups: Group[] = []; for (const block of blocks) { const last = groups.at(-1); if (block.kind === 'thinking' || block.kind === 'tool' || block.kind === 'progress') { if (last?.kind === 'work') last.steps.push(block); else groups.push({ kind: 'work', key: last ? `work:${last.key}` : 'work:root', steps: [block] }); } else groups.push(block); } return groups;}