agentgui 1.0.282 → 1.0.284

package/lib/speech.js

@@ -9,8 +9,10 @@ const require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.dirname(__dirname);
 
-const serverSTT = require('webtalk/server-stt');
-const serverTTS = require('webtalk/server-tts');
+let serverSTT = null, serverTTS = null, edgeTTS = 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')];
 
@@ -26,20 +28,50 @@ 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;
 
-function safeGetVoices(extraDirs) {
-  if (typeof serverTTS.getVoices === 'function') {
-    return serverTTS.getVoices(extraDirs || []);
+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) {
+    return { cacheDir: path.join(process.env.PORTABLE_DATA_DIR, 'models') };
   }
-  return [];
+  return {};
 }
 
-const needsPatch = !safeGetVoices(EXTRA_VOICE_DIRS).some(v => v.id === 'alba' && !v.isCustom);
+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 synthesizeDirect(text, voiceId) {
-  const voicePath = serverTTS.findVoiceFile(voiceId, EXTRA_VOICE_DIRS);
+  const voicePath = serverTTS && typeof serverTTS.findVoiceFile === 'function'
+    ? serverTTS.findVoiceFile(voiceId, EXTRA_VOICE_DIRS) : null;
   const isPredefined = voiceId && PREDEFINED_IDS.has(voiceId);
   const boundary = '----PocketTTS' + Date.now();
   const parts = [];
@@ -78,60 +110,75 @@ function synthesizeDirect(text, voiceId) {
   });
 }
 
-function getSttOptions() {
-  if (process.env.PORTABLE_DATA_DIR) {
-    return { cacheDir: path.join(process.env.PORTABLE_DATA_DIR, 'models') };
-  }
-  return {};
-}
-
 function transcribe(audioBuffer) {
+  if (!serverSTT) throw new Error('STT not available');
   return serverSTT.transcribe(audioBuffer, getSttOptions());
 }
 
 function getSTT() {
+  if (!serverSTT) throw new Error('STT not available');
   return serverSTT.getSTT(getSttOptions());
 }
 
-function synthesize(text, voiceId) {
-  if (needsPatch && voiceId && PREDEFINED_IDS.has(voiceId)) {
-    return synthesizeDirect(text, voiceId);
+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 serverTTS.synthesize(text, voiceId, EXTRA_VOICE_DIRS);
+  return edgeSynthesize(text, voiceId);
 }
 
-function synthesizeStream(text, voiceId) {
-  if (needsPatch && voiceId && PREDEFINED_IDS.has(voiceId)) {
-    return (async function* () {
-      yield await synthesizeDirect(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);
+    }
   }
-  return serverTTS.synthesizeStream(text, voiceId, EXTRA_VOICE_DIRS);
+  yield await edgeSynthesize(text, voiceId);
 }
 
 function getVoices() {
-  const upstream = safeGetVoices(EXTRA_VOICE_DIRS);
-  const custom = upstream.filter(v => v.isCustom);
-  return [...POCKET_TTS_VOICES, ...custom];
+  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; }
 }
 
 function getStatus() {
-  const sttStatus = serverSTT.getStatus();
-  const ttsStatus = serverTTS.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,
+    ttsReady: ttsStatus.ready || !!edgeTTS,
     sttLoading: sttStatus.loading,
     ttsLoading: false,
     sttError: sttStatus.error,
-    ttsError: ttsStatus.ready ? null : (ttsStatus.lastError || 'pocket-tts not running'),
+    ttsError: (ttsStatus.ready || edgeTTS) ? null : (ttsStatus.lastError || 'TTS not available'),
     pocketTts: ttsStatus,
+    edgeTtsAvailable: !!edgeTTS,
   };
 }
 
 function preloadTTS() {
-  if (typeof serverTTS.findVoiceFile !== 'function' || typeof serverTTS.start !== 'function') {
-    console.log('[TTS] pocket-tts functions not available');
+  if (!serverTTS || typeof serverTTS.start !== 'function') {
+    if (edgeTTS) console.log('[TTS] Using edge-tts fallback');
     return;
   }
   if (typeof serverTTS.isInstalled === 'function' && !serverTTS.isInstalled()) {
@@ -143,26 +190,31 @@ function preloadTTS() {
     path.join(portableDataDir, 'pocket-venv', 'Scripts', 'pocket-tts.exe'),
     path.join(portableDataDir, 'pocket-venv', 'bin', 'pocket-tts'),
   ] : undefined;
-  const defaultVoice = serverTTS.findVoiceFile('custom_cleetus', EXTRA_VOICE_DIRS) || '/config/voices/cleetus.wav';
-  const voicePath = fs.existsSync(defaultVoice) ? defaultVoice : null;
+  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 not available - will use edge-tts fallback');
+    else console.log('[TTS] pocket-tts unavailable, edge-tts fallback active:', !!edgeTTS);
   }).catch(err => {
     console.error('[TTS] pocket-tts start error:', err.message);
   });
 }
 
 function ttsCacheKey(text, voiceId) {
-  return typeof serverTTS.ttsCacheKey === 'function' ? serverTTS.ttsCacheKey(text, voiceId) : null;
+  return serverTTS && typeof serverTTS.ttsCacheKey === 'function' ? serverTTS.ttsCacheKey(text, voiceId) : null;
 }
 
 function ttsCacheGet(key) {
-  return typeof serverTTS.ttsCacheGet === 'function' ? serverTTS.ttsCacheGet(key) : null;
+  return serverTTS && typeof serverTTS.ttsCacheGet === 'function' ? serverTTS.ttsCacheGet(key) : null;
 }
 
 function splitSentences(text) {
-  return typeof serverTTS.splitSentences === 'function' ? serverTTS.splitSentences(text) : [text];
+  return serverTTS && typeof serverTTS.splitSentences === 'function' ? serverTTS.splitSentences(text) : [text];
 }
 
 export { transcribe, synthesize, synthesizeStream, getSTT, getStatus, getVoices, preloadTTS, ttsCacheKey, ttsCacheGet, splitSentences };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.282",
+  "version": "1.0.284",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",