agentgui 1.0.801 → 1.0.803

package/CLAUDE.md

@@ -39,7 +39,7 @@ lib/oauth-codex.js     Codex CLI OAuth flow (PKCE S256, token exchange, callback
 lib/plugin-interface.js  Plugin interface contract definition
 lib/plugin-loader.js   Plugin discovery and loading (EventEmitter-based)
 lib/pm2-manager.js     PM2 process management wrapper
-lib/speech.js          Speech-to-text and text-to-speech via webtalk (lazy-loaded, on-demand install)
+lib/speech.js          Speech-to-text and text-to-speech via @huggingface/transformers
 lib/speech-manager.js  TTS orchestration (eager TTS, voice cache, model download, broadcastModelProgress)
 lib/tool-install-machine.js  XState v5 machine per tool: unchecked/checking/idle/installing/installed/updating/needs_update/failed states
 lib/tool-manager.js    Tool facade - re-exports from tool-version, tool-spawner, tool-provisioner
@@ -223,13 +223,11 @@ Tool updates are managed through a complete pipeline:
 
 ## Tool Detection System
 
-TOOLS array in `lib/tool-manager.js` — three categories:
+TOOLS array in `lib/tool-manager.js` — two categories:
 - **`cli`**: `{ id, name, pkg, category: 'cli' }` — detected via `which <bin>` + `<bin> --version`
 - **`plugin`**: `{ id, name, pkg, installPkg, pluginId, category: 'plugin', frameWork }` — detected via plugin.json files
-- **`npm-local`**: `{ id, name, pkg, category: 'npm-local' }` — detected via `node_modules/<pkg>/package.json`, installed via `npm install --save` in project root
 
 Current tools:
-- `speech-engine`: pkg=`webtalk`, category=`npm-local` — STT/TTS (Whisper + ONNX), not a hard npm dep; install from tools tab
 - `cli-claude`: bin=`claude`, pkg=`@anthropic-ai/claude-code`
 - `cli-opencode`: bin=`opencode`, pkg=`opencode-ai`
 - `cli-gemini`: bin=`gemini`, pkg=`@google/gemini-cli`

package/lib/acp-sdk-manager.js

@@ -179,8 +179,20 @@ export async function queryModels(agentId) {
   const port = await ensureRunning(agentId);
   if (!port) return [];
   try {
-    const res = await fetch('http://127.0.0.1:' + port + '/models', { signal: AbortSignal.timeout(3000) });
-    return res.ok ? ((await res.json()).models || []) : [];
+    const res = await fetch('http://127.0.0.1:' + port + '/provider', { signal: AbortSignal.timeout(5000) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const connected = data.connected || [];
+    const allProvs = Object.fromEntries((data.all || []).map(p => [p.id, p]));
+    const src = connected.length ? connected : Object.keys(allProvs);
+    const models = [];
+    for (const pid of src) {
+      const prov = allProvs[pid] || {};
+      for (const [, m] of Object.entries(prov.models || {})) {
+        models.push({ id: (m.providerID || pid) + '/' + m.id, label: m.name || m.id });
+      }
+    }
+    return models;
   } catch (_) { return []; }
 }
 

package/lib/speech-manager.js

@@ -14,38 +14,14 @@ export function initSpeechManager({ broadcastSync, syncClients, queries }) {
   _queries = queries;
 }
 
-export function isSpeechInstalled() {
-  try {
-    const r = createRequire(import.meta.url);
-    r.resolve('webtalk/speech');
-    return true;
-  } catch (_) { return false; }
-}
-
 export async function ensurePocketTtsSetup(onProgress) {
   const r = createRequire(import.meta.url);
-  try {
-    const serverTTS = r('webtalk/server-tts');
-    return serverTTS.ensureInstalled(onProgress);
-  } catch (err) {
-    if (err.code === 'MODULE_NOT_FOUND' || err.code === 'SPEECH_NOT_INSTALLED') return false;
-    throw err;
-  }
+  const serverTTS = r('webtalk/server-tts');
+  return serverTTS.ensureInstalled(onProgress);
 }
 
 export async function getSpeech() {
-  if (!speechModule) {
-    try {
-      speechModule = await import('./speech.js');
-    } catch (err) {
-      if (err.code === 'MODULE_NOT_FOUND' || err.code === 'SPEECH_NOT_INSTALLED') {
-        const e = new Error('speech_not_installed: Install Speech Engine from the Tools tab.');
-        e.code = 'SPEECH_NOT_INSTALLED';
-        throw e;
-      }
-      throw err;
-    }
-  }
+  if (!speechModule) speechModule = await import('./speech.js');
   return speechModule;
 }
 
@@ -140,10 +116,6 @@ async function validateAndCleanupModels(modelsDir) {
 }
 
 export async function ensureModelsDownloaded() {
-  if (!isSpeechInstalled()) {
-    console.log('[MODELS] Speech Engine not installed, skipping model download.');
-    return false;
-  }
   if (modelDownloadState.downloading) {
     return new Promise(resolve => { modelDownloadState.waiters.push(resolve); });
   }

package/lib/speech.js

@@ -1,67 +1,50 @@
-import { createRequire } from 'module';
-
-const _require = createRequire(import.meta.url);
-const ttsMemCache = new Map();
-const TTS_CACHE_MAX_BYTES = 10 * 1024 * 1024;
-let ttsCacheBytes = 0;
-let _speech = null;
-
-function loadSpeech() {
-  if (_speech) return _speech;
-  try {
-    _speech = _require('webtalk/speech');
-    return _speech;
-  } catch (err) {
-    const e = new Error('speech_not_installed: Install Speech Engine from the Tools tab.');
-    e.code = 'SPEECH_NOT_INSTALLED';
-    throw e;
-  }
-}
-
-export function ttsCacheKey(text, voiceId) {
-  return (voiceId || 'default') + ':' + text;
-}
-
-export function ttsCacheGet(key) {
-  return ttsMemCache.get(key) || null;
-}
-
-export function ttsCacheSet(key, wav) {
-  if (ttsMemCache.has(key)) return;
-  const size = wav ? wav.length : 0;
-  while (ttsCacheBytes + size > TTS_CACHE_MAX_BYTES && ttsMemCache.size > 0) {
-    const oldest = ttsMemCache.keys().next().value;
-    const old = ttsMemCache.get(oldest);
-    ttsCacheBytes -= old ? old.length : 0;
-    ttsMemCache.delete(oldest);
-  }
-  ttsMemCache.set(key, wav);
-  ttsCacheBytes += size;
-}
-
-export async function transcribe(...args) { return loadSpeech().transcribe(...args); }
-
-export async function synthesize(text, voiceId) {
-  const key = ttsCacheKey(text, voiceId);
-  const cached = ttsCacheGet(key);
-  if (cached) return cached;
-  const wav = await loadSpeech().synthesize(text, voiceId);
-  ttsCacheSet(key, wav);
-  return wav;
-}
-
-export async function synthesizeStream(...args) { return loadSpeech().synthesizeStream(...args); }
-export function getSTT() { return loadSpeech().getSTT(); }
-export function getStatus() {
-  try { return loadSpeech().getStatus(); }
-  catch (_) { return { sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false, speechNotInstalled: true }; }
-}
-export function getVoices() {
-  try { return loadSpeech().getVoices(); }
-  catch (_) { return []; }
-}
-export function preloadTTS() { try { loadSpeech().preloadTTS?.(); } catch (_) {} }
-export function resetSTTError() { try { loadSpeech().resetSTTError?.(); } catch (_) {} }
-export function clearCorruptedSTTCache() { try { return loadSpeech().clearCorruptedSTTCache?.(); } catch (_) {} }
-export function getSttOptions() { try { return loadSpeech().getSttOptions?.(); } catch (_) { return {}; } }
-export const VOICE_DIRS = (() => { try { return loadSpeech().VOICE_DIRS; } catch (_) { return []; } })();
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const speech = require('webtalk/speech');
+
+const ttsMemCache = new Map();
+const TTS_CACHE_MAX_BYTES = 10 * 1024 * 1024;
+let ttsCacheBytes = 0;
+
+function ttsCacheKey(text, voiceId) {
+  return (voiceId || 'default') + ':' + text;
+}
+
+function ttsCacheGet(key) {
+  return ttsMemCache.get(key) || null;
+}
+
+function ttsCacheSet(key, wav) {
+  if (ttsMemCache.has(key)) return;
+  const size = wav ? wav.length : 0;
+  while (ttsCacheBytes + size > TTS_CACHE_MAX_BYTES && ttsMemCache.size > 0) {
+    const oldest = ttsMemCache.keys().next().value;
+    const old = ttsMemCache.get(oldest);
+    ttsCacheBytes -= old ? old.length : 0;
+    ttsMemCache.delete(oldest);
+  }
+  ttsMemCache.set(key, wav);
+  ttsCacheBytes += size;
+}
+
+async function synthesizeWithCache(text, voiceId) {
+  const key = ttsCacheKey(text, voiceId);
+  const cached = ttsCacheGet(key);
+  if (cached) return cached;
+  const wav = await speech.synthesize(text, voiceId);
+  ttsCacheSet(key, wav);
+  return wav;
+}
+
+export const transcribe = speech.transcribe;
+export const synthesize = synthesizeWithCache;
+export const synthesizeStream = speech.synthesizeStream;
+export const getSTT = speech.getSTT;
+export const getStatus = speech.getStatus;
+export const getVoices = speech.getVoices;
+export const preloadTTS = speech.preloadTTS;
+export { ttsCacheKey, ttsCacheGet, ttsCacheSet };
+export const resetSTTError = speech.resetSTTError;
+export const clearCorruptedSTTCache = speech.clearCorruptedSTTCache;
+export const getSttOptions = speech.getSttOptions;
+export const VOICE_DIRS = speech.VOICE_DIRS;

package/lib/tool-manager.js

@@ -3,7 +3,6 @@ import { createInstaller } from './tool-spawner.js';
 import { autoProvision as _autoProvision, startPeriodicUpdateCheck as _startPeriodicUpdateCheck, stopPeriodicUpdateCheck } from './tool-provisioner.js';
 
 const TOOLS = [
-  { id: 'speech-engine', name: 'Speech Engine', pkg: 'webtalk', category: 'npm-local', description: 'STT/TTS support (Whisper + ONNX)' },
   { id: 'cli-claude', name: 'Claude Code', pkg: '@anthropic-ai/claude-code', category: 'cli' },
   { id: 'cli-opencode', name: 'OpenCode', pkg: 'opencode-ai', category: 'cli' },
   { id: 'cli-gemini', name: 'Gemini CLI', pkg: '@google/gemini-cli', category: 'cli' },

package/lib/tool-spawner.js

@@ -1,7 +1,5 @@
 import { spawn } from 'child_process';
 import os from 'os';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import { getCliVersion, getInstalledVersion, clearVersionCache, checkToolViaBunx } from './tool-version.js';
 import * as toolInstallMachine from './tool-install-machine.js';
 
@@ -75,33 +73,8 @@ const spawnBunxProc = (pkg, onProgress) => new Promise((resolve) => {
   });
 });
 
-const spawnNpmLocalInstall = (pkg, onProgress) => new Promise((resolve) => {
-  const cmd = isWindows ? 'npm.cmd' : 'npm';
-  let completed = false, stderr = '', stdout = '';
-  let proc;
-  const rootDir = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-  try {
-    proc = spawn(cmd, ['install', '--save', pkg], { stdio: ['pipe', 'pipe', 'pipe'], timeout: 300000, shell: isWindows, windowsHide: true, cwd: rootDir });
-  } catch (err) {
-    return resolve({ success: false, error: `Failed to spawn npm install: ${err.message}` });
-  }
-  if (!proc) return resolve({ success: false, error: 'Failed to spawn npm process' });
-  const timer = setTimeout(() => { if (!completed) { completed = true; try { proc.kill('SIGKILL'); } catch (_) {} resolve({ success: false, error: 'Timeout (5min)' }); } }, 300000);
-  const onData = (d) => { if (onProgress) onProgress({ type: 'progress', data: d.toString() }); };
-  if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d.toString(); onData(d); });
-  if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d.toString(); onData(d); });
-  proc.on('close', (code) => {
-    clearTimeout(timer);
-    if (completed) return;
-    completed = true;
-    resolve(code === 0 ? { success: true, error: null, pkg } : { success: false, error: (stdout + stderr).substring(0, 1000) || 'Failed' });
-  });
-  proc.on('error', (err) => { clearTimeout(timer); if (!completed) { completed = true; resolve({ success: false, error: err.message }); } });
-});
-
 function spawnForTool(tool, onProgress) {
   const pkg = tool.installPkg || tool.pkg;
-  if (tool.category === 'npm-local') return spawnNpmLocalInstall(pkg, onProgress);
   return tool.category === 'cli' ? spawnNpmInstall(pkg, onProgress) : spawnBunxProc(pkg, onProgress);
 }
 

package/lib/tool-version.js

@@ -216,26 +216,11 @@ export function clearVersionCache() {
   versionCache.clear();
 }
 
-const ROOT_DIR = path.dirname(new URL(import.meta.url).pathname).replace(/\/lib$/, '');
-
-export function checkNpmLocalInstalled(pkg) {
-  return fs.existsSync(path.join(ROOT_DIR, 'node_modules', pkg, 'package.json'));
-}
-
-export function getNpmLocalVersion(pkg) {
-  try {
-    const p = path.join(ROOT_DIR, 'node_modules', pkg, 'package.json');
-    if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, 'utf8')).version;
-  } catch (_) {}
-  return null;
-}
-
 export async function checkToolViaBunx(pkg, pluginId = null, category = 'plugin', frameWork = null, skipPublishedVersion = false, tools = []) {
   try {
-    const isNpmLocal = category === 'npm-local';
     const isCli = category === 'cli';
-    const installed = isNpmLocal ? checkNpmLocalInstalled(pkg) : isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
-    const installedVersion = isNpmLocal ? getNpmLocalVersion(pkg) : isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
     let publishedVersion = null;
     if (!skipPublishedVersion) {
       publishedVersion = await fetchPublishedVersion(pkg);
@@ -245,10 +230,9 @@ export async function checkToolViaBunx(pkg, pluginId = null, category = 'plugin'
     return { installed, isUpToDate, upgradeNeeded: needsUpdate, output: 'version-check', installedVersion, publishedVersion };
   } catch (err) {
     console.log(`[tool-manager] Error checking ${pkg}:`, err.message);
-    const isNpmLocal = category === 'npm-local';
     const isCli = category === 'cli';
-    const installed = isNpmLocal ? checkNpmLocalInstalled(pkg) : isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
-    const installedVersion = isNpmLocal ? getNpmLocalVersion(pkg) : isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
     return { installed, isUpToDate: false, upgradeNeeded: false, output: '', installedVersion, publishedVersion: null };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.801",
+  "version": "1.0.803",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",
@@ -24,6 +24,11 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.4.1",
+    "@anthropic-ai/claude-code": "^2.1.37",
+    "@google/gemini-cli": "latest",
+    "@huggingface/transformers": "^3.8.1",
+    "@kilocode/cli": "latest",
+    "audio-decode": "^2.2.3",
     "better-sqlite3": "^12.6.2",
     "busboy": "^1.6.0",
     "execa": "^9.6.1",
@@ -33,9 +38,13 @@
     "google-auth-library": "^10.5.0",
     "lru-cache": "^11.2.7",
     "msgpackr": "^1.11.8",
+    "onnxruntime-node": "1.21.0",
+    "opencode-ai": "^1.2.15",
     "p-retry": "^7.1.1",
     "pm2": "^5.4.3",
+    "puppeteer-core": "^24.37.5",
     "webjsx": "^0.0.73",
+    "webtalk": "^1.0.31",
     "ws": "^8.14.2",
     "xstate": "^5.28.0",
     "zod": "^4.3.6"
@@ -43,6 +52,12 @@
   "optionalDependencies": {
     "node-pty": "^1.0.0"
   },
+  "overrides": {
+    "onnxruntime-web": "npm:empty-npm-package@1.0.0",
+    "sharp": "npm:empty-npm-package@1.0.0",
+    "onnxruntime-common": "1.21.0",
+    "onnxruntime-node": "1.21.0"
+  },
   "devDependencies": {
     "electron": "^35.0.0"
   }

package/server.js

@@ -247,6 +247,9 @@ async function getModelsForAgent(agentId) {
     if (agent?.protocol === 'acp') {
       await ensureRunning(agentId);
       try { models = await queryACPModels(agentId); } catch (_) {}
+    } else if (agent?.protocol === 'cli-wrapper' && agent.acpId) {
+      await ensureRunning(agent.acpId);
+      try { models = await queryACPModels(agent.acpId); } catch (_) {}
     }
   }
   modelCache.set(agentId, { models, timestamp: Date.now() });