@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/bot/runtime/index.js

@@ -1,417 +0,0 @@
-import { execFileSync, spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { planBotRuntimeSpawn } from "./windows.js";
-import { GrokAcpClient } from "./grok-acp.js";
-import { createClaudeRuntime } from "./claude.js";
-import { createCodexRuntime } from "./codex.js";
-import { createGrokRuntime, grokRetryArgsAfterInvalidOutputFormat, probeGrokOutputFormat } from "./grok.js";
-import { stripControlTokens } from "./sanitize.js";
-import { parseJsonLine, RuntimeError, turnTimeoutMs, stderrExcerpt, } from "./types.js";
-export * from "./types.js";
-export { createClaudeRuntime, claudePermissionMode } from "./claude.js";
-export { createCodexRuntime, codexPrompt } from "./codex.js";
-export { createGrokRuntime, grokPrompt } from "./grok.js";
-export function runtimeFor(id, env = process.env) {
-    if (id === "claude")
-        return createClaudeRuntime(env);
-    if (id === "codex")
-        return createCodexRuntime();
-    probeGrokOutputFormat();
-    return createGrokRuntime();
-}
-/**
- * Real child spawn, stdin closed. stdout is delivered line by line while the
- * process runs (for streaming runtimes) and also returned whole at the end.
- * No time limit unless `timeoutMs` is set; `signal` kills the process.
- */
-/**
- * Every live descendant of `pid` (children first found, deepest last). The
- * model CLI starts its own tools and shells; stopping only the top process
- * leaves those running and holding the output pipe open, so a stop would hang
- * until they finish. POSIX only; empty when `ps` is unavailable.
- */
-export function descendantPids(pid, listProcesses = defaultListProcesses) {
-    let table;
-    try {
-        table = listProcesses();
-    }
-    catch {
-        return [];
-    }
-    const children = new Map();
-    for (const row of table.split("\n")) {
-        const m = /^\s*(\d+)\s+(\d+)\s*$/.exec(row);
-        if (!m)
-            continue;
-        const child = Number(m[1]);
-        const parent = Number(m[2]);
-        const list = children.get(parent) ?? [];
-        list.push(child);
-        children.set(parent, list);
-    }
-    const out = [];
-    const queue = [...(children.get(pid) ?? [])];
-    const seen = new Set([pid]);
-    while (queue.length > 0) {
-        const next = queue.shift();
-        if (seen.has(next))
-            continue;
-        seen.add(next);
-        out.push(next);
-        queue.push(...(children.get(next) ?? []));
-    }
-    return out;
-}
-function defaultListProcesses() {
-    return execFileSync("ps", ["-A", "-o", "pid=,ppid="], { encoding: "utf8", timeout: 5_000 });
-}
-/** After a stop, wait this long for the output pipes to close before settling anyway. */
-export const STOP_SETTLE_GRACE_MS = 2_000;
-export const defaultSpawn = (command, args, options) => new Promise((resolve, reject) => {
-    let stdout = "";
-    let stderr = "";
-    let partial = "";
-    let settled = false;
-    const plan = planBotRuntimeSpawn(command, args, options.env);
-    const child = spawn(plan.cmd, plan.args, {
-        cwd: options.cwd,
-        env: options.env,
-        stdio: [options.stdin !== undefined || options.protocol ? "pipe" : "ignore", "pipe", "pipe"],
-        ...(plan.shell ? { shell: plan.shell } : {}),
-        ...(plan.windowsVerbatimArguments !== undefined
-            ? { windowsVerbatimArguments: plan.windowsVerbatimArguments }
-            : {}),
-        windowsHide: true,
-    });
-    let stopping = false;
-    let protocolComplete = false;
-    const signalTree = (sig, pids) => {
-        for (const p of pids) {
-            try {
-                process.kill(p, sig);
-            }
-            catch {
-                /* already gone */
-            }
-        }
-    };
-    const kill = () => {
-        stopping = true;
-        if (process.platform === "win32" && child.pid !== undefined) {
-            const rootKey = Object.keys(options.env).find((key) => key.toUpperCase() === "SYSTEMROOT");
-            const systemRoot = rootKey ? options.env[rootKey] : undefined;
-            const taskkill = path.win32.join(systemRoot || "C:\\Windows", "System32", "taskkill.exe");
-            let finished = false;
-            const fallbackKill = (reason) => {
-                if (finished)
-                    return;
-                finished = true;
-                stderr += `\n[hq bot] could not stop the Windows process tree with taskkill.exe: ${reason}`;
-                try {
-                    child.kill();
-                }
-                catch (err) {
-                    stderr += `\n[hq bot] could not stop the runtime wrapper: ${err instanceof Error ? err.message : String(err)}`;
-                }
-            };
-            let killer;
-            try {
-                killer = spawn(taskkill, ["/PID", String(child.pid), "/T", "/F"], {
-                    env: options.env,
-                    stdio: "ignore",
-                    windowsHide: true,
-                });
-            }
-            catch (err) {
-                fallbackKill(err instanceof Error ? err.message : String(err));
-                return;
-            }
-            const fallbackTimer = setTimeout(() => fallbackKill("taskkill.exe did not finish within 5 seconds"), 5_000);
-            killer.once("error", (err) => {
-                clearTimeout(fallbackTimer);
-                fallbackKill(err.message);
-            });
-            killer.once("close", (code) => {
-                clearTimeout(fallbackTimer);
-                finished = true;
-                if (code !== 0 && child.exitCode === null && child.signalCode === null) {
-                    stderr += `\n[hq bot] taskkill.exe exited with code ${code} while stopping the runtime process tree`;
-                    try {
-                        child.kill();
-                    }
-                    catch (err) {
-                        stderr += `\n[hq bot] could not stop the runtime wrapper: ${err instanceof Error ? err.message : String(err)}`;
-                    }
-                }
-            });
-            return;
-        }
-        // Snapshot the tree before the parent dies (its children get re-parented).
-        const tree = process.platform === "win32" || child.pid === undefined ? [] : descendantPids(child.pid);
-        try {
-            child.kill("SIGTERM");
-        }
-        catch {
-            /* ignore */
-        }
-        signalTree("SIGTERM", tree);
-        // A CLI (or a tool it started) that ignores SIGTERM still goes.
-        setTimeout(() => {
-            try {
-                if (child.exitCode === null && child.signalCode === null)
-                    child.kill("SIGKILL");
-            }
-            catch {
-                /* ignore */
-            }
-            signalTree("SIGKILL", tree);
-        }, 5_000).unref?.();
-    };
-    const timer = options.timeoutMs !== undefined
-        ? setTimeout(() => {
-            if (settled)
-                return;
-            stderr += `\n[hq bot] runtime turn exceeded ${options.timeoutMs}ms (HQ_BOT_TURN_TIMEOUT_MS) and was stopped`;
-            kill();
-        }, options.timeoutMs)
-        : null;
-    const onAbort = () => {
-        if (!settled)
-            kill();
-    };
-    if (options.signal) {
-        if (options.signal.aborted)
-            onAbort();
-        else
-            options.signal.addEventListener("abort", onAbort, { once: true });
-    }
-    const emit = (line) => {
-        if (!options.onStdoutLine || !line.trim())
-            return;
-        try {
-            options.onStdoutLine(line);
-        }
-        catch {
-            /* a listener must never break the turn */
-        }
-    };
-    const emitProtocolLine = (line) => {
-        stdout += line + "\n";
-        emit(line);
-    };
-    const cleanup = () => {
-        if (timer)
-            clearTimeout(timer);
-        options.signal?.removeEventListener("abort", onAbort);
-    };
-    let protocolPartial = "";
-    const protocol = options.protocol?.kind === "grok-acp"
-        ? new GrokAcpClient({
-            cwd: options.cwd,
-            env: options.env,
-            prompt: options.protocol.prompt,
-            ...(options.protocol.sessionId ? { sessionId: options.protocol.sessionId } : {}),
-            send: (message) => {
-                try {
-                    child.stdin?.write(JSON.stringify(message) + "\n");
-                }
-                catch (err) {
-                    stderr += `\n[hq bot] could not write to the Grok ACP process: ${err instanceof Error ? err.message : String(err)}`;
-                }
-            },
-            onText: emitProtocolLine,
-            onComplete: (sessionId, text) => {
-                protocolComplete = true;
-                emitProtocolLine(JSON.stringify({ type: "result", subtype: "success", is_error: false, result: text, session_id: sessionId }));
-                child.stdin?.end();
-                setTimeout(() => {
-                    if (!settled && child.exitCode === null && child.signalCode === null)
-                        kill();
-                }, STOP_SETTLE_GRACE_MS).unref?.();
-            },
-            onFailure: (message) => {
-                stderr += `\n[hq bot] ${message}`;
-                stopping = true;
-                child.stdin?.end();
-                setTimeout(() => {
-                    if (!settled && child.exitCode === null && child.signalCode === null)
-                        kill();
-                }, STOP_SETTLE_GRACE_MS).unref?.();
-            },
-        })
-        : undefined;
-    child.stdout?.on("data", (d) => {
-        const chunk = d.toString();
-        if (protocol) {
-            protocolPartial += chunk;
-            let nl = protocolPartial.indexOf("\n");
-            while (nl >= 0) {
-                protocol.receive(protocolPartial.slice(0, nl).replace(/\r$/, ""));
-                protocolPartial = protocolPartial.slice(nl + 1);
-                nl = protocolPartial.indexOf("\n");
-            }
-            return;
-        }
-        stdout += chunk;
-        if (!options.onStdoutLine)
-            return;
-        partial += chunk;
-        let nl = partial.indexOf("\n");
-        while (nl >= 0) {
-            emit(partial.slice(0, nl));
-            partial = partial.slice(nl + 1);
-            nl = partial.indexOf("\n");
-        }
-    });
-    child.stderr?.on("data", (d) => {
-        stderr += d.toString();
-    });
-    child.stdin?.on("error", (err) => {
-        if (!settled)
-            stderr += `\n[hq bot] could not write input to ${command}: ${err.message}`;
-    });
-    child.on("error", (err) => {
-        if (settled)
-            return;
-        settled = true;
-        cleanup();
-        reject(err);
-    });
-    if (protocol && !options.signal?.aborted)
-        protocol.start();
-    else if (options.stdin !== undefined)
-        child.stdin?.end(options.stdin);
-    // A stopped process can exit while something it started (and we could not
-    // reach) still holds stdout open; settle shortly after the exit instead of
-    // waiting for that pipe.
-    child.on("exit", (code, signal) => {
-        if (!stopping)
-            return;
-        setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            child.stdout?.destroy();
-            child.stderr?.destroy();
-            if (partial)
-                emit(partial);
-            resolve({ code, signal, stdout, stderr });
-        }, STOP_SETTLE_GRACE_MS).unref?.();
-    });
-    child.on("close", (code, signal) => {
-        if (settled)
-            return;
-        settled = true;
-        cleanup();
-        if (partial)
-            emit(partial);
-        resolve({
-            code: protocol ? (protocolComplete ? 0 : 1) : code,
-            signal: protocolComplete ? null : signal,
-            stdout,
-            stderr,
-        });
-    });
-});
-/**
- * Run one turn: spawn the runtime CLI, parse the reply, clean up scratch.
- * Throws RuntimeError (with a bounded stderr excerpt) on any failure.
- */
-export async function runRuntimeTurn(runtime, input, deps = {}) {
-    const spawnImpl = deps.spawnImpl ?? defaultSpawn;
-    const scratchDir = deps.scratchDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "hq-bot-turn-"));
-    const outputFile = path.join(scratchDir, "last-message.txt");
-    const newSessionId = input.newSessionId ?? (deps.newSessionId ?? randomUUID)();
-    const turnInput = { ...input, platform: deps.platform ?? input.platform ?? process.platform };
-    const args = runtime.buildArgs(turnInput, { outputFile, newSessionId });
-    const env = input.env ?? deps.env ?? process.env;
-    const binary = runtime.resolveBinary?.(env, input.cwd, turnInput.platform) ?? runtime.binary;
-    const stdin = runtime.stdinInput?.(turnInput);
-    const protocol = runtime.spawnProtocol?.(turnInput);
-    const onEvent = input.onEvent;
-    const onStdoutLine = onEvent && runtime.parseStreamLine
-        ? (line) => {
-            for (const event of runtime.parseStreamLine(line)) {
-                try {
-                    onEvent(event);
-                }
-                catch {
-                    /* a listener must never break the turn */
-                }
-            }
-        }
-        : undefined;
-    const timeoutMs = deps.timeoutMs ?? turnTimeoutMs(env);
-    const spawnOptions = {
-        cwd: input.cwd,
-        env,
-        ...(stdin !== undefined ? { stdin } : {}),
-        ...(protocol ? { protocol } : {}),
-        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(onStdoutLine ? { onStdoutLine } : {}),
-        ...(input.signal ? { signal: input.signal } : {}),
-    };
-    let result;
-    try {
-        result = await spawnImpl(binary, args, spawnOptions);
-        if (runtime.id === "grok" && result.code !== 0 && !input.signal?.aborted) {
-            const retryArgs = grokRetryArgsAfterInvalidOutputFormat(args, result.stderr);
-            if (retryArgs)
-                result = await spawnImpl(binary, retryArgs, spawnOptions);
-        }
-    }
-    catch (err) {
-        const code = err.code;
-        const msg = code === "ENOENT"
-            ? `${runtime.binary} is not installed or not on PATH`
-            : `failed to start ${runtime.binary}: ${err instanceof Error ? err.message : String(err)}`;
-        throw new RuntimeError(msg, msg, null, { started: false });
-    }
-    if (input.signal?.aborted) {
-        throw new RuntimeError(`${runtime.binary} was stopped`, "stopped by the owner", result.code, { aborted: true });
-    }
-    let outputFileText;
-    try {
-        if (fs.existsSync(outputFile))
-            outputFileText = fs.readFileSync(outputFile, "utf8");
-    }
-    catch {
-        /* ignore */
-    }
-    finally {
-        if (!deps.scratchDir) {
-            try {
-                fs.rmSync(scratchDir, { recursive: true, force: true });
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    if (result.code !== 0 || result.signal) {
-        const reason = runtime.failureReason?.(result.stdout, result.stderr);
-        // Streaming runtimes write JSON events to stdout: never show those to a
-        // person as the reason. stderr, then a plain description, instead.
-        const stdoutIsEvents = result.stdout.split("\n").some((line) => parseJsonLine(line) !== null);
-        const fallback = result.stderr.trim()
-            ? stderrExcerpt(result.stderr)
-            : result.stdout.trim() && !stdoutIsEvents
-                ? stderrExcerpt(result.stdout)
-                : result.signal
-                    ? `the ${runtime.binary} process was killed (${result.signal})`
-                    : `${runtime.binary} exited with code ${result.code}`;
-        throw new RuntimeError(`${runtime.binary} exited with ${result.code ?? `signal ${result.signal}`}${reason ? `: ${reason.slice(0, 200)}` : ""}`, reason ? reason.slice(0, 400) : fallback, result.code);
-    }
-    const parsed = runtime.parseOutput(result.stdout, { outputFile, outputFileText });
-    // Strip any leaked model control token (`<|eos|>` etc.) from the final reply
-    // before it is posted; a reply that was only such tokens becomes empty and the
-    // caller applies its normal empty-reply handling.
-    const text = stripControlTokens(parsed.text);
-    // A resumed session keeps its id even when the CLI omits it from the envelope.
-    return { text, sessionId: parsed.sessionId ?? input.sessionId };
-}
-//# sourceMappingURL=index.js.map

package/dist/lib/bot/runtime/messages-stream.d.ts

@@ -1,56 +0,0 @@
-/**
- * The NDJSON stream Claude Code (`--output-format stream-json --verbose`) and
- * older Grok (`--output-format streaming-messages-json`) both write: Anthropic
- * Messages wire shapes, one event per line.
- *
- *   {"type":"system","subtype":"init","session_id":…}
- *   {"type":"assistant","message":{"content":[{"type":"text","text":…},
- *     {"type":"tool_use","name":…},{"type":"thinking",…}]},"parent_tool_use_id":null,"session_id":…}
- *   {"type":"user","message":{"content":[{"type":"tool_result",…}]}}
- *   {"type":"result","subtype":"success","is_error":false,"result":"<last message>","session_id":…}
- *
- * grok 0.2.56 dropped `streaming-messages-json` for `streaming-json`, which
- * is token deltas rather than whole messages:
- *
- *   {"type":"thought","data":…}
- *   {"type":"text","data":"Hi"}
- *   {"type":"end","stopReason":"EndTurn","sessionId":…}
- *
- * Text `data` chunks are concatenated for the final reply and never emitted
- * as progress (they are token deltas). Recorded from Claude Code 2.1.258 and
- * grok (model grok-4.6) on 2026-09-12, plus grok 0.2.56 on 2026-09-21;
- * fixtures in runtime/fixtures/. Claude sends one content block per assistant
- * event; older Grok sends a whole message (thinking + text + tool_use) per event.
- */
-import { type RuntimeStreamEvent, type RuntimeTurnResult } from "./types.js";
-/** Progress events in one stream line: top-level assistant text and tool starts only. */
-export declare function messagesStreamEvents(line: string): RuntimeStreamEvent[];
-/**
- * The turn's result from the whole stream. Prefers the `result` event; also
- * accepts the older single-object `--output-format json` envelope. Throws a
- * RuntimeError for an error result, or when there is nothing usable.
- */
-export declare function messagesStreamResult(stdout: string, runtimeName: string): RuntimeTurnResult;
-/**
- * The error text of an `is_error` result event, if the stream has one.
- *
- * Also handles the case grok 0.2.56+ produces on some non-zero exits: the
- * whole stdout is one pretty-printed JSON object (a `result` envelope
- * spanning many lines) rather than NDJSON. The per-line parser sees only
- * `{` / `"key": …` / `}` fragments and cannot recover the fields, so
- * `stderrExcerpt(stdout)` ended up logging the tail of the pretty JSON —
- * "…costUsdTicks…numTurns…" — instead of the actual error text
- * (observed 2026-09-25 in sheister's log). We try a whole-stdout JSON parse
- * as a fallback and pull the real error string out of the envelope.
- */
-export declare function messagesStreamFailure(stdout: string): string | undefined;
-/**
- * Whole stdout parsed as ONE JSON object (grok 0.2.56+ pretty-printed
- * result envelope). Pulls the error text out of the fields the runtimes
- * actually populate: `error.message` / `error`, then `result` when
- * `is_error` is set, then `subtype` when it isn't "success". Returns
- * undefined when there is nothing useful to say — the caller falls back
- * to its own default.
- */
-export declare function prettyJsonFailure(stdout: string): string | undefined;
-//# sourceMappingURL=messages-stream.d.ts.map

package/dist/lib/bot/runtime/messages-stream.js

@@ -1,194 +0,0 @@
-/**
- * The NDJSON stream Claude Code (`--output-format stream-json --verbose`) and
- * older Grok (`--output-format streaming-messages-json`) both write: Anthropic
- * Messages wire shapes, one event per line.
- *
- *   {"type":"system","subtype":"init","session_id":…}
- *   {"type":"assistant","message":{"content":[{"type":"text","text":…},
- *     {"type":"tool_use","name":…},{"type":"thinking",…}]},"parent_tool_use_id":null,"session_id":…}
- *   {"type":"user","message":{"content":[{"type":"tool_result",…}]}}
- *   {"type":"result","subtype":"success","is_error":false,"result":"<last message>","session_id":…}
- *
- * grok 0.2.56 dropped `streaming-messages-json` for `streaming-json`, which
- * is token deltas rather than whole messages:
- *
- *   {"type":"thought","data":…}
- *   {"type":"text","data":"Hi"}
- *   {"type":"end","stopReason":"EndTurn","sessionId":…}
- *
- * Text `data` chunks are concatenated for the final reply and never emitted
- * as progress (they are token deltas). Recorded from Claude Code 2.1.258 and
- * grok (model grok-4.6) on 2026-09-12, plus grok 0.2.56 on 2026-09-21;
- * fixtures in runtime/fixtures/. Claude sends one content block per assistant
- * event; older Grok sends a whole message (thinking + text + tool_use) per event.
- */
-import { stripControlTokens } from "./sanitize.js";
-import { parseJsonLine, RuntimeError } from "./types.js";
-/** Progress events in one stream line: top-level assistant text and tool starts only. */
-export function messagesStreamEvents(line) {
-    const ev = parseJsonLine(line);
-    if (!ev || ev.type !== "assistant")
-        return [];
-    // Sub-agent traffic is the sub-agent's business, not a message to the person.
-    if (ev.parent_tool_use_id !== null && ev.parent_tool_use_id !== undefined)
-        return [];
-    const message = ev.message && typeof ev.message === "object" ? ev.message : null;
-    // Claude Code wraps its own notices (a dead login: "Not logged in", "Failed
-    // to authenticate…") in an assistant message from model "<synthetic>". That
-    // is the tool talking, not the model: never post it as progress, so a
-    // sign-in failure is still recognised as one (the result event carries it).
-    if (message?.model === "<synthetic>")
-        return [];
-    const content = Array.isArray(message?.content) ? message.content : [];
-    const out = [];
-    for (const block of content) {
-        if (!block || typeof block !== "object")
-            continue;
-        const b = block;
-        if (b.type === "text" && typeof b.text === "string") {
-            // Strip leaked control tokens from in-between progress posts too.
-            const clean = stripControlTokens(b.text).trim();
-            if (clean)
-                out.push({ kind: "message", text: clean });
-        }
-        else if (b.type === "tool_use" && typeof b.name === "string")
-            out.push({ kind: "tool", name: b.name });
-    }
-    return out;
-}
-/**
- * The turn's result from the whole stream. Prefers the `result` event; also
- * accepts the older single-object `--output-format json` envelope. Throws a
- * RuntimeError for an error result, or when there is nothing usable.
- */
-export function messagesStreamResult(stdout, runtimeName) {
-    const token = grokTokenStreamResult(stdout, runtimeName);
-    if (token)
-        return token;
-    let result = null;
-    let sessionId;
-    let lastText;
-    let sawJson = false;
-    for (const line of stdout.split("\n")) {
-        const ev = parseJsonLine(line);
-        if (!ev)
-            continue;
-        sawJson = true;
-        if (typeof ev.session_id === "string")
-            sessionId = ev.session_id;
-        if (ev.type === "result" || (ev.type === undefined && ("result" in ev || "is_error" in ev)))
-            result = ev;
-        else if (ev.type === "assistant") {
-            const texts = messagesStreamEvents(line).flatMap((e) => (e.kind === "message" ? [e.text] : []));
-            if (texts.length > 0)
-                lastText = texts.join("\n\n");
-        }
-    }
-    if (!sawJson)
-        throw new RuntimeError(`${runtimeName} returned non-JSON output`, stdout.trim().slice(-400), null);
-    if (result?.is_error === true) {
-        const detail = typeof result.result === "string" && result.result ? result.result : String(result.subtype ?? "error");
-        throw new RuntimeError(`${runtimeName} reported an error: ${detail.slice(0, 200)}`, detail.slice(0, 400), null);
-    }
-    const text = (typeof result?.result === "string" && result.result.trim() ? result.result : lastText) ?? "";
-    if (typeof result?.session_id === "string")
-        sessionId = result.session_id;
-    return { text, sessionId };
-}
-/**
- * grok 0.2.56 `--output-format streaming-json`: concatenate text deltas and
- * take sessionId from the terminal `end` event. Throws on `error`. Null when
- * the stream is not this shape (so the Anthropic Messages parser can run).
- */
-function grokTokenStreamResult(stdout, runtimeName) {
-    let text = "";
-    let sessionId;
-    let saw = false;
-    for (const line of stdout.split("\n")) {
-        const ev = parseJsonLine(line);
-        if (!ev)
-            continue;
-        if (ev.type === "text" && typeof ev.data === "string") {
-            saw = true;
-            text += ev.data;
-        }
-        else if (ev.type === "thought") {
-            saw = true;
-        }
-        else if (ev.type === "end") {
-            saw = true;
-            if (typeof ev.sessionId === "string")
-                sessionId = ev.sessionId;
-        }
-        else if (ev.type === "error" && typeof ev.message === "string") {
-            const detail = ev.message;
-            throw new RuntimeError(`${runtimeName} reported an error: ${detail.slice(0, 200)}`, detail.slice(0, 400), null);
-        }
-    }
-    return saw ? { text, sessionId } : null;
-}
-/**
- * The error text of an `is_error` result event, if the stream has one.
- *
- * Also handles the case grok 0.2.56+ produces on some non-zero exits: the
- * whole stdout is one pretty-printed JSON object (a `result` envelope
- * spanning many lines) rather than NDJSON. The per-line parser sees only
- * `{` / `"key": …` / `}` fragments and cannot recover the fields, so
- * `stderrExcerpt(stdout)` ended up logging the tail of the pretty JSON —
- * "…costUsdTicks…numTurns…" — instead of the actual error text
- * (observed 2026-09-25 in sheister's log). We try a whole-stdout JSON parse
- * as a fallback and pull the real error string out of the envelope.
- */
-export function messagesStreamFailure(stdout) {
-    let reason;
-    for (const line of stdout.split("\n")) {
-        const ev = parseJsonLine(line);
-        if (ev?.type === "result" && ev.is_error === true && typeof ev.result === "string" && ev.result.trim())
-            reason = ev.result.trim();
-        if (ev?.type === "error" && typeof ev.message === "string" && ev.message.trim())
-            reason = ev.message.trim();
-    }
-    if (reason)
-        return reason;
-    return prettyJsonFailure(stdout);
-}
-/**
- * Whole stdout parsed as ONE JSON object (grok 0.2.56+ pretty-printed
- * result envelope). Pulls the error text out of the fields the runtimes
- * actually populate: `error.message` / `error`, then `result` when
- * `is_error` is set, then `subtype` when it isn't "success". Returns
- * undefined when there is nothing useful to say — the caller falls back
- * to its own default.
- */
-export function prettyJsonFailure(stdout) {
-    const trimmed = stdout.trim();
-    if (!trimmed.startsWith("{"))
-        return undefined;
-    let ev = null;
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
-            ev = parsed;
-    }
-    catch {
-        return undefined;
-    }
-    if (!ev)
-        return undefined;
-    const err = ev.error;
-    if (err && typeof err === "object" && !Array.isArray(err)) {
-        const m = err.message;
-        if (typeof m === "string" && m.trim())
-            return m.trim();
-    }
-    if (typeof err === "string" && err.trim())
-        return err.trim();
-    if (ev.is_error === true && typeof ev.result === "string" && ev.result.trim())
-        return ev.result.trim();
-    if (typeof ev.message === "string" && ev.message.trim())
-        return ev.message.trim();
-    if (typeof ev.subtype === "string" && ev.subtype.trim() && ev.subtype !== "success")
-        return ev.subtype.trim();
-    return undefined;
-}
-//# sourceMappingURL=messages-stream.js.map

package/dist/lib/bot/runtime/sanitize.d.ts

@@ -1,18 +0,0 @@
-/**
- * Model control-token stripping for bot replies.
- *
- * A model can leak a raw control token as visible text — grok posted a bare
- * `<|eos|>` as a room reply on 2026-09-25. These tokens are never meant for a
- * person, so they are removed from both the in-between progress messages and
- * the final reply before anything is posted.
- *
- * The generic `<|...|>` form covers any single control token in that shape
- * (`<|eos|>`, `<|endoftext|>`, `<|im_end|>`, `<|eot_id|>`, and any other).
- * Whitespace-only reply after stripping is empty, and callers apply the same
- * empty-reply handling they already have (silent on an unmentioned room turn).
- */
-/** Remove every `<|...|>` control token from `text`, leaving the rest intact. */
-export declare function stripControlTokens(text: string): string;
-/** True when `text` is nothing but control tokens and whitespace. */
-export declare function isOnlyControlTokens(text: string): boolean;
-//# sourceMappingURL=sanitize.d.ts.map