agentgui 1.0.186 → 1.0.188

package/lib/claude-runner.js

@@ -107,11 +107,34 @@ class AgentRunner {
         const errorText = chunk.toString();
         console.error(`[${this.id}] stderr:`, errorText);
 
-        const rateLimitMatch = errorText.match(/rate.?limit|429|too many requests|overloaded|throttl/i);
+        const rateLimitMatch = errorText.match(/rate.?limit|429|too many requests|overloaded|throttl|hit your limit/i);
         if (rateLimitMatch) {
           rateLimited = true;
           const retryMatch = errorText.match(/retry.?after[:\s]+(\d+)/i);
-          if (retryMatch) retryAfterSec = parseInt(retryMatch[1], 10) || 60;
+          if (retryMatch) {
+            retryAfterSec = parseInt(retryMatch[1], 10) || 60;
+          } else {
+            const resetTimeMatch = errorText.match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(?(UTC|[A-Z]{2,4})\)?/i);
+            if (resetTimeMatch) {
+              let hours = parseInt(resetTimeMatch[1], 10);
+              const minutes = resetTimeMatch[2] ? parseInt(resetTimeMatch[2], 10) : 0;
+              const period = resetTimeMatch[3]?.toLowerCase();
+              const tz = resetTimeMatch[4]?.toUpperCase() || 'UTC';
+
+              if (period === 'pm' && hours !== 12) hours += 12;
+              if (period === 'am' && hours === 12) hours = 0;
+
+              const now = new Date();
+              const resetTime = new Date(now);
+              resetTime.setUTCHours(hours, minutes, 0, 0);
+
+              if (resetTime <= now) {
+                resetTime.setUTCDate(resetTime.getUTCDate() + 1);
+              }
+
+              retryAfterSec = Math.max(60, Math.ceil((resetTime.getTime() - now.getTime()) / 1000));
+            }
+          }
         }
 
         if (onError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.186",
+  "version": "1.0.188",
   "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;
 
@@ -1014,10 +1025,35 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
     });
 
     if (isRateLimit) {
+      const existingState = rateLimitState.get(conversationId) || {};
+      const retryCount = (existingState.retryCount || 0) + 1;
+      const maxRateLimitRetries = 3;
+
+      if (retryCount > maxRateLimitRetries) {
+        debugLog(`[rate-limit] Conv ${conversationId} hit rate limit ${retryCount} times, giving up`);
+        broadcastSync({
+          type: 'streaming_error',
+          sessionId,
+          conversationId,
+          error: `Rate limit exceeded after ${retryCount} attempts. Please try again later.`,
+          recoverable: false,
+          timestamp: Date.now()
+        });
+        const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${retryCount} attempts. Please try again later.`);
+        broadcastSync({
+          type: 'message_created',
+          conversationId,
+          message: errorMessage,
+          timestamp: Date.now()
+        });
+        queries.setIsStreaming(conversationId, false);
+        return;
+      }
+
       const cooldownMs = (error.retryAfterSec || 60) * 1000;
       const retryAt = Date.now() + cooldownMs;
-      rateLimitState.set(conversationId, { retryAt, cooldownMs });
-      debugLog(`[rate-limit] Conv ${conversationId} hit rate limit, retry in ${cooldownMs}ms`);
+      rateLimitState.set(conversationId, { retryAt, cooldownMs, retryCount });
+      debugLog(`[rate-limit] Conv ${conversationId} hit rate limit (attempt ${retryCount}/${maxRateLimitRetries}), retry in ${cooldownMs}ms`);
 
       broadcastSync({
         type: 'rate_limit_hit',
@@ -1025,14 +1061,18 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
         conversationId,
         retryAfterMs: cooldownMs,
         retryAt,
+        retryCount,
         timestamp: Date.now()
       });
 
       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`);
+        debugLog(`[rate-limit] Conv ${conversationId} cooldown expired, restarting (attempt ${retryCount + 1})`);
         broadcastSync({
           type: 'rate_limit_clear',
           conversationId,
@@ -1062,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,
@@ -1082,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) {