agent-state-machine 2.3.0 → 2.5.0

package/lib/runtime/runtime.js

@@ -68,6 +68,9 @@ export class WorkflowRuntime {
     this.status = savedState.status || 'IDLE';
     this.startedAt = savedState.startedAt || null;
 
+    // Load usage totals
+    this._usageTotals = savedState.usage || null;
+
     // Create memory proxy for auto-persistence
     this.memory = createMemoryProxy(this._rawMemory, () => this.persist());
 
@@ -197,12 +200,67 @@ export class WorkflowRuntime {
       memory: this._rawMemory,
       _error: this._error,
       startedAt: this.startedAt,
-      lastUpdatedAt: new Date().toISOString()
+      lastUpdatedAt: new Date().toISOString(),
+      usage: this._usageTotals
     };
 
     fs.writeFileSync(this.stateFile, JSON.stringify(state, null, 2));
   }
 
+  /**
+   * Update running token usage totals
+   * @param {string} agentName - Name of the agent that generated the usage
+   * @param {object} usage - Usage object with inputTokens, outputTokens, etc.
+   */
+  updateUsageTotals(agentName, usage) {
+    if (!usage) return;
+
+    if (!this._usageTotals) {
+      this._usageTotals = {
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCachedTokens: 0,
+        totalCost: 0,
+        agentUsage: {},
+        modelUsage: {}
+      };
+    }
+
+    // Update totals
+    this._usageTotals.totalInputTokens += usage.inputTokens || 0;
+    this._usageTotals.totalOutputTokens += usage.outputTokens || 0;
+    this._usageTotals.totalCachedTokens += usage.cachedTokens || 0;
+    this._usageTotals.totalCost += usage.cost || 0;
+
+    // Per-agent tracking
+    if (!this._usageTotals.agentUsage[agentName]) {
+      this._usageTotals.agentUsage[agentName] = { inputTokens: 0, outputTokens: 0, calls: 0 };
+    }
+    this._usageTotals.agentUsage[agentName].inputTokens += usage.inputTokens || 0;
+    this._usageTotals.agentUsage[agentName].outputTokens += usage.outputTokens || 0;
+    this._usageTotals.agentUsage[agentName].calls += usage.calls || 1;
+
+    // Per-model tracking
+    if (usage.models) {
+      for (const [model, modelUsage] of Object.entries(usage.models)) {
+        if (!this._usageTotals.modelUsage[model]) {
+          this._usageTotals.modelUsage[model] = { inputTokens: 0, outputTokens: 0 };
+        }
+        this._usageTotals.modelUsage[model].inputTokens += modelUsage.inputTokens || 0;
+        this._usageTotals.modelUsage[model].outputTokens += modelUsage.outputTokens || 0;
+      }
+    }
+
+    this.persist();
+  }
+
+  /**
+   * Reset usage totals
+   */
+  resetUsageTotals() {
+    this._usageTotals = null;
+  }
+
   /**
    * Prepend an event to history.jsonl (newest first)
    */
@@ -527,6 +585,31 @@ export class WorkflowRuntime {
     }
   }
 
+  /**
+   * Handle config update from remote browser UI
+   * Called by RemoteClient when it receives a config_update message
+   */
+  handleRemoteConfigUpdate(config) {
+    if (config.fullAuto !== undefined) {
+      const wasFullAuto = this.workflowConfig.fullAuto;
+      this.workflowConfig.fullAuto = config.fullAuto;
+      if (wasFullAuto !== config.fullAuto) {
+        console.log(`${C.cyan}Remote: Full-auto mode ${config.fullAuto ? 'enabled' : 'disabled'}${C.reset}`);
+      }
+    }
+
+    if (config.autoSelectDelay !== undefined) {
+      this.workflowConfig.autoSelectDelay = config.autoSelectDelay;
+      console.log(`${C.dim}Remote: Auto-select delay set to ${config.autoSelectDelay}s${C.reset}`);
+    }
+
+    if (config.stop) {
+      console.log(`\n${C.yellow}${C.bold}Remote: Stop requested${C.reset}`);
+      // Trigger graceful shutdown
+      process.emit('SIGINT');
+    }
+  }
+
   /**
    * Read the user's response from an interaction file
    */
@@ -562,14 +645,14 @@ export class WorkflowRuntime {
   showStatus() {
     console.log(`\n${C.bold}Workflow: ${C.cyan}${this.workflowName}${C.reset}`);
     console.log(`${C.dim}${'─'.repeat(40)}${C.reset}`);
-    
+
     let statusColor = C.reset;
     if (this.status === 'COMPLETED') statusColor = C.green;
     if (this.status === 'FAILED') statusColor = C.red;
     if (this.status === 'STOPPED') statusColor = C.yellow;
     if (this.status === 'RUNNING') statusColor = C.blue;
     if (this.status === 'IDLE') statusColor = C.gray;
-    
+
     console.log(`Status: ${statusColor}${this.status}${C.reset}`);
 
     if (this.startedAt) {
@@ -580,6 +663,36 @@ export class WorkflowRuntime {
       console.log(`Error: ${C.red}${this._error}${C.reset}`);
     }
 
+    // Display token usage if available
+    if (this._usageTotals && (this._usageTotals.totalInputTokens > 0 || this._usageTotals.totalOutputTokens > 0)) {
+      console.log(`\n${C.bold}Token Usage:${C.reset}`);
+      const formatTokens = (count) => {
+        if (count >= 1000000) return `${(count / 1000000).toFixed(1)}M`;
+        if (count >= 10000) return `${Math.round(count / 1000)}k`;
+        if (count >= 1000) return `${(count / 1000).toFixed(1)}k`;
+        return count.toString();
+      };
+      console.log(`  Input:  ${formatTokens(this._usageTotals.totalInputTokens)}`);
+      console.log(`  Output: ${formatTokens(this._usageTotals.totalOutputTokens)}`);
+      if (this._usageTotals.totalCachedTokens > 0) {
+        console.log(`  Cached: ${formatTokens(this._usageTotals.totalCachedTokens)}`);
+      }
+      console.log(`  ${C.bold}Total:  ${formatTokens(this._usageTotals.totalInputTokens + this._usageTotals.totalOutputTokens)}${C.reset}`);
+      if (this._usageTotals.totalCost > 0) {
+        console.log(`  ${C.cyan}Cost:   $${this._usageTotals.totalCost.toFixed(4)}${C.reset}`);
+      }
+
+      // Show per-model breakdown if multiple models used
+      const models = Object.keys(this._usageTotals.modelUsage || {});
+      if (models.length > 1) {
+        console.log(`\n${C.dim}By Model:${C.reset}`);
+        for (const model of models) {
+          const m = this._usageTotals.modelUsage[model];
+          console.log(`  ${model}: ${formatTokens(m.inputTokens)} in / ${formatTokens(m.outputTokens)} out`);
+        }
+      }
+    }
+
     const memoryKeys = Object.keys(this._rawMemory).filter((k) => !k.startsWith('_'));
     console.log(`\nMemory Keys: ${C.yellow}${memoryKeys.length}${C.reset}`);
     if (memoryKeys.length > 0) {
@@ -633,6 +746,7 @@ export class WorkflowRuntime {
     this._error = null;
     this.status = 'IDLE';
     this.startedAt = null;
+    this.resetUsageTotals();
 
     // Recreate memory proxy
     this.memory = createMemoryProxy(this._rawMemory, () => this.persist());
@@ -663,6 +777,7 @@ export class WorkflowRuntime {
     this._error = null;
     this.status = 'IDLE';
     this.startedAt = null;
+    this.resetUsageTotals();
 
     // Recreate memory proxy
     this.memory = createMemoryProxy(this._rawMemory, () => this.persist());
@@ -689,6 +804,9 @@ export class WorkflowRuntime {
       onInteractionResponse: (slug, targetKey, response) => {
         this.handleRemoteInteraction(slug, targetKey, response);
       },
+      onConfigUpdate: (config) => {
+        this.handleRemoteConfigUpdate(config);
+      },
       onStatusChange: (status) => {
         if (status === 'disconnected') {
           console.log(`${C.yellow}Remote: Connection lost, attempting to reconnect...${C.reset}`);
@@ -700,10 +818,14 @@ export class WorkflowRuntime {
 
     await this.remoteClient.connect();
 
-    // Send existing history if connected
+    // Send existing history if connected, including current config
     if (this.remoteClient.connected) {
       const history = this.loadHistory();
-      await this.remoteClient.sendSessionInit(history);
+      const config = {
+        fullAuto: this.workflowConfig.fullAuto || false,
+        autoSelectDelay: this.workflowConfig.autoSelectDelay ?? 20,
+      };
+      await this.remoteClient.sendSessionInit(history, config);
     }
 
     this.remoteEnabled = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-state-machine",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "type": "module",
   "description": "A workflow orchestrator for running agents and scripts in sequence with state management",
   "main": "lib/index.js",

package/templates/project-builder/config.js

@@ -1,9 +1,9 @@
 export const config = {
   models: {
-    fast: "gemini -m gemini-2.5-flash-lite",
-    low: "gemini -m gemini-2.5-flash-lite",
-    med: "gemini -m gemini-2.5-flash-lite",
-    high: "gemini -m gemini-2.5-flash-lite",
+    fast: "gemini -m gemini-2.5-pro",
+    low: "gemini -m gemini-2.5-pro",
+    med: "gemini -m gemini-2.5-pro",
+    high: "gemini -m gemini-2.5-pro",
   },
   apiKeys: {
     gemini: process.env.GEMINI_API_KEY,

package/vercel-server/api/config/[token].js

@@ -0,0 +1,76 @@
+/**
+ * File: /vercel-server/api/config/[token].js
+ *
+ * POST endpoint for browser config updates (fullAuto, autoSelectDelay, stop)
+ */
+
+import {
+  getSession,
+  updateSession,
+  pushConfigUpdate,
+} from '../../lib/redis.js';
+
+export default async function handler(req, res) {
+  // Enable CORS
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+  if (req.method === 'OPTIONS') {
+    return res.status(200).end();
+  }
+
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const { token } = req.query;
+
+  if (!token) {
+    return res.status(400).json({ error: 'Missing token parameter' });
+  }
+
+  try {
+    // Validate session
+    const session = await getSession(token);
+    if (!session) {
+      return res.status(404).json({ error: 'Session not found or expired' });
+    }
+
+    // Check if CLI is connected
+    if (!session.cliConnected) {
+      return res.status(503).json({ error: 'CLI is disconnected. Cannot update config.' });
+    }
+
+    // Parse body
+    const body = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
+    const { fullAuto, autoSelectDelay, stop } = body;
+
+    // Build config update object with only provided fields
+    const configUpdate = {};
+    if (fullAuto !== undefined) configUpdate.fullAuto = fullAuto;
+    if (autoSelectDelay !== undefined) configUpdate.autoSelectDelay = autoSelectDelay;
+    if (stop !== undefined) configUpdate.stop = stop;
+
+    if (Object.keys(configUpdate).length === 0) {
+      return res.status(400).json({ error: 'No config fields provided' });
+    }
+
+    // Push config update to pending queue for CLI to poll
+    await pushConfigUpdate(token, configUpdate);
+
+    // Update session metadata with new config (except stop which is transient)
+    if (!stop) {
+      const currentConfig = session.config || { fullAuto: false, autoSelectDelay: 20 };
+      const newConfig = { ...currentConfig };
+      if (fullAuto !== undefined) newConfig.fullAuto = fullAuto;
+      if (autoSelectDelay !== undefined) newConfig.autoSelectDelay = autoSelectDelay;
+      await updateSession(token, { config: newConfig });
+    }
+
+    return res.status(200).json({ success: true });
+  } catch (err) {
+    console.error('Error updating config:', err);
+    return res.status(500).json({ error: err.message });
+  }
+}

package/vercel-server/api/history/[token].js

@@ -42,6 +42,7 @@ export default async function handler(req, res) {
     return res.status(200).json({
       workflowName: session.workflowName,
       cliConnected: session.cliConnected,
+      config: session.config || { fullAuto: false, autoSelectDelay: 20 },
       entries,
     });
   } catch (err) {

package/vercel-server/api/ws/cli.js

@@ -14,6 +14,8 @@ import {
   setCLIConnected,
   addEvent,
   setEvents,
+  peekConfigUpdate,
+  popConfigUpdate,
   redis,
   KEYS,
 } from '../../lib/redis.js';
@@ -59,10 +61,14 @@ async function handlePost(req, res) {
   try {
     switch (action) {
       case 'session_init': {
-        const { workflowName, history } = body;
+        const { workflowName, history, config } = body;
 
-        // Create session
-        await createSession(sessionToken, { workflowName, cliConnected: true });
+        // Create session with initial config
+        await createSession(sessionToken, {
+          workflowName,
+          cliConnected: true,
+          config: config || null,
+        });
 
         // Replace events with the provided history snapshot (single source of truth)
         await setEvents(sessionToken, history || []);
@@ -140,7 +146,7 @@ async function handlePost(req, res) {
 }
 
 /**
- * Handle GET requests - long-poll for interaction responses
+ * Handle GET requests - long-poll for interaction responses and config updates
  * Uses efficient polling with 5-second intervals (Upstash doesn't support BLPOP)
  */
 async function handleGet(req, res) {
@@ -165,8 +171,7 @@ async function handleGet(req, res) {
 
     // Poll every 5 seconds (10 calls per 50s timeout vs 50 calls before)
     while (Date.now() - startTime < timeoutMs) {
-      // Peek at first item without removing (LINDEX 0)
-      // We only remove AFTER CLI confirms receipt via DELETE request
+      // Check for pending interactions first (higher priority)
       const pending = await redis.lindex(pendingKey, 0);
 
       if (pending) {
@@ -175,9 +180,6 @@ async function handleGet(req, res) {
         // Generate a receipt ID so CLI can confirm
         const receiptId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 
-        // DON'T remove yet - CLI will confirm with DELETE request
-        // This prevents data loss if response doesn't reach CLI
-
         return res.status(200).json({
           type: 'interaction_response',
           receiptId,
@@ -185,11 +187,24 @@ async function handleGet(req, res) {
         });
       }
 
-      // Wait 5 seconds before checking again (was 1 second)
+      // Check for pending config updates
+      const configUpdate = await peekConfigUpdate(token);
+
+      if (configUpdate) {
+        const receiptId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+        return res.status(200).json({
+          type: 'config_update',
+          receiptId,
+          ...configUpdate,
+        });
+      }
+
+      // Wait 5 seconds before checking again
       await new Promise((resolve) => setTimeout(resolve, 5000));
     }
 
-    // Timeout - no interaction received
+    // Timeout - no interaction or config update received
     return res.status(204).end();
   } catch (err) {
     console.error('Error polling for interactions:', err);
@@ -198,25 +213,29 @@ async function handleGet(req, res) {
 }
 
 /**
- * Handle DELETE requests - CLI confirms receipt of interaction
- * This removes the interaction from the pending queue
+ * Handle DELETE requests - CLI confirms receipt of interaction or config update
+ * This removes the item from the pending queue
  */
 async function handleDelete(req, res) {
-  const { token } = req.query;
+  const { token, type = 'interaction' } = req.query;
 
   if (!token) {
     return res.status(400).json({ error: 'Missing token parameter' });
   }
 
-  const channel = KEYS.interactions(token);
-  const pendingKey = `${channel}:pending`;
-
   try {
-    // Remove the first item (the one we just sent)
-    await redis.lpop(pendingKey);
+    if (type === 'config') {
+      // Remove pending config update
+      await popConfigUpdate(token);
+    } else {
+      // Remove pending interaction (default)
+      const channel = KEYS.interactions(token);
+      const pendingKey = `${channel}:pending`;
+      await redis.lpop(pendingKey);
+    }
     return res.status(200).json({ success: true });
   } catch (err) {
-    console.error('Error confirming interaction receipt:', err);
+    console.error('Error confirming receipt:', err);
     return res.status(500).json({ error: err.message });
   }
 }

package/vercel-server/local-server.js

@@ -42,6 +42,8 @@ function createSession(token, data) {
     cliConnected: true,
     history: data.history || [],
     pendingInteractions: [],
+    pendingConfigUpdates: [],
+    config: data.config || { fullAuto: false, autoSelectDelay: 20 },
     createdAt: Date.now(),
   };
   sessions.set(token, session);
@@ -66,6 +68,23 @@ function broadcastToSession(token, event) {
   }
 }
 
+/**
+ * Broadcast "update" to trigger browser refetch
+ * The browser SSE handler listens for this string to call fetchData()
+ */
+function broadcastUpdate(token) {
+  const clients = sseClients.get(token);
+  if (!clients) return;
+
+  for (const client of clients) {
+    try {
+      client.write('data: update\n\n');
+    } catch (e) {
+      clients.delete(client);
+    }
+  }
+}
+
 /**
  * Parse request body
  */
@@ -122,8 +141,8 @@ async function handleCliPost(req, res) {
 
   switch (action) {
     case 'session_init': {
-      const { workflowName, history } = body;
-      createSession(sessionToken, { workflowName, history });
+      const { workflowName, history, config } = body;
+      createSession(sessionToken, { workflowName, history, config });
 
       broadcastToSession(sessionToken, {
         type: 'cli_connected',
@@ -138,6 +157,9 @@ async function handleCliPost(req, res) {
         });
       }
 
+      // Trigger browser refetch to pick up config and latest state
+      broadcastUpdate(sessionToken);
+
       return sendJson(res, 200, { success: true });
     }
 
@@ -186,7 +208,7 @@ async function handleCliPost(req, res) {
 }
 
 /**
- * Handle CLI GET (long-poll for interactions)
+ * Handle CLI GET (long-poll for interactions and config updates)
  * Peeks at first item without removing - CLI confirms via DELETE
  */
 async function handleCliGet(req, res, query) {
@@ -204,11 +226,11 @@ async function handleCliGet(req, res, query) {
   const timeoutMs = Math.min(parseInt(timeout, 10), 55000);
   const startTime = Date.now();
 
-  // Poll for pending interactions
+  // Poll for pending interactions and config updates
   const checkInterval = setInterval(() => {
+    // Check interactions first (higher priority)
     if (session.pendingInteractions.length > 0) {
       clearInterval(checkInterval);
-      // Peek at first item WITHOUT removing - CLI will confirm via DELETE
       const interaction = session.pendingInteractions[0];
       return sendJson(res, 200, {
         type: 'interaction_response',
@@ -216,6 +238,16 @@ async function handleCliGet(req, res, query) {
       });
     }
 
+    // Check config updates
+    if (session.pendingConfigUpdates && session.pendingConfigUpdates.length > 0) {
+      clearInterval(checkInterval);
+      const configUpdate = session.pendingConfigUpdates[0];
+      return sendJson(res, 200, {
+        type: 'config_update',
+        ...configUpdate,
+      });
+    }
+
     if (Date.now() - startTime >= timeoutMs) {
       clearInterval(checkInterval);
       res.writeHead(204);
@@ -230,11 +262,11 @@ async function handleCliGet(req, res, query) {
 }
 
 /**
- * Handle CLI DELETE (confirm receipt of interaction)
- * Removes the first pending interaction after CLI confirms receipt
+ * Handle CLI DELETE (confirm receipt of interaction or config update)
+ * Removes the first pending item after CLI confirms receipt
  */
 function handleCliDelete(req, res, query) {
-  const { token } = query;
+  const { token, type = 'interaction' } = query;
 
   if (!token) {
     return sendJson(res, 400, { error: 'Missing token' });
@@ -245,9 +277,16 @@ function handleCliDelete(req, res, query) {
     return sendJson(res, 404, { error: 'Session not found' });
   }
 
-  // Remove the first pending interaction (the one we just sent)
-  if (session.pendingInteractions.length > 0) {
-    session.pendingInteractions.shift();
+  if (type === 'config') {
+    // Remove the first pending config update
+    if (session.pendingConfigUpdates && session.pendingConfigUpdates.length > 0) {
+      session.pendingConfigUpdates.shift();
+    }
+  } else {
+    // Remove the first pending interaction (default)
+    if (session.pendingInteractions.length > 0) {
+      session.pendingInteractions.shift();
+    }
   }
 
   return sendJson(res, 200, { success: true });
@@ -318,6 +357,7 @@ function handleHistoryGet(res, token) {
   return sendJson(res, 200, {
     workflowName: session.workflowName,
     cliConnected: session.cliConnected,
+    config: session.config || { fullAuto: false, autoSelectDelay: 20 },
     entries: session.history,
   });
 }
@@ -352,6 +392,47 @@ async function handleSubmitPost(req, res, token) {
   return sendJson(res, 200, { success: true });
 }
 
+/**
+ * Handle config update POST from browser
+ */
+async function handleConfigPost(req, res, token) {
+  const session = getSession(token);
+  if (!session) {
+    return sendJson(res, 404, { error: 'Session not found' });
+  }
+
+  if (!session.cliConnected) {
+    return sendJson(res, 503, { error: 'CLI is disconnected' });
+  }
+
+  const body = await parseBody(req);
+  const { fullAuto, autoSelectDelay, stop } = body;
+
+  // Build config update object
+  const configUpdate = {};
+  if (fullAuto !== undefined) configUpdate.fullAuto = fullAuto;
+  if (autoSelectDelay !== undefined) configUpdate.autoSelectDelay = autoSelectDelay;
+  if (stop !== undefined) configUpdate.stop = stop;
+
+  if (Object.keys(configUpdate).length === 0) {
+    return sendJson(res, 400, { error: 'No config fields provided' });
+  }
+
+  // Add to pending config updates for CLI to pick up
+  if (!session.pendingConfigUpdates) {
+    session.pendingConfigUpdates = [];
+  }
+  session.pendingConfigUpdates.push(configUpdate);
+
+  // Update session config (except stop which is transient)
+  if (!stop) {
+    if (fullAuto !== undefined) session.config.fullAuto = fullAuto;
+    if (autoSelectDelay !== undefined) session.config.autoSelectDelay = autoSelectDelay;
+  }
+
+  return sendJson(res, 200, { success: true });
+}
+
 /**
  * Serve session UI
  */
@@ -496,6 +577,12 @@ async function handleRequest(req, res) {
     return handleSubmitPost(req, res, submitMatch[1]);
   }
 
+  // Route: Config
+  const configMatch = pathname.match(/^\/api\/config\/([^/]+)$/);
+  if (configMatch && req.method === 'POST') {
+    return handleConfigPost(req, res, configMatch[1]);
+  }
+
   // Route: Static files
   if (pathname === '/') {
     const defaultToken = getDefaultSessionToken();