gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/universal-config/tools.js

@@ -0,0 +1,57 @@
+/**
+ * Universal Config Discovery — tool registry
+ *
+ * Known AI coding tools with their config directory locations.
+ * Based on research of Oh My Pi's discovery system and direct config
+ * file inspection of each tool.
+ */
+export const TOOLS = [
+    {
+        id: "claude",
+        name: "Claude Code",
+        userDir: ".claude",
+        projectDir: ".claude",
+    },
+    {
+        id: "cursor",
+        name: "Cursor",
+        userDir: ".cursor",
+        projectDir: ".cursor",
+    },
+    {
+        id: "windsurf",
+        name: "Windsurf",
+        userDir: ".codeium/windsurf",
+        projectDir: ".windsurf",
+    },
+    {
+        id: "gemini",
+        name: "Gemini CLI",
+        userDir: ".gemini",
+        projectDir: ".gemini",
+    },
+    {
+        id: "codex",
+        name: "OpenAI Codex",
+        userDir: ".codex",
+        projectDir: ".codex",
+    },
+    {
+        id: "cline",
+        name: "Cline",
+        userDir: null,
+        projectDir: null, // Uses root-level .clinerules (handled specially)
+    },
+    {
+        id: "github-copilot",
+        name: "GitHub Copilot",
+        userDir: null,
+        projectDir: ".github",
+    },
+    {
+        id: "vscode",
+        name: "VS Code",
+        userDir: null,
+        projectDir: ".vscode",
+    },
+];

package/dist/resources/extensions/universal-config/types.js

@@ -0,0 +1,8 @@
+/**
+ * Universal Config Discovery — shared types
+ *
+ * Normalized schema for discovered configuration items from all supported
+ * AI coding tools: Claude Code, Cursor, Windsurf, Gemini CLI, Codex,
+ * Cline, GitHub Copilot, VS Code.
+ */
+export {};

package/dist/resources/extensions/voice/index.js

@@ -0,0 +1,247 @@
+import { shortcutDesc } from "../shared/mod.js";
+import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import { spawn, execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+const __extensionDir = import.meta.dirname;
+const SWIFT_SRC = path.join(__extensionDir, "speech-recognizer.swift");
+const RECOGNIZER_BIN = path.join(__extensionDir, "speech-recognizer");
+const PYTHON_SCRIPT = path.join(__extensionDir, "speech-recognizer.py");
+const IS_DARWIN = process.platform === "darwin";
+const IS_LINUX = process.platform === "linux";
+const VOICE_VENV_PYTHON = path.join(process.env.HOME || process.env.USERPROFILE || "/tmp", ".gsd", "voice-venv", "bin", "python3");
+/** Return the python3 binary path — prefer venv if it exists, else system. */
+function linuxPython() {
+    if (fs.existsSync(VOICE_VENV_PYTHON))
+        return VOICE_VENV_PYTHON;
+    return "python3";
+}
+function ensureBinary() {
+    if (fs.existsSync(RECOGNIZER_BIN))
+        return true;
+    try {
+        execSync(`swiftc "${SWIFT_SRC}" -o "${RECOGNIZER_BIN}" -framework Speech -framework AVFoundation`, {
+            timeout: 60000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+let linuxReady = false;
+function ensureLinuxReady(ctx) {
+    if (linuxReady)
+        return true;
+    // Check GROQ_API_KEY is available
+    if (!process.env.GROQ_API_KEY) {
+        ctx.ui.notify("Voice: GROQ_API_KEY not set — run 'gsd config' to configure", "error");
+        return false;
+    }
+    // Check python3 exists
+    try {
+        execSync("which python3", { stdio: "pipe" });
+    }
+    catch {
+        ctx.ui.notify("Voice: python3 not found — install with: sudo apt install python3", "error");
+        return false;
+    }
+    // Check that sounddevice is importable
+    const py = linuxPython();
+    try {
+        execSync(`${py} -c "import sounddevice"`, {
+            stdio: "pipe",
+            timeout: 10000,
+        });
+    }
+    catch (err) {
+        const stderr = err?.stderr?.toString() ?? "";
+        if (stderr.includes("sounddevice") || stderr.includes("PortAudio") || stderr.includes("portaudio")) {
+            ctx.ui.notify("Voice: install libportaudio2 with: sudo apt install libportaudio2", "error");
+        }
+        else if (stderr.includes("No module") || stderr.includes("ModuleNotFoundError")) {
+            // Deps missing — the Python script handles auto-install on first run,
+            // so we let it through. The script's own ensure_deps() will pip install.
+            ctx.ui.notify("Voice: installing dependencies on first run — this may take a moment", "info");
+            linuxReady = true;
+            return true;
+        }
+        else {
+            ctx.ui.notify(`Voice: dependency check failed — ${stderr.split("\n")[0] || "unknown error"}`, "error");
+            return false;
+        }
+        return false;
+    }
+    linuxReady = true;
+    return true;
+}
+export default function (pi) {
+    if (!IS_DARWIN && !IS_LINUX)
+        return;
+    let active = false;
+    let recognizerProcess = null;
+    let flashOn = true;
+    let flashTimer = null;
+    let footerTui = null;
+    function setVoiceFooter(ctx, on) {
+        if (!on) {
+            stopFlash();
+            ctx.ui.setFooter(undefined);
+            return;
+        }
+        flashOn = true;
+        flashTimer = setInterval(() => {
+            flashOn = !flashOn;
+            footerTui?.requestRender();
+        }, 500);
+        ctx.ui.setFooter((tui, theme, footerData) => {
+            footerTui = tui;
+            const branchUnsub = footerData.onBranchChange(() => tui.requestRender());
+            return {
+                dispose: branchUnsub,
+                invalidate() { },
+                render(width) {
+                    // Row 1: pwd (branch) ... ● transcribing
+                    let pwd = process.cwd();
+                    const home = process.env.HOME || process.env.USERPROFILE;
+                    if (home && pwd.startsWith(home))
+                        pwd = `~${pwd.slice(home.length)}`;
+                    const branch = footerData.getGitBranch();
+                    if (branch)
+                        pwd = `${pwd} (${branch})`;
+                    const dot = flashOn ? theme.fg("error", "●") : theme.fg("dim", "●");
+                    const voiceTag = `${dot} ${theme.fg("error", "transcribing")}`;
+                    const voiceTagWidth = visibleWidth(voiceTag);
+                    const maxPwdWidth = width - voiceTagWidth - 2;
+                    const pwdStr = truncateToWidth(theme.fg("dim", pwd), maxPwdWidth, theme.fg("dim", "..."));
+                    const pad1 = " ".repeat(Math.max(1, width - visibleWidth(pwdStr) - voiceTagWidth));
+                    const row1 = truncateToWidth(pwdStr + pad1 + voiceTag, width);
+                    // Row 2: stats ... model
+                    let totalInput = 0, totalOutput = 0, totalCost = 0;
+                    for (const entry of ctx.sessionManager.getEntries()) {
+                        if (entry.type === "message" && entry.message.role === "assistant") {
+                            const m = entry.message;
+                            totalInput += m.usage.input;
+                            totalOutput += m.usage.output;
+                            totalCost += m.usage.cost.total;
+                        }
+                    }
+                    const fmt = (n) => n < 1000 ? `${n}` : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+                    const parts = [];
+                    if (totalInput)
+                        parts.push(`↑${fmt(totalInput)}`);
+                    if (totalOutput)
+                        parts.push(`↓${fmt(totalOutput)}`);
+                    if (totalCost)
+                        parts.push(`$${totalCost.toFixed(3)}`);
+                    const usage = ctx.getContextUsage();
+                    const ctxPct = usage?.percent !== null && usage?.percent !== undefined ? `${usage.percent.toFixed(1)}%` : "?";
+                    const ctxWin = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+                    parts.push(`${ctxPct}/${fmt(ctxWin)}`);
+                    const statsLeft = theme.fg("dim", parts.join(" "));
+                    const modelRight = theme.fg("dim", ctx.model?.id || "no-model");
+                    const statsLeftW = visibleWidth(statsLeft);
+                    const modelRightW = visibleWidth(modelRight);
+                    const pad2 = " ".repeat(Math.max(2, width - statsLeftW - modelRightW));
+                    const row2 = truncateToWidth(statsLeft + pad2 + modelRight, width);
+                    return [row1, row2];
+                },
+            };
+        });
+    }
+    function stopFlash() {
+        if (flashTimer) {
+            clearInterval(flashTimer);
+            flashTimer = null;
+        }
+        footerTui = null;
+    }
+    async function toggleVoice(ctx) {
+        if (active) {
+            killRecognizer();
+            active = false;
+            setVoiceFooter(ctx, false);
+            return;
+        }
+        if (IS_DARWIN) {
+            if (!ensureBinary()) {
+                ctx.ui.notify("Voice: failed to compile speech recognizer (need Xcode CLI tools)", "error");
+                return;
+            }
+        }
+        else if (IS_LINUX) {
+            if (!ensureLinuxReady(ctx)) {
+                return;
+            }
+        }
+        active = true;
+        setVoiceFooter(ctx, true);
+        await runVoiceSession(ctx);
+    }
+    pi.registerCommand("voice", {
+        description: "Toggle voice mode",
+        handler: async (_args, ctx) => toggleVoice(ctx),
+    });
+    pi.registerShortcut("ctrl+alt+v", {
+        description: shortcutDesc("Toggle voice mode", "/voice"),
+        handler: async (ctx) => toggleVoice(ctx),
+    });
+    function killRecognizer() {
+        if (recognizerProcess) {
+            recognizerProcess.kill("SIGTERM");
+            recognizerProcess = null;
+        }
+    }
+    function startRecognizer(onPartial, onFinal, onError, onReady) {
+        if (IS_LINUX) {
+            recognizerProcess = spawn(linuxPython(), [PYTHON_SCRIPT], {
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        else {
+            recognizerProcess = spawn(RECOGNIZER_BIN, [], { stdio: ["pipe", "pipe", "pipe"] });
+        }
+        const rl = readline.createInterface({ input: recognizerProcess.stdout });
+        rl.on("line", (line) => {
+            if (line === "READY") {
+                onReady();
+                return;
+            }
+            if (line.startsWith("PARTIAL:"))
+                onPartial(line.slice(8));
+            else if (line.startsWith("FINAL:"))
+                onFinal(line.slice(6));
+            else if (line.startsWith("ERROR:"))
+                onError(line.slice(6));
+        });
+        recognizerProcess.on("error", (err) => onError(err.message));
+        recognizerProcess.on("exit", () => { recognizerProcess = null; });
+    }
+    async function runVoiceSession(ctx) {
+        return new Promise((resolve) => {
+            // The Swift recognizer handles accumulation across pause-induced
+            // transcription resets. Both PARTIAL and FINAL messages contain
+            // the full accumulated text, so we just pass them through.
+            startRecognizer((text) => {
+                ctx.ui.setEditorText(text);
+            }, (text) => {
+                ctx.ui.setEditorText(text);
+            }, (msg) => ctx.ui.notify(`Voice: ${msg}`, "error"), () => { });
+            ctx.ui.custom((_tui, _theme, _kb, done) => ({
+                render() { return []; },
+                handleInput(data) {
+                    if (isKeyRelease(data))
+                        return;
+                    if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter)) {
+                        killRecognizer();
+                        active = false;
+                        setVoiceFooter(ctx, false);
+                        done();
+                    }
+                },
+                invalidate() { },
+            }), { overlay: true, overlayOptions: { anchor: "bottom-center", width: "100%" } }).then(() => resolve());
+        });
+    }
+}

package/dist/startup-timings.d.ts

@@ -0,0 +1,2 @@
+export declare function markStartup(label: string): void;
+export declare function printStartupTimings(): void;

package/dist/startup-timings.js

@@ -0,0 +1,22 @@
+const flag = (process.env.GSD_STARTUP_TIMING ?? process.env.PI_TIMING ?? "").toLowerCase();
+const ENABLED = flag === "1" || flag === "true" || flag === "yes";
+const timings = [];
+let lastTime = Date.now();
+export function markStartup(label) {
+    if (!ENABLED)
+        return;
+    const now = Date.now();
+    timings.push({ label, ms: now - lastTime });
+    lastTime = now;
+}
+export function printStartupTimings() {
+    if (!ENABLED || timings.length === 0)
+        return;
+    const total = timings.reduce((sum, timing) => sum + timing.ms, 0);
+    process.stderr.write("\n--- GSD Startup Timings ---\n");
+    for (const timing of timings) {
+        process.stderr.write(`  ${timing.label}: ${timing.ms}ms\n`);
+    }
+    process.stderr.write(`  TOTAL: ${total}ms\n`);
+    process.stderr.write("----------------------------\n\n");
+}

package/dist/tool-bootstrap.js

@@ -1,4 +1,4 @@
-import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, rmSync, statSync, symlinkSync, unlinkSync } from "node:fs";
 import { delimiter, join } from "node:path";
 const TOOL_SPECS = {
     fd: {
@@ -32,6 +32,45 @@ function isRegularFile(path) {
         return false;
     }
 }
+function pathExistsIncludingBrokenSymlink(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBrokenSymlink(path) {
+    try {
+        const stat = lstatSync(path);
+        if (!stat.isSymbolicLink())
+            return false;
+        try {
+            statSync(path);
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function removeTargetPath(path) {
+    try {
+        const stat = lstatSync(path);
+        if (stat.isSymbolicLink()) {
+            unlinkSync(path);
+            return;
+        }
+        rmSync(path, { force: true });
+    }
+    catch {
+        // Path already absent.
+    }
+}
 export function resolveToolFromPath(tool, pathValue = process.env.PATH) {
     const spec = TOOL_SPECS[tool];
     for (const dir of splitPath(pathValue)) {
@@ -48,23 +87,32 @@ export function resolveToolFromPath(tool, pathValue = process.env.PATH) {
 }
 function provisionTool(targetDir, tool, sourcePath) {
     const targetPath = join(targetDir, TOOL_SPECS[tool].targetName);
-    if (existsSync(targetPath))
-        return targetPath;
-    mkdirSync(targetDir, { recursive: true });
-    try {
-        symlinkSync(sourcePath, targetPath);
+    const brokenTarget = isBrokenSymlink(targetPath);
+    if (pathExistsIncludingBrokenSymlink(targetPath)) {
+        if (!brokenTarget)
+            return targetPath;
+        removeTargetPath(targetPath);
     }
-    catch {
-        rmSync(targetPath, { force: true });
-        copyFileSync(sourcePath, targetPath);
-        chmodSync(targetPath, 0o755);
+    mkdirSync(targetDir, { recursive: true });
+    if (!brokenTarget) {
+        try {
+            symlinkSync(sourcePath, targetPath);
+            return targetPath;
+        }
+        catch {
+            // Fall back to copying below.
+        }
     }
+    removeTargetPath(targetPath);
+    copyFileSync(sourcePath, targetPath);
+    chmodSync(targetPath, 0o755);
     return targetPath;
 }
 export function ensureManagedTools(targetDir, pathValue = process.env.PATH) {
     const provisioned = [];
     for (const tool of Object.keys(TOOL_SPECS)) {
-        if (existsSync(join(targetDir, TOOL_SPECS[tool].targetName)))
+        const targetPath = join(targetDir, TOOL_SPECS[tool].targetName);
+        if (pathExistsIncludingBrokenSymlink(targetPath) && !isBrokenSymlink(targetPath))
             continue;
         const sourcePath = resolveToolFromPath(tool, pathValue);
         if (!sourcePath)

package/dist/worktree-cli.js

@@ -20,22 +20,22 @@
 import chalk from 'chalk';
 import { createJiti } from '@mariozechner/jiti';
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
 import { generateWorktreeName } from './worktree-name-gen.js';
 import { existsSync } from 'node:fs';
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { resolveBundledSourceResource } from './bundled-resource-path.js';
 const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+const gsdExtensionPath = (...segments) => resolveBundledSourceResource(import.meta.url, 'extensions', 'gsd', ...segments);
 // Lazily-loaded extension modules (loaded once on first use via jiti)
 let _ext = null;
 async function loadExtensionModules() {
     if (_ext)
         return _ext;
     const [wtMgr, autoWt, gitBridge, gitSvc, wt] = await Promise.all([
-        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree-manager.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/auto-worktree.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/native-git-bridge.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/git-service.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree.ts'), {}),
+        jiti.import(gsdExtensionPath('worktree-manager.ts'), {}),
+        jiti.import(gsdExtensionPath('auto-worktree.ts'), {}),
+        jiti.import(gsdExtensionPath('native-git-bridge.ts'), {}),
+        jiti.import(gsdExtensionPath('git-service.ts'), {}),
+        jiti.import(gsdExtensionPath('worktree.ts'), {}),
     ]);
     _ext = {
         createWorktree: wtMgr.createWorktree,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.33.1",
+  "version": "2.34.0-dev.6769913",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/native/dist/native.d.ts

@@ -55,5 +55,3 @@ export declare const native: {
     parseStreamingJson: (text: string) => unknown;
     xxHash32: (input: string, seed: number) => number;
 };
-/** True when the native addon loaded successfully. False on unsupported platforms. */
-export declare const nativeAvailable = false;

package/packages/native/dist/native.js

@@ -74,5 +74,3 @@ function loadNative() {
     });
 }
 export const native = loadNative();
-/** True when the native addon loaded successfully. False on unsupported platforms. */
-export const nativeAvailable = _loadedSuccessfully;

package/packages/native/src/native.ts

@@ -151,6 +151,3 @@ export const native = loadNative() as {
   parseStreamingJson: (text: string) => unknown;
   xxHash32: (input: string, seed: number) => number;
 };
-
-/** True when the native addon loaded successfully. False on unsupported platforms. */
-export const nativeAvailable = _loadedSuccessfully;

package/packages/pi-agent-core/dist/agent-loop.d.ts

@@ -4,6 +4,20 @@
  */
 import { EventStream } from "@gsd/pi-ai";
 import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.js";
+export declare const ZERO_USAGE: {
+    readonly input: 0;
+    readonly output: 0;
+    readonly cacheRead: 0;
+    readonly cacheWrite: 0;
+    readonly totalTokens: 0;
+    readonly cost: {
+        readonly input: 0;
+        readonly output: 0;
+        readonly cacheRead: 0;
+        readonly cacheWrite: 0;
+        readonly total: 0;
+    };
+};
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.

package/packages/pi-agent-core/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGN,WAAW,EAIX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAIZ,QAAQ,EACR,MAAM,YAAY,CAAC;AA8BpB;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CA8BzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CA+BzC"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGN,WAAW,EAIX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAIZ,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,UAAU;;;;;;;;;;;;;CAOb,CAAC;AA4CX;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CA0BzC"}

package/packages/pi-agent-core/dist/agent-loop.js

@@ -3,7 +3,7 @@
  * Transforms to Message[] only at the LLM call boundary.
  */
 import { EventStream, streamSimple, validateToolArguments, } from "@gsd/pi-ai";
-const ZERO_USAGE = {
+export const ZERO_USAGE = {
     input: 0,
     output: 0,
     cacheRead: 0,
@@ -29,6 +29,23 @@ function createErrorMessage(error, config) {
         timestamp: Date.now(),
     };
 }
+/**
+ * Emit a message_start + message_end pair for a single message.
+ */
+function emitMessagePair(stream, message) {
+    stream.push({ type: "message_start", message });
+    stream.push({ type: "message_end", message });
+}
+/**
+ * Emit the standard error sequence when the outer agent loop catches an error.
+ * Pushes message_start/end, turn_end, agent_end, then closes the stream.
+ */
+function emitErrorSequence(stream, errMsg, newMessages) {
+    emitMessagePair(stream, errMsg);
+    stream.push({ type: "turn_end", message: errMsg, toolResults: [] });
+    stream.push({ type: "agent_end", messages: [...newMessages, errMsg] });
+    stream.end([...newMessages, errMsg]);
+}
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.
@@ -44,19 +61,13 @@ export function agentLoop(prompts, context, config, signal, streamFn) {
         stream.push({ type: "agent_start" });
         stream.push({ type: "turn_start" });
         for (const prompt of prompts) {
-            stream.push({ type: "message_start", message: prompt });
-            stream.push({ type: "message_end", message: prompt });
+            emitMessagePair(stream, prompt);
         }
         try {
             await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
         }
         catch (error) {
-            const errMsg = createErrorMessage(error, config);
-            stream.push({ type: "message_start", message: errMsg });
-            stream.push({ type: "message_end", message: errMsg });
-            stream.push({ type: "turn_end", message: errMsg, toolResults: [] });
-            stream.push({ type: "agent_end", messages: [...newMessages, errMsg] });
-            stream.end([...newMessages, errMsg]);
+            emitErrorSequence(stream, createErrorMessage(error, config), newMessages);
         }
     })();
     return stream;
@@ -86,12 +97,7 @@ export function agentLoopContinue(context, config, signal, streamFn) {
             await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
         }
         catch (error) {
-            const errMsg = createErrorMessage(error, config);
-            stream.push({ type: "message_start", message: errMsg });
-            stream.push({ type: "message_end", message: errMsg });
-            stream.push({ type: "turn_end", message: errMsg, toolResults: [] });
-            stream.push({ type: "agent_end", messages: [...newMessages, errMsg] });
-            stream.end([...newMessages, errMsg]);
+            emitErrorSequence(stream, createErrorMessage(error, config), newMessages);
         }
     })();
     return stream;
@@ -121,8 +127,7 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
             // Process pending messages (inject before next assistant response)
             if (pendingMessages.length > 0) {
                 for (const message of pendingMessages) {
-                    stream.push({ type: "message_start", message });
-                    stream.push({ type: "message_end", message });
+                    emitMessagePair(stream, message);
                     currentContext.messages.push(message);
                     newMessages.push(message);
                 }
@@ -144,14 +149,7 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
                     api: config.model.api,
                     provider: config.model.provider,
                     model: config.model.id,
-                    usage: {
-                        input: 0,
-                        output: 0,
-                        cacheRead: 0,
-                        cacheWrite: 0,
-                        totalTokens: 0,
-                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-                    },
+                    usage: ZERO_USAGE,
                     stopReason: signal?.aborted ? "aborted" : "error",
                     errorMessage: errorText,
                     timestamp: Date.now(),
@@ -478,8 +476,7 @@ function emitToolCallOutcome(toolCall, result, isError, stream) {
         isError,
         timestamp: Date.now(),
     };
-    stream.push({ type: "message_start", message: toolResultMessage });
-    stream.push({ type: "message_end", message: toolResultMessage });
+    emitMessagePair(stream, toolResultMessage);
     return toolResultMessage;
 }
 function skipToolCall(toolCall, stream, options) {