agentgui 1.0.688 → 1.0.690

package/lib/claude-runner.js

@@ -88,6 +88,10 @@ class AgentRunner {
         onRateLimit = null
       } = config;
 
+      if (process.env.DEBUG === '1') {
+        const sp = config.systemPrompt;
+        console.error(`[prompt-trace] convId=${config.conversationId} promptType=${typeof prompt} promptLen=${String(prompt).length} prompt0=${String(prompt).slice(0, 100)} sysLen=${sp ? String(sp).length : 0}`);
+      }
       const args = this.buildArgs(prompt, config);
       const spawnOpts = getSpawnOptions(cwd);
       if (Object.keys(this.spawnEnv).length > 0) {

package/lib/ws-handlers-conv.js

@@ -7,7 +7,7 @@ function expandTilde(p) { return p && p.startsWith('~') ? path.join(os.homedir()
 
 export function register(router, deps) {
   const { queries, activeExecutions, messageQueues, rateLimitState,
-    broadcastSync, processMessageWithStreaming, cleanupExecution } = deps;
+    broadcastSync, processMessageWithStreaming, cleanupExecution, logError = () => {} } = deps;
 
   // Per-conversation queue seq counter for event ordering
   const queueSeqByConv = new Map();
@@ -179,7 +179,7 @@ export function register(router, deps) {
     activeExecutions.set(convId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
     queries.setIsStreaming(convId, true);
     broadcastSync({ type: 'streaming_start', sessionId: session.id, conversationId: convId, messageId: message.id, agentId, timestamp: Date.now() });
-    processMessageWithStreaming(convId, message.id, session.id, content, agentId, model, subAgent).catch(() => {});
+    processMessageWithStreaming(convId, message.id, session.id, content, agentId, model, subAgent).catch(e => logError('startExecution', e, { convId }));
     return session;
   }
 
@@ -199,6 +199,10 @@ export function register(router, deps) {
     const subAgent = p.subAgent || conv.subAgent || null;
     const idempotencyKey = p.idempotencyKey || null;
     const rawContent = p.content;
+    if (rawContent !== undefined && typeof rawContent !== 'string') {
+      console.warn(`[ws-validation] msg.send content is ${typeof rawContent}: ${JSON.stringify(rawContent).slice(0, 200)}`);
+      logError('ws-content-type', new TypeError(`non-string content in msg.send`), { method: 'msg.send', type: typeof rawContent });
+    }
     p.content = typeof rawContent === 'string' ? rawContent : (rawContent ? JSON.stringify(rawContent) : '');
     const message = queries.createMessage(p.id, 'user', p.content, idempotencyKey);
     queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
@@ -225,6 +229,10 @@ export function register(router, deps) {
     const conv = queries.getConversation(p.id);
     if (!conv) notFound('Conversation not found');
     const rawContent = p.content || p.message;
+    if (rawContent !== undefined && typeof rawContent !== 'string') {
+      console.warn(`[ws-validation] msg.stream content is ${typeof rawContent}: ${JSON.stringify(rawContent).slice(0, 200)}`);
+      logError('ws-content-type', new TypeError(`non-string content in msg.stream`), { method: 'msg.stream', type: typeof rawContent });
+    }
     const prompt = typeof rawContent === 'string' ? rawContent : (rawContent ? JSON.stringify(rawContent) : '');
     const agentId = p.agentId || conv.agentType || conv.agentId || 'claude-code';
     const model = p.model || conv.model || null;

package/package.json

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

package/server.js

@@ -309,6 +309,14 @@ const debugLog = (msg) => {
   console.error(`[${timestamp}] ${msg}`);
 };
 
+const _errLogPath = path.join(os.homedir(), 'logs', 'agentgui-errors.log');
+function logError(op, err, ctx = {}) {
+  try {
+    const line = JSON.stringify({ ts: new Date().toISOString(), op, msg: err?.message, stack: err?.stack, ...ctx }) + '\n';
+    fs.appendFile(_errLogPath, line, () => {});
+  } catch (_) {}
+}
+
 // Atomic cleanup function - ensures consistent state across all data structures
 function cleanupExecution(conversationId, broadcastCompletion = false) {
   debugLog(`[cleanup] Starting cleanup for ${conversationId}`);
@@ -586,6 +594,7 @@ async function initializeAgentDiscovery() {
     console.log('[AGENTS] Total count:', discoveredAgents.length);
   } catch (err) {
     console.error('[AGENTS] Discovery error:', err.message);
+    logError('initializeAgentDiscovery', err);
   }
 }
 
@@ -1269,6 +1278,7 @@ const server = http.createServer(async (req, res) => {
           .catch(err => {
             console.error(`[messages] Uncaught error for conv ${conversationId}:`, err.message);
             debugLog(`[messages] Uncaught error: ${err.message}`);
+            logError('processMessageWithStreaming', err, { convId: conversationId });
           });
         return;
       }
@@ -1777,6 +1787,40 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/health' && req.method === 'GET') {
+      let dbStatus = { ok: true };
+      try { queries._db.prepare('SELECT 1').get(); } catch (e) { dbStatus = { ok: false, error: e.message }; }
+      const queueSizes = {};
+      for (const [k, v] of messageQueues) queueSizes[k] = v.length;
+      sendJSON(req, res, 200, {
+        uptime: process.uptime(),
+        db: dbStatus,
+        activeExecutionCount: activeExecutions.size,
+        queueSizes,
+        wsClientCount: syncClients.size,
+        memory: process.memoryUsage()
+      });
+      return;
+    }
+
+    if (pathOnly === '/api/debug' && req.method === 'GET') {
+      const execSnap = {};
+      for (const [k, v] of activeExecutions) execSnap[k] = { pid: v.pid, startTime: v.startTime, sessionId: v.sessionId, lastActivity: v.lastActivity };
+      const queueSnap = {};
+      for (const [k, v] of messageQueues) queueSnap[k] = { length: v.length, messageIds: v.map(m => m.messageId) };
+      let streamingConvs = [];
+      try { streamingConvs = queries.getConversationsList().filter(c => c.isStreaming).map(c => ({ id: c.id, isStreaming: c.isStreaming })); } catch (_) {}
+      const clientSubs = [];
+      for (const ws of syncClients) clientSubs.push({ clientId: ws.clientId, subs: ws.subscriptions ? [...ws.subscriptions] : [] });
+      let recentErrors = [];
+      try {
+        const raw = fs.readFileSync(_errLogPath, 'utf8');
+        recentErrors = raw.trim().split('\n').slice(-20).map(l => { try { return JSON.parse(l); } catch { return l; } });
+      } catch (_) {}
+      sendJSON(req, res, 200, { activeExecutions: execSnap, messageQueues: queueSnap, streamingConversations: streamingConvs, wsClients: clientSubs, recentErrors });
+      return;
+    }
+
     if (pathOnly === '/api/tools' && req.method === 'GET') {
       console.log('[TOOLS-API] Handling GET /api/tools');
       try {
@@ -1899,6 +1943,7 @@ const server = http.createServer(async (req, res) => {
         installCompleted = true;
         const error = err?.message || 'Unknown error';
         console.error(`[TOOLS-API] Install error for ${toolId}:`, error);
+        logError('toolInstall', err, { toolId });
         queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
         broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error } });
         queries.addToolInstallHistory(toolId, 'install', 'failed', error);
@@ -1958,6 +2003,7 @@ const server = http.createServer(async (req, res) => {
         updateCompleted = true;
         const error = err?.message || 'Unknown error';
         console.error(`[TOOLS-API] Update error for ${toolId}:`, error);
+        logError('toolUpdate', err, { toolId });
         queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
         broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error } });
         queries.addToolInstallHistory(toolId, 'update', 'failed', error);
@@ -4095,7 +4141,7 @@ const wsRouter = new WsRouter();
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, messageQueues, rateLimitState,
-  broadcastSync, processMessageWithStreaming, cleanupExecution
+  broadcastSync, processMessageWithStreaming, cleanupExecution, logError
 });
 
 console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);

package/static/js/streaming-renderer.js

@@ -285,6 +285,9 @@ class StreamingRenderer {
       if (nodeCount > 0) {
         this.outputContainer.appendChild(fragment);
         this.domNodeCount += nodeCount;
+
+        // Nest tool result blocks inside their corresponding tool use blocks
+        this.nestToolResultsInToolUses();
       }
 
       // Auto-scroll to bottom
@@ -757,7 +760,7 @@ class StreamingRenderer {
     const input = block.input || {};
 
     const details = document.createElement('details');
-    details.className = 'block-tool-use folded-tool permanently-expanded';
+    details.className = 'block-tool-use folded-tool';
     if (block.id) details.dataset.toolUseId = block.id;
     details.classList.add(this._getBlockTypeClass('tool_use'));
     details.classList.add(this._getToolColorClass(toolName));
@@ -1249,7 +1252,7 @@ class StreamingRenderer {
     const details = document.createElement('details');
     details.className = 'folded-tool' + (isError ? ' folded-tool-error' : ' folded-tool-success');
     details.dataset.eventType = 'tool_result';
-    // Only open by default if the content is an image
+    // Only open by default if the content is an image and it's not an error
     const isImageContent = contentStr.includes('data:image/') || (block.content && block.content.type === 'base64');
     if (!isError && isImageContent) details.open = true;
     if (block.tool_use_id) details.dataset.toolUseId = block.tool_use_id;
@@ -2070,6 +2073,26 @@ class StreamingRenderer {
     return div;
   }
 
+  /**
+   * Nest tool result blocks inside their corresponding tool use blocks
+   */
+  nestToolResultsInToolUses() {
+    if (!this.outputContainer) return;
+
+    const toolUseBlocks = this.outputContainer.querySelectorAll('details.block-tool-use[data-tool-use-id]');
+    const toolResultBlocks = this.outputContainer.querySelectorAll('details[data-event-type="tool_result"][data-tool-use-id]');
+
+    toolResultBlocks.forEach(resultBlock => {
+      const toolUseId = resultBlock.dataset.toolUseId;
+      const toolUseBlock = Array.from(toolUseBlocks).find(b => b.dataset.toolUseId === toolUseId);
+
+      if (toolUseBlock && toolUseBlock.parentElement === resultBlock.parentElement) {
+        // Result is a sibling of the tool use block, move it inside
+        toolUseBlock.appendChild(resultBlock);
+      }
+    });
+  }
+
   /**
    * Auto-scroll to bottom of container
    */