agentgui 1.0.798 → 1.0.800

package/lib/speech-manager.js

@@ -14,14 +14,38 @@ 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);
-  const serverTTS = r('webtalk/server-tts');
-  return serverTTS.ensureInstalled(onProgress);
+  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;
+  }
 }
 
 export async function getSpeech() {
-  if (!speechModule) speechModule = await import('./speech.js');
+  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;
+    }
+  }
   return speechModule;
 }
 
@@ -116,6 +140,10 @@ 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,50 +1,67 @@
-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;
+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 []; } })();

package/lib/tool-manager.js

@@ -3,6 +3,7 @@ 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,5 +1,7 @@
 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';
 
@@ -73,8 +75,33 @@ 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,11 +216,26 @@ 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 = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
-    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    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);
     let publishedVersion = null;
     if (!skipPublishedVersion) {
       publishedVersion = await fetchPublishedVersion(pkg);
@@ -230,9 +245,10 @@ 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 = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
-    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    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);
     return { installed, isUpToDate: false, upgradeNeeded: false, output: '', installedVersion, publishedVersion: null };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.798",
+  "version": "1.0.800",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",
@@ -24,11 +24,6 @@
   },
   "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",
@@ -38,13 +33,9 @@
     "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"
@@ -52,12 +43,6 @@
   "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/static/js/client.js

@@ -2173,16 +2173,17 @@ class AgentGUIClient {
       blockFrag.appendChild(el);
     }
     blocksEl.appendChild(blockFrag);
+    // Build tool-use element index once for O(1) lookups instead of O(n) querySelectorAll per chunk
+    const toolUseIndex = new Map();
+    blocksEl.querySelectorAll('.block-tool-use[data-tool-use-id]').forEach(el => toolUseIndex.set(el.dataset.toolUseId, el));
     for (const chunk of deferred) {
       const b = chunk.block;
       if (b.type === 'tool_result') {
-        const tid = b.tool_use_id;
-        const toolUseEl = (tid ? blocksEl.querySelector(`.block-tool-use[data-tool-use-id="${tid}"]`) : null)
+        const toolUseEl = (b.tool_use_id && toolUseIndex.get(b.tool_use_id))
           || (blocksEl.lastElementChild?.classList.contains('block-tool-use') ? blocksEl.lastElementChild : null);
         if (toolUseEl) this.renderer.mergeResultIntoToolUse(toolUseEl, b);
       } else if (b.type === 'tool_status') {
-        const tid = b.tool_use_id;
-        const toolUseEl = tid && blocksEl.querySelector(`.block-tool-use[data-tool-use-id="${tid}"]`);
+        const toolUseEl = b.tool_use_id && toolUseIndex.get(b.tool_use_id);
         if (toolUseEl) {
           const isError = b.status === 'failed';
           const isDone = b.status === 'completed';
@@ -2845,10 +2846,9 @@ class AgentGUIClient {
       if (cached && (Date.now() - cached.timestamp) < 300000) {
         const outputEl = document.getElementById('output');
         if (outputEl) {
-          outputEl.innerHTML = '';
-          while (cached.dom.firstChild) {
-            outputEl.appendChild(cached.dom.firstChild);
-          }
+          const children = [];
+          while (cached.dom.firstChild) children.push(cached.dom.firstChild);
+          outputEl.replaceChildren(...children);
           window.ConversationState?.selectConversation(conversationId, 'dom_cache_load', 1);
           this.state.currentConversation = cached.conversation;
           window.dispatchEvent(new CustomEvent('conversation-changed', { detail: { conversationId, conversation: cached.conversation } }));
@@ -2921,23 +2921,15 @@ class AgentGUIClient {
       const hasActivity = (allMessages && allMessages.length > 0) || isActivelyStreaming || latestSession || this._convIsStreaming(conversationId);
       this.applyAgentAndModelSelection(conversation, hasActivity);
 
+      // Parse chunk data and fetch queue in parallel
+      const queuePromise = window.wsClient.rpc('q.ls', { id: conversationId }).catch(() => ({ queue: [] }));
       const chunks = (rawChunks || []).map(chunk => ({
         ...chunk,
         block: typeof chunk.data === 'string' ? JSON.parse(chunk.data) : chunk.data
       }));
 
-      // Fetch queue to exclude queued messages from being rendered as regular user messages
-      let queuedMessageIds = new Set();
-      try {
-        const { queue } = await window.wsClient.rpc('q.ls', { id: conversationId });
-        if (queue && queue.length > 0) {
-          queuedMessageIds = new Set(queue.map(q => q.messageId));
-        }
-      } catch (e) {
-        console.warn('Failed to fetch queue:', e.message);
-      }
-
-      // Filter out queued messages from user messages - they'll be rendered in queue indicator instead
+      const { queue: queueResult } = await queuePromise;
+      const queuedMessageIds = new Set((queueResult || []).map(q => q.messageId));
       const userMessages = (allMessages || []).filter(m => m.role === 'user' && !queuedMessageIds.has(m.id));
       const hasMoreChunks = totalChunks && chunks.length < totalChunks;