agentgui 1.0.227 → 1.0.229

package/package.json

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

package/server.js

@@ -24,6 +24,68 @@ async function ensurePocketTtsSetup(onProgress) {
   return serverTTS.ensureInstalled(onProgress);
 }
 
+// Model download manager
+const modelDownloadState = {
+  downloading: false,
+  progress: null,
+  error: null,
+  complete: false
+};
+
+async function ensureModelsDownloaded() {
+  const { createRequire: cr } = await import('module');
+  const r = cr(import.meta.url);
+  const { checkAllFilesExist, downloadModels } = r('sttttsmodels');
+  
+  if (checkAllFilesExist()) {
+    modelDownloadState.complete = true;
+    return true;
+  }
+  
+  if (modelDownloadState.downloading) {
+    // Wait for current download
+    while (modelDownloadState.downloading) {
+      await new Promise(r => setTimeout(r, 100));
+    }
+    return modelDownloadState.complete;
+  }
+  
+  modelDownloadState.downloading = true;
+  modelDownloadState.error = null;
+  
+  try {
+    await downloadModels((progress) => {
+      modelDownloadState.progress = progress;
+      // Broadcast progress to all connected clients
+      broadcastSync({
+        type: 'model_download_progress',
+        progress: {
+          started: progress.started,
+          done: progress.done,
+          error: progress.error,
+          downloading: progress.downloading,
+          type: progress.type,
+          completedFiles: progress.completedFiles,
+          totalFiles: progress.totalFiles,
+          totalDownloaded: progress.totalDownloaded,
+          totalBytes: progress.totalBytes
+        }
+      });
+    });
+    modelDownloadState.complete = true;
+    return true;
+  } catch (err) {
+    modelDownloadState.error = err.message;
+    broadcastSync({
+      type: 'model_download_progress',
+      progress: { error: err.message, done: true }
+    });
+    return false;
+  } finally {
+    modelDownloadState.downloading = false;
+  }
+}
+
 function eagerTTS(text, conversationId, sessionId) {
   getSpeech().then(speech => {
     const status = speech.getStatus();
@@ -182,6 +244,7 @@ function discoverAgents() {
     { cmd: 'claude', id: 'claude-code', name: 'Claude Code', icon: 'C' },
     { cmd: 'opencode', id: 'opencode', name: 'OpenCode', icon: 'O' },
     { cmd: 'gemini', id: 'gemini', name: 'Gemini CLI', icon: 'G' },
+    { cmd: 'kilo', id: 'kilo', name: 'Kilo Code', icon: 'K' },
     { cmd: 'goose', id: 'goose', name: 'Goose', icon: 'g' },
     { cmd: 'openhands', id: 'openhands', name: 'OpenHands', icon: 'H' },
     { cmd: 'augment', id: 'augment', name: 'Augment Code', icon: 'A' },
@@ -802,7 +865,14 @@ const server = http.createServer(async (req, res) => {
     }
 
     if (pathOnly === '/api/conversations' && req.method === 'GET') {
-            sendJSON(req, res, 200, { conversations: queries.getConversationsList() });
+      const conversations = queries.getConversationsList();
+      // Filter out stale streaming state for conversations not in activeExecutions
+      for (const conv of conversations) {
+        if (conv.isStreaming && !activeExecutions.has(conv.id)) {
+          conv.isStreaming = 0;
+        }
+      }
+            sendJSON(req, res, 200, { conversations });
       return;
     }
 
@@ -1601,11 +1671,18 @@ const server = http.createServer(async (req, res) => {
           pythonDetected: pyInfo.found,
           pythonVersion: pyInfo.version || null,
           setupMessage: baseStatus.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request',
+          modelsDownloading: modelDownloadState.downloading,
+          modelsComplete: modelDownloadState.complete,
+          modelsError: modelDownloadState.error,
+          modelsProgress: modelDownloadState.progress,
         });
       } catch (err) {
         sendJSON(req, res, 200, {
           sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false,
           setupMessage: 'Will setup on first TTS request',
+          modelsDownloading: modelDownloadState.downloading,
+          modelsComplete: modelDownloadState.complete,
+          modelsError: modelDownloadState.error,
         });
       }
       return;
@@ -2532,14 +2609,9 @@ function performAgentHealthCheck() {
         markAgentDead(conversationId, entry, 'Agent process died unexpectedly');
       } else if (now - entry.lastActivity > STUCK_AGENT_THRESHOLD_MS) {
         debugLog(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} has no activity for ${Math.round((now - entry.lastActivity) / 1000)}s`);
-        broadcastSync({
-          type: 'streaming_error',
-          sessionId: entry.sessionId,
-          conversationId,
-          error: 'Agent may be stuck (no activity for 10 minutes)',
-          recoverable: true,
-          timestamp: now
-        });
+        // Kill stuck agent and clear streaming state
+        try { process.kill(entry.pid, 'SIGTERM'); } catch (e) {}
+        markAgentDead(conversationId, entry, 'Agent was stuck (no activity for 10 minutes)');
       }
     } else {
       if (now - entry.startTime > NO_PID_GRACE_PERIOD_MS) {
@@ -2555,26 +2627,28 @@ function onServerReady() {
   console.log(`Agents: ${discoveredAgents.map(a => a.name).join(', ') || 'none'}`);
   console.log(`Hot reload: ${watch ? 'on' : 'off'}`);
 
-  // Clean up empty conversations on startup
   const deletedCount = queries.cleanupEmptyConversations();
   if (deletedCount > 0) {
     console.log(`Cleaned up ${deletedCount} empty conversation(s) on startup`);
   }
 
-  // Recover stale active sessions from previous run
   recoverStaleSessions();
 
-  // Resume interrupted streams after recovery
   resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
 
+  ensureModelsDownloaded().then(ok => {
+    if (ok) console.log('[MODELS] Speech models ready');
+    else console.log('[MODELS] Speech model download failed');
+  }).catch(err => {
+    console.error('[MODELS] Download error:', err.message);
+  });
+
   getSpeech().then(s => s.preloadTTS()).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
 
   performAutoImport();
 
-  // Then run it every 30 seconds (constant automatic importing)
   setInterval(performAutoImport, 30000);
 
-  // Agent health check every 30 seconds
   setInterval(performAgentHealthCheck, 30000);
 
 }

package/static/index.html

@@ -2271,6 +2271,7 @@
     .connection-dot.unknown { background: #6b7280; }
     .connection-dot.disconnected { background: #ef4444; animation: pulse 1.5s ease-in-out infinite; }
     .connection-dot.reconnecting { background: #f59e0b; animation: pulse 1s ease-in-out infinite; }
+    .connection-dot.downloading { background: #3b82f6; animation: pulse 1s ease-in-out infinite; }
 
     .connection-tooltip {
       position: absolute;

package/static/js/client.js

@@ -432,6 +432,9 @@ class AgentGUIClient {
         case 'rate_limit_clear':
           this.handleRateLimitClear(data);
           break;
+        case 'model_download_progress':
+          this._handleModelDownloadProgress(data.progress);
+          break;
         default:
           break;
       }
@@ -1833,7 +1836,7 @@ class AgentGUIClient {
   }
 
   _updateConnectionIndicator(quality) {
-    if (this._indicatorDebounce) return;
+    if (this._indicatorDebounce && !this._modelDownloadInProgress) return;
     this._indicatorDebounce = true;
     setTimeout(() => { this._indicatorDebounce = false; }, 1000);
 
@@ -1855,6 +1858,21 @@ class AgentGUIClient {
     const label = indicator.querySelector('.connection-label');
     if (!dot || !label) return;
 
+    // Check if model download is in progress
+    if (this._modelDownloadInProgress) {
+      dot.className = 'connection-dot downloading';
+      const progress = this._modelDownloadProgress;
+      if (progress && progress.totalBytes > 0) {
+        const pct = Math.round((progress.totalDownloaded / progress.totalBytes) * 100);
+        label.textContent = `Models ${pct}%`;
+      } else if (progress && progress.downloading) {
+        label.textContent = 'Downloading...';
+      } else {
+        label.textContent = 'Loading models...';
+      }
+      return;
+    }
+
     dot.className = 'connection-dot';
     if (quality === 'disconnected' || quality === 'reconnecting') {
       dot.classList.add(quality);
@@ -1866,6 +1884,29 @@ class AgentGUIClient {
     }
   }
 
+  _handleModelDownloadProgress(progress) {
+    this._modelDownloadProgress = progress;
+    
+    if (progress.error) {
+      this._modelDownloadInProgress = false;
+      console.error('[Models] Download error:', progress.error);
+      this._updateConnectionIndicator(this.wsManager?.latency?.quality || 'unknown');
+      return;
+    }
+    
+    if (progress.done) {
+      this._modelDownloadInProgress = false;
+      console.log('[Models] Download complete');
+      this._updateConnectionIndicator(this.wsManager?.latency?.quality || 'unknown');
+      return;
+    }
+    
+    if (progress.started || progress.downloading) {
+      this._modelDownloadInProgress = true;
+      this._updateConnectionIndicator(this.wsManager?.latency?.quality || 'unknown');
+    }
+  }
+
   _toggleConnectionTooltip() {
     let tooltip = document.getElementById('connection-tooltip');
     if (tooltip) { tooltip.remove(); return; }