agentgui 1.0.181 → 1.0.183

package/database.js

@@ -354,6 +354,13 @@ export const queries = {
     return stmt.all();
   },
 
+  getResumableConversations() {
+    const stmt = prep(
+      "SELECT id, title, claudeSessionId, agentType, workingDirectory FROM conversations WHERE isStreaming = 1 AND claudeSessionId IS NOT NULL AND claudeSessionId != ''"
+    );
+    return stmt.all();
+  },
+
   clearAllStreamingFlags() {
     const stmt = prep('UPDATE conversations SET isStreaming = 0 WHERE isStreaming = 1');
     return stmt.run().changes;

package/lib/speech.js

@@ -105,6 +105,8 @@ let transformersModule = null;
 let sttPipeline = null;
 let sttLoading = false;
 let sttLoadError = null;
+let sttLoadErrorTime = 0;
+const STT_RETRY_MS = 30000;
 const SAMPLE_RATE_STT = 16000;
 
 const TTS_CACHE_MAX_BYTES = 10 * 1024 * 1024;
@@ -118,12 +120,16 @@ async function loadTransformers() {
   return transformersModule;
 }
 
+const PERSISTENT_CACHE = path.join(os.homedir(), '.gmgui', 'models');
+
 function whisperModelPath() {
   try {
     const webtalkDir = path.dirname(require.resolve('webtalk'));
     const p = path.join(webtalkDir, 'models', 'onnx-community', 'whisper-base');
     if (fs.existsSync(p)) return p;
   } catch (_) {}
+  const cached = path.join(PERSISTENT_CACHE, 'onnx-community', 'whisper-base');
+  if (fs.existsSync(cached)) return cached;
   return 'onnx-community/whisper-base';
 }
 
@@ -159,10 +165,10 @@ async function decodeAudioFile(filePath) {
 
 async function getSTT() {
   if (sttPipeline) return sttPipeline;
-  if (sttLoadError) throw sttLoadError;
+  if (sttLoadError && (Date.now() - sttLoadErrorTime < STT_RETRY_MS)) throw sttLoadError;
   if (sttLoading) {
     while (sttLoading) await new Promise(r => setTimeout(r, 100));
-    if (sttLoadError) throw sttLoadError;
+    if (sttLoadError && (Date.now() - sttLoadErrorTime < STT_RETRY_MS)) throw sttLoadError;
     if (!sttPipeline) throw new Error('STT pipeline failed to load');
     return sttPipeline;
   }
@@ -173,9 +179,11 @@ async function getSTT() {
     const isLocal = !modelPath.includes('/') || fs.existsSync(modelPath);
     env.allowLocalModels = true;
     env.allowRemoteModels = !isLocal;
+    env.cacheDir = PERSISTENT_CACHE;
     if (isLocal) env.localModelPath = '';
     sttPipeline = await pipeline('automatic-speech-recognition', modelPath, {
       device: 'cpu',
+      cache_dir: PERSISTENT_CACHE,
       local_files_only: isLocal,
     });
     sttLoadError = null;
@@ -183,6 +191,7 @@ async function getSTT() {
   } catch (err) {
     sttPipeline = null;
     sttLoadError = new Error('STT model load failed: ' + err.message);
+    sttLoadErrorTime = Date.now();
     throw sttLoadError;
   } finally {
     sttLoading = false;

package/package.json

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

package/server.js

@@ -1311,34 +1311,121 @@ function recoverStaleSessions() {
   try {
     const now = Date.now();
 
+    const resumable = new Set();
+    const resumableConvs = queries.getResumableConversations ? queries.getResumableConversations() : [];
+    for (const conv of resumableConvs) {
+      if (conv.agentType === 'claude-code') {
+        resumable.add(conv.id);
+      }
+    }
+
     const staleSessions = queries.getActiveSessions ? queries.getActiveSessions() : [];
+    let markedCount = 0;
     for (const session of staleSessions) {
       if (activeExecutions.has(session.conversationId)) continue;
+      if (resumable.has(session.conversationId)) continue;
       queries.updateSession(session.id, {
         status: 'error',
         error: 'Server restarted',
         completed_at: now
       });
+      markedCount++;
     }
-    if (staleSessions.length > 0) {
-      console.log(`[RECOVERY] Marked ${staleSessions.length} stale session(s) as error`);
+    if (markedCount > 0) {
+      console.log(`[RECOVERY] Marked ${markedCount} stale session(s) as error`);
     }
 
     const streamingConvs = queries.getStreamingConversations ? queries.getStreamingConversations() : [];
     let clearedCount = 0;
     for (const conv of streamingConvs) {
       if (activeExecutions.has(conv.id)) continue;
+      if (resumable.has(conv.id)) continue;
       queries.setIsStreaming(conv.id, false);
       clearedCount++;
     }
     if (clearedCount > 0) {
       console.log(`[RECOVERY] Cleared isStreaming flag on ${clearedCount} stale conversation(s)`);
     }
+    if (resumable.size > 0) {
+      console.log(`[RECOVERY] Found ${resumable.size} resumable conversation(s)`);
+    }
   } catch (err) {
     console.error('[RECOVERY] Stale session recovery error:', err.message);
   }
 }
 
+async function resumeInterruptedStreams() {
+  try {
+    const resumableConvs = queries.getResumableConversations ? queries.getResumableConversations() : [];
+    const toResume = resumableConvs.filter(c => c.agentType === 'claude-code');
+
+    if (toResume.length === 0) return;
+
+    console.log(`[RESUME] Resuming ${toResume.length} interrupted conversation(s)`);
+
+    for (let i = 0; i < toResume.length; i++) {
+      const conv = toResume[i];
+      try {
+        const staleSessions = [...queries.getSessionsByStatus(conv.id, 'active'), ...queries.getSessionsByStatus(conv.id, 'pending')];
+        for (const s of staleSessions) {
+          queries.updateSession(s.id, { status: 'interrupted', error: 'Server restarted, resuming', completed_at: Date.now() });
+        }
+
+        const lastMsg = queries.getLastUserMessage(conv.id);
+        const prompt = lastMsg?.content || 'continue';
+        const promptText = typeof prompt === 'string' ? prompt : JSON.stringify(prompt);
+
+        const session = queries.createSession(conv.id);
+        queries.createEvent('session.created', {
+          sessionId: session.id,
+          resumeReason: 'server_restart',
+          claudeSessionId: conv.claudeSessionId
+        }, conv.id, session.id);
+
+        activeExecutions.set(conv.id, {
+          pid: null,
+          startTime: Date.now(),
+          sessionId: session.id,
+          lastActivity: Date.now()
+        });
+
+        broadcastSync({
+          type: 'streaming_start',
+          sessionId: session.id,
+          conversationId: conv.id,
+          agentId: conv.agentType,
+          resumed: true,
+          timestamp: Date.now()
+        });
+
+        const messageId = lastMsg?.id || null;
+        console.log(`[RESUME] Resuming conv ${conv.id} (claude session: ${conv.claudeSessionId})`);
+
+        processMessageWithStreaming(conv.id, messageId, session.id, promptText, conv.agentType)
+          .catch(err => debugLog(`[RESUME] Error resuming conv ${conv.id}: ${err.message}`));
+
+        if (i < toResume.length - 1) {
+          await new Promise(r => setTimeout(r, 200));
+        }
+      } catch (err) {
+        console.error(`[RESUME] Failed to resume conv ${conv.id}: ${err.message}`);
+        queries.setIsStreaming(conv.id, false);
+        const activeSessions = queries.getSessionsByStatus(conv.id, 'active');
+        const pendingSessions = queries.getSessionsByStatus(conv.id, 'pending');
+        for (const s of [...activeSessions, ...pendingSessions]) {
+          queries.updateSession(s.id, {
+            status: 'error',
+            error: 'Resume failed: ' + err.message,
+            completed_at: Date.now()
+          });
+        }
+      }
+    }
+  } catch (err) {
+    console.error('[RESUME] Error during stream resumption:', err.message);
+  }
+}
+
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -1414,6 +1501,9 @@ function onServerReady() {
   // Recover stale active sessions from previous run
   recoverStaleSessions();
 
+  // Resume interrupted streams after recovery
+  resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
+
   getSpeech().then(s => s.preloadTTS()).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
 
   performAutoImport();