agentgui 1.0.288 → 1.0.290

package/lib/speech.js

@@ -1,7 +1,6 @@
 import { createRequire } from 'module';
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 import http from 'http';
 import { fileURLToPath } from 'url';
 
@@ -9,12 +8,11 @@ const require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.dirname(__dirname);
 
-let serverSTT = null, serverTTS = null, edgeTTS = null;
+let serverSTT = null;
 try { serverSTT = require('webtalk/server-stt'); } catch(e) { console.warn('[STT] webtalk/server-stt unavailable:', e.message); }
-try { serverTTS = require('webtalk/server-tts'); } catch(e) { console.warn('[TTS] webtalk/server-tts unavailable:', e.message); }
-try { edgeTTS = require('edge-tts-universal'); } catch(e) { console.warn('[TTS] edge-tts-universal unavailable:', e.message); }
 
-const EXTRA_VOICE_DIRS = [path.join(ROOT, 'voices')];
+const VOICE_DIRS = [path.join(ROOT, 'voices')];
+const POCKET_PORT = 8787;
 
 const POCKET_TTS_VOICES = [
   { id: 'default', name: 'Default', gender: 'female', accent: 'French' },
@@ -28,31 +26,7 @@ const POCKET_TTS_VOICES = [
   { id: 'azelma', name: 'Azelma', gender: 'female', accent: 'French' },
 ];
 
-const EDGE_VOICE_MAP = {
-  default: 'fr-FR-DeniseNeural', alba: 'fr-FR-DeniseNeural',
-  marius: 'fr-FR-HenriNeural', javert: 'fr-FR-HenriNeural',
-  jean: 'fr-FR-HenriNeural', fantine: 'fr-FR-DeniseNeural',
-  cosette: 'fr-FR-DeniseNeural', eponine: 'fr-FR-DeniseNeural',
-  azelma: 'fr-FR-DeniseNeural',
-};
-
 const PREDEFINED_IDS = new Set(POCKET_TTS_VOICES.filter(v => v.id !== 'default').map(v => v.id));
-const POCKET_PORT = 8787;
-
-// Detect if serverTTS has the expected API (getVoices = old server-tts, not the ONNX version)
-// The ONNX server-tts-onnx has a different API (synthesize takes modelDir not extraDirs)
-// and is incompatible with our voice-based approach - skip it and use edge-tts instead
-if (serverTTS && typeof serverTTS.getVoices !== 'function') {
-  console.warn('[TTS] webtalk/server-tts has incompatible API (ONNX version), disabling it');
-  serverTTS = null;
-}
-
-let needsPatch = true;
-try {
-  if (serverTTS && typeof serverTTS.getVoices === 'function') {
-    needsPatch = !serverTTS.getVoices(EXTRA_VOICE_DIRS).some(v => v.id === 'alba' && !v.isCustom);
-  }
-} catch(e) { needsPatch = true; }
 
 function getSttOptions() {
   if (process.env.PORTABLE_DATA_DIR) {
@@ -61,25 +35,16 @@ function getSttOptions() {
   return {};
 }
 
-async function edgeSynthesize(text, voiceId) {
-  if (!edgeTTS) throw new Error('edge-tts-universal not available');
-  const voice = EDGE_VOICE_MAP[voiceId] || EDGE_VOICE_MAP.default;
-  const c = new edgeTTS.Communicate(text, voice);
-  const chunks = [];
-  const timeout = new Promise((_, rej) => setTimeout(() => rej(new Error('edge-tts timeout')), 30000));
-  const collect = (async () => {
-    for await (const chunk of c.stream()) {
-      if (chunk.type === 'audio' && chunk.data) chunks.push(Buffer.from(chunk.data));
-    }
-  })();
-  await Promise.race([collect, timeout]);
-  if (!chunks.length) throw new Error('edge-tts returned no audio');
-  return Buffer.concat(chunks);
+function findVoiceFile(voiceId) {
+  for (const dir of VOICE_DIRS) {
+    const p = path.join(dir, `custom_${voiceId}.wav`);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
 }
 
-function synthesizeDirect(text, voiceId) {
-  const voicePath = serverTTS && typeof serverTTS.findVoiceFile === 'function'
-    ? serverTTS.findVoiceFile(voiceId, EXTRA_VOICE_DIRS) : null;
+function synthesize(text, voiceId) {
+  const voicePath = voiceId ? findVoiceFile(voiceId) : null;
   const isPredefined = voiceId && PREDEFINED_IDS.has(voiceId);
   const boundary = '----PocketTTS' + Date.now();
   const parts = [];
@@ -118,6 +83,10 @@ function synthesizeDirect(text, voiceId) {
   });
 }
 
+async function* synthesizeStream(text, voiceId) {
+  yield await synthesize(text, voiceId);
+}
+
 function transcribe(audioBuffer) {
   if (!serverSTT) throw new Error('STT not available');
   return serverSTT.transcribe(audioBuffer, getSttOptions());
@@ -128,101 +97,31 @@ function getSTT() {
   return serverSTT.getSTT(getSttOptions());
 }
 
-async function synthesize(text, voiceId) {
-  if (serverTTS) {
-    try {
-      if (needsPatch && voiceId && PREDEFINED_IDS.has(voiceId)) {
-        return await synthesizeDirect(text, voiceId);
-      }
-      return await serverTTS.synthesize(text, voiceId, EXTRA_VOICE_DIRS);
-    } catch(e) {
-      console.warn('[TTS] webtalk synthesize failed, falling back to edge-tts:', e.message);
-    }
-  }
-  return edgeSynthesize(text, voiceId);
-}
-
-async function* synthesizeStream(text, voiceId) {
-  if (serverTTS) {
-    try {
-      if (needsPatch && voiceId && PREDEFINED_IDS.has(voiceId)) {
-        yield await synthesizeDirect(text, voiceId);
-        return;
-      }
-      for await (const chunk of serverTTS.synthesizeStream(text, voiceId, EXTRA_VOICE_DIRS)) {
-        yield chunk;
-      }
-      return;
-    } catch(e) {
-      console.warn('[TTS] webtalk stream failed, falling back to edge-tts:', e.message);
-    }
-  }
-  yield await edgeSynthesize(text, voiceId);
-}
-
 function getVoices() {
-  try {
-    const upstream = serverTTS && typeof serverTTS.getVoices === 'function'
-      ? serverTTS.getVoices(EXTRA_VOICE_DIRS) : [];
-    const custom = upstream.filter(v => v.isCustom);
-    return [...POCKET_TTS_VOICES, ...custom];
-  } catch(e) { return POCKET_TTS_VOICES; }
+  return POCKET_TTS_VOICES;
 }
 
 function getStatus() {
   const sttStatus = serverSTT ? serverSTT.getStatus() : { ready: false, loading: false, error: 'STT unavailable' };
-  const ttsStatus = serverTTS ? serverTTS.getStatus() : { ready: false, lastError: 'TTS unavailable' };
   return {
     sttReady: sttStatus.ready,
-    ttsReady: ttsStatus.ready || !!edgeTTS,
+    ttsReady: true,
     sttLoading: sttStatus.loading,
     ttsLoading: false,
     sttError: sttStatus.error,
-    ttsError: (ttsStatus.ready || edgeTTS) ? null : (ttsStatus.lastError || 'TTS not available'),
-    pocketTts: ttsStatus,
-    edgeTtsAvailable: !!edgeTTS,
+    ttsError: null,
   };
 }
 
 function preloadTTS() {
-  if (!serverTTS || typeof serverTTS.start !== 'function') {
-    if (edgeTTS) console.log('[TTS] Using edge-tts fallback');
-    return;
-  }
-  if (typeof serverTTS.isInstalled === 'function' && !serverTTS.isInstalled()) {
-    console.log('[TTS] pocket-tts not installed yet - will install on first use');
-    return;
-  }
-  const portableDataDir = process.env.PORTABLE_DATA_DIR;
-  const binaryPaths = portableDataDir ? [
-    path.join(portableDataDir, 'pocket-venv', 'Scripts', 'pocket-tts.exe'),
-    path.join(portableDataDir, 'pocket-venv', 'bin', 'pocket-tts'),
-  ] : undefined;
-  let voicePath = null;
-  try {
-    const defaultVoice = typeof serverTTS.findVoiceFile === 'function'
-      ? (serverTTS.findVoiceFile('custom_cleetus', EXTRA_VOICE_DIRS) || '/config/voices/cleetus.wav')
-      : '/config/voices/cleetus.wav';
-    voicePath = fs.existsSync(defaultVoice) ? defaultVoice : null;
-  } catch(e) {}
-  serverTTS.start(voicePath, binaryPaths ? { binaryPaths } : {}).then(ok => {
-    if (ok) console.log('[TTS] pocket-tts sidecar started');
-    else console.log('[TTS] pocket-tts unavailable, edge-tts fallback active:', !!edgeTTS);
-  }).catch(err => {
-    console.error('[TTS] pocket-tts start error:', err.message);
-  });
+  // pocket-tts is managed externally; nothing to preload
 }
 
-function ttsCacheKey(text, voiceId) {
-  return serverTTS && typeof serverTTS.ttsCacheKey === 'function' ? serverTTS.ttsCacheKey(text, voiceId) : null;
-}
-
-function ttsCacheGet(key) {
-  return serverTTS && typeof serverTTS.ttsCacheGet === 'function' ? serverTTS.ttsCacheGet(key) : null;
-}
+function ttsCacheKey(text, voiceId) { return null; }
+function ttsCacheGet(key) { return null; }
 
 function splitSentences(text) {
-  return serverTTS && typeof serverTTS.splitSentences === 'function' ? serverTTS.splitSentences(text) : [text];
+  return text.match(/[^.!?]+[.!?]*/g)?.map(s => s.trim()).filter(Boolean) || [text];
 }
 
 export { transcribe, synthesize, synthesizeStream, getSTT, getStatus, getVoices, preloadTTS, ttsCacheKey, ttsCacheGet, splitSentences };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.288",
+  "version": "1.0.290",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -26,7 +26,6 @@
     "audio-decode": "^2.2.3",
     "better-sqlite3": "^12.6.2",
     "busboy": "^1.6.0",
-    "edge-tts-universal": "^1.0.1",
     "express": "^5.2.1",
     "fsbrowse": "^0.2.18",
     "google-auth-library": "^10.5.0",

package/server.js

@@ -2611,13 +2611,20 @@ const server = http.createServer(async (req, res) => {
       try {
         const { getStatus } = await getSpeech();
         const baseStatus = getStatus();
-        const r = createRequire(import.meta.url);
-        const serverTTS = r('webtalk/server-tts');
-        const pyInfo = serverTTS.detectPython();
+        let pythonDetected = false, pythonVersion = null;
+        try {
+          const r = createRequire(import.meta.url);
+          const serverTTS = r('webtalk/server-tts');
+          if (typeof serverTTS.detectPython === 'function') {
+            const pyInfo = serverTTS.detectPython();
+            pythonDetected = pyInfo.found;
+            pythonVersion = pyInfo.version || null;
+          }
+        } catch(e) {}
         sendJSON(req, res, 200, {
           ...baseStatus,
-          pythonDetected: pyInfo.found,
-          pythonVersion: pyInfo.version || null,
+          pythonDetected,
+          pythonVersion,
           setupMessage: baseStatus.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request',
           modelsDownloading: modelDownloadState.downloading,
           modelsComplete: modelDownloadState.complete,