agentgui 1.0.226 → 1.0.227

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.227",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -204,39 +204,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 (agentId === 'opencode') {
+
+  if (AGENT_DEFAULT_MODELS[agentId]) {
+    const models = AGENT_DEFAULT_MODELS[agentId];
+    modelCache.set(agentId, { models, timestamp: Date.now() });
+    return models;
+  }
+
+  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 [];
 }
 

package/static/js/client.js

@@ -813,6 +813,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 +827,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 = `

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;