agentgui 1.0.795 → 1.0.797

package/lib/model-download-machine.js

@@ -0,0 +1,107 @@
+import { createMachine, createActor, assign } from 'xstate';
+
+const machine = createMachine({
+  id: 'model-download',
+  initial: 'idle',
+  context: {
+    progress: null,
+    error: null,
+    startTime: null,
+    waiters: [],
+  },
+  states: {
+    idle: {
+      on: {
+        START: {
+          target: 'downloading',
+          actions: assign({ startTime: () => Date.now(), error: null }),
+        },
+        WAIT: {
+          actions: assign(({ context, event }) => ({
+            waiters: [...context.waiters, event.resolve],
+          })),
+        },
+      },
+    },
+    downloading: {
+      on: {
+        PROGRESS: {
+          actions: assign(({ event }) => ({ progress: event.progress })),
+        },
+        COMPLETE: { target: 'complete' },
+        ERROR: {
+          target: 'error',
+          actions: assign(({ event }) => ({ error: event.error })),
+        },
+        WAIT: {
+          actions: assign(({ context, event }) => ({
+            waiters: [...context.waiters, event.resolve],
+          })),
+        },
+      },
+    },
+    complete: {
+      entry: assign(({ context }) => {
+        for (const resolve of context.waiters) resolve(true);
+        return { waiters: [] };
+      }),
+      on: {
+        RESET: { target: 'idle' },
+      },
+    },
+    error: {
+      entry: assign(({ context }) => {
+        for (const resolve of context.waiters) resolve(false);
+        return { waiters: [] };
+      }),
+      on: {
+        RESET: { target: 'idle' },
+        START: {
+          target: 'downloading',
+          actions: assign({ startTime: () => Date.now(), error: null }),
+        },
+      },
+    },
+  },
+});
+
+let actor = null;
+
+export function getActor() {
+  if (!actor) {
+    actor = createActor(machine);
+    actor.start();
+  }
+  return actor;
+}
+
+export function send(event) {
+  return getActor().send(event);
+}
+
+export function snapshot() {
+  return getActor().getSnapshot();
+}
+
+export function isDownloading() {
+  const s = snapshot();
+  return s.value === 'downloading';
+}
+
+export function isComplete() {
+  const s = snapshot();
+  return s.value === 'complete';
+}
+
+export function isError() {
+  const s = snapshot();
+  return s.value === 'error';
+}
+
+export function getState() {
+  return snapshot().value;
+}
+
+export function getContext() {
+  return snapshot().context;
+}

package/lib/rate-limit-machine.js

@@ -0,0 +1,99 @@
+import { createMachine, createActor, assign } from 'xstate';
+
+const machine = createMachine({
+  id: 'rate-limit',
+  initial: 'normal',
+  context: {
+    retryCount: 0,
+    retryAt: null,
+    cooldownMs: null,
+    isStreamDetected: false,
+  },
+  states: {
+    normal: {
+      entry: assign({ retryCount: 0, retryAt: null, cooldownMs: null, isStreamDetected: false }),
+      on: {
+        HIT: {
+          target: 'limited',
+          actions: assign(({ context, event }) => ({
+            retryCount: context.retryCount + 1,
+            retryAt: event.retryAt,
+            cooldownMs: event.cooldownMs,
+            isStreamDetected: event.isStreamDetected || false,
+          })),
+        },
+      },
+    },
+    limited: {
+      on: {
+        CLEAR: [
+          { guard: ({ context }) => context.retryCount >= 3, target: 'exceeded' },
+          { target: 'normal' },
+        ],
+        HIT: {
+          actions: assign(({ context, event }) => ({
+            retryCount: context.retryCount + 1,
+            retryAt: event.retryAt,
+            cooldownMs: event.cooldownMs,
+            isStreamDetected: event.isStreamDetected || false,
+          })),
+        },
+      },
+    },
+    exceeded: {
+      on: {
+        RESET: { target: 'normal' },
+      },
+    },
+  },
+});
+
+const actors = new Map();
+
+export function getOrCreate(convId) {
+  if (actors.has(convId)) return actors.get(convId);
+  const actor = createActor(machine);
+  actor.start();
+  actors.set(convId, actor);
+  return actor;
+}
+
+export function get(convId) {
+  return actors.get(convId) || null;
+}
+
+export function remove(convId) {
+  const actor = actors.get(convId);
+  if (actor) { actor.stop(); actors.delete(convId); }
+}
+
+export function snapshot(convId) {
+  const actor = actors.get(convId);
+  return actor ? actor.getSnapshot() : null;
+}
+
+export function send(convId, event) {
+  const actor = getOrCreate(convId);
+  actor.send(event);
+  return actor.getSnapshot();
+}
+
+export function isLimited(convId) {
+  const s = snapshot(convId);
+  return s ? s.value === 'limited' : false;
+}
+
+export function isExceeded(convId) {
+  const s = snapshot(convId);
+  return s ? s.value === 'exceeded' : false;
+}
+
+export function getContext(convId) {
+  const s = snapshot(convId);
+  return s ? s.context : null;
+}
+
+export function has(convId) {
+  const s = snapshot(convId);
+  return s ? s.value !== 'normal' : false;
+}

package/lib/script-machine.js

@@ -0,0 +1,81 @@
+import { createMachine, createActor, assign } from 'xstate';
+
+const machine = createMachine({
+  id: 'script',
+  initial: 'idle',
+  context: {
+    process: null,
+    script: null,
+    startTime: null,
+    pid: null,
+  },
+  states: {
+    idle: {
+      entry: assign({ process: null, script: null, startTime: null, pid: null }),
+      on: {
+        START: {
+          target: 'running',
+          actions: assign(({ event }) => ({
+            process: event.process,
+            script: event.script,
+            startTime: Date.now(),
+            pid: event.pid || null,
+          })),
+        },
+      },
+    },
+    running: {
+      on: {
+        STOP: { target: 'stopping' },
+        CLOSE: { target: 'idle' },
+        ERROR: { target: 'idle' },
+      },
+    },
+    stopping: {
+      on: {
+        CLOSE: { target: 'idle' },
+        ERROR: { target: 'idle' },
+      },
+    },
+  },
+});
+
+const actors = new Map();
+
+export function getOrCreate(convId) {
+  if (actors.has(convId)) return actors.get(convId);
+  const actor = createActor(machine);
+  actor.start();
+  actors.set(convId, actor);
+  return actor;
+}
+
+export function get(convId) {
+  return actors.get(convId) || null;
+}
+
+export function remove(convId) {
+  const actor = actors.get(convId);
+  if (actor) { actor.stop(); actors.delete(convId); }
+}
+
+export function snapshot(convId) {
+  const actor = actors.get(convId);
+  return actor ? actor.getSnapshot() : null;
+}
+
+export function send(convId, event) {
+  const actor = getOrCreate(convId);
+  actor.send(event);
+  return actor.getSnapshot();
+}
+
+export function isRunning(convId) {
+  const s = snapshot(convId);
+  return s ? s.value === 'running' || s.value === 'stopping' : false;
+}
+
+export function getContext(convId) {
+  const s = snapshot(convId);
+  return s ? s.context : null;
+}

package/lib/ws-handlers-scripts.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { spawn } from 'child_process';
+import * as scriptMachine from './script-machine.js';
 
 function err(code, message) { const e = new Error(message); e.code = code; throw e; }
 
@@ -19,15 +20,16 @@ export function register(router, deps) {
       hasStart = !!scripts.start;
       hasDev = !!scripts.dev;
     } catch {}
-    const running = activeScripts.has(p.id);
-    const runningScript = running ? activeScripts.get(p.id).script : null;
+    const running = scriptMachine.isRunning(p.id);
+    const ctx = scriptMachine.getContext(p.id);
+    const runningScript = running ? ctx?.script : null;
     return { hasStart, hasDev, running, runningScript };
   });
 
   router.handle('conv.run-script', (p) => {
     const conv = queries.getConversation(p.id);
     if (!conv) err(404, 'Not found');
-    if (activeScripts.has(p.id)) err(409, 'Script already running');
+    if (scriptMachine.isRunning(p.id)) err(409, 'Script already running');
     const script = p.script;
     if (script !== 'start' && script !== 'dev') err(400, 'Invalid script');
     const wd = conv.workingDirectory || STARTUP_CWD;
@@ -39,21 +41,26 @@ export function register(router, deps) {
     delete childEnv.PORT; delete childEnv.BASE_URL; delete childEnv.HOT_RELOAD;
     const isWindows = os.platform() === 'win32';
     const child = spawn('npm', ['run', script], { cwd: wd, stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: childEnv, shell: isWindows });
+    scriptMachine.send(p.id, { type: 'START', process: child, script, pid: child.pid });
     activeScripts.set(p.id, { process: child, script, startTime: Date.now() });
     broadcastSync({ type: 'script_started', conversationId: p.id, script, timestamp: Date.now() });
     const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId: p.id, data: chunk.toString(), stream, timestamp: Date.now() });
     child.stdout.on('data', onData('stdout'));
     child.stderr.on('data', onData('stderr'));
-    child.on('error', (e) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: 1, error: e.message, timestamp: Date.now() }); });
-    child.on('close', (code) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: code || 0, timestamp: Date.now() }); });
+    child.on('error', (e) => { scriptMachine.send(p.id, { type: 'ERROR' }); activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: 1, error: e.message, timestamp: Date.now() }); });
+    child.on('close', (code) => { scriptMachine.send(p.id, { type: 'CLOSE' }); activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: code || 0, timestamp: Date.now() }); });
     return { ok: true, script, pid: child.pid };
   });
 
   router.handle('conv.stop-script', (p) => {
-    const entry = activeScripts.get(p.id);
-    if (!entry) err(404, 'No running script');
-    try { process.kill(-entry.process.pid, 'SIGTERM'); } catch { try { entry.process.kill('SIGTERM'); } catch {} }
-    setTimeout(() => { try { process.kill(-entry.process.pid, 'SIGKILL'); } catch { try { entry.process.kill('SIGKILL'); } catch {} } }, 5000);
+    if (!scriptMachine.isRunning(p.id)) err(404, 'No running script');
+    const ctx = scriptMachine.getContext(p.id);
+    const proc = ctx?.process;
+    scriptMachine.send(p.id, { type: 'STOP' });
+    if (proc) {
+      try { process.kill(-proc.pid, 'SIGTERM'); } catch { try { proc.kill('SIGTERM'); } catch {} }
+      setTimeout(() => { try { process.kill(-proc.pid, 'SIGKILL'); } catch { try { proc.kill('SIGKILL'); } catch {} } }, 5000);
+    }
     return { ok: true };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.795",
+  "version": "1.0.797",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/server.js

@@ -2072,27 +2072,38 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
               } catch (e) {}
             }
             
-            rateLimitState.set(conversationId, { 
-              retryAt: Date.now() + (retryAfterSec * 1000), 
-              cooldownMs: retryAfterSec * 1000, 
-              retryCount: 0,
+            const existingRetryCount2 = rateLimitState.get(conversationId)?.retryCount || 0;
+            if (existingRetryCount2 >= 3) {
+              debugLog(`[rate-limit] Conv ${conversationId} result rate limit hit ${existingRetryCount2 + 1} times, giving up`);
+              batcher.drain();
+              activeExecutions.delete(conversationId);
+              queries.setIsStreaming(conversationId, false);
+              const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingRetryCount2 + 1} attempts. Please try again later.`);
+              broadcastSync({ type: 'message_created', conversationId, message: errorMessage, timestamp: Date.now() });
+              broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
+              return;
+            }
+            rateLimitState.set(conversationId, {
+              retryAt: Date.now() + (retryAfterSec * 1000),
+              cooldownMs: retryAfterSec * 1000,
+              retryCount: existingRetryCount2 + 1,
               isStreamDetected: true
             });
-            
+
             broadcastSync({
               type: 'rate_limit_hit',
               sessionId,
               conversationId,
               retryAfterMs: retryAfterSec * 1000,
               retryAt: Date.now() + (retryAfterSec * 1000),
-              retryCount: 1,
+              retryCount: existingRetryCount2 + 1,
               timestamp: Date.now()
             });
-            
+
             batcher.drain();
             activeExecutions.delete(conversationId);
             queries.setIsStreaming(conversationId, false);
-            
+
             setTimeout(() => {
               rateLimitState.delete(conversationId);
               broadcastSync({
@@ -2102,7 +2113,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
               });
               scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
             }, retryAfterSec * 1000);
-            
+
             return;
           }