agentgui 1.0.639 → 1.0.640

package/lib/ws-handlers-conv.js

@@ -5,7 +5,7 @@ function notFound(msg = 'Not found') { fail(404, msg); }
 
 export function register(router, deps) {
   const { queries, activeExecutions, messageQueues, rateLimitState,
-    broadcastSync, processMessageWithStreaming, activeProcessesByConvId } = deps;
+    broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts } = deps;
 
   router.handle('conv.ls', () => {
     const conversations = queries.getConversationsList();
@@ -118,7 +118,11 @@ export function register(router, deps) {
     if (!conv) notFound('Conversation not found');
     if (!p.content) fail(400, 'Missing content');
     const entry = activeExecutions.get(p.id);
-    if (!entry) fail(409, 'No active execution to steer');
+    if (!entry) {
+      // Allow steering if we still have a process, even if execution entry is gone
+      const proc = activeProcessesByConvId.get(p.id);
+      if (!proc || !proc.stdin) fail(409, 'No active execution to steer');
+    }
     const proc = activeProcessesByConvId.get(p.id);
     if (!proc || !proc.stdin) fail(409, 'Process not available for steering');
 
@@ -129,7 +133,7 @@ export function register(router, deps) {
     try {
       // Send steering prompt using JSON-RPC format so agent processes it immediately
       // Get the active session ID from the entry
-      const sessionId = entry.sessionId;
+      const sessionId = entry?.sessionId || queries.getConversation(p.id)?.sessionId;
 
       // Send JSON-RPC prompt request with requestId for tracking
       const promptRequest = {
@@ -143,6 +147,19 @@ export function register(router, deps) {
       };
 
       proc.stdin.write(JSON.stringify(promptRequest) + '\n');
+
+      // Clear the steering cleanup timeout so process stays alive longer
+      const timeout = steeringTimeouts.get(p.id);
+      if (timeout) {
+        clearTimeout(timeout);
+        // Set a new timeout (another 30 seconds for follow-up steers)
+        const newTimeout = setTimeout(() => {
+          activeProcessesByConvId.delete(p.id);
+          steeringTimeouts.delete(p.id);
+        }, 30000);
+        steeringTimeouts.set(p.id, newTimeout);
+      }
+
       return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
     } catch (err) {
       fail(500, `Failed to steer: ${err.message}`);

package/lib/ws-handlers-session.js

@@ -74,6 +74,7 @@ export function register(router, deps) {
   const { db, discoveredAgents, modelCache,
     getAgentDescriptor, activeScripts, broadcastSync, startGeminiOAuth,
     geminiOAuthState } = deps;
+  console.log('[ws-handlers-session] register() called with discoveredAgents.length:', discoveredAgents.length);
 
   router.handle('sess.get', (p) => {
     const sess = db.getSession(p.id);
@@ -101,12 +102,16 @@ export function register(router, deps) {
     return { sessionId: p.id, events: [], total: 0, limit, offset, hasMore: false, metadata: { status: 'pending', startTime: Date.now(), duration: 0, eventCount: 0 } };
   });
 
-  router.handle('agent.ls', () => ({
-    agents: discoveredAgents.map(a => ({
-      id: a.id, name: a.name, icon: a.icon, path: a.path,
-      protocol: a.protocol || 'unknown', description: a.description || '', status: 'available'
-    }))
-  }));
+  router.handle('agent.ls', () => {
+    console.log('[agent.ls] discoveredAgents.length:', discoveredAgents.length);
+    console.log('[agent.ls] agent IDs:', discoveredAgents.map(a => a.id).join(', '));
+    return {
+      agents: discoveredAgents.map(a => ({
+        id: a.id, name: a.name, icon: a.icon, path: a.path,
+        protocol: a.protocol || 'unknown', description: a.description || '', status: 'available'
+      }))
+    };
+  });
   // Note: agent.subagents is handled by ws-handlers-util.js which is registered after this file
   // Keeping this note to avoid duplicate handler registration
 

package/lib/ws-handlers-util.js

@@ -13,10 +13,8 @@ export function register(router, deps) {
 
   router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
 
-  router.handle('agent.ls', () => {
-    const agents = discoveredAgents || [];
-    return { agents };
-  });
+  // NOTE: agent.ls is handled by ws-handlers-session.js to ensure proper agent mapping
+  // Do not re-register here as it will override the session handler
 
   router.handle('folders', (p) => {
     const folderPath = p.path || STARTUP_CWD;

package/package.json

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

package/server.js

@@ -300,6 +300,7 @@ const messageQueues = new Map();
 const rateLimitState = new Map();
 const activeProcessesByRunId = new Map();
 const activeProcessesByConvId = new Map(); // Store process handles by conversationId for steering
+const steeringTimeouts = new Map(); // Track timeout handles for process cleanup
 const acpQueries = queries;
 const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 600000;
@@ -512,6 +513,29 @@ function discoverAgents() {
       agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: null, protocol: bin.protocol, npxPackage: '@anthropic-ai/claude-code', npxLaunchable: true });
     }
   }
+
+  // Add CLI tool wrappers for ACP agents (these map CLI commands to plugin sub-agents)
+  // These allow users to select "OpenCode", "Gemini", etc. and then pick a model/variant
+  const cliWrappers = [
+    { id: 'cli-opencode', name: 'OpenCode', icon: 'O', protocol: 'cli-wrapper', acpId: 'opencode' },
+    { id: 'cli-gemini', name: 'Gemini', icon: 'G', protocol: 'cli-wrapper', acpId: 'gemini' },
+    { id: 'cli-kilo', name: 'Kilo', icon: 'K', protocol: 'cli-wrapper', acpId: 'kilo' },
+    { id: 'cli-codex', name: 'Codex', icon: 'X', protocol: 'cli-wrapper', acpId: 'codex' },
+  ];
+
+  // Only add CLI wrappers for agents that are already discovered
+  console.log('[discoverAgents] Found agents:', agents.map(a => a.id).join(', '));
+  for (const wrapper of cliWrappers) {
+    if (agents.some(a => a.id === wrapper.acpId)) {
+      console.log(`[discoverAgents] Adding CLI wrapper for ${wrapper.id}`);
+      agents.push(wrapper);
+      console.log(`[discoverAgents] After push, agents.length = ${agents.length}, includes ${wrapper.id}? ${agents.some(a => a.id === wrapper.id)}`);
+    } else {
+      console.log(`[discoverAgents] Skipping CLI wrapper ${wrapper.id} (ACP agent ${wrapper.acpId} not found)`);
+    }
+  }
+  console.log('[discoverAgents] Final agent count:', agents.length, 'Agent IDs:', agents.map(a => a.id).join(', '));
+
   return agents;
 }
 
@@ -533,16 +557,23 @@ initializeDescriptors(discoveredAgents);
 // Agent discovery happens asynchronously in background to not block startup
 async function initializeAgentDiscovery() {
   try {
-    discoveredAgents = discoverAgents();
+    const agents = discoverAgents();
+    // Mutate the existing array instead of reassigning to preserve closure references in handlers
+    discoveredAgents.length = 0;
+    discoveredAgents.push(...agents);
     initializeDescriptors(discoveredAgents);
-    console.log('[AGENTS] Discovered:', discoveredAgents.map(a => ({ id: a.id, found: !!a.path })));
+    console.log('[AGENTS] Discovered:', discoveredAgents.map(a => ({ id: a.id, found: !!a.path, protocol: a.protocol })));
+    console.log('[AGENTS] Total count:', discoveredAgents.length);
   } catch (err) {
     console.error('[AGENTS] Discovery error:', err.message);
   }
 }
 
 // Start immediately but don't wait for it
-initializeAgentDiscovery().catch(() => {});
+const startTime = Date.now();
+initializeAgentDiscovery().then(() => {
+  console.log('[INIT] initializeAgentDiscovery completed in', Date.now() - startTime, 'ms');
+}).catch(() => {});
 
 const modelCache = new Map();
 
@@ -1878,6 +1909,7 @@ const server = http.createServer(async (req, res) => {
     }
 
     if (pathOnly === '/api/agents' && req.method === 'GET') {
+      console.log(`[API /api/agents] Returning ${discoveredAgents.length} agents:`, discoveredAgents.map(a => a.id).join(', '));
             sendJSON(req, res, 200, { agents: discoveredAgents });
       return;
     }
@@ -3936,7 +3968,12 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
     }
 
     activeExecutions.delete(conversationId);
-    activeProcessesByConvId.delete(conversationId);
+    // Keep process alive for steering for up to 30 seconds after execution completes
+    const steeringTimeout = setTimeout(() => {
+      activeProcessesByConvId.delete(conversationId);
+      steeringTimeouts.delete(conversationId);
+    }, 30000);
+    steeringTimeouts.set(conversationId, steeringTimeout);
     batcher.drain();
     debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
 
@@ -4281,14 +4318,16 @@ const wsRouter = new WsRouter();
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, messageQueues, rateLimitState,
-  broadcastSync, processMessageWithStreaming, activeProcessesByConvId
+  broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts
 });
 
+console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);
 registerSessionHandlers(wsRouter, {
   db: queries, discoveredAgents, modelCache,
   getAgentDescriptor, activeScripts, broadcastSync,
   startGeminiOAuth, geminiOAuthState: () => geminiOAuthState
 });
+console.log('[INIT] registerSessionHandlers completed');
 
 registerRunHandlers(wsRouter, {
   queries, discoveredAgents, activeExecutions, activeProcessesByRunId,

package/static/js/client.js

@@ -442,6 +442,11 @@ class AgentGUIClient {
 
     if (this.ui.agentSelector) {
       this.ui.agentSelector.addEventListener('change', () => {
+        // Load models for the selected sub-agent
+        const selectedSubAgentId = this.ui.agentSelector.value;
+        if (selectedSubAgentId) {
+          this.loadModelsForAgent(selectedSubAgentId);
+        }
         if (!this._agentLocked) {
           this.saveAgentAndModelToConversation();
         }
@@ -2068,13 +2073,34 @@ class AgentGUIClient {
           .join('');
         this.ui.agentSelector.style.display = 'inline-block';
         console.log(`[Agent Selector] Loaded ${subAgents.length} sub-agents for ${cliAgentId}`);
-        this.loadModelsForAgent(cliAgentId);
+        // Auto-select first sub-agent and load its models
+        const firstSubAgentId = subAgents[0].id;
+        this.ui.agentSelector.value = firstSubAgentId;
+        this.loadModelsForAgent(firstSubAgentId);
       } else {
         console.log(`[Agent Selector] No sub-agents found for ${cliAgentId}`);
+        // Load models for the CLI agent itself (fallback for agents without sub-agents)
+        const cliToAcpMap = {
+          'cli-opencode': 'opencode',
+          'cli-gemini': 'gemini',
+          'cli-kilo': 'kilo',
+          'cli-codex': 'codex'
+        };
+        const acpAgentId = cliToAcpMap[cliAgentId] || cliAgentId;
+        this.loadModelsForAgent(acpAgentId);
       }
     } catch (err) {
       // No sub-agents available for this CLI tool — keep hidden
       console.warn(`[Agent Selector] Failed to load sub-agents for ${cliAgentId}:`, err.message);
+      // Fallback: load models for the corresponding ACP agent
+      const cliToAcpMap = {
+        'cli-opencode': 'opencode',
+        'cli-gemini': 'gemini',
+        'cli-kilo': 'kilo',
+        'cli-codex': 'codex'
+      };
+      const acpAgentId = cliToAcpMap[cliAgentId] || cliAgentId;
+      this.loadModelsForAgent(acpAgentId);
     }
   }