agent-state-machine 2.4.0 → 2.5.0

package/bin/cli.js

@@ -338,13 +338,7 @@ async function runOrResume(
     remoteUrl = process.env.STATE_MACHINE_REMOTE_URL || DEFAULT_REMOTE_URL;
   }
 
-  // Enable remote follow mode if we have a URL
-  if (remoteUrl) {
-    const sessionToken = ensureRemotePath(configFile, { forceNew: forceNewRemotePath });
-    await runtime.enableRemote(remoteUrl, { sessionToken, uiBaseUrl: useLocalServer });
-  }
-
-  // Set full-auto mode from CLI flag (will be merged with config.js during runWorkflow)
+  // Set full-auto mode from CLI flag BEFORE enabling remote (so session_init includes correct config)
   if (fullAuto) {
     runtime.workflowConfig.fullAuto = true;
     if (autoSelectDelay !== null) {
@@ -354,6 +348,12 @@ async function runOrResume(
     console.log(`\n\x1b[36m\x1b[1m⚡ Full-auto mode enabled\x1b[0m - Agent will auto-select recommended options after ${delay}s countdown`);
   }
 
+  // Enable remote follow mode if we have a URL
+  if (remoteUrl) {
+    const sessionToken = ensureRemotePath(configFile, { forceNew: forceNewRemotePath });
+    await runtime.enableRemote(remoteUrl, { sessionToken, uiBaseUrl: useLocalServer });
+  }
+
   // Set non-verbose mode from CLI flag
   if (nonVerbose) {
     runtime.workflowConfig.nonVerbose = true;

package/lib/remote/client.js

@@ -89,6 +89,7 @@ export class RemoteClient {
    * @param {string} options.serverUrl - Base URL of remote server (e.g., https://example.vercel.app)
    * @param {string} options.workflowName - Name of the workflow
    * @param {function} options.onInteractionResponse - Callback when interaction response received
+   * @param {function} [options.onConfigUpdate] - Callback when config update received from browser
    * @param {function} [options.onStatusChange] - Callback when connection status changes
    * @param {string} [options.sessionToken] - Optional session token to reuse
    * @param {boolean} [options.uiBaseUrl] - If true, return base URL for UI instead of /s/{token}
@@ -97,6 +98,7 @@ export class RemoteClient {
     this.serverUrl = options.serverUrl.replace(/\/$/, ''); // Remove trailing slash
     this.workflowName = options.workflowName;
     this.onInteractionResponse = options.onInteractionResponse;
+    this.onConfigUpdate = options.onConfigUpdate || (() => {});
     this.onStatusChange = options.onStatusChange || (() => {});
     this.uiBaseUrl = Boolean(options.uiBaseUrl);
 
@@ -166,16 +168,18 @@ export class RemoteClient {
   }
 
   /**
-   * Send initial session info with history
+   * Send initial session info with history and config
    * @param {Array} history - Array of history entries
+   * @param {object} [config] - Optional workflow config (fullAuto, autoSelectDelay)
    */
-  async sendSessionInit(history = []) {
+  async sendSessionInit(history = [], config = null) {
     this.initialHistorySent = true;
     await this.send({
       type: 'session_init',
       sessionToken: this.sessionToken,
       workflowName: this.workflowName,
       history,
+      config,
     });
   }
 
@@ -231,7 +235,7 @@ export class RemoteClient {
   }
 
   /**
-   * Poll for interaction responses
+   * Poll for interaction responses and config updates
    * Uses 35s timeout to stay under Vercel's 50s limit with buffer
    */
   async poll() {
@@ -246,20 +250,29 @@ export class RemoteClient {
         consecutiveErrors = 0; // Reset on success
 
         if (response.status === 200 && response.data) {
-          const { type, slug, targetKey, response: interactionResponse } = response.data;
+          const { type, slug, targetKey, response: interactionResponse, fullAuto, autoSelectDelay, stop } = response.data;
 
           if (type === 'interaction_response' && this.onInteractionResponse) {
             // Confirm receipt BEFORE processing - removes from Redis pending queue
-            // This ensures we don't lose the interaction if processing fails
             try {
               const confirmUrl = `${this.serverUrl}/api/ws/cli?token=${this.sessionToken}`;
               await makeRequest(confirmUrl, { method: 'DELETE' }, null, 10000);
             } catch (err) {
-              // Non-fatal - interaction will be re-delivered on next poll
               console.error(`${C.dim}Remote: Failed to confirm receipt: ${err.message}${C.reset}`);
             }
 
             this.onInteractionResponse(slug, targetKey, interactionResponse);
+          } else if (type === 'config_update') {
+            // Confirm receipt of config update
+            try {
+              const confirmUrl = `${this.serverUrl}/api/ws/cli?token=${this.sessionToken}&type=config`;
+              await makeRequest(confirmUrl, { method: 'DELETE' }, null, 10000);
+            } catch (err) {
+              console.error(`${C.dim}Remote: Failed to confirm config receipt: ${err.message}${C.reset}`);
+            }
+
+            // Call config update callback
+            this.onConfigUpdate({ fullAuto, autoSelectDelay, stop });
           }
         }
 

package/lib/runtime/agent.js

@@ -13,6 +13,8 @@ import { pathToFileURL } from 'url';
 import { getCurrentRuntime } from './runtime.js';
 import { formatInteractionPrompt } from './interaction.js';
 import { withChangeTracking } from './track-changes.js';
+import { resolveUnknownModel } from './model-resolution.js';
+import { detectAvailableCLIs } from '../llm.js';
 
 const require = createRequire(import.meta.url);
 
@@ -374,6 +376,23 @@ async function executeMDAgent(runtime, agentPath, name, params, options = {}) {
 
       const model = config.model || 'fast';
 
+      // Resolve model alias to actual model config for display
+      let resolvedModel = baseConfig.models?.[model];
+      if (!resolvedModel) {
+        // Auto-resolve unknown model (same logic as llm.js)
+        try {
+          resolvedModel = await resolveUnknownModel(model, baseConfig, runtime.workflowDir, {
+            availableCLIs: detectAvailableCLIs()
+          });
+          // Cache it for future use
+          if (!baseConfig.models) baseConfig.models = {};
+          baseConfig.models[model] = resolvedModel;
+          runtime.workflowConfig.models[model] = resolvedModel;
+        } catch {
+          resolvedModel = model; // Fallback to alias if resolution fails
+        }
+      }
+
       const fullPrompt = buildPrompt(context, {
         model,
         prompt: interpolatedPrompt,
@@ -381,7 +400,7 @@ async function executeMDAgent(runtime, agentPath, name, params, options = {}) {
         responseType: config.response
       });
 
-      await logAgentStart(runtime, name, fullPrompt);
+      await logAgentStart(runtime, name, fullPrompt, resolvedModel, model);
 
       console.log(`    Using model: ${model}`);
 
@@ -647,7 +666,7 @@ ${content}
   return response;
 }
 
-async function logAgentStart(runtime, name, prompt) {
+async function logAgentStart(runtime, name, prompt, model = null, modelAlias = null) {
   if (runtime._agentResumeFlags?.has(name)) {
     runtime._agentResumeFlags.delete(name);
     await runtime.prependHistory({
@@ -666,5 +685,13 @@ async function logAgentStart(runtime, name, prompt) {
     entry.prompt = prompt;
   }
 
+  if (model) {
+    entry.model = model;
+  }
+
+  if (modelAlias && modelAlias !== model) {
+    entry.modelAlias = modelAlias;
+  }
+
   await runtime.prependHistory(entry);
 }

package/lib/runtime/runtime.js

@@ -585,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
    */
@@ -779,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}`);
@@ -790,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.4.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/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();