@almyty/chat 1.2.0 → 1.4.0

package/dist/stream.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The run stream, reduced.
+ *
+ * Every event a run or a pipeline emits lands here and turns into three
+ * things: the assistant text so far (rendered as it arrives), lines for
+ * the transcript, and a running cost/token tally. Kept pure and free of
+ * ink so both the REPL and the non-interactive path drive the same
+ * reducer, and so it can be tested without a terminal.
+ *
+ * Event shapes come from the backend: run events are
+ * llm.started / llm.chunk / llm.response / tool.started / tool.result /
+ * step.completed / verify.failed / run.completed / run.failed /
+ * run.cancelled; workflow pipelines emit execution.started /
+ * node.started / node.output / node.completed / node.skipped /
+ * execution.completed / execution.failed.
+ */
+import type { StreamEvent } from '@almyty/client';
+export type ActivityRole = 'agent' | 'tool' | 'info' | 'error';
+export interface Activity {
+    role: ActivityRole;
+    text: string;
+}
+/** What a run cost, as far as the stream has said. */
+export interface Usage {
+    /** US dollars. The backend's cost fields are dollars, not cents. */
+    cost: number;
+    tokens: number;
+    steps: number;
+    /** Which model answered, when the server names one. */
+    model?: string;
+    /** Why the router picked it, when routing is in play. */
+    rationale?: string;
+    /** 1-based position of the answering candidate in the routing plan. */
+    attempt?: number;
+}
+export interface StreamState {
+    /** Assistant text streamed so far. Rendered live, not at the end. */
+    partial: string;
+    /** Spinner label: what the agent is doing right now. */
+    label: string;
+    /** Transcript lines produced since the last drain. */
+    emit: Activity[];
+    usage: Usage;
+    /** Terminal output, once a completion event carries one. */
+    output?: string;
+    done: boolean;
+    failed?: string;
+    cancelled: boolean;
+}
+export declare const INITIAL_LABEL = "Thinking";
+export declare function initialStreamState(): StreamState;
+/** Anything the server hands back as an "output", as text. */
+export declare function formatOutput(value: unknown): string;
+/**
+ * Fold one event into the state.
+ *
+ * Returns a new object every time so a React setState sees a change.
+ */
+export declare function reduceStreamEvent(prev: StreamState, event: StreamEvent): StreamState;
+/**
+ * The assistant text a finished stream should show.
+ *
+ * The streamed tokens are preferred over the completion event's output:
+ * they are what the user already watched arrive, and re-rendering a
+ * re-serialised copy of the same answer makes it flicker.
+ */
+export declare function finalText(state: StreamState, fallbackOutput?: unknown): string;
+/** Take the pending transcript lines, leaving the state without them. */
+export declare function drain(state: StreamState): {
+    activities: Activity[];
+    state: StreamState;
+};
+/** Add two tallies, for a session total across turns. */
+export declare function addUsage(a: Usage, b: Usage): Usage;
+/** Dollars, at a precision that does not round a real cost to zero. */
+export declare function formatCost(dollars: number): string;
+export declare function formatTokens(tokens: number): string;
+/**
+ * One line of attribution: what answered, what it cost.
+ *
+ * This is the product's whole argument — many models, routed, with the
+ * bill attached — so a chat session says it out loud rather than
+ * leaving it in an audit log.
+ */
+export declare function formatUsage(usage: Usage): string;
+/**
+ * Model attribution off a finished run's steps.
+ *
+ * The llm.response event does not carry the answering model, so a run
+ * that streamed to completion has to be asked afterwards. Only the
+ * tool-calling step records `routing` today, so a single-step answer
+ * has no attribution to find and this returns null rather than
+ * guessing.
+ */
+export declare function routingFromSteps(steps: unknown): Pick<Usage, 'model' | 'rationale' | 'attempt'> | null;

package/dist/stream.js

@@ -0,0 +1,276 @@
+/**
+ * The run stream, reduced.
+ *
+ * Every event a run or a pipeline emits lands here and turns into three
+ * things: the assistant text so far (rendered as it arrives), lines for
+ * the transcript, and a running cost/token tally. Kept pure and free of
+ * ink so both the REPL and the non-interactive path drive the same
+ * reducer, and so it can be tested without a terminal.
+ *
+ * Event shapes come from the backend: run events are
+ * llm.started / llm.chunk / llm.response / tool.started / tool.result /
+ * step.completed / verify.failed / run.completed / run.failed /
+ * run.cancelled; workflow pipelines emit execution.started /
+ * node.started / node.output / node.completed / node.skipped /
+ * execution.completed / execution.failed.
+ */
+export const INITIAL_LABEL = 'Thinking';
+export function initialStreamState() {
+    return {
+        partial: '',
+        label: INITIAL_LABEL,
+        emit: [],
+        usage: { cost: 0, tokens: 0, steps: 0 },
+        done: false,
+        cancelled: false,
+    };
+}
+/** Anything the server hands back as an "output", as text. */
+export function formatOutput(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    return JSON.stringify(value, null, 2);
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function str(value) {
+    return typeof value === 'string' && value ? value : undefined;
+}
+/** A tool's duration, when the event reported one. */
+function duration(ms) {
+    const n = num(ms);
+    if (!n)
+        return '';
+    return n >= 1000 ? ` ${(n / 1000).toFixed(1)}s` : ` ${Math.round(n)}ms`;
+}
+/**
+ * Fold one event into the state.
+ *
+ * Returns a new object every time so a React setState sees a change.
+ */
+export function reduceStreamEvent(prev, event) {
+    const s = { ...prev, emit: [...prev.emit], usage: { ...prev.usage } };
+    const d = (event.data ?? {});
+    switch (event.type) {
+        case 'llm.started':
+            s.label = 'Thinking';
+            return s;
+        case 'llm.chunk': {
+            const chunk = str(d.content);
+            if (chunk)
+                s.partial += chunk;
+            return s;
+        }
+        case 'llm.response': {
+            s.usage.cost += num(d.cost);
+            const usage = (d.usage ?? {});
+            s.usage.tokens += num(usage.totalTokens) || num(usage.inputTokens) + num(usage.outputTokens);
+            const routing = (d.routing ?? {});
+            s.usage.model = str(d.model) ?? str(routing.vendorModelId) ?? str(routing.modelId) ?? s.usage.model;
+            s.usage.rationale = str(routing.rationale) ?? s.usage.rationale;
+            if (typeof routing.attempt === 'number')
+                s.usage.attempt = routing.attempt;
+            const content = str(d.content);
+            const toolCalls = Array.isArray(d.toolCalls) ? d.toolCalls : [];
+            // A provider without token streaming emits no chunks at all, so
+            // the response body is the only copy of the answer.
+            if (content && !s.partial)
+                s.partial = content;
+            // Text that came before a tool call is a preamble, not the
+            // answer: flush it so the tool lines read underneath it, and
+            // start the next step with an empty buffer.
+            if (toolCalls.length) {
+                if (s.partial.trim())
+                    s.emit.push({ role: 'agent', text: s.partial.trim() });
+                s.partial = '';
+                s.label = 'Working';
+            }
+            return s;
+        }
+        case 'tool.started': {
+            const tool = str(d.tool);
+            if (tool) {
+                s.emit.push({ role: 'tool', text: tool });
+                s.label = `Running ${tool}`;
+            }
+            return s;
+        }
+        case 'tool.result': {
+            const tool = str(d.tool) ?? 'tool';
+            const ok = d.success !== false;
+            s.emit.push({
+                role: ok ? 'info' : 'error',
+                text: `${tool} ${ok ? 'ok' : 'failed'}${duration(d.executionTime)}`,
+            });
+            s.label = 'Thinking';
+            return s;
+        }
+        case 'step.completed': {
+            s.usage.steps += 1;
+            const status = str(d.status);
+            if (status === 'waiting_input')
+                s.label = 'Waiting for your input';
+            else if (status === 'sleeping')
+                s.label = 'Sleeping';
+            else if (status === 'revising')
+                s.label = 'Revising';
+            else
+                s.label = 'Thinking';
+            return s;
+        }
+        case 'verify.failed':
+            s.emit.push({ role: 'info', text: 'verification rejected the draft — revising' });
+            s.label = 'Revising';
+            return s;
+        // ── Workflow pipelines ───────────────────────────────────────
+        case 'execution.started':
+            s.label = 'Starting';
+            return s;
+        case 'node.started': {
+            const label = str(d.nodeType) ?? 'node';
+            const id = str(d.nodeId);
+            s.emit.push({ role: 'tool', text: id ? `${label} · ${id}` : label });
+            s.label = `Running ${label}`;
+            return s;
+        }
+        case 'node.completed': {
+            s.usage.cost += num(d.cost);
+            s.usage.tokens += num(d.tokens);
+            s.usage.steps += 1;
+            const error = str(d.error);
+            if (error)
+                s.emit.push({ role: 'error', text: `${str(d.nodeId) ?? 'node'} failed: ${error}` });
+            return s;
+        }
+        case 'node.skipped':
+            s.emit.push({ role: 'info', text: `${str(d.nodeId) ?? 'node'} skipped` });
+            return s;
+        case 'node.output':
+            // Intermediate node output is noise in a chat transcript; the
+            // pipeline's final output arrives on execution.completed.
+            return s;
+        case 'execution.completed': {
+            s.usage.cost += num(d.totalCost);
+            s.usage.tokens += num(d.totalTokens);
+            const output = formatOutput(d.output);
+            if (output)
+                s.output = output;
+            s.done = true;
+            return s;
+        }
+        case 'execution.failed':
+            s.failed = str(d.error) ?? str(d.message) ?? 'The pipeline failed';
+            s.done = true;
+            return s;
+        // ── Autonomous runs ──────────────────────────────────────────
+        case 'run.completed': {
+            const output = formatOutput(d.output);
+            if (output)
+                s.output = output;
+            s.done = true;
+            return s;
+        }
+        case 'run.failed':
+            s.failed = str(d.error) ?? 'The run failed';
+            s.done = true;
+            return s;
+        case 'run.cancelled':
+            s.cancelled = true;
+            s.done = true;
+            return s;
+        default:
+            return s;
+    }
+}
+/**
+ * The assistant text a finished stream should show.
+ *
+ * The streamed tokens are preferred over the completion event's output:
+ * they are what the user already watched arrive, and re-rendering a
+ * re-serialised copy of the same answer makes it flicker.
+ */
+export function finalText(state, fallbackOutput) {
+    const streamed = state.partial.trim();
+    if (streamed)
+        return streamed;
+    if (state.output)
+        return state.output;
+    return formatOutput(fallbackOutput);
+}
+/** Take the pending transcript lines, leaving the state without them. */
+export function drain(state) {
+    if (!state.emit.length)
+        return { activities: [], state };
+    return { activities: state.emit, state: { ...state, emit: [] } };
+}
+/** Add two tallies, for a session total across turns. */
+export function addUsage(a, b) {
+    return {
+        cost: a.cost + b.cost,
+        tokens: a.tokens + b.tokens,
+        steps: a.steps + b.steps,
+        model: b.model ?? a.model,
+        rationale: b.rationale ?? a.rationale,
+        attempt: b.attempt ?? a.attempt,
+    };
+}
+/** Dollars, at a precision that does not round a real cost to zero. */
+export function formatCost(dollars) {
+    if (!dollars)
+        return '$0';
+    if (dollars < 0.01)
+        return `$${dollars.toFixed(4)}`;
+    if (dollars < 1)
+        return `$${dollars.toFixed(3)}`;
+    return `$${dollars.toFixed(2)}`;
+}
+export function formatTokens(tokens) {
+    return tokens.toLocaleString('en-US');
+}
+/**
+ * One line of attribution: what answered, what it cost.
+ *
+ * This is the product's whole argument — many models, routed, with the
+ * bill attached — so a chat session says it out loud rather than
+ * leaving it in an audit log.
+ */
+export function formatUsage(usage) {
+    const parts = [];
+    if (usage.model) {
+        parts.push(usage.attempt && usage.attempt > 1 ? `${usage.model} (attempt ${usage.attempt})` : usage.model);
+    }
+    if (usage.tokens)
+        parts.push(`${formatTokens(usage.tokens)} tok`);
+    if (usage.cost)
+        parts.push(formatCost(usage.cost));
+    if (usage.steps)
+        parts.push(`${usage.steps} step${usage.steps === 1 ? '' : 's'}`);
+    return parts.join(' · ');
+}
+/**
+ * Model attribution off a finished run's steps.
+ *
+ * The llm.response event does not carry the answering model, so a run
+ * that streamed to completion has to be asked afterwards. Only the
+ * tool-calling step records `routing` today, so a single-step answer
+ * has no attribution to find and this returns null rather than
+ * guessing.
+ */
+export function routingFromSteps(steps) {
+    if (!Array.isArray(steps))
+        return null;
+    for (let i = steps.length - 1; i >= 0; i--) {
+        const routing = steps[i]?.output?.routing;
+        if (routing && typeof routing === 'object') {
+            return {
+                model: str(routing.vendorModelId) ?? str(routing.modelId),
+                rationale: str(routing.rationale),
+                attempt: typeof routing.attempt === 'number' ? routing.attempt : undefined,
+            };
+        }
+    }
+    return null;
+}

package/dist/turn.d.ts

@@ -0,0 +1,53 @@
+/**
+ * One turn of a conversation, driven the same way in both modes.
+ *
+ * The REPL and the non-interactive path used to be different code, and
+ * the non-interactive path did not exist. Both now call `runTurn`,
+ * which owns the choice between a streamed autonomous run and a
+ * streamed workflow pipeline, the cancellation handshake, and the
+ * cost tally. It takes the gateway as an interface so it can be tested
+ * against a fake without a network or a terminal.
+ */
+import type { AgentRun, RunLimits, StreamEvent } from '@almyty/client';
+import { type Activity, type Usage } from './stream.js';
+/** The part of GatewayClient a turn needs. */
+export interface TurnTarget {
+    startRun(input: any, options?: RunLimits & {
+        conversationId?: string;
+    }): Promise<AgentRun>;
+    streamRun(runId: string, handler: (event: StreamEvent) => void, signal?: AbortSignal): Promise<AgentRun>;
+    streamInvoke(input: Record<string, any>, handler: (event: StreamEvent) => void, signal?: AbortSignal): Promise<void>;
+    invoke(input: Record<string, any>): Promise<any>;
+    sendRunInput(runId: string, input: string): Promise<void>;
+    cancelRun(runId: string): Promise<void>;
+    cancelExecution(executionId: string): Promise<void>;
+}
+export interface TurnHooks {
+    /** The assistant text so far, on every change. */
+    partial?(text: string): void;
+    /** A transcript line: a tool call, a node, a warning. */
+    activity?(activity: Activity): void;
+    /** What the agent is doing, for a spinner. */
+    label?(label: string): void;
+}
+export type TurnStatus = 'completed' | 'failed' | 'cancelled' | 'waiting_input';
+export interface TurnResult {
+    status: TurnStatus;
+    text: string;
+    usage: Usage;
+    error?: string;
+    runId?: string;
+    conversationId?: string;
+    /** Set when the agent asked a question and is holding the run open. */
+    pendingRunId?: string;
+}
+export interface TurnOptions {
+    mode?: string;
+    conversationId?: string;
+    /** A run already waiting on input: this message answers it. */
+    pendingRunId?: string;
+    limits?: RunLimits;
+    signal?: AbortSignal;
+    hooks?: TurnHooks;
+}
+export declare function runTurn(target: TurnTarget, message: string, options?: TurnOptions): Promise<TurnResult>;

package/dist/turn.js

@@ -0,0 +1,147 @@
+/**
+ * One turn of a conversation, driven the same way in both modes.
+ *
+ * The REPL and the non-interactive path used to be different code, and
+ * the non-interactive path did not exist. Both now call `runTurn`,
+ * which owns the choice between a streamed autonomous run and a
+ * streamed workflow pipeline, the cancellation handshake, and the
+ * cost tally. It takes the gateway as an interface so it can be tested
+ * against a fake without a network or a terminal.
+ */
+import { drain, finalText, initialStreamState, reduceStreamEvent, routingFromSteps, } from './stream.js';
+function isAborted(err, signal) {
+    const e = err;
+    return !!signal?.aborted || (!!e && (e.name === 'AbortError' || e.code === 'ABORT_ERR'));
+}
+/** True when the pipeline stream endpoint is not there to be used. */
+function streamUnavailable(err) {
+    const status = err?.status;
+    if (status === 404 || status === 405)
+        return true;
+    return /Unknown agent action|SSE 404|SSE 405/.test(err?.message ?? '');
+}
+/** Wire the reducer's output into the hooks, once per event. */
+function pump(hooks, state, event) {
+    const before = state.partial;
+    const beforeLabel = state.label;
+    let next = reduceStreamEvent(state, event);
+    const drained = drain(next);
+    next = drained.state;
+    for (const activity of drained.activities)
+        hooks?.activity?.(activity);
+    if (next.partial !== before)
+        hooks?.partial?.(next.partial);
+    if (next.label !== beforeLabel)
+        hooks?.label?.(next.label);
+    return next;
+}
+/** Fill in attribution and totals the stream did not carry. */
+function settleUsage(usage, run) {
+    const settled = { ...usage };
+    if (!settled.model && run) {
+        const routing = routingFromSteps(run.steps);
+        if (routing) {
+            settled.model = routing.model ?? settled.model;
+            settled.rationale = routing.rationale ?? settled.rationale;
+            settled.attempt = routing.attempt ?? settled.attempt;
+        }
+    }
+    // The persisted totals are authoritative when the stream missed
+    // events (a reconnect, or a fallback to polling).
+    if (run && typeof run.totalCost === 'number' && run.totalCost > settled.cost)
+        settled.cost = run.totalCost;
+    if (run && typeof run.totalTokens === 'number' && run.totalTokens > settled.tokens)
+        settled.tokens = run.totalTokens;
+    return settled;
+}
+export async function runTurn(target, message, options = {}) {
+    const { hooks, signal } = options;
+    let state = initialStreamState();
+    hooks?.label?.(state.label);
+    if (options.mode === 'autonomous') {
+        let runId;
+        let conversationId = options.conversationId;
+        if (options.pendingRunId) {
+            await target.sendRunInput(options.pendingRunId, message);
+            runId = options.pendingRunId;
+        }
+        else {
+            const run = await target.startRun(message, { ...options.limits, conversationId });
+            runId = run.id;
+            conversationId = run.conversationId ?? conversationId;
+        }
+        let final;
+        try {
+            final = await target.streamRun(runId, (event) => { state = pump(hooks, state, event); }, signal);
+        }
+        catch (err) {
+            if (!isAborted(err, signal))
+                throw err;
+            // Stop the run where it is running, not just where it is watched.
+            // Killing the client alone leaves the run spending money with
+            // nobody reading the answer.
+            await target.cancelRun(runId).catch(() => { });
+            return {
+                status: 'cancelled',
+                text: state.partial.trim(),
+                usage: settleUsage(state.usage, undefined),
+                runId,
+                conversationId,
+            };
+        }
+        if (state.cancelled) {
+            return { status: 'cancelled', text: state.partial.trim(), usage: settleUsage(state.usage, final), runId, conversationId };
+        }
+        const usage = settleUsage(state.usage, final);
+        const text = finalText(state, final?.output);
+        if (final?.status === 'waiting_input') {
+            return { status: 'waiting_input', text, usage, runId, conversationId, pendingRunId: runId };
+        }
+        if (state.failed || final?.status === 'failed' || final?.status === 'timeout') {
+            return { status: 'failed', text, usage, error: state.failed ?? final?.error ?? 'The run failed', runId, conversationId };
+        }
+        return { status: 'completed', text, usage, runId, conversationId };
+    }
+    // Workflow agents: a pipeline, streamed so its nodes are visible.
+    // The execution id arrives on execution.started and is the only handle
+    // on the pipeline: it is not known before the stream opens, and without
+    // it a cancel has nothing to name.
+    let executionId;
+    try {
+        await target.streamInvoke({ message }, (event) => {
+            const id = event?.data?.executionId;
+            if (typeof id === 'string' && id)
+                executionId = id;
+            state = pump(hooks, state, event);
+        }, signal);
+    }
+    catch (err) {
+        if (isAborted(err, signal)) {
+            // Stop the pipeline where it is running, not just where it is
+            // watched -- the same handshake the autonomous branch does with
+            // cancelRun. A workflow run is an execution, not a run, so
+            // cancelRun could never reach it: Ctrl-C reported `cancelled`
+            // while the pipeline ran on, billing model calls nobody would read.
+            if (executionId)
+                await target.cancelExecution(executionId).catch(() => { });
+            return { status: 'cancelled', text: state.partial.trim(), usage: state.usage, conversationId: options.conversationId };
+        }
+        if (!streamUnavailable(err))
+            throw err;
+        // A deployment without the pipeline stream still answers the
+        // blocking call; the run is just invisible while it happens.
+        const result = await target.invoke({ message });
+        const output = result?.output ?? result?.data?.output ?? result;
+        return {
+            status: result?.status && result.status !== 'completed' ? 'failed' : 'completed',
+            text: finalText(state, output),
+            usage: state.usage,
+            error: result?.error,
+            conversationId: options.conversationId,
+        };
+    }
+    if (state.failed) {
+        return { status: 'failed', text: finalText(state), usage: state.usage, error: state.failed, conversationId: options.conversationId };
+    }
+    return { status: 'completed', text: finalText(state), usage: state.usage, conversationId: options.conversationId };
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare function readVersion(fallback?: string): string;
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,27 @@
+/**
+ * The CLI's own version, read from its package.json at startup.
+ *
+ * Hardcoding it drifted: `--version` answered 0.2.0 while the
+ * published package was 1.2.0, so a bug report never identified the
+ * build it came from. Both `dist/index.js` and `src/index.tsx` sit one
+ * directory below the package root, so the same relative path resolves
+ * for the built bin and for `tsx src/index.tsx`.
+ *
+ * A single-file executable (the `/apps` tui target compiles this client
+ * with `bun --compile`) has no package.json to read, so it falls back.
+ * A compiled terminal app's version is the app's, not this client's,
+ * and the build is where that belongs.
+ */
+import { readFileSync } from 'node:fs';
+export function readVersion(fallback = '0.0.0') {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+        return typeof pkg.version === 'string' && pkg.version.length > 0
+            ? pkg.version
+            : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export const VERSION = readVersion();

package/dist/viewport.d.ts

@@ -0,0 +1,61 @@
+/**
+ * How much of the transcript fits on screen.
+ *
+ * ink redraws its whole tree, so a transcript taller than the terminal
+ * garbles the frame instead of scrolling it. The fix is to draw only
+ * what fits and say how much is above. Pure arithmetic, kept out of the
+ * components so it can be tested at any terminal size — including the
+ * 40-column window nobody remembers to try.
+ */
+/** Narrowest width worth laying out for. */
+export declare const MIN_COLUMNS = 40;
+/** Fewest transcript rows to draw, even on a very short terminal. */
+export declare const MIN_ROWS = 5;
+export declare function columns(stdoutColumns?: number): number;
+/**
+ * Rows left for the transcript once the header, prompt and status bar
+ * have taken theirs.
+ */
+export declare function usableRows(stdoutRows: number | undefined, chromeRows: number): number;
+/**
+ * How many terminal columns a string occupies.
+ *
+ * `String.length` counts UTF-16 units, which is not width. A CJK
+ * character is one unit and two columns; an emoji is two units and two
+ * columns; a combining mark or a zero-width joiner is a unit and no
+ * columns. Measuring by length made a Japanese or Chinese transcript
+ * estimate half its real height, so the window packed twice what fits
+ * and ink drew a frame taller than the terminal — the garbling the rest
+ * of this module exists to prevent.
+ */
+export declare function displayWidth(text: string): number;
+/**
+ * Rows one message will occupy at this width.
+ *
+ * Counts the wrap, not the characters: a 300-character paragraph is
+ * four rows at 80 columns and eight at 40.
+ */
+export declare function estimateLines(text: string, cols: number): number;
+export interface WindowSelection {
+    startIdx: number;
+    endIdx: number;
+    hiddenBefore: number;
+    hiddenAfter: number;
+}
+/**
+ * The slice of messages to draw.
+ *
+ * Walks backwards from the end so the newest message is always visible:
+ * a transcript that scrolls away from the answer you just asked for is
+ * worse than one that hides the beginning. The newest message is kept
+ * even when it alone is taller than the window, because dropping it
+ * would leave an empty screen.
+ */
+export declare function selectWindow(messages: Array<{
+    text: string;
+}>, options: {
+    rows: number;
+    cols: number;
+    reservedRows?: number;
+    scrollOffset?: number;
+}): WindowSelection;