agentgui 1.0.166 → 1.0.168

package/lib/speech.js

@@ -21,6 +21,9 @@ let speakerEmbeddings = null;
 let sttLoading = false;
 let ttsLoading = false;
 
+const TTS_CACHE_MAX = 100;
+const ttsCache = new Map();
+
 async function loadTransformers() {
   if (transformersModule) return transformersModule;
   transformersModule = await import('@huggingface/transformers');
@@ -216,11 +219,52 @@ async function transcribe(audioBuffer) {
   return result.text;
 }
 
+function splitSentences(text) {
+  const raw = text.match(/[^.!?]+[.!?]+[\s]?|[^.!?]+$/g);
+  if (!raw) return [text];
+  return raw.map(s => s.trim()).filter(s => s.length > 0);
+}
+
+function cachePut(key, buf) {
+  if (ttsCache.size >= TTS_CACHE_MAX) {
+    const oldest = ttsCache.keys().next().value;
+    ttsCache.delete(oldest);
+  }
+  ttsCache.set(key, buf);
+}
+
 async function synthesize(text) {
+  const cached = ttsCache.get(text);
+  if (cached) {
+    ttsCache.delete(text);
+    ttsCache.set(text, cached);
+    return cached;
+  }
   const tts = await getTTS();
   const embeddings = await ensureSpeakerEmbeddings();
   const result = await tts(text, { speaker_embeddings: embeddings });
-  return encodeWav(result.audio, result.sampling_rate || SAMPLE_RATE_TTS);
+  const wav = encodeWav(result.audio, result.sampling_rate || SAMPLE_RATE_TTS);
+  cachePut(text, wav);
+  return wav;
+}
+
+async function* synthesizeStream(text) {
+  const sentences = splitSentences(text);
+  const tts = await getTTS();
+  const embeddings = await ensureSpeakerEmbeddings();
+  for (const sentence of sentences) {
+    const cached = ttsCache.get(sentence);
+    if (cached) {
+      ttsCache.delete(sentence);
+      ttsCache.set(sentence, cached);
+      yield cached;
+      continue;
+    }
+    const result = await tts(sentence, { speaker_embeddings: embeddings });
+    const wav = encodeWav(result.audio, result.sampling_rate || SAMPLE_RATE_TTS);
+    cachePut(sentence, wav);
+    yield wav;
+  }
 }
 
 function getStatus() {
@@ -232,4 +276,4 @@ function getStatus() {
   };
 }
 
-export { transcribe, synthesize, getSTT, getTTS, getStatus };
+export { transcribe, synthesize, synthesizeStream, getSTT, getTTS, getStatus };

package/package.json

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

package/server.js

@@ -554,6 +554,36 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (routePath === '/api/tts-stream' && req.method === 'POST') {
+      try {
+        const body = await parseBody(req);
+        const text = body.text || '';
+        if (!text) {
+          sendJSON(req, res, 400, { error: 'No text provided' });
+          return;
+        }
+        const { synthesizeStream } = await getSpeech();
+        res.writeHead(200, {
+          'Content-Type': 'application/octet-stream',
+          'Transfer-Encoding': 'chunked',
+          'X-Content-Type': 'audio/wav-stream',
+          'Cache-Control': 'no-cache'
+        });
+        for await (const wavChunk of synthesizeStream(text)) {
+          const lenBuf = Buffer.alloc(4);
+          lenBuf.writeUInt32BE(wavChunk.length, 0);
+          res.write(lenBuf);
+          res.write(wavChunk);
+        }
+        res.end();
+      } catch (err) {
+        debugLog('[TTS-STREAM] Error: ' + err.message);
+        if (!res.headersSent) sendJSON(req, res, 500, { error: err.message || 'TTS stream failed' });
+        else res.end();
+      }
+      return;
+    }
+
     if (routePath === '/api/speech-status' && req.method === 'GET') {
       try {
         const { getStatus } = await getSpeech();
@@ -1304,7 +1334,8 @@ function onServerReady() {
   // Recover stale active sessions from previous run
   recoverStaleSessions();
 
-  // Run auto-import immediately
+  getSpeech().then(s => s.getTTS()).then(() => debugLog('[TTS] Model preloaded')).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
+
   performAutoImport();
 
   // Then run it every 30 seconds (constant automatic importing)

package/static/js/client.js

@@ -1288,12 +1288,11 @@ class AgentGUIClient {
       }
 
       const { conversation } = await response.json();
-      this.state.currentConversation = conversation;
 
       await this.loadConversations();
 
       if (window.conversationManager) {
-        window.conversationManager.loadConversations();
+        await window.conversationManager.loadConversations();
         window.conversationManager.select(conversation.id);
       }
 

package/static/js/voice.js

@@ -245,39 +245,91 @@
     processQueue();
   }
 
+  var audioChunkQueue = [];
+  var isPlayingChunk = false;
+  var streamDone = false;
+
+  function playNextChunk() {
+    if (audioChunkQueue.length === 0) {
+      isPlayingChunk = false;
+      if (streamDone) {
+        isSpeaking = false;
+        processQueue();
+      }
+      return;
+    }
+    isPlayingChunk = true;
+    var blob = audioChunkQueue.shift();
+    var url = URL.createObjectURL(blob);
+    currentAudio = new Audio(url);
+    currentAudio.onended = function() {
+      URL.revokeObjectURL(url);
+      currentAudio = null;
+      playNextChunk();
+    };
+    currentAudio.onerror = function() {
+      URL.revokeObjectURL(url);
+      currentAudio = null;
+      playNextChunk();
+    };
+    currentAudio.play().catch(function() {
+      URL.revokeObjectURL(url);
+      currentAudio = null;
+      playNextChunk();
+    });
+  }
+
   function processQueue() {
     if (isSpeaking || speechQueue.length === 0) return;
     isSpeaking = true;
+    streamDone = false;
     var text = speechQueue.shift();
-    fetch(BASE + '/api/tts', {
+    audioChunkQueue = [];
+    isPlayingChunk = false;
+    fetch(BASE + '/api/tts-stream', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ text: text })
     }).then(function(resp) {
       if (!resp.ok) throw new Error('TTS failed');
-      return resp.blob();
-    }).then(function(blob) {
-      var url = URL.createObjectURL(blob);
-      currentAudio = new Audio(url);
-      currentAudio.onended = function() {
-        URL.revokeObjectURL(url);
-        currentAudio = null;
-        isSpeaking = false;
-        processQueue();
-      };
-      currentAudio.onerror = function() {
-        URL.revokeObjectURL(url);
-        currentAudio = null;
-        isSpeaking = false;
-        processQueue();
-      };
-      currentAudio.play().catch(function() {
-        URL.revokeObjectURL(url);
-        currentAudio = null;
-        isSpeaking = false;
-        processQueue();
-      });
+      var reader = resp.body.getReader();
+      var buffer = new Uint8Array(0);
+
+      function concat(a, b) {
+        var c = new Uint8Array(a.length + b.length);
+        c.set(a, 0);
+        c.set(b, a.length);
+        return c;
+      }
+
+      function pump() {
+        return reader.read().then(function(result) {
+          if (result.done) {
+            streamDone = true;
+            if (!isPlayingChunk && audioChunkQueue.length === 0) {
+              isSpeaking = false;
+              processQueue();
+            }
+            return;
+          }
+          buffer = concat(buffer, result.value);
+          while (buffer.length >= 4) {
+            var view = new DataView(buffer.buffer, buffer.byteOffset, 4);
+            var chunkLen = view.getUint32(0, false);
+            if (buffer.length < 4 + chunkLen) break;
+            var wavData = buffer.slice(4, 4 + chunkLen);
+            buffer = buffer.slice(4 + chunkLen);
+            var blob = new Blob([wavData], { type: 'audio/wav' });
+            audioChunkQueue.push(blob);
+            if (!isPlayingChunk) playNextChunk();
+          }
+          return pump();
+        });
+      }
+
+      return pump();
     }).catch(function() {
+      streamDone = true;
       isSpeaking = false;
       processQueue();
     });
@@ -285,6 +337,8 @@
 
   function stopSpeaking() {
     speechQueue = [];
+    audioChunkQueue = [];
+    isPlayingChunk = false;
     isSpeaking = false;
     if (currentAudio) {
       currentAudio.pause();