open-agents-ai 0.4.1 → 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

@@ -6287,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"],
@@ -6519,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";
@@ -6631,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 {
@@ -6995,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}`, {
@@ -7082,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";
@@ -7138,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,
@@ -7153,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) {
@@ -7203,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,
@@ -7234,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();
@@ -7259,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));
     }
@@ -7318,6 +7811,7 @@ var init_interactive = __esm({
     init_commands();
     init_setup();
     init_render();
+    init_voice();
   }
 });
 
@@ -7352,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"() {
@@ -7396,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 {
           }
@@ -7411,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)
@@ -7457,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: []
                 };
@@ -7532,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);
   }
@@ -7784,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);
@@ -7807,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");
@@ -8038,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];
@@ -8161,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;
@@ -8221,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";
@@ -8329,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.1",
+  "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",