moqi-tui 0.2.0

package/lib/types/tui/state.d.ts

@@ -0,0 +1,323 @@
+/**
+ * App state: the transcript, the composer, the slash palette, and the picker.
+ *
+ * This module is deliberately free of terminal and Harness concerns so the
+ * interaction rules stay testable on their own — it only knows strings,
+ * cursors, and selections.
+ * @module
+ */
+/** Minimum and maximum composer height, in text rows. */
+export declare const MIN_INPUT_LINES = 1;
+export declare const MAX_INPUT_LINES = 10;
+/** How many sent prompts the composer history retains. */
+export declare const HISTORY_LIMIT = 500;
+/**
+ * One piece of a turn, in the order it actually happened.
+ *
+ * A turn is not prose with tool calls bolted on the side: the agent says
+ * something, runs a tool, says something about what came back. Holding the text
+ * as one string and the calls as a separate list threw that order away, so the
+ * prose arrived as one run of concatenated fragments under a block of calls —
+ * which is exactly how a turn stops making sense to read.
+ */
+export type Segment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'tool';
+    tool: ToolActivity;
+};
+/** One turn of the transcript. */
+export interface Message {
+    role: 'user' | 'assistant';
+    /** The turn's pieces in arrival order — prose and tool calls interleaved. */
+    segments: readonly Segment[];
+    /** Reasoning text, shown only when thinking is toggled on. */
+    reasoning?: string;
+    /** Set when this message is a command result rather than model output. */
+    command?: {
+        name: string;
+        ok: boolean;
+    };
+    /** Set on a user prompt steered into a still-running turn. */
+    steering?: boolean;
+    /** Images sent with this user prompt, drawn as one summary line. */
+    attachments?: readonly {
+        name: string;
+        width: number;
+        height: number;
+    }[];
+}
+/** A turn that is nothing but text: a prompt, a command result, a log replay. */
+export declare function textMessage(role: Message['role'], text: string, rest?: Omit<Message, 'role' | 'segments'>): Message;
+/**
+ * The turn's prose with the tool calls dropped, for `/copy`, `/export`,
+ * `/find`, and the tab title.
+ *
+ * Segments are joined with a blank line because a tool call is where the model
+ * stopped and started again — running the two halves together is what made a
+ * reply read as one endless paragraph.
+ */
+export declare function segmentsText(segments: readonly Segment[]): string;
+export declare function messageText(message: Message): string;
+/**
+ * Every tool row, in order. The rows are the live objects, not copies, so a
+ * later `tool/result` event settles the row where it already sits in the turn.
+ */
+export declare function segmentTools(segments: readonly Segment[]): ToolActivity[];
+/** Every tool row in the turn, in order — for result events and counting. */
+export declare function messageTools(message: Message): ToolActivity[];
+/**
+ * Append streamed text to the turn, continuing the trailing run when there is
+ * one. A tool call in between is what opens a new text segment, which is how
+ * the order gets recorded at all.
+ */
+export declare function appendText(segments: Segment[], text: string): void;
+/** The tool row for a call id, wherever it sits in the turn. */
+export declare function findTool(segments: readonly Segment[], match: (tool: ToolActivity) => boolean): ToolActivity | undefined;
+/** A single tool invocation surfaced in the transcript. */
+export interface ToolActivity {
+    /** Provider-issued call id; the only stable handle across argument deltas. */
+    id?: string;
+    name: string;
+    status: 'running' | 'ok' | 'error';
+    detail?: string;
+    /** One line of what came back, rendered under the call it belongs to. */
+    result?: string;
+}
+/**
+ * Whether a turn's queued prompts should send once it settles.
+ *
+ * A clean finish always drains the queue. An interrupt is the user asking for
+ * silence — so it freezes the queue — *unless* the interrupt was asked for as
+ * a redirection (`/interrupt`): stop this answer, then run what was queued.
+ */
+export declare function queueShouldDrain(options: {
+    interrupted: boolean;
+    drainRequested: boolean;
+}): boolean;
+/**
+ * What a session is doing, for the tab bar.
+ *
+ * `ready` is the state worth interrupting someone for: the turn finished and
+ * the answer has not been seen. It is what the bell announces.
+ */
+export type SessionStatus = 'idle' | 'running' | 'ready';
+/** One open session, as the tab bar shows it. */
+export interface SessionSummary {
+    id: string;
+    title: string;
+    status: SessionStatus;
+    active: boolean;
+}
+/**
+ * A live agent other than the one the transcript is showing.
+ *
+ * The Harness can run delegated work — subagents the foreground turn spawned —
+ * and without a row here that work is invisible: the screen looks idle while
+ * the machine is busy.
+ */
+export interface BackgroundAgent {
+    /** Session id, used as the stable identity. */
+    id: string;
+    /** Short human label: the preset name when composed from one. */
+    label: string;
+    status: 'idle' | 'running';
+    /** Delegation depth; 1 is a direct child of the foreground agent. */
+    depth: number;
+    /** Epoch millis when this agent was first seen. */
+    startedAt: number;
+}
+/** A slash command as the palette shows it. */
+export interface PaletteCommand {
+    name: string;
+    args: string;
+    description: string;
+}
+/** Which list the picker is currently showing. */
+export type PickerKind = 'sessions' | 'models' | 'themes' | 'plugins' | 'open' | 'delete' | 'rewind' | 'stored' | 'lang' | 'none';
+/** One row in the picker. */
+export interface PickerItem {
+    id: string;
+    title: string;
+    subtitle: string;
+    /** Set on a model row: the provider route that owns the model. */
+    provider?: string;
+    /** Set on a model row: the model id passed to the request. */
+    model?: string;
+    /** Marks the row that is currently in use. */
+    active?: boolean;
+}
+/**
+ * The composer. A plain multi-line buffer with a cursor, wide enough in
+ * behavior to feel like an editor: word motion, line motion, and kill-to-end.
+ */
+export declare class Composer {
+    private text;
+    private cursor;
+    value(): string;
+    position(): number;
+    setValue(value: string): void;
+    /** Replace the whole buffer and land the cursor at an explicit offset. */
+    adopt(text: string, cursor: number): void;
+    reset(): void;
+    insert(chunk: string): void;
+    backspace(): void;
+    deleteForward(): void;
+    /** Delete from the cursor back to the start of the current word. */
+    deleteWord(): void;
+    /** Delete from the cursor to the end of the buffer. */
+    killToEnd(): void;
+    /** Delete from the start of the buffer to the cursor. */
+    killToStart(): void;
+    left(): void;
+    right(): void;
+    wordLeft(): void;
+    wordRight(): void;
+    home(): void;
+    end(): void;
+    toStart(): void;
+    toEnd(): void;
+    /** Offset of the first character of the cursor's logical line. */
+    lineStartIndex(): number;
+    /** Offset of the newline (or end of buffer) that closes the cursor's line. */
+    lineEndIndex(): number;
+    /**
+     * Delete a half-open range and park the cursor at its start.
+     *
+     * The bounds are clamped, so a motion that ran off either end of the buffer
+     * deletes what it actually covered rather than throwing.
+     */
+    deleteRange(start: number, end: number): void;
+    /** Move the cursor one visual row up or down within the wrapped composer. */
+    moveRow(delta: number, width: number): void;
+    /**
+     * Wrap the buffer to `width`, returning each visual row with the buffer
+     * offsets it covers. The view and the cursor both read this, so they cannot
+     * disagree about where a row begins.
+     */
+    layout(width: number): {
+        text: string;
+        start: number;
+        end: number;
+    }[];
+    /** Height in rows the composer wants at `width`, clamped to the app's bounds. */
+    height(width: number): number;
+    /**
+     * Whether the cursor sits on the first visual row, so `↑` would otherwise be
+     * a no-op — the moment input-history recall should take over.
+     */
+    atFirstRow(width: number): boolean;
+    /** The mirror of {@link atFirstRow} for `↓` and newer history entries. */
+    atLastRow(width: number): boolean;
+}
+/**
+ * Recall of previously sent prompts, the way a shell recalls its history.
+ *
+ * `recall` walks older (`-1`) or newer (`+1`) entries and returns the text to
+ * show, or `undefined` when there is nothing further in that direction — the
+ * caller then falls back to ordinary cursor motion. The draft being typed is
+ * remembered the first time recall leaves it, so walking back down to the end
+ * restores it rather than stranding the user on the last sent prompt.
+ */
+export declare class InputHistory {
+    private entries;
+    /** Position while recalling; `-1` means the live draft, not any entry. */
+    private index;
+    private draft;
+    /** Record a sent prompt, ignoring empties and immediate repeats. */
+    add(text: string): void;
+    /** Adopt persisted entries (oldest first), keeping the most recent ones. */
+    load(entries: readonly string[]): void;
+    /** Every recorded prompt, oldest first, for persistence. */
+    snapshot(): readonly string[];
+    /**
+     * Walk the history. `draft` is what the composer holds now; it is saved the
+     * first time recall moves away from live typing.
+     */
+    recall(delta: number, draft: string): string | undefined;
+    /** Whether a recall is in flight, i.e. ↑/↓ should keep walking history. */
+    isRecalling(): boolean;
+    /** Return to live typing; called whenever the composer is edited or sent. */
+    reset(): void;
+}
+/** The popup that filters slash commands as they are typed. */
+export declare class Palette {
+    open: boolean;
+    matches: PaletteCommand[];
+    selected: number;
+    /**
+     * Recompute from the composer text. The palette lives only while the input
+     * is a single unfinished `/word`; once a space is typed the user has moved
+     * on to the command's own arguments.
+     */
+    update(input: string, commands: readonly PaletteCommand[]): void;
+    move(delta: number): void;
+    current(): PaletteCommand | undefined;
+    close(): void;
+}
+/**
+ * Subsequence match, the same shape of filter an editor's command palette
+ * uses: every character of the query appears in order, not necessarily
+ * adjacent, so "g53" finds "glm-5.3".
+ */
+export declare function fuzzyMatch(query: string, text: string): boolean;
+/**
+ * The full-pane list that replaces the transcript for `/resume` and `/model`.
+ *
+ * It filters as you type and, when grouped, prints a header each time the
+ * subtitle changes — so a model list reads provider by provider rather than as
+ * one undifferentiated column.
+ */
+export declare class Picker {
+    kind: PickerKind;
+    title: string;
+    items: PickerItem[];
+    selected: number;
+    query: string;
+    /** Whether rows are grouped under their subtitle. */
+    grouped: boolean;
+    show(kind: Exclude<PickerKind, 'none'>, title: string, items: PickerItem[], options?: {
+        grouped?: boolean;
+    }): void;
+    hide(): void;
+    /** Rows surviving the current query, in their original order. */
+    matches(): PickerItem[];
+    /** Narrow or widen the filter, keeping the selection in range. */
+    setQuery(query: string): void;
+    move(delta: number): void;
+    /** Put the cursor on a given row of the unfiltered list, if it survives. */
+    selectById(id: string): void;
+    current(): PickerItem | undefined;
+}
+/** The minimum a session has to expose for {@link ownerOfDelegated}. */
+export interface DelegationHost {
+    id: string;
+    streaming: boolean;
+}
+/**
+ * Which open session a delegated agent belongs to, as an index.
+ *
+ * The Harness does not report a delegation parent, so this is a rule rather
+ * than a lookup, and it is worth stating plainly because the alternative --
+ * one list shared by every session -- is what made another conversation's
+ * subagents appear in whichever tab was on screen.
+ *
+ * Fork lineage wins when it names a session that is actually open. Otherwise
+ * timing decides: delegated work is spawned while its parent's turn runs, so
+ * the streaming session claims it. With neither, the active session is the
+ * only honest guess.
+ */
+export declare function ownerOfDelegated(sessions: readonly DelegationHost[], parentSessionId: string | undefined, activeIndex: number): number;
+/**
+ * Walk a transcript selection.
+ *
+ * There is no selection until the first key: `alt+↑`/`alt+↓` then start at the
+ * newest turn and move, clamped at both ends and empty when there is nothing
+ * to select.
+ */
+export declare function moveSelection(current: number | undefined, delta: number, count: number): number | undefined;
+/** Format a token count the way a status bar wants it: 834, 1.2K, 64K. */
+export declare function formatTokens(count: number): string;
+/** A deliberately rough chars/4 estimate, used until real usage is reported. */
+export declare function estimateTokens(text: string): number;

package/lib/types/tui/stream.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Pure projection of a Harness assistant-stream chunk onto the transcript.
+ *
+ * `TuiApp.onFrame` used to hold this switch inline, which made the one path
+ * that turns a live model reply into visible text untestable without a full
+ * Harness runtime. This module keeps the identical logic but depends on
+ * nothing: it imports no Harness types and no npm packages, so a synthetic
+ * chunk sequence can be replayed in a dependency-free test (see
+ * `tests/stream-smoke.ts`) the same way `render-smoke.ts` exercises `view.ts`.
+ *
+ * @module moqi-tui/tui/stream
+ */
+import type { Segment } from './state.ts';
+/**
+ * The mutable streaming surface a chunk projects onto — a structural subset of
+ * the app's session tab, so the function works on the real tab or a test stub
+ * with no Harness types in sight.
+ */
+export interface StreamingSurface {
+    /** The turn so far, prose and calls in the order they arrived. */
+    streamingSegments: Segment[];
+    streamingReasoning: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    haveUsage: boolean;
+    /** Prompt tokens served from the provider's cache, when it reports them. */
+    cacheReadTokens: number;
+    /** Prompt tokens written to the provider's cache, when it reports them. */
+    cacheWriteTokens: number;
+    /** Output tokens per second for the last settled turn, when measurable. */
+    tps: number;
+}
+/**
+ * Structural view of a Harness `StreamChunk`, carrying only the fields the TUI
+ * renders. It is deliberately wide (every field optional) so the real union —
+ * whose variants carry `index`, `argumentsDelta`, `reason`, etc. — assigns to
+ * it without a cast, and unknown future chunk kinds fall through the default.
+ */
+export interface StreamChunkLike {
+    type: string;
+    text?: string;
+    id?: string | number;
+    name?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+    };
+    block?: {
+        type: string;
+        id?: string | number;
+        name?: string;
+        arguments?: string;
+    };
+    /** Rendered fields the union carries but this app ignores. */
+    index?: number;
+    argumentsDelta?: string;
+    blockType?: unknown;
+    reason?: unknown;
+    replayState?: unknown;
+}
+/**
+ * Apply one stream chunk to a streaming surface, mutating it in place.
+ *
+ * `text-delta` continues the turn's trailing run of prose, a `tool-call-delta`
+ * adds or names a running tool row keyed by call id, `usage` lands the token
+ * counters, and `block-end` settles the matching row to `ok`. Unknown chunk
+ * kinds are ignored on purpose — the chunk union is merge-extensible and a
+ * plugin may emit one this app has never heard of.
+ *
+ * Order is the point: text after a call opens a new segment rather than
+ * extending the text before it, so "checking…", the call, and "found it" stay
+ * three things in sequence instead of one paragraph and a detached list.
+ */
+export declare function projectStreamChunk(surface: StreamingSurface, chunk: StreamChunkLike): void;

package/lib/types/tui/text.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Width-aware text helpers.
+ *
+ * Every measurement in the app goes through {@link displayWidth}, which ignores
+ * SGR escapes and counts East Asian wide characters as two columns. Without
+ * that, styled or CJK content silently breaks the column arithmetic the whole
+ * layout depends on.
+ * @module
+ */
+/** Remove every escape sequence, leaving the printable text. */
+export declare function stripAnsi(text: string): string;
+/** Printable width of a string in terminal columns, ignoring escapes. */
+export declare function displayWidth(text: string): number;
+/**
+ * Cut a string to `limit` columns, appending an ellipsis when it did not fit.
+ * Escape sequences pass through so styling is never severed mid-code, and a
+ * reset is appended when the cut text carried any styling.
+ */
+export declare function truncate(text: string, limit: number): string;
+/** Pad a string on the right to `width` columns. */
+export declare function padEnd(text: string, width: number): string;
+/**
+ * Hard-wrap plain text to `width` columns, breaking on spaces where possible
+ * and mid-word only when a single word cannot fit on a line of its own.
+ */
+export declare function wrap(text: string, width: number): string[];
+/** Take exactly as many code points as fit in `width` columns, no ellipsis. */
+export declare function cut(text: string, width: number): string;

package/lib/types/tui/theme.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Palette and text styling for the terminal app.
+ *
+ * The colors default to the Rose Pine-ish pair the original Go client used,
+ * kept as explicit light/dark variants so the app reads on either terminal
+ * background. Everything emits truecolor SGR directly: the app already owns
+ * the screen, so there is no styling library between it and the escape codes.
+ *
+ * Which palette is in force is swappable at runtime — see {@link applyTheme}
+ * and the table in `themes.ts`. That is deliberately orthogonal to the
+ * light/dark question: a theme supplies both variants, and the terminal's own
+ * background still decides which of the two is drawn.
+ * @module
+ */
+import { type Theme } from './themes.ts';
+/** One color with a variant per terminal background. */
+export interface AdaptiveColor {
+    light: string;
+    dark: string;
+}
+export declare const colAccent: AdaptiveColor;
+export declare const colMuted: AdaptiveColor;
+export declare const colBorder: AdaptiveColor;
+export declare const colText: AdaptiveColor;
+export declare const colWarn: AdaptiveColor;
+export declare const colOK: AdaptiveColor;
+export declare const colGreen: AdaptiveColor;
+export declare const colGold: AdaptiveColor;
+export declare const colRose: AdaptiveColor;
+export declare const colInvert: AdaptiveColor;
+/**
+ * Install a named palette, returning false when there is no such theme.
+ *
+ * Every other module imported the color constants by name, so the switch has
+ * to happen *through* those objects rather than by replacing them: an import
+ * binding points at the object that existed when the module was evaluated,
+ * and reassigning the constant here would leave every call site drawing with
+ * the old palette. Writing the two fields in place is what makes a theme
+ * change a one-line operation instead of a rewrite of every view.
+ *
+ * An unknown name is reported rather than thrown: it arrives from `/theme
+ * <name>` or from a state file written by a future version, and neither is a
+ * reason to take the app down.
+ */
+export declare function applyTheme(name: string): boolean;
+/** The name of the palette currently installed. */
+export declare function activeTheme(): string;
+/** Every palette {@link applyTheme} will accept, in the order to list them. */
+export declare function listThemes(): readonly Theme[];
+/**
+ * Re-exported so a caller that only wants to list or name a palette imports
+ * this module alone, the way every drawing module already does.
+ */
+export type { Theme, ThemePalette } from './themes.ts';
+/**
+ * Re-read the environment, so a change of terminal background applies without
+ * a restart. This is about the light/dark variant only — the choice of
+ * palette is {@link applyTheme}'s.
+ */
+export declare function refreshTheme(): void;
+/** Whether styling currently targets a dark background. */
+export declare function isDark(): boolean;
+/** Resolve an adaptive color against the active background. */
+export declare function resolve(color: AdaptiveColor): string;
+/** Clears every attribute set by {@link style}. */
+export declare const RESET = "\u001B[0m";
+/** Attributes a style can carry beyond its colors. */
+export interface StyleOptions {
+    fg?: AdaptiveColor;
+    bg?: AdaptiveColor;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+    strike?: boolean;
+}
+/**
+ * Wrap text in a style. Each line is styled independently so a styled block
+ * survives being split, padded, or placed beside other cells.
+ */
+export declare function style(text: string, options: StyleOptions): string;
+export declare const muted: (text: string) => string;
+export declare const warn: (text: string) => string;
+export declare const ok: (text: string) => string;
+export declare const bold: (text: string) => string;
+export declare const accent: (text: string) => string;
+export declare const selected: (text: string) => string;

package/lib/types/tui/themes.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The palettes `/theme` can choose between.
+ *
+ * This is a data module on purpose: `theme.ts` owns the colour objects every
+ * other module imports by name, and it would grow unreadable if five full
+ * palettes sat between the `style()` machinery and the SGR encoder. Keeping
+ * the table here means adding a palette is an edit to one list of hex pairs
+ * and nothing else.
+ *
+ * Every palette carries both a light and a dark variant because the variant
+ * is picked separately, from the terminal background — a user on a light
+ * terminal must get a readable Nord, not a dark one washed out.
+ * @module
+ */
+import type { AdaptiveColor } from './theme.ts';
+/**
+ * The ten colour slots a palette has to fill.
+ *
+ * The names are the semantic roles the app draws with rather than hues, so a
+ * palette that has no literal gold still has to answer the question "what do
+ * inline code spans look like here".
+ */
+export interface ThemePalette {
+    /** The app's signature colour: prompts, selections, the composer border. */
+    accent: AdaptiveColor;
+    /** Secondary text that should recede: hints, timestamps, footers. */
+    muted: AdaptiveColor;
+    /** Box rules and separators. */
+    border: AdaptiveColor;
+    /** Ordinary foreground text. */
+    text: AdaptiveColor;
+    /** Errors and anything the user should not miss. */
+    warn: AdaptiveColor;
+    /** Success: a finished tool call, a healthy device. */
+    ok: AdaptiveColor;
+    /** Activity in progress: spinners, live rows. */
+    green: AdaptiveColor;
+    /** Inline code and emphasis inside markdown. */
+    gold: AdaptiveColor;
+    /** List markers and ordinals. */
+    rose: AdaptiveColor;
+    /** Foreground against an accent background, i.e. the terminal's own base. */
+    invert: AdaptiveColor;
+}
+/** A named palette, as `/theme` lists it. */
+export interface Theme {
+    /** The id typed after `/theme`; lowercase and hyphenated. */
+    name: string;
+    /** One line explaining what the palette is, for the picker's right column. */
+    description: string;
+    colors: ThemePalette;
+}
+/** The name the app starts with when nothing has been chosen or persisted. */
+export declare const DEFAULT_THEME = "rose-pine";
+/**
+ * The colours the exported constants in `theme.ts` are seeded with.
+ *
+ * They are seeded from the table rather than written out a second time so the
+ * default and the `rose-pine` entry cannot drift apart: if they did, `/theme
+ * rose-pine` would quietly stop being a way back to how the app started.
+ */
+export declare const DEFAULT_PALETTE: ThemePalette;
+/**
+ * Every palette, in the order `/theme` lists them: the default first, then
+ * the rest alphabetically, with the accessibility option last so it reads as
+ * the deliberate escape hatch it is.
+ */
+export declare const THEMES: readonly Theme[];
+/** Look a palette up by name, or `undefined` when no such palette exists. */
+export declare function findTheme(name: string): Theme | undefined;

package/lib/types/tui/tooldetail.d.ts

@@ -0,0 +1,45 @@
+/**
+ * What a tool call says about itself, and what came back.
+ *
+ * A tool row used to carry only the tool's name — `bash` four times over said
+ * nothing about what the agent was doing. The raw `arguments` JSON is already
+ * on the call (and its result already in the session log), so the readable
+ * summary is a pair of pure functions over strings: no Harness types, no I/O,
+ * replayable in a dependency-free suite next to the stream projection.
+ *
+ * @module moqi-tui/tui/tooldetail
+ */
+import type { ToolActivity } from './state.ts';
+/**
+ * Summarize what a tool call does from its raw `arguments` JSON — the exact
+ * string the model produced, parsed leniently. `bash` becomes
+ * `bash  docker ps --format {{.Names}}`; a read becomes its path; anything
+ * unrecognized falls back to its first string-valued argument, then to the
+ * compact JSON, then to nothing rather than to noise.
+ */
+export declare function describeToolCall(name: string, rawArguments: string | undefined): string;
+/**
+ * The one-line face of a tool result: its text content folded to a single
+ * line, or the failure's identity when the result block says the tool erred.
+ * `content` is the result block's content array; each text block contributes.
+ *
+ * @returns the summary, or `undefined` when the result says nothing readable.
+ */
+export declare function summarizeResult(content: readonly unknown[], error?: {
+    name?: string;
+    code?: string;
+}): string | undefined;
+/**
+ * Fold one session-log event onto the live tool rows of the turn in flight.
+ *
+ * `tool/call` fills a row's detail (the deltas name it, the log says what it
+ * does); `tool/result` settles the row — `ok` or `error` — and attaches its
+ * outcome underneath the very call that produced it, in flow. Rows are keyed
+ * by call id and never created here: only stream deltas and block ends, which
+ * observe the same calls, add rows, so an event from an earlier turn logged
+ * before the sync point finds no row and is ignored.
+ */
+export declare function applyToolEvent(tools: ToolActivity[], event: {
+    type?: string;
+    data?: Record<string, unknown> | undefined;
+}): void;