agentgui 1.0.226 → 1.0.228

package/lib/claude-runner.js

@@ -347,18 +347,28 @@ class AgentRunner {
 
         if (message.id === promptId && message.result && message.result.stopReason) {
           completed = true;
+          draining = true;
           clearTimeout(timeoutHandle);
-          proc.kill();
-          resolve({ outputs, sessionId });
+          // Wait a short time for any remaining events to be flushed before killing
+          setTimeout(() => {
+            draining = false;
+            try { proc.kill(); } catch (e) {}
+            resolve({ outputs, sessionId });
+          }, 1000);
           return;
         }
 
         if (message.id === promptId && message.error) {
-          originalHandler(message);
           completed = true;
+          draining = true;
           clearTimeout(timeoutHandle);
-          proc.kill();
-          reject(new Error(message.error.message || 'ACP prompt error'));
+          // Process the error message first, then delay for remaining events
+          originalHandler(message);
+          setTimeout(() => {
+            draining = false;
+            try { proc.kill(); } catch (e) {}
+            reject(new Error(message.error.message || 'ACP prompt error'));
+          }, 1000);
           return;
         }
 
@@ -367,8 +377,11 @@ class AgentRunner {
 
       buffer = '';
       proc.stdout.removeAllListeners('data');
+      let draining = false;
       proc.stdout.on('data', (chunk) => {
-        if (timedOut || completed) return;
+        if (timedOut) return;
+        // Continue processing during drain period after stopReason/error
+        if (completed && !draining) return;
 
         buffer += chunk.toString();
         const lines = buffer.split('\n');
@@ -397,6 +410,19 @@ class AgentRunner {
         clearTimeout(timeoutHandle);
         if (timedOut || completed) return;
 
+        // Flush any remaining buffer content
+        if (buffer.trim()) {
+          try {
+            const message = JSON.parse(buffer.trim());
+            if (message.id === 1 && message.result) {
+              initialized = true;
+            }
+            enhancedHandler(message);
+          } catch (e) {
+            // Buffer might be incomplete, ignore parse errors on close
+          }
+        }
+
         if (code === 0 || outputs.length > 0) {
           resolve({ outputs, sessionId });
         } else {
@@ -889,6 +915,28 @@ registry.register({
   protocolHandler: acpProtocolHandler
 });
 
+/**
+ * Kilo CLI Agent (OpenCode fork)
+ * Built on OpenCode, supports ACP protocol
+ * Uses 'kilo' command - installed via npm install -g @kilocode/cli
+ */
+registry.register({
+  id: 'kilo',
+  name: 'Kilo CLI',
+  command: 'kilo',
+  protocol: 'acp',
+  supportsStdin: false,
+  supportedFeatures: ['streaming', 'resume', 'acp-protocol', 'models'],
+
+  buildArgs(prompt, config) {
+    return ['acp'];
+  },
+
+  protocolHandler(message, context) {
+    return acpProtocolHandler(message, context);
+  }
+});
+
 /**
  * Main export function - runs any registered agent
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.226",
+  "version": "1.0.228",
   "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();
@@ -204,39 +266,87 @@ const discoveredAgents = discoverAgents();
 
 const modelCache = new Map();
 
+const AGENT_MODEL_COMMANDS = {
+  'opencode': 'opencode models',
+  'kilo': 'kilo models',
+};
+
+const AGENT_DEFAULT_MODELS = {
+  'claude-code': [
+    { id: '', label: 'Default' },
+    { id: 'sonnet', label: 'Sonnet' },
+    { id: 'opus', label: 'Opus' },
+    { id: 'haiku', label: 'Haiku' },
+    { id: 'claude-sonnet-4-5-20250929', label: 'Sonnet 4.5' },
+    { id: 'claude-opus-4-6', label: 'Opus 4.6' },
+    { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5' }
+  ],
+  'gemini': [
+    { id: '', label: 'Default' },
+    { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+    { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
+    { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' }
+  ],
+  'goose': [
+    { id: '', label: 'Default' },
+    { id: 'claude-sonnet-4-5', label: 'Sonnet 4.5' },
+    { id: 'claude-opus-4-5', label: 'Opus 4.5' }
+  ],
+  'codex': [
+    { id: '', label: 'Default' },
+    { id: 'o4-mini', label: 'o4-mini' },
+    { id: 'o3', label: 'o3' },
+    { id: 'o3-mini', label: 'o3-mini' }
+  ]
+};
+
 async function getModelsForAgent(agentId) {
-  if (agentId === 'claude-code') {
-    return [
-      { id: '', label: 'Default' },
-      { id: 'sonnet', label: 'Sonnet' },
-      { id: 'opus', label: 'Opus' },
-      { id: 'haiku', label: 'Haiku' },
-      { id: 'claude-sonnet-4-5-20250929', label: 'Sonnet 4.5' },
-      { id: 'claude-opus-4-6', label: 'Opus 4.6' },
-      { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5' }
-    ];
+  const cached = modelCache.get(agentId);
+  if (cached && Date.now() - cached.timestamp < 300000) {
+    return cached.models;
+  }
+
+  if (AGENT_DEFAULT_MODELS[agentId]) {
+    const models = AGENT_DEFAULT_MODELS[agentId];
+    modelCache.set(agentId, { models, timestamp: Date.now() });
+    return models;
   }
-  if (agentId === 'opencode') {
+
+  if (AGENT_MODEL_COMMANDS[agentId]) {
     try {
-      const result = execSync('opencode models 2>/dev/null', { encoding: 'utf-8', timeout: 10000 });
+      const result = execSync(AGENT_MODEL_COMMANDS[agentId], { encoding: 'utf-8', timeout: 15000 });
       const lines = result.split('\n').map(l => l.trim()).filter(Boolean);
       const models = [{ id: '', label: 'Default' }];
       for (const line of lines) {
         models.push({ id: line, label: line });
       }
+      modelCache.set(agentId, { models, timestamp: Date.now() });
       return models;
     } catch (_) {
       return [{ id: '', label: 'Default' }];
     }
   }
-  if (agentId === 'gemini') {
-    return [
-      { id: '', label: 'Default' },
-      { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
-      { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
-      { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' }
-    ];
+
+  const { getRegisteredAgents } = await import('./lib/claude-runner.js');
+  const agents = getRegisteredAgents();
+  const agent = agents.find(a => a.id === agentId);
+  
+  if (agent && agent.command) {
+    const modelCmd = `${agent.command} models`;
+    try {
+      const result = execSync(modelCmd, { encoding: 'utf-8', timeout: 15000 });
+      const lines = result.split('\n').map(l => l.trim()).filter(Boolean);
+      if (lines.length > 0) {
+        const models = [{ id: '', label: 'Default' }];
+        for (const line of lines) {
+          models.push({ id: line, label: line });
+        }
+        modelCache.set(agentId, { models, timestamp: Date.now() });
+        return models;
+      }
+    } catch (_) {}
   }
+
   return [];
 }
 
@@ -754,7 +864,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;
     }
 
@@ -1553,11 +1670,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;
@@ -2484,14 +2608,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) {
@@ -2519,6 +2638,16 @@ function onServerReady() {
   // Resume interrupted streams after recovery
   resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
 
+  // Start model downloads in background after server is ready
+  setTimeout(() => {
+    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);
+    });
+  }, 2000);
+
   getSpeech().then(s => s.preloadTTS()).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
 
   performAutoImport();

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;
       }
@@ -813,6 +816,7 @@ class AgentGUIClient {
     }
 
     if (data.message.role === 'user') {
+      // Find pending message by matching content to avoid duplicates
       const pending = outputEl.querySelector('.message-sending');
       if (pending) {
         pending.id = '';
@@ -826,6 +830,12 @@ class AgentGUIClient {
         this.emit('message:created', data);
         return;
       }
+      // Check if a user message with this ID already exists (prevents duplicate on race condition)
+      const existingMsg = outputEl.querySelector(`[data-msg-id="${data.message.id}"]`);
+      if (existingMsg) {
+        this.emit('message:created', data);
+        return;
+      }
     }
 
     const messageHtml = `
@@ -1826,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);
 
@@ -1848,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);
@@ -1859,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; }

package/static/js/conversations.js

@@ -13,6 +13,7 @@ class ConversationManager {
     this.newBtn = document.querySelector('[data-new-conversation]');
     this.sidebarEl = document.querySelector('[data-sidebar]');
     this.streamingConversations = new Set();
+    this.agents = new Map();
 
     this.folderBrowser = {
       modal: null,
@@ -32,6 +33,7 @@ class ConversationManager {
   async init() {
     this.newBtn?.addEventListener('click', () => this.openFolderBrowser());
     this.setupDelegatedListeners();
+    await this.loadAgents();
     this.loadConversations();
     this.setupWebSocketListener();
     this.setupFolderBrowser();
@@ -40,6 +42,25 @@ class ConversationManager {
     setInterval(() => this.loadConversations(), 30000);
   }
 
+  async loadAgents() {
+    try {
+      const res = await fetch((window.__BASE_URL || '') + '/api/agents');
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      for (const agent of data.agents || []) {
+        this.agents.set(agent.id, agent);
+      }
+    } catch (err) {
+      console.error('[ConversationManager] Error loading agents:', err);
+    }
+  }
+
+  getAgentDisplayName(agentId) {
+    if (!agentId) return 'Unknown';
+    const agent = this.agents.get(agentId);
+    return agent?.name || agentId;
+  }
+
   setupDelegatedListeners() {
     this.listEl.addEventListener('click', (e) => {
       const deleteBtn = e.target.closest('[data-delete-conv]');
@@ -375,7 +396,7 @@ class ConversationManager {
     const isStreaming = this.streamingConversations.has(conv.id);
     const title = conv.title || `Conversation ${conv.id.slice(0, 8)}`;
     const timestamp = conv.created_at ? new Date(conv.created_at).toLocaleDateString() : 'Unknown';
-    const agent = conv.agentType || 'unknown';
+    const agent = this.getAgentDisplayName(conv.agentType);
     const modelLabel = conv.model ? ` (${conv.model})` : '';
     const wd = conv.workingDirectory ? conv.workingDirectory.split('/').pop() : '';
     const metaParts = [agent + modelLabel, timestamp];
@@ -403,7 +424,7 @@ class ConversationManager {
 
     const title = conv.title || `Conversation ${conv.id.slice(0, 8)}`;
     const timestamp = conv.created_at ? new Date(conv.created_at).toLocaleDateString() : 'Unknown';
-    const agent = conv.agentType || 'unknown';
+    const agent = this.getAgentDisplayName(conv.agentType);
     const modelLabel = conv.model ? ` (${conv.model})` : '';
     const wd = conv.workingDirectory ? conv.workingDirectory.split('/').pop() : '';
     const metaParts = [agent + modelLabel, timestamp];

package/static/js/voice.js

@@ -15,6 +15,8 @@
   var spokenChunks = new Set();
   var renderedSeqs = new Set();
   var isLoadingHistory = false;
+  var _lastVoiceBlockText = null;
+  var _lastVoiceBlockTime = 0;
   var selectedVoiceId = localStorage.getItem('voice-selected-id') || 'default';
   var ttsAudioCache = new Map();
   var TTS_CLIENT_CACHE_MAX = 50;
@@ -646,6 +648,14 @@
   function handleVoiceBlock(block, isNew) {
     if (!block || !block.type) return;
     if (block.type === 'text' && block.text) {
+      // Deduplicate: prevent rendering the same text block twice within 500ms
+      var now = Date.now();
+      if (_lastVoiceBlockText === block.text && (now - _lastVoiceBlockTime) < 500) {
+        return;
+      }
+      _lastVoiceBlockText = block.text;
+      _lastVoiceBlockTime = now;
+
       var div = addVoiceBlock(block.text, false);
       if (div && isNew && ttsEnabled) {
         div.classList.add('speaking');
@@ -661,6 +671,9 @@
     var container = document.getElementById('voiceMessages');
     if (!container) return;
     container.innerHTML = '';
+    // Reset dedup state when loading a new conversation
+    _lastVoiceBlockText = null;
+    _lastVoiceBlockTime = 0;
     if (!conversationId) {
       showVoiceEmpty(container);
       return;