@falkenslab/agent-kit 0.10.1

package/dist/tui/chatTui.js

@@ -0,0 +1,265 @@
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { createWriteStream } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createInputQueue } from "../core/session.js";
+import { runQuery } from "../core/runner.js";
+import { isSharedQuestionActive, setSharedReadline } from "./terminalInteraction.js";
+import * as ui from "./ui.js";
+import { createConsoleRenderer } from "./consoleRenderer.js";
+// Only strips picocolors' own SGR sequences (`\x1b[<codes>m`) — the only kind this file
+// ever writes to the console — not a general-purpose ANSI stripper for arbitrary escape
+// sequences (cursor movement, OSC, ...) this kit never emits.
+// eslint-disable-next-line no-control-regex -- \x1b is the ESC byte SGR sequences start with, not an accident
+const ANSI_SGR = /\x1b\[[0-9;]*m/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_SGR, "");
+}
+const DEFAULT_PROMPT_LABEL = "\n> ";
+const DEFAULT_EXIT_COMMANDS = ["/exit", "/quit"];
+const DEFAULT_HISTORY_LIMIT = 100;
+/** Keeps only the most recent `limit` entries (oldest-first order in, oldest-first out). */
+export function capHistory(entries, limit) {
+    return entries.length > limit ? entries.slice(-limit) : entries.slice();
+}
+/** Oldest-first. Missing file reads as empty — nothing to load yet is the normal case. */
+export async function loadHistory(filePath) {
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    return raw
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+}
+/** Overwrites the whole file (not appended) so a prior prune (oldest entries dropped) sticks. */
+export async function saveHistory(filePath, entries) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const body = entries.map((entry) => JSON.stringify(entry)).join("\n");
+    await writeFile(filePath, entries.length > 0 ? `${body}\n` : "", "utf8");
+}
+/**
+ * The command name a typed line would invoke (e.g. "chiste" for both "/chiste" and
+ * "/chiste con salsa"), or `null` for a line that isn't a slash command at all (doesn't
+ * start with "/") or is just a bare "/" with nothing after it.
+ */
+export function slashCommandToken(line) {
+    if (!line.startsWith("/"))
+        return null;
+    const token = line.slice(1).split(/\s/, 1)[0];
+    return token ? token : null;
+}
+/**
+ * Reads `events` one turn at a time — up to and including a `turn-end` — via manual
+ * `.next()` calls, calling `onEvent` for each. Deliberately never uses
+ * `for await...of` + `break`: `run.events` (see runner.ts) is one long-lived generator
+ * spanning the *whole* multi-turn session, not one per turn, and breaking out of a
+ * `for-await-of` loop calls the generator's `.return()`, permanently closing it — the next
+ * turn's drain would then see `done: true` immediately and silently lose the rest of the
+ * conversation. Exported on its own (not part of the package's public API — see index.ts)
+ * so this exact behavior has a direct regression test.
+ */
+export async function drainTurn(events, onEvent) {
+    while (true) {
+        const { value, done } = await events.next();
+        if (done)
+            return;
+        onEvent(value);
+        if (value.type === "turn-end")
+            return;
+    }
+}
+/**
+ * A ready-to-run interactive terminal chat loop, assembled from this kit's own chat
+ * primitives: `createInputQueue()` feeds typed lines into a multi-turn `query()` session,
+ * `runQuery()`'s normalized event stream is rendered to the console (streamed text,
+ * friendly action labels via `createFriendlyToolLabel()`, turn failures), and this loop's
+ * own `readline.Interface` is registered via `setSharedReadline()` so any human-in-the-loop
+ * checkpoint the session hits (the interactive-mode step gate, or the guided-mode approval/
+ * manual-login tools — see terminalInteraction.ts) prompts on the same interface instead of a
+ * second one fighting it for stdin's raw mode.
+ *
+ * Takes the SDK `Options` produced by `buildSessionOptions()` rather than an `AgentSpec`
+ * directly, so it stays reusable for an `Options` assembled any other way:
+ *
+ *   const { options } = await buildSessionOptions(config, runDir, spec);
+ *   await runChatTui(options, { welcomeMessage: "Ready. Type /exit to quit." });
+ *
+ * Resolves once the chat ends (an exit command, Ctrl+C/Ctrl+D at an idle prompt) — this
+ * function owns the whole session lifecycle, closing the underlying query and readline
+ * interface itself before returning.
+ */
+export async function runChatTui(options, tuiOptions = {}) {
+    const exitCommands = new Set((tuiOptions.exitCommands ?? DEFAULT_EXIT_COMMANDS).map((c) => c.toLowerCase()));
+    const promptLabel = tuiOptions.promptLabel ?? DEFAULT_PROMPT_LABEL;
+    const queue = createInputQueue();
+    const run = runQuery(queue.iterable, options);
+    const events = run.events[Symbol.asyncIterator]();
+    const historyLimit = tuiOptions.historyLimit ?? DEFAULT_HISTORY_LIMIT;
+    let historyEntries = tuiOptions.historyPath ? capHistory(await loadHistory(tuiOptions.historyPath), historyLimit) : [];
+    const rl = readline.createInterface({
+        input: stdin,
+        output: stdout,
+        // readline wants most-recent-first (↑ shows historyEntries' last/newest entry first);
+        // this file is stored oldest-first (append-friendly, reads top-to-bottom like a log).
+        history: historyEntries.map((entry) => entry.text).reverse(),
+        historySize: historyLimit,
+    });
+    setSharedReadline(rl);
+    const sessionLog = tuiOptions.sessionLogPath ? createWriteStream(tuiOptions.sessionLogPath, { flags: "a" }) : null;
+    // Mirrors to the log file only — for text already visible on the terminal some other
+    // way (readline's own prompt + the human's local echo), so it isn't printed twice.
+    function mirror(text) {
+        sessionLog?.write(stripAnsi(text));
+    }
+    // Prints to the console *and* mirrors to the log file — the normal case for anything
+    // this loop itself puts on screen (streamed reply text, action/error lines, ...).
+    // Tracks whether the terminal cursor currently sits at column 0 of a fresh row — true
+    // right after any write ending in "\n" (writeLine's normal case), false right after a
+    // streamed text delta that doesn't (the common case: deltas rarely end mid-sentence on a
+    // newline). Confirmed empirically (against a working chat loop that
+    // ends its streamed text block with an explicit newline): even with `prevRows` reset to 0 above, if the
+    // cursor is left *mid-row* when the next prompt redraws, `[kRefreshLine]`'s `cursorTo(0)`
+    // moves it to column 0 of that *same* row — the row still holding the tail of what we
+    // just wrote — and the following `clearScreenDown` wipes the row from there on, eating
+    // whatever was on it (for a short reply, potentially the whole thing, since "that row" is
+    // its only row). Ending every turn's output on a fresh blank row (see below, after
+    // `drainTurn()`) sidesteps this entirely: `clearScreenDown` then only ever clears blank
+    // space, on any row.
+    // Every write goes through the shared console renderer (./consoleRenderer.ts), which
+    // tracks whether the cursor sits at the start of a line and never emits a blank line
+    // between consecutive action lines.
+    const renderer = createConsoleRenderer({
+        formatAction: tuiOptions.formatAction,
+        agentLabel: tuiOptions.agentLabel,
+        output: (text) => void stdout.write(text),
+        onWrite: (text) => {
+            mirror(text);
+            // node:readline's `Interface` tracks, on itself, how many terminal rows its own last
+            // rendered prompt+line took (`prevRows`), so that the *next* time it redraws (the next
+            // `rl.question()` for the following turn, but — confirmed empirically — also any
+            // ordinary keystroke typed ahead while a long reply is still streaming here, since the
+            // interface keeps listening to stdin the whole time, not just while a `question()` is
+            // pending) it knows how far to move the cursor up before clearing. Every write this
+            // function makes happens outside readline entirely, so that bookkeeping goes stale the
+            // moment we print anything — left uncorrected, that next redraw moves the cursor up by
+            // the stale (small/zero) row count from wherever it *actually* is now (the bottom of
+            // everything just written) and clears from there down, visibly eating the tail of a
+            // short reply (or, for a long one the user started typing over), a chunk out of its
+            // middle. `prevRows` isn't part of readline's public/typed API, but it *is* a plain,
+            // externally-settable instance property at runtime (not a real JS `#private` field) —
+            // resetting it to 0 after every write of our own keeps that bookkeeping honest right up
+            // to the moment readline's own logic (ours or a stray keystroke's) needs it next, so
+            // the cursor-up step is always a no-op and the clear only ever touches blank space
+            // below the real cursor.
+            rl.prevRows = 0;
+        },
+    });
+    const { writeLine } = renderer;
+    // Cached lazily (not fetched until the first "/..." line, and only once — the SDK docs
+    // don't promise this list changes mid-session, and re-fetching per line would add a
+    // round-trip to the CLI subprocess for every turn): every registered command name/alias,
+    // built-ins (`/compact`, ...) included, so `/exit`-style local ones never false-flag.
+    let knownCommandTokens = null;
+    async function isKnownSlashCommand(token) {
+        if (!knownCommandTokens) {
+            const commands = await run.supportedCommands();
+            knownCommandTokens = new Set(commands.flatMap((c) => [c.name, ...(c.aliases ?? [])]));
+        }
+        return knownCommandTokens.has(token);
+    }
+    let turnInFlight = false;
+    let turnInterrupted = false;
+    function interruptTurn() {
+        if (turnInterrupted)
+            return;
+        turnInterrupted = true;
+        void run.interrupt();
+        writeLine(ui.warn("(interrupted)"));
+    }
+    rl.on("SIGINT", () => {
+        if (turnInFlight) {
+            interruptTurn();
+        }
+        else {
+            queue.end();
+            rl.close();
+        }
+    });
+    // Esc interrupts the turn in flight too, like Ctrl+C — but, unlike it, never ends the
+    // chat, and does nothing while a human-in-the-loop checkpoint is asking on this same
+    // interface (Esc there is just a keystroke on the question). The readline interface
+    // already emits "keypress" on stdin, and only reports name "escape" for a lone Esc, not
+    // for the Esc-prefixed sequences of arrow/function keys.
+    const onKeypress = (_chunk, key) => {
+        if (key?.name === "escape" && turnInFlight && !isSharedQuestionActive())
+            interruptTurn();
+    };
+    stdin.on("keypress", onKeypress);
+    if (tuiOptions.welcomeMessage)
+        writeLine(tuiOptions.welcomeMessage);
+    try {
+        if (tuiOptions.initialPrompt) {
+            mirror(`${promptLabel}${tuiOptions.initialPrompt}\n`);
+            queue.push(tuiOptions.initialPrompt);
+            turnInFlight = true;
+            turnInterrupted = false;
+            renderer.startTurn();
+            await drainTurn(events, renderer.render);
+            turnInFlight = false;
+            renderer.endLine();
+        }
+        while (true) {
+            let line;
+            try {
+                line = (await rl.question(promptLabel)).trim();
+            }
+            catch {
+                break; // the interface closed underneath us (SIGINT/EOF while idle)
+            }
+            if (!line)
+                continue;
+            mirror(`${promptLabel}${line}\n`);
+            if (tuiOptions.historyPath) {
+                historyEntries = capHistory([...historyEntries, { text: line, timestamp: new Date().toISOString() }], historyLimit);
+                await saveHistory(tuiOptions.historyPath, historyEntries);
+            }
+            if (exitCommands.has(line.toLowerCase()))
+                break;
+            // A line that *looks* like a slash command but matches nothing registered (a typo,
+            // an unnamespaced plugin command, ...) would otherwise reach the model as literal
+            // text with no special handling — confirmed empirically (captain-whiskers'
+            // /chiste before it was renamed /captain-whiskers:chiste) that this can look
+            // exactly like nothing happened at all. Caught here, before the turn even starts,
+            // so it's an immediate, unambiguous message instead of a guess at what the model's
+            // silence on unrecognized input might mean.
+            const commandToken = slashCommandToken(line);
+            if (commandToken && !(await isKnownSlashCommand(commandToken))) {
+                writeLine(ui.warn(`Unknown command: /${commandToken}`));
+                continue;
+            }
+            queue.push(line);
+            turnInFlight = true;
+            turnInterrupted = false;
+            renderer.startTurn();
+            await drainTurn(events, renderer.render);
+            turnInFlight = false;
+            renderer.endLine();
+        }
+    }
+    finally {
+        stdin.off("keypress", onKeypress);
+        queue.end();
+        run.close();
+        setSharedReadline(null);
+        rl.close();
+        sessionLog?.end();
+    }
+}

package/dist/tui/claudeAuth.d.ts

@@ -0,0 +1,19 @@
+import { type ClaudeAuthConfig } from "../core/claudeAuth.js";
+/**
+ * The terminal-facing counterpart to `resolveClaudeAuth()` (core/claudeAuth.ts), which only
+ * *looks up* a token. This one also gets you one: if `resolveClaudeAuth(config)` comes back
+ * empty, it prints why, offers to run "claude setup-token" interactively, and sets the
+ * result on `process.env.CLAUDE_CODE_OAUTH_TOKEN` for this run. Exits the process if the
+ * user declines or cancels — there's no agent to run without a token.
+ *
+ * Persisting a freshly-generated token across runs is *not* this function's job — unlike an
+ * earlier version, this kit owns no config-file storage of its own (see git history). When
+ * the interactive flow does generate one, it's returned so the caller can save it wherever
+ * it wants (a file, an OS keychain, ...) and pass it back in as `config.claudeCodeOAuthToken`
+ * next time; returns `undefined` when auth was already resolved (an env var, or the `config`
+ * passed in) and nothing new was generated.
+ *
+ * Only makes sense with a real terminal in front of a human (a `runWizard()` confirm, colored console
+ * output), which is why it lives here rather than in the non-interactive core.
+ */
+export declare function ensureClaudeAuth(config?: ClaudeAuthConfig): Promise<string | undefined>;

package/dist/tui/claudeAuth.js

@@ -0,0 +1,96 @@
+import { spawn } from "node:child_process";
+import { resolveClaudeAuth } from "../core/claudeAuth.js";
+import { isExitPromptError } from "./promptErrors.js";
+import * as ui from "./ui.js";
+import { runWizard } from "./ink/wizard.js";
+// The real format of "claude setup-token" tokens ("sk-ant-oat01-...", seen in the
+// installed @anthropic-ai/claude-code binary) — used to extract the token from its output.
+const TOKEN_PATTERN = /sk-ant-oat\d{2}-[A-Za-z0-9_-]+/;
+/**
+ * Launches "claude setup-token" as an interactive child process: it opens a browser and
+ * asks the user to authenticate, with instructions it prints itself. stdin/stderr are
+ * inherited as-is so the interaction (pasting the authorization code, etc.) is identical
+ * to running the command by hand; stdout is duplicated live and also buffered to extract
+ * the token it prints at the end ("Your OAuth token (...): sk-ant-oat01-...").
+ */
+function runSetupToken() {
+    return new Promise((resolve, reject) => {
+        // On Windows npx is npx.cmd, which only runs through a shell. The command is passed as
+        // one fixed string there (nothing user-supplied in it): an args array with
+        // `shell: true` triggers Node's DEP0190 warning, since args are concatenated unescaped.
+        const stdio = ["inherit", "pipe", "inherit"];
+        const child = process.platform === "win32"
+            ? spawn("npx @anthropic-ai/claude-code setup-token", { stdio, shell: true })
+            : spawn("npx", ["@anthropic-ai/claude-code", "setup-token"], { stdio });
+        let output = "";
+        child.stdout.on("data", (chunk) => {
+            const text = chunk.toString("utf-8");
+            output += text;
+            process.stdout.write(text);
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code !== 0) {
+                reject(new Error(`"claude setup-token" exited with code ${code}.`));
+                return;
+            }
+            const match = output.match(TOKEN_PATTERN);
+            if (!match) {
+                reject(new Error('"claude setup-token" exited without errors, but no token was found in its ' +
+                    "output (sk-ant-oat...). Copy it by hand into CLAUDE_CODE_OAUTH_TOKEN if you see it above."));
+                return;
+            }
+            resolve(match[0]);
+        });
+    });
+}
+/**
+ * The terminal-facing counterpart to `resolveClaudeAuth()` (core/claudeAuth.ts), which only
+ * *looks up* a token. This one also gets you one: if `resolveClaudeAuth(config)` comes back
+ * empty, it prints why, offers to run "claude setup-token" interactively, and sets the
+ * result on `process.env.CLAUDE_CODE_OAUTH_TOKEN` for this run. Exits the process if the
+ * user declines or cancels — there's no agent to run without a token.
+ *
+ * Persisting a freshly-generated token across runs is *not* this function's job — unlike an
+ * earlier version, this kit owns no config-file storage of its own (see git history). When
+ * the interactive flow does generate one, it's returned so the caller can save it wherever
+ * it wants (a file, an OS keychain, ...) and pass it back in as `config.claudeCodeOAuthToken`
+ * next time; returns `undefined` when auth was already resolved (an env var, or the `config`
+ * passed in) and nothing new was generated.
+ *
+ * Only makes sense with a real terminal in front of a human (a `runWizard()` confirm, colored console
+ * output), which is why it lives here rather than in the non-interactive core.
+ */
+export async function ensureClaudeAuth(config = {}) {
+    if (resolveClaudeAuth(config))
+        return undefined;
+    console.log(ui.warn("\nNo Claude authentication token was found"));
+    console.log(ui.dim("(neither the CLAUDE_CODE_OAUTH_TOKEN environment variable, nor one passed in)."));
+    try {
+        const { generate } = await runWizard([
+            {
+                type: "confirm",
+                name: "generate",
+                message: 'Generate one now with "claude setup-token" (requires a Claude Pro/Max subscription)?',
+                default: true,
+            },
+        ]);
+        if (!generate) {
+            console.log(ui.error("\nThe agent can't start without a token. Set CLAUDE_CODE_OAUTH_TOKEN by hand " +
+                "(or run this again and accept generating it) and try again."));
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        if (isExitPromptError(error))
+            process.exit(0);
+        throw error;
+    }
+    console.log(ui.heading("\n=== Generating a Claude authentication token ==="));
+    console.log(ui.dim("A browser will open to log in; follow the instructions the command itself prints " +
+        "below.\n"));
+    const token = await runSetupToken();
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = token;
+    console.log(ui.success("\nToken generated for this run. Save it yourself (e.g. CLAUDE_CODE_OAUTH_TOKEN in your shell profile) to skip this next time.\n"));
+    return token;
+}

package/dist/tui/consoleRenderer.d.ts

@@ -0,0 +1,32 @@
+import type { AgentEvent } from "../core/runner.js";
+export interface ConsoleRendererOptions {
+    /** Turns a tool call into its console label; defaults to `createFriendlyToolLabel()`. */
+    formatAction?: (toolName: string, toolInput: unknown) => string;
+    /** Printed (already styled) before the first text of each turn, e.g. "my-agent>". */
+    agentLabel?: string;
+    /** Where the text goes; defaults to `process.stdout`. */
+    output?: (text: string) => void;
+    /** Called after every write with the same text, e.g. to mirror it into a log file. */
+    onWrite?: (text: string) => void;
+}
+export interface ConsoleRenderer {
+    /** Prints one normalized event from `runQuery()`. */
+    render(event: AgentEvent): void;
+    write(text: string): void;
+    /** Writes `text` on a line of its own: after ending the current line if needed. */
+    writeLine(text: string): void;
+    /** Ends the current line, if the cursor isn't already at the start of one. */
+    endLine(): void;
+    /** Marks the start of a new turn, so the agent label is printed again before its text. */
+    startTurn(): void;
+    /** Whether the cursor sits at the start of a line (after anything ending in "\n"). */
+    readonly atLineStart: boolean;
+}
+/**
+ * The console rendering of `runQuery()`'s event stream, shared by `runChatTui()` and by any
+ * one-shot run that prints the same events. Streamed text rarely ends in a newline, so
+ * every other line (actions, notices, errors) starts by ending the current line only if
+ * it isn't already ended — never with a fixed "\n", which leaves a blank line between
+ * consecutive actions.
+ */
+export declare function createConsoleRenderer(options?: ConsoleRendererOptions): ConsoleRenderer;

package/dist/tui/consoleRenderer.js

@@ -0,0 +1,72 @@
+import { stdout } from "node:process";
+import { createFriendlyToolLabel } from "../core/toolLabels.js";
+import * as ui from "./ui.js";
+/**
+ * The console rendering of `runQuery()`'s event stream, shared by `runChatTui()` and by any
+ * one-shot run that prints the same events. Streamed text rarely ends in a newline, so
+ * every other line (actions, notices, errors) starts by ending the current line only if
+ * it isn't already ended — never with a fixed "\n", which leaves a blank line between
+ * consecutive actions.
+ */
+export function createConsoleRenderer(options = {}) {
+    const formatAction = options.formatAction ?? createFriendlyToolLabel();
+    const output = options.output ?? ((text) => void stdout.write(text));
+    let atLineStart = true;
+    let labelPrinted = false;
+    function write(text) {
+        if (text.length === 0)
+            return;
+        output(text);
+        options.onWrite?.(text);
+        atLineStart = text.endsWith("\n");
+    }
+    function endLine() {
+        if (!atLineStart)
+            write("\n");
+    }
+    function writeLine(text) {
+        endLine();
+        write(`${text}\n`);
+    }
+    function render(event) {
+        switch (event.type) {
+            case "text":
+                if (options.agentLabel && !labelPrinted) {
+                    endLine();
+                    write(`${options.agentLabel} `);
+                    labelPrinted = true;
+                }
+                write(ui.agent(event.text));
+                return;
+            case "action":
+                writeLine(ui.action(`[action] ${formatAction(event.toolName, event.input)}`));
+                return;
+            case "subagent-action":
+            case "tool-result":
+            case "prompt-suggestion":
+                return;
+            case "mcp-error":
+                writeLine(ui.warn(`Some MCP servers failed to connect: ${event.failedServers.join(", ")}`));
+                return;
+            case "info":
+                writeLine((event.level === "warning" ? ui.warn : ui.dim)(`(${event.text})`));
+                return;
+            case "turn-end":
+                if (event.failed && event.errorText)
+                    writeLine(ui.error(event.errorText));
+                return;
+        }
+    }
+    return {
+        render,
+        write,
+        writeLine,
+        endLine,
+        startTurn: () => {
+            labelPrinted = false;
+        },
+        get atLineStart() {
+            return atLineStart;
+        },
+    };
+}

package/dist/tui/ink/PromptInput.d.ts

@@ -0,0 +1,40 @@
+/** Commands (names without "/") a partial "/name" line could still become. */
+export declare function matchingCommands(value: string, commands: readonly string[]): string[];
+/** Tab: completes a unique match (plus a space for its arguments), else the common prefix. */
+export declare function completeCommand(value: string, commands: readonly string[]): string;
+/**
+ * The slice [start, end) of a `length`-character line shown in `room` columns, keeping the
+ * cursor in view: like the live area, the prompt must never reach the terminal's edge (see
+ * lineBuffer.ts), so a long line scrolls sideways, with "…" on each cut side.
+ */
+export declare function visibleWindow(length: number, cursor: number, room: number): [number, number];
+export interface PromptInputProps {
+    label: string;
+    /** Columns taken around the prompt (a frame), so a long line scrolls before reaching the edge. */
+    inset?: number;
+    /** A suggested prompt, shown dim in the empty prompt; Tab takes it. */
+    suggestion?: string | null;
+    /** Earlier lines, oldest first, for ↑/↓ and Ctrl+R. */
+    history: readonly string[];
+    /** Slash command names (without "/") for suggestions and Tab completion. */
+    commands: readonly string[];
+    /** Gets the text as sent: pasted blocks expanded. */
+    onSubmit(line: string): void;
+    /** Ctrl+D on an empty line. */
+    onExit(): void;
+    /** ↑ on an empty prompt: takes the last queued line back (see runChatInk.tsx), or null if none. */
+    onRecallQueued?: () => string | null;
+    /** Project files for `@` mentions (paths relative to the session's folder). */
+    files?: readonly string[];
+}
+/** The shortcuts panel, opened with "?" on an empty prompt. */
+export declare const SHORTCUTS: string[];
+/**
+ * The chat's prompt: history (↑/↓), "/command" completion and suggestions (Tab), pasted
+ * blocks folded into a token, multi-line input (`\` + Enter or Ctrl+J), word and line
+ * shortcuts (Ctrl+W/K/U, Ctrl+←/→, Home/End, Ctrl+A/E), reverse history search (Ctrl+R)
+ * and taking a queued line back (↑ on an empty prompt). Written here rather than taken from
+ * @inkjs/ui because its TextInput is uncontrolled. Backspace also arrives as `delete` on
+ * Windows terminals, so both erase backwards.
+ */
+export declare function PromptInput({ label, inset, suggestion, history, commands, onSubmit, onExit, onRecallQueued, files }: PromptInputProps): import("react").JSX.Element;