open-agents-ai 0.4.0 → 0.5.0

package/README.md

@@ -160,6 +160,28 @@ The agent follows an iterative fix loop:
 -V, --version              Show version
 ```
 
+### Voice Feedback (TTS)
+
+The agent can speak what it's doing using neural TTS voices. Enable it in the interactive REPL:
+
+```bash
+/voice              # Toggle voice on/off (default: GLaDOS)
+/voice glados       # Switch to GLaDOS voice
+/voice overwatch    # Switch to Overwatch voice
+```
+
+On first enable, the agent auto-downloads the ONNX voice model (~50MB) and installs `onnxruntime-node` in `~/.open-agents/voice/`. For best quality, install `espeak-ng`:
+
+```bash
+# Ubuntu/Debian
+sudo apt install espeak-ng
+
+# macOS
+brew install espeak-ng
+```
+
+When enabled, the agent speaks brief descriptions of each tool call ("Reading auth.ts", "Running tests", "Editing config.js") through your system speakers.
+
 ### Configuration
 
 Config priority: CLI flags > environment variables > `~/.open-agents/config.json` > defaults.

package/dist/index.js

@@ -1116,21 +1116,29 @@ var init_tool_executor = __esm({
 });
 
 // packages/execution/dist/tools/shell.js
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync, ShellTool;
+import { spawn } from "node:child_process";
+var ShellTool;
 var init_shell = __esm({
   "packages/execution/dist/tools/shell.js"() {
     "use strict";
-    execFileAsync = promisify(execFile);
     ShellTool = class {
       name = "shell";
-      description = "Execute a shell command in the project working directory";
+      description = "Execute a shell command in the project working directory. Commands run non-interactively (CI=true). For commands that need input, use the stdin parameter or pass non-interactive flags (--yes, --no-input).";
       parameters = {
         type: "object",
         properties: {
-          command: { type: "string", description: "The shell command to execute" },
-          timeout: { type: "number", description: "Timeout in milliseconds" }
+          command: {
+            type: "string",
+            description: "The shell command to execute"
+          },
+          timeout: {
+            type: "number",
+            description: "Timeout in milliseconds (default: 30000)"
+          },
+          stdin: {
+            type: "string",
+            description: "Text to write to the command's standard input. Use newlines to separate multiple inputs. For arrow-key prompts, prefer --yes or non-interactive flags instead."
+          }
         },
         required: ["command"]
       };
@@ -1143,29 +1151,89 @@ var init_shell = __esm({
       async execute(args) {
         const command = args["command"];
         const timeout = args["timeout"] ?? this.defaultTimeout;
+        const stdinInput = args["stdin"];
         const start = performance.now();
-        try {
-          const { stdout, stderr } = await execFileAsync("bash", ["-c", command], {
+        return new Promise((resolve12) => {
+          const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
-            timeout,
-            maxBuffer: 1024 * 1024
+            env: {
+              ...process.env,
+              // Non-interactive mode: libraries like prompts, inquirer,
+              // create-next-app, and many Node CLI tools check CI to skip
+              // interactive prompts and use defaults instead.
+              CI: "true",
+              NONINTERACTIVE: "1",
+              // Disable color in most tools to get clean output
+              NO_COLOR: "1",
+              FORCE_COLOR: "0"
+            },
+            stdio: ["pipe", "pipe", "pipe"]
           });
-          return {
-            success: true,
-            output: stdout + (stderr ? `
+          let stdout = "";
+          let stderr = "";
+          let killed = false;
+          const maxBuf = 1024 * 1024;
+          const timer = setTimeout(() => {
+            killed = true;
+            child.kill("SIGTERM");
+            setTimeout(() => {
+              try {
+                child.kill("SIGKILL");
+              } catch {
+              }
+            }, 5e3);
+          }, timeout);
+          child.stdout.on("data", (data) => {
+            stdout += data.toString();
+            if (stdout.length > maxBuf) {
+              stdout = stdout.slice(0, maxBuf);
+            }
+          });
+          child.stderr.on("data", (data) => {
+            stderr += data.toString();
+            if (stderr.length > maxBuf) {
+              stderr = stderr.slice(0, maxBuf);
+            }
+          });
+          if (stdinInput) {
+            child.stdin.write(stdinInput);
+          }
+          child.stdin.end();
+          child.on("close", (code) => {
+            clearTimeout(timer);
+            const durationMs = performance.now() - start;
+            if (killed) {
+              const combined = stdout + stderr;
+              const looksInteractive = /\? .+[›>]|y\/n|yes\/no|\(Y\/n\)|\[y\/N\]/i.test(combined);
+              const hint = looksInteractive ? " The command appears to be waiting for interactive input. Use non-interactive flags (e.g., --yes, --no-input) or provide input via the stdin parameter." : "";
+              resolve12({
+                success: false,
+                output: stdout,
+                error: `Command timed out after ${timeout}ms.${hint}`,
+                durationMs
+              });
+              return;
+            }
+            const success = code === 0;
+            resolve12({
+              success,
+              output: stdout + (stderr && success ? `
 STDERR:
 ${stderr}` : ""),
-            durationMs: performance.now() - start
-          };
-        } catch (error) {
-          const err = error;
-          return {
-            success: false,
-            output: err.stdout ?? "",
-            error: err.stderr ?? err.message,
-            durationMs: performance.now() - start
-          };
-        }
+              error: success ? void 0 : stderr || `Exit code ${code}`,
+              durationMs
+            });
+          });
+          child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve12({
+              success: false,
+              output: stdout,
+              error: err.message,
+              durationMs: performance.now() - start
+            });
+          });
+        });
       }
     };
   }
@@ -1275,14 +1343,14 @@ var init_file_write = __esm({
 });
 
 // packages/execution/dist/tools/grep-search.js
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { resolve as resolve3 } from "node:path";
-var execFileAsync2, MAX_OUTPUT_LINES, GrepSearchTool;
+var execFileAsync, MAX_OUTPUT_LINES, GrepSearchTool;
 var init_grep_search = __esm({
   "packages/execution/dist/tools/grep-search.js"() {
     "use strict";
-    execFileAsync2 = promisify2(execFile2);
+    execFileAsync = promisify(execFile);
     MAX_OUTPUT_LINES = 100;
     GrepSearchTool = class {
       name = "grep_search";
@@ -1323,7 +1391,7 @@ var init_grep_search = __esm({
               rgArgs.push("--glob", include);
             }
             rgArgs.push(pattern, searchPath);
-            const { stdout } = await execFileAsync2("rg", rgArgs, {
+            const { stdout } = await execFileAsync("rg", rgArgs, {
               cwd: this.workingDir,
               maxBuffer: 1024 * 1024
             });
@@ -1334,7 +1402,7 @@ var init_grep_search = __esm({
               grepArgs.push(`--include=${include}`);
             }
             grepArgs.push(pattern, searchPath);
-            const { stdout } = await execFileAsync2("grep", grepArgs, {
+            const { stdout } = await execFileAsync("grep", grepArgs, {
               cwd: this.workingDir,
               maxBuffer: 1024 * 1024
             });
@@ -1369,7 +1437,7 @@ var init_grep_search = __esm({
       }
       async #isRipgrepAvailable() {
         try {
-          await execFileAsync2("rg", ["--version"], { timeout: 2e3 });
+          await execFileAsync("rg", ["--version"], { timeout: 2e3 });
           return true;
         } catch {
           return false;
@@ -1380,14 +1448,14 @@ var init_grep_search = __esm({
 });
 
 // packages/execution/dist/tools/glob-find.js
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
 import { resolve as resolve4 } from "node:path";
-var execFileAsync3, MAX_RESULTS, GlobFindTool;
+var execFileAsync2, MAX_RESULTS, GlobFindTool;
 var init_glob_find = __esm({
   "packages/execution/dist/tools/glob-find.js"() {
     "use strict";
-    execFileAsync3 = promisify3(execFile3);
+    execFileAsync2 = promisify2(execFile2);
     MAX_RESULTS = 50;
     GlobFindTool = class {
       name = "find_files";
@@ -1415,7 +1483,7 @@ var init_glob_find = __esm({
         const searchPath = resolve4(this.workingDir, args["path"] ?? ".");
         const start = performance.now();
         try {
-          const { stdout } = await execFileAsync3("find", [
+          const { stdout } = await execFileAsync2("find", [
             searchPath,
             "-type",
             "f",
@@ -4087,13 +4155,13 @@ var init_plannerRunner = __esm({
 });
 
 // packages/retrieval/dist/grep-search.js
-import { execFile as execFile4 } from "node:child_process";
-import { promisify as promisify4 } from "node:util";
-var execFileAsync4, GrepSearch;
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var execFileAsync3, GrepSearch;
 var init_grep_search2 = __esm({
   "packages/retrieval/dist/grep-search.js"() {
     "use strict";
-    execFileAsync4 = promisify4(execFile4);
+    execFileAsync3 = promisify3(execFile3);
     GrepSearch = class {
       rootDir;
       constructor(rootDir) {
@@ -4115,7 +4183,7 @@ var init_grep_search2 = __esm({
         }
         args.push(pattern, this.rootDir);
         try {
-          const { stdout } = await execFileAsync4("rg", args, {
+          const { stdout } = await execFileAsync3("rg", args, {
             maxBuffer: 10 * 1024 * 1024
           });
           return this.parseRipgrepOutput(stdout);
@@ -4190,8 +4258,8 @@ var init_code_retriever = __esm({
 });
 
 // packages/retrieval/dist/lexicalSearch.js
-import { execFile as execFile5 } from "node:child_process";
-import { promisify as promisify5 } from "node:util";
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
 import { readFile as readFile6, readdir, stat } from "node:fs/promises";
 import { join as join10, extname as extname2 } from "node:path";
 async function searchByPath(pathPattern, options) {
@@ -4235,7 +4303,7 @@ async function runSearch(pattern, kind, options) {
 }
 async function isRipgrepAvailable() {
   try {
-    await execFileAsync5("rg", ["--version"], { timeout: 2e3 });
+    await execFileAsync4("rg", ["--version"], { timeout: 2e3 });
     return true;
   } catch {
     return false;
@@ -4255,7 +4323,7 @@ async function searchWithRipgrep(pattern, kind, options) {
   args.push(pattern, options.rootDir);
   let stdout;
   try {
-    const result = await execFileAsync5("rg", args, {
+    const result = await execFileAsync4("rg", args, {
       maxBuffer: 20 * 1024 * 1024,
       timeout: 1e4
     });
@@ -4365,11 +4433,11 @@ function matchesGlob(filePath, glob2) {
     return false;
   }
 }
-var execFileAsync5, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS, DEFAULT_MAX_MATCHES, ALWAYS_SKIP, ALL_CODE_EXTS;
+var execFileAsync4, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS, DEFAULT_MAX_MATCHES, ALWAYS_SKIP, ALL_CODE_EXTS;
 var init_lexicalSearch = __esm({
   "packages/retrieval/dist/lexicalSearch.js"() {
     "use strict";
-    execFileAsync5 = promisify5(execFile5);
+    execFileAsync4 = promisify4(execFile4);
     DEFAULT_INCLUDE_GLOBS = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.py"];
     DEFAULT_EXCLUDE_GLOBS = ["node_modules", "dist", ".git", "build", "coverage"];
     DEFAULT_MAX_MATCHES = 50;
@@ -5115,9 +5183,9 @@ var init_verifierRunner = __esm({
       async executeTests(patch, repoRoot) {
         if (patch.testsToRun.length === 0)
           return "(no tests specified)";
-        const { execFile: execFile6 } = await import("node:child_process");
-        const { promisify: promisify6 } = await import("node:util");
-        const execFileAsync6 = promisify6(execFile6);
+        const { execFile: execFile5 } = await import("node:child_process");
+        const { promisify: promisify5 } = await import("node:util");
+        const execFileAsync5 = promisify5(execFile5);
         const outputs = [];
         const workDir = this.options.workingDir || repoRoot;
         for (const cmd of patch.testsToRun.slice(0, 3)) {
@@ -5126,7 +5194,7 @@ var init_verifierRunner = __esm({
             const [bin, ...args] = parts;
             if (!bin)
               continue;
-            const { stdout, stderr } = await execFileAsync6(bin, args, {
+            const { stdout, stderr } = await execFileAsync5(bin, args, {
               cwd: workDir,
               timeout: 6e4,
               maxBuffer: 1024 * 1024
@@ -5701,7 +5769,7 @@ var init_agenticRunner = __esm({
 - file_edit: Make a precise string replacement in a file (preferred over rewriting). Uses old_string/new_string.
 - find_files: Find files by name pattern (glob). Searches recursively, excludes node_modules/.git.
 - grep_search: Search file contents with regex. Returns matching lines with paths and line numbers.
-- shell: Execute any shell command (tests, builds, git, npm, etc.)
+- shell: Execute any shell command (tests, builds, git, npm, etc.). Supports stdin parameter for input. Commands run with CI=true for non-interactive mode.
 - list_directory: List files in a directory with types and sizes
 - web_search: Search the web for documentation or solutions
 - web_fetch: Fetch a web page and extract text content (for docs, MDN, w3schools.com, etc.)
@@ -5752,6 +5820,15 @@ When a test or build fails:
 8. If it fails with the SAME error, try a different approach
 9. After 3 failed attempts at the same error, use web_search for solutions
 
+## Interactive Commands
+
+Commands run non-interactively (CI=true). When running scaffolding tools:
+- ALWAYS add non-interactive flags: --yes, --no-input, --defaults, etc.
+- For npx create-next-app: use --yes (skips all prompts, uses defaults)
+- For npm init: use -y
+- If a command needs specific answers, use the stdin parameter
+- If a command times out, it likely hit an interactive prompt \u2014 retry with --yes
+
 ## Context Efficiency
 
 - Use grep_search to find specific code instead of reading many files
@@ -6210,6 +6287,8 @@ function renderSlashHelp() {
     ["/endpoint <url> --auth <t>", "Set endpoint with Bearer auth"],
     ["/config", "Show current configuration"],
     ["/update", "Check for updates and auto-install"],
+    ["/voice", "Toggle TTS voice feedback (GLaDOS)"],
+    ["/voice <model>", "Set voice: glados, overwatch"],
     ["/verbose", "Toggle verbose mode"],
     ["/clear", "Clear the screen"],
     ["/help", "Show this help"],
@@ -6267,8 +6346,10 @@ function formatToolArgs(toolName, args) {
     case "file_write":
     case "file_edit":
       return String(args["path"] ?? "");
-    case "shell":
-      return truncStr(String(args["command"] ?? ""), 60);
+    case "shell": {
+      const cmd = truncStr(String(args["command"] ?? ""), 60);
+      return args["stdin"] ? `${cmd} ${c2.dim("(with stdin)")}` : cmd;
+    }
     case "grep_search":
       return `${c2.yellow(String(args["pattern"] ?? ""))}${args["path"] ? ` in ${args["path"]}` : ""}`;
     case "find_files":
@@ -6440,6 +6521,16 @@ async function handleSlashCommand(input, ctx) {
     case "upgrade":
       await handleUpdate();
       return "handled";
+    case "voice": {
+      if (arg) {
+        const msg = await ctx.voiceSetModel(arg);
+        renderInfo(msg);
+      } else {
+        const msg = await ctx.voiceToggle();
+        renderInfo(msg);
+      }
+      return "handled";
+    }
     default:
       renderWarning(`Unknown command: /${cmd}. Type /help for available commands.`);
       return "handled";
@@ -6552,11 +6643,11 @@ async function handleEndpoint(arg, ctx) {
 async function handleUpdate() {
   let currentVersion = "0.0.0";
   try {
-    const { createRequire: createRequire2 } = await import("node:module");
+    const { createRequire: createRequire3 } = await import("node:module");
     const { fileURLToPath: fileURLToPath2 } = await import("node:url");
-    const { dirname: dirname4, join: join17 } = await import("node:path");
-    const require2 = createRequire2(import.meta.url);
-    const pkgPath = join17(dirname4(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const { dirname: dirname4, join: join18 } = await import("node:path");
+    const require2 = createRequire3(import.meta.url);
+    const pkgPath = join18(dirname4(fileURLToPath2(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     currentVersion = pkg.version ?? "0.0.0";
   } catch {
@@ -6916,9 +7007,9 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict 16384`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir = join12(homedir3(), ".open-agents", "models");
-        mkdirSync3(modelDir, { recursive: true });
-        const modelfilePath = join12(modelDir, `Modelfile.${customName}`);
+        const modelDir2 = join12(homedir3(), ".open-agents", "models");
+        mkdirSync3(modelDir2, { recursive: true });
+        const modelfilePath = join12(modelDir2, `Modelfile.${customName}`);
         writeFileSync3(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
         execSync7(`ollama create ${customName} -f ${modelfilePath}`, {
@@ -7003,6 +7094,472 @@ var init_setup = __esm({
   }
 });
 
+// packages/cli/dist/tui/voice.js
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync6, unlinkSync } from "node:fs";
+import { join as join13 } from "node:path";
+import { homedir as homedir4, tmpdir, platform } from "node:os";
+import { execSync as execSync8, spawn as nodeSpawn } from "node:child_process";
+import { createRequire } from "node:module";
+function modelDir(id) {
+  return join13(MODELS_DIR, id);
+}
+function modelOnnxPath(id) {
+  return join13(modelDir(id), "model.onnx");
+}
+function modelConfigPath(id) {
+  return join13(modelDir(id), "config.json");
+}
+function describeToolCall(toolName, args) {
+  const path = args["path"];
+  const file = path ? path.split("/").pop() ?? path : "";
+  switch (toolName) {
+    case "file_read":
+      return `Reading ${file}`;
+    case "file_write":
+      return `Writing ${file}`;
+    case "file_edit":
+      return `Editing ${file}`;
+    case "shell": {
+      const cmd = String(args["command"] ?? "");
+      if (/npm\s+test|vitest|jest|mocha/.test(cmd))
+        return "Running tests";
+      if (/npm\s+run\s+build|tsc|esbuild/.test(cmd))
+        return "Building project";
+      if (/npm\s+install|pnpm\s+install/.test(cmd))
+        return "Installing dependencies";
+      if (/git\s+/.test(cmd))
+        return "Running git command";
+      if (/npm\s+run\s+lint|eslint|biome/.test(cmd))
+        return "Running linter";
+      if (cmd.length > 40)
+        return "Running shell command";
+      return `Running ${cmd.slice(0, 30)}`;
+    }
+    case "grep_search":
+      return `Searching for ${args["pattern"] ?? "pattern"}`;
+    case "find_files":
+      return `Finding files matching ${args["pattern"] ?? "pattern"}`;
+    case "list_directory":
+      return `Listing directory ${file || "contents"}`;
+    case "web_search":
+      return `Searching the web`;
+    case "web_fetch":
+      return `Fetching web page`;
+    case "memory_read":
+      return `Reading from memory`;
+    case "memory_write":
+      return `Saving to memory`;
+    case "task_complete":
+      return String(args["summary"] ?? "Task complete");
+    case "batch_edit":
+      return `Editing multiple files`;
+    case "codebase_map":
+      return `Mapping project structure`;
+    case "diagnostic":
+      return `Running diagnostics`;
+    case "git_info":
+      return `Checking git status`;
+    case "aiwg_setup":
+      return `Setting up development framework`;
+    case "aiwg_health":
+      return `Analyzing project health`;
+    case "aiwg_workflow":
+      return `Running workflow command`;
+    default:
+      return `Using ${toolName}`;
+  }
+}
+function describeToolResult(toolName, success) {
+  if (toolName === "task_complete")
+    return "";
+  return success ? "Done" : "That failed, trying to fix it";
+}
+function formatBytes2(bytes) {
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(0)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+var VOICE_MODELS, VOICE_DIR, MODELS_DIR, VoiceEngine;
+var init_voice = __esm({
+  "packages/cli/dist/tui/voice.js"() {
+    "use strict";
+    init_render();
+    VOICE_MODELS = {
+      glados: {
+        id: "glados",
+        label: "GLaDOS",
+        onnxUrl: "https://raw.githubusercontent.com/robit-man/EGG/main/voice/glados_piper_medium.onnx",
+        configUrl: "https://raw.githubusercontent.com/robit-man/EGG/main/voice/glados_piper_medium.onnx.json"
+      },
+      overwatch: {
+        id: "overwatch",
+        label: "Overwatch",
+        onnxUrl: "https://raw.githubusercontent.com/robit-man/combine_overwatch_onnx/main/overwatch.onnx",
+        configUrl: "https://raw.githubusercontent.com/robit-man/combine_overwatch_onnx/main/overwatch.onnx.json"
+      }
+    };
+    VOICE_DIR = join13(homedir4(), ".open-agents", "voice");
+    MODELS_DIR = join13(VOICE_DIR, "models");
+    VoiceEngine = class {
+      enabled = false;
+      modelId = "glados";
+      ready = false;
+      session = null;
+      // ort.InferenceSession
+      ort = null;
+      // onnxruntime-node module
+      config = null;
+      currentPlayback = null;
+      speakQueue = [];
+      speaking = false;
+      hasEspeak = false;
+      // -------------------------------------------------------------------------
+      // Public API
+      // -------------------------------------------------------------------------
+      async toggle() {
+        if (this.enabled) {
+          this.enabled = false;
+          this.killPlayback();
+          return "Voice feedback disabled.";
+        }
+        try {
+          await this.ensureRuntime();
+          await this.ensureModel(this.modelId);
+          await this.loadSession();
+          this.enabled = true;
+          this.ready = true;
+          return `Voice feedback enabled (${VOICE_MODELS[this.modelId]?.label ?? this.modelId}).`;
+        } catch (err) {
+          return `Failed to enable voice: ${err instanceof Error ? err.message : String(err)}`;
+        }
+      }
+      async setModel(id) {
+        const key = id.toLowerCase();
+        if (!VOICE_MODELS[key]) {
+          return `Unknown voice model: "${id}". Available: ${Object.keys(VOICE_MODELS).join(", ")}`;
+        }
+        this.modelId = key;
+        this.session = null;
+        this.config = null;
+        this.ready = false;
+        if (this.enabled) {
+          try {
+            await this.ensureModel(key);
+            await this.loadSession();
+            this.ready = true;
+            return `Switched to ${VOICE_MODELS[key].label} voice.`;
+          } catch (err) {
+            this.enabled = false;
+            return `Failed to load ${key}: ${err instanceof Error ? err.message : String(err)}`;
+          }
+        }
+        return `Voice model set to ${VOICE_MODELS[key].label}. Enable with /voice.`;
+      }
+      /**
+       * Speak text asynchronously (non-blocking).
+       * Queues if already speaking; drops if queue gets too deep.
+       */
+      speak(text) {
+        if (!this.enabled || !this.ready)
+          return;
+        if (this.speakQueue.length >= 3) {
+          this.speakQueue.length = 0;
+        }
+        this.speakQueue.push(text);
+        if (!this.speaking) {
+          this.drainQueue().catch(() => {
+          });
+        }
+      }
+      dispose() {
+        this.enabled = false;
+        this.killPlayback();
+        this.session = null;
+        this.ort = null;
+        this.config = null;
+      }
+      // -------------------------------------------------------------------------
+      // Queue drain
+      // -------------------------------------------------------------------------
+      async drainQueue() {
+        this.speaking = true;
+        while (this.speakQueue.length > 0) {
+          const text = this.speakQueue.pop();
+          this.speakQueue.length = 0;
+          try {
+            await this.synthesizeAndPlay(text);
+          } catch {
+          }
+        }
+        this.speaking = false;
+      }
+      // -------------------------------------------------------------------------
+      // Synthesis pipeline
+      // -------------------------------------------------------------------------
+      async synthesizeAndPlay(text) {
+        if (!this.session || !this.config || !this.ort)
+          return;
+        const phonemeIds = this.textToPhonemeIds(text);
+        if (phonemeIds.length === 0)
+          return;
+        const inputLength = phonemeIds.length;
+        const inputTensor = new this.ort.Tensor("int64", BigInt64Array.from(phonemeIds.map((id) => BigInt(id))), [1, inputLength]);
+        const lengthTensor = new this.ort.Tensor("int64", BigInt64Array.from([BigInt(inputLength)]), [1]);
+        const scalesTensor = new this.ort.Tensor("float32", Float32Array.from([0.667, 1, 0.8]), [3]);
+        const feeds = {
+          input: inputTensor,
+          input_lengths: lengthTensor,
+          scales: scalesTensor
+        };
+        if (this.config.num_speakers > 1) {
+          feeds["sid"] = new this.ort.Tensor("int64", BigInt64Array.from([BigInt(0)]), [1]);
+        }
+        const result = await this.session.run(feeds);
+        const audioData = result["output"].data;
+        if (audioData.length === 0)
+          return;
+        const wavPath = join13(tmpdir(), `oa-voice-${Date.now()}.wav`);
+        this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
+        await this.playWav(wavPath);
+        try {
+          unlinkSync(wavPath);
+        } catch {
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Phonemization
+      // -------------------------------------------------------------------------
+      textToPhonemeIds(text) {
+        const map = this.config.phoneme_id_map;
+        let phonemes;
+        if (this.hasEspeak) {
+          try {
+            const voice = this.config.espeak?.voice ?? "en-us";
+            phonemes = execSync8(`espeak-ng --ipa -q --sep="" -v ${voice} "${text.replace(/"/g, '\\"')}"`, { encoding: "utf8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+          } catch {
+            phonemes = text.toLowerCase();
+          }
+        } else {
+          phonemes = text.toLowerCase();
+        }
+        const ids = [];
+        if (map["^"])
+          ids.push(...map["^"]);
+        for (const char of phonemes) {
+          if (map[char]) {
+            ids.push(...map[char]);
+            if (map["_"])
+              ids.push(...map["_"]);
+          }
+        }
+        if (map["$"])
+          ids.push(...map["$"]);
+        return ids;
+      }
+      // -------------------------------------------------------------------------
+      // WAV encoder (PCM 16-bit mono)
+      // -------------------------------------------------------------------------
+      writeWav(samples, sampleRate, path) {
+        const numChannels = 1;
+        const bitsPerSample = 16;
+        const byteRate = sampleRate * numChannels * (bitsPerSample / 8);
+        const blockAlign = numChannels * (bitsPerSample / 8);
+        const int16 = new Int16Array(samples.length);
+        for (let i = 0; i < samples.length; i++) {
+          const s = Math.max(-1, Math.min(1, samples[i]));
+          int16[i] = s < 0 ? s * 32768 : s * 32767;
+        }
+        const dataSize = int16.length * 2;
+        const buffer = Buffer.alloc(44 + dataSize);
+        buffer.write("RIFF", 0);
+        buffer.writeUInt32LE(36 + dataSize, 4);
+        buffer.write("WAVE", 8);
+        buffer.write("fmt ", 12);
+        buffer.writeUInt32LE(16, 16);
+        buffer.writeUInt16LE(1, 20);
+        buffer.writeUInt16LE(numChannels, 22);
+        buffer.writeUInt32LE(sampleRate, 24);
+        buffer.writeUInt32LE(byteRate, 28);
+        buffer.writeUInt16LE(blockAlign, 32);
+        buffer.writeUInt16LE(bitsPerSample, 34);
+        buffer.write("data", 36);
+        buffer.writeUInt32LE(dataSize, 40);
+        Buffer.from(int16.buffer, int16.byteOffset, int16.byteLength).copy(buffer, 44);
+        writeFileSync4(path, buffer);
+      }
+      // -------------------------------------------------------------------------
+      // Audio playback (system default speakers)
+      // -------------------------------------------------------------------------
+      async playWav(path) {
+        this.killPlayback();
+        const cmd = this.getPlayCommand(path);
+        if (!cmd)
+          return;
+        return new Promise((resolve12) => {
+          const child = nodeSpawn(cmd[0], cmd.slice(1), {
+            stdio: "ignore",
+            detached: false
+          });
+          this.currentPlayback = child;
+          child.on("close", () => {
+            if (this.currentPlayback === child)
+              this.currentPlayback = null;
+            resolve12();
+          });
+          child.on("error", () => {
+            if (this.currentPlayback === child)
+              this.currentPlayback = null;
+            resolve12();
+          });
+          setTimeout(() => {
+            this.killPlayback();
+            resolve12();
+          }, 15e3);
+        });
+      }
+      getPlayCommand(path) {
+        const os = platform();
+        if (os === "darwin")
+          return ["afplay", path];
+        if (os === "win32") {
+          return [
+            "powershell",
+            "-c",
+            `(New-Object Media.SoundPlayer '${path}').PlaySync()`
+          ];
+        }
+        for (const player of ["paplay", "pw-play", "aplay"]) {
+          try {
+            execSync8(`which ${player}`, { stdio: "pipe" });
+            return [player, path];
+          } catch {
+          }
+        }
+        return null;
+      }
+      killPlayback() {
+        if (this.currentPlayback) {
+          try {
+            this.currentPlayback.kill("SIGTERM");
+          } catch {
+          }
+          this.currentPlayback = null;
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Setup: ONNX runtime installation
+      // -------------------------------------------------------------------------
+      async ensureRuntime() {
+        if (this.ort)
+          return;
+        mkdirSync4(VOICE_DIR, { recursive: true });
+        const pkgPath = join13(VOICE_DIR, "package.json");
+        if (!existsSync8(pkgPath)) {
+          writeFileSync4(pkgPath, JSON.stringify({
+            name: "open-agents-voice",
+            private: true,
+            dependencies: { "onnxruntime-node": "^1.21.0" }
+          }, null, 2));
+        }
+        const voiceRequire = createRequire(join13(VOICE_DIR, "index.js"));
+        try {
+          this.ort = voiceRequire("onnxruntime-node");
+        } catch {
+          renderInfo("Installing ONNX runtime for voice synthesis...");
+          try {
+            execSync8("npm install --no-audit --no-fund", {
+              cwd: VOICE_DIR,
+              stdio: "pipe",
+              timeout: 12e4
+            });
+            this.ort = voiceRequire("onnxruntime-node");
+          } catch (err) {
+            throw new Error(`Failed to install onnxruntime-node. Try manually: cd ${VOICE_DIR} && npm install
+Error: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        try {
+          execSync8("espeak-ng --version", { stdio: "pipe" });
+          this.hasEspeak = true;
+        } catch {
+          this.hasEspeak = false;
+          renderWarning("espeak-ng not found \u2014 using basic phonemization. For better voice quality: sudo apt install espeak-ng");
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Setup: Model download
+      // -------------------------------------------------------------------------
+      async ensureModel(id) {
+        const model = VOICE_MODELS[id];
+        if (!model)
+          throw new Error(`Unknown model: ${id}`);
+        const dir = modelDir(id);
+        const onnxPath = modelOnnxPath(id);
+        const configPath = modelConfigPath(id);
+        if (existsSync8(onnxPath) && existsSync8(configPath))
+          return;
+        mkdirSync4(dir, { recursive: true });
+        if (!existsSync8(configPath)) {
+          renderInfo(`Downloading ${model.label} voice config...`);
+          const configResp = await fetch(model.configUrl);
+          if (!configResp.ok)
+            throw new Error(`Failed to download config: HTTP ${configResp.status}`);
+          const configText = await configResp.text();
+          writeFileSync4(configPath, configText);
+        }
+        if (!existsSync8(onnxPath)) {
+          renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
+          const onnxResp = await fetch(model.onnxUrl);
+          if (!onnxResp.ok)
+            throw new Error(`Failed to download model: HTTP ${onnxResp.status}`);
+          const reader = onnxResp.body?.getReader();
+          if (!reader)
+            throw new Error("No response body");
+          const contentLength = parseInt(onnxResp.headers.get("content-length") || "0", 10);
+          const chunks = [];
+          let received = 0;
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            chunks.push(value);
+            received += value.length;
+            if (contentLength > 0) {
+              const pct = Math.round(received / contentLength * 100);
+              process.stdout.write(`\r  ${c2.dim(`  ${pct}% (${formatBytes2(received)} / ${formatBytes2(contentLength)})`)}`);
+            }
+          }
+          process.stdout.write("\r" + " ".repeat(60) + "\r");
+          const fullBuffer = Buffer.concat(chunks);
+          writeFileSync4(onnxPath, fullBuffer);
+          renderInfo(`${model.label} model downloaded (${formatBytes2(fullBuffer.length)}).`);
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Load ONNX session
+      // -------------------------------------------------------------------------
+      async loadSession() {
+        if (!this.ort)
+          throw new Error("ONNX runtime not loaded");
+        const onnxPath = modelOnnxPath(this.modelId);
+        const configPath = modelConfigPath(this.modelId);
+        if (!existsSync8(onnxPath) || !existsSync8(configPath)) {
+          throw new Error(`Model files not found for ${this.modelId}`);
+        }
+        this.config = JSON.parse(readFileSync6(configPath, "utf8"));
+        renderInfo("Loading voice model...");
+        this.session = await this.ort.InferenceSession.create(onnxPath, {
+          executionProviders: ["cpu"],
+          graphOptimizationLevel: "all"
+        });
+        renderInfo("Voice model loaded.");
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/interactive.js
 import * as readline2 from "node:readline";
 import { cwd } from "node:process";
@@ -7059,7 +7616,7 @@ function buildTools(repoRoot) {
   ];
   return [...executionTools.map(adaptTool), createTaskCompleteTool()];
 }
-async function runTask(task, config, repoRoot) {
+async function runTask(task, config, repoRoot, voice) {
   const backend = new OllamaAgenticBackend(config.backendUrl.replace(/\/$/, ""), config.model);
   const runner = new AgenticRunner(backend, {
     maxTurns: 30,
@@ -7074,9 +7631,16 @@ async function runTask(task, config, repoRoot) {
     switch (event.type) {
       case "tool_call":
         renderToolCallStart(event.toolName ?? "unknown", event.toolArgs ?? {});
+        if (voice?.enabled) {
+          const desc = describeToolCall(event.toolName ?? "unknown", event.toolArgs ?? {});
+          voice.speak(desc);
+        }
         break;
       case "tool_result":
         renderToolResult(event.toolName ?? "unknown", event.success ?? false, event.content ?? "");
+        if (voice?.enabled && !(event.success ?? true)) {
+          voice.speak(describeToolResult(event.toolName ?? "unknown", false));
+        }
         break;
       case "model_response":
         if (config.verbose && event.content) {
@@ -7124,6 +7688,7 @@ async function startInteractive(config, repoPath) {
     process.exit(1);
   }
   renderHeader(config.model);
+  const voiceEngine = new VoiceEngine();
   let currentConfig = { ...config };
   const rl = readline2.createInterface({
     input: process.stdin,
@@ -7155,7 +7720,14 @@ async function startInteractive(config, repoPath) {
       renderCompactHeader(currentConfig.model);
     },
     exit() {
+      voiceEngine.dispose();
       rl.close();
+    },
+    async voiceToggle() {
+      return voiceEngine.toggle();
+    },
+    async voiceSetModel(id) {
+      return voiceEngine.setModel(id);
     }
   };
   rl.prompt();
@@ -7180,7 +7752,7 @@ ${c2.dim("Goodbye!")}
     }
     renderUserMessage(input);
     try {
-      await runTask(input, currentConfig, repoRoot);
+      await runTask(input, currentConfig, repoRoot, voiceEngine);
     } catch (err) {
       renderError(err instanceof Error ? err.message : String(err));
     }
@@ -7239,6 +7811,7 @@ var init_interactive = __esm({
     init_commands();
     init_setup();
     init_render();
+    init_voice();
   }
 });
 
@@ -7273,7 +7846,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join13, relative as relative2, extname as extname3, basename } from "node:path";
+import { join as join14, relative as relative2, extname as extname3, basename } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -7317,7 +7890,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile8(join13(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile8(join14(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -7332,7 +7905,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join13(this.config.rootDir, relativePath);
+          const fullPath = join14(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat2(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -7378,7 +7951,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join13(current.path, part),
+                  path: join14(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -7453,13 +8026,13 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve11 } from "node:path";
-import { existsSync as existsSync8, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync9, statSync as statSync4 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve11(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync8(repoRoot)) {
+  if (!existsSync9(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -7705,8 +8278,8 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join14 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { join as join15 } from "node:path";
+import { homedir as homedir5 } from "node:os";
 async function configCommand(opts, config) {
   if (opts.subCommand === "set") {
     return handleSet(opts, config);
@@ -7728,7 +8301,7 @@ function handleShow(opts, config) {
   printKeyValue("verbose", String(config.verbose), 2);
   printKeyValue("dbPath", config.dbPath, 2);
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join14(homedir4(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join15(homedir5(), ".open-agents", "config.json")})`);
   printSection("Environment Variables");
   printInfo("OPEN_AGENTS_BACKEND_URL  \u2014 override backendUrl");
   printInfo("OPEN_AGENTS_MODEL        \u2014 override model");
@@ -7802,7 +8375,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -7895,7 +8468,7 @@ async function serveVllm(opts, config) {
 }
 async function runVllmServer(args, verbose) {
   return new Promise((resolve12, reject) => {
-    const child = spawn("python", args, {
+    const child = spawn2("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -7959,9 +8532,9 @@ var eval_exports = {};
 __export(eval_exports, {
   evalCommand: () => evalCommand
 });
-import { tmpdir } from "node:os";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join15 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join16 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -8082,9 +8655,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join15(tmpdir(), `open-agents-eval-${Date.now()}`);
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync4(join15(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join16(tmpdir2(), `open-agents-eval-${Date.now()}`);
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync5(join16(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -8142,9 +8715,9 @@ init_config();
 init_output();
 init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname3, join as join16 } from "node:path";
+import { dirname as dirname3, join as join17 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -8250,8 +8823,8 @@ init_spinner();
 init_output();
 function getVersion() {
   try {
-    const require2 = createRequire(import.meta.url);
-    const pkgPath = join16(dirname3(fileURLToPath(import.meta.url)), "..", "package.json");
+    const require2 = createRequire2(import.meta.url);
+    const pkgPath = join17(dirname3(fileURLToPath(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — Claude Code-style TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,10 @@
     "tool-calling",
     "agentic",
     "code-generation",
-    "developer-tools"
+    "developer-tools",
+    "tts",
+    "voice",
+    "onnx"
   ],
   "author": "robit-man",
   "license": "MIT",