@indigoai-us/hq-cli 5.314.0 → 5.316.0

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

@@ -0,0 +1,417 @@
+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

@@ -0,0 +1,56 @@
+/**
+ * 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

@@ -0,0 +1,194 @@
+/**
+ * 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

@@ -0,0 +1,18 @@
+/**
+ * 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