agentgui 1.0.187 → 1.0.189

package/package.json

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

package/server.js

@@ -352,7 +352,10 @@ const server = http.createServer(async (req, res) => {
         sendJSON(req, res, 201, { message, session, idempotencyKey });
 
         processMessageWithStreaming(conversationId, message.id, session.id, body.content, agentId)
-          .catch(err => debugLog(`[messages] Uncaught error: ${err.message}`));
+          .catch(err => {
+            console.error(`[messages] Uncaught error for conv ${conversationId}:`, err.message);
+            debugLog(`[messages] Uncaught error: ${err.message}`);
+          });
         return;
       }
     }
@@ -837,6 +840,15 @@ function createChunkBatcher() {
 
 async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId) {
   const startTime = Date.now();
+  
+  const conv = queries.getConversation(conversationId);
+  if (!conv) {
+    console.error(`[stream] Conversation ${conversationId} not found, aborting`);
+    queries.updateSession(sessionId, { status: 'error', error: 'Conversation not found' });
+    queries.setIsStreaming(conversationId, false);
+    return;
+  }
+  
   activeExecutions.set(conversationId, { pid: null, startTime, sessionId, lastActivity: startTime });
   queries.setIsStreaming(conversationId, true);
   queries.updateSession(sessionId, { status: 'active' });
@@ -845,7 +857,6 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
   try {
     debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
 
-    const conv = queries.getConversation(conversationId);
     const cwd = conv?.workingDirectory || STARTUP_CWD;
     const resumeSessionId = conv?.claudeSessionId || null;
 
@@ -1035,6 +1046,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
           message: errorMessage,
           timestamp: Date.now()
         });
+        queries.setIsStreaming(conversationId, false);
         return;
       }
 
@@ -1055,7 +1067,10 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
 
       batcher.drain();
 
+      debugLog(`[rate-limit] Scheduling retry for conv ${conversationId} in ${cooldownMs}ms (attempt ${retryCount + 1})`);
+      
       setTimeout(() => {
+        debugLog(`[rate-limit] Timeout fired for conv ${conversationId}, calling scheduleRetry`);
         rateLimitState.delete(conversationId);
         debugLog(`[rate-limit] Conv ${conversationId} cooldown expired, restarting (attempt ${retryCount + 1})`);
         broadcastSync({
@@ -1087,17 +1102,27 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
   } finally {
     batcher.drain();
     activeExecutions.delete(conversationId);
-    queries.setIsStreaming(conversationId, false);
     if (!rateLimitState.has(conversationId)) {
+      queries.setIsStreaming(conversationId, false);
       drainMessageQueue(conversationId);
     }
   }
 }
 
 function scheduleRetry(conversationId, messageId, content, agentId) {
+  debugLog(`[rate-limit] scheduleRetry called for conv ${conversationId}, messageId=${messageId}`);
+  
+  if (!content) {
+    const conv = queries.getConversation(conversationId);
+    const lastMsg = queries.getLastUserMessage(conversationId);
+    content = lastMsg?.content || 'continue';
+    debugLog(`[rate-limit] Recovered content from last message: ${content?.substring?.(0, 50)}...`);
+  }
+  
   const newSession = queries.createSession(conversationId);
   queries.createEvent('session.created', { messageId, sessionId: newSession.id, retryReason: 'rate_limit' }, conversationId, newSession.id);
 
+  debugLog(`[rate-limit] Broadcasting streaming_start for retry session ${newSession.id}`);
   broadcastSync({
     type: 'streaming_start',
     sessionId: newSession.id,
@@ -1107,8 +1132,12 @@ function scheduleRetry(conversationId, messageId, content, agentId) {
     timestamp: Date.now()
   });
 
+  debugLog(`[rate-limit] Calling processMessageWithStreaming for retry`);
   processMessageWithStreaming(conversationId, messageId, newSession.id, content, agentId)
-    .catch(err => debugLog(`[retry] Error: ${err.message}`));
+    .catch(err => {
+      debugLog(`[rate-limit] Retry failed: ${err.message}`);
+      console.error(`[rate-limit] Retry error for conv ${conversationId}:`, err);
+    });
 }
 
 function drainMessageQueue(conversationId) {

package/static/js/client.js

@@ -977,6 +977,29 @@ class AgentGUIClient {
         body: JSON.stringify({ content: prompt, agentId })
       });
 
+      if (response.status === 404) {
+        console.warn('Conversation not found, recreating:', conversationId);
+        const conv = this.state.currentConversation;
+        const createResp = await fetch(window.__BASE_URL + '/api/conversations', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            agentId,
+            title: conv?.title || prompt.substring(0, 50),
+            workingDirectory: conv?.workingDirectory || null
+          })
+        });
+        if (!createResp.ok) throw new Error(`Failed to recreate conversation: HTTP ${createResp.status}`);
+        const { conversation: newConv } = await createResp.json();
+        this.state.currentConversation = newConv;
+        if (window.conversationManager) {
+          window.conversationManager.loadConversations();
+          window.conversationManager.select(newConv.id);
+        }
+        this.updateUrlForConversation(newConv.id);
+        return this.streamToConversation(newConv.id, prompt, agentId);
+      }
+
       if (!response.ok) throw new Error(`HTTP ${response.status}`);
 
       const result = await response.json();
@@ -1367,6 +1390,17 @@ class AgentGUIClient {
       this.conversationCache.delete(conversationId);
 
       const resp = await fetch(window.__BASE_URL + `/api/conversations/${conversationId}/full`);
+      if (resp.status === 404) {
+        console.warn('Conversation no longer exists:', conversationId);
+        this.state.currentConversation = null;
+        if (window.conversationManager) {
+          window.conversationManager.loadConversations();
+        }
+        const outputEl = document.getElementById('output');
+        if (outputEl) outputEl.innerHTML = '<p class="text-secondary" style="padding:2rem;text-align:center">Conversation not found. It may have been lost during a server restart.</p>';
+        this.enableControls();
+        return;
+      }
       if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
       const { conversation, isActivelyStreaming, latestSession, chunks: rawChunks, totalChunks, messages: allMessages } = await resp.json();