onbuzz 5.1.0 → 5.4.0

package/src/tools/importAnalyzerTool.js

@@ -7,6 +7,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { BaseTool } from './baseTool.js';
 import TagParser from '../utilities/tagParser.js';
+import { parseModule, collectModuleInfo, analyzeCalls } from './importAnalysis/callableChecker.js';
 
 /**
  * Configuration constants for the import analyzer
@@ -23,6 +24,11 @@ const ANALYZER_CONFIG = {
   FILE_READ_TIMEOUT: 5000              // Timeout for reading large files
 };
 
+/** Sort key so high-confidence findings render first. */
+function confidenceRank(confidence) {
+  return confidence === 'high' ? 0 : confidence === 'medium' ? 1 : 2;
+}
+
 /**
  * ImportAnalyzerTool - Modern implementation
  * Analyzes JavaScript/TypeScript projects to detect broken imports, missing exports, and dependency issues
@@ -74,6 +80,14 @@ export class ImportAnalyzerTool extends BaseTool {
 - Missing exports (symbols not exported from target files)
 - Circular dependencies (files that depend on each other in a loop)
 - Unused exports (exports never imported anywhere)
+- "Not a function" calls (full/fix mode) — call sites that would throw
+  "<x> is not a function" / "<obj>.<method> is not a function" at runtime:
+  calling a renamed/removed/typo'd export, a default-vs-named mix-up, a
+  namespace object, or a non-function value/instance member. Each finding is
+  tagged with a confidence — high (resolved through the import/export graph),
+  medium (a local object/instance shape), or low (module has wildcard
+  re-exports, so it may be valid). Note: dynamic shapes are not analyzable
+  statically, so this catches the common resolvable cases, not literally all.
 
 **Examples:**
 
@@ -321,7 +335,9 @@ export class ImportAnalyzerTool extends BaseTool {
           totalFiles: results.summary.totalFiles,
           totalImports: results.summary.totalImports,
           totalExports: results.summary.totalExports,
-          issuesFound: results.fileNotFoundImports.length + Object.values(results.missingExports).reduce((sum, arr) => sum + arr.length, 0)
+          issuesFound: results.fileNotFoundImports.length
+            + Object.values(results.missingExports).reduce((sum, arr) => sum + arr.length, 0)
+            + (results.notCallable ? results.notCallable.length : 0)
         },
         output: output === 'json' ? formattedOutput : outputLines.join('\n'),
         results
@@ -358,6 +374,8 @@ export class ImportAnalyzerTool extends BaseTool {
     const missingFilesCount = results.fileNotFoundImports.length;
     const missingExportsCount = Object.values(results.missingExports).reduce((sum, arr) => sum + arr.length, 0);
     const circularDepsCount = results.circularDependencies ? results.circularDependencies.length : 0;
+    const notCallable = results.notCallable || [];
+    const notCallableByConfidence = (c) => notCallable.filter(f => f.confidence === c).length;
 
     if (missingFilesCount > 0) {
       lines.push(`❌ Missing files: ${missingFilesCount} imports pointing to non-existent files`);
@@ -371,7 +389,11 @@ export class ImportAnalyzerTool extends BaseTool {
       lines.push(`🔄 Circular dependencies: ${circularDepsCount} circular dependency chains detected`);
     }
 
-    if (missingFilesCount === 0 && missingExportsCount === 0 && circularDepsCount === 0) {
+    if (notCallable.length > 0) {
+      lines.push(`🚫 Not-a-function calls: ${notCallable.length} (high: ${notCallableByConfidence('high')}, medium: ${notCallableByConfidence('medium')}, low: ${notCallableByConfidence('low')})`);
+    }
+
+    if (missingFilesCount === 0 && missingExportsCount === 0 && circularDepsCount === 0 && notCallable.length === 0) {
       lines.push('✅ No import/export issues detected!');
     } else {
       lines.push('\n🔍 Top Issues to Fix:');
@@ -391,6 +413,14 @@ export class ImportAnalyzerTool extends BaseTool {
         });
       }
 
+      if (notCallable.length > 0) {
+        lines.push('\n  Not-a-function calls (high confidence first):');
+        [...notCallable]
+          .sort((a, b) => confidenceRank(a.confidence) - confidenceRank(b.confidence))
+          .slice(0, 3)
+          .forEach(f => lines.push(`    • ${f.file}:${f.line} — ${f.reason} [${f.confidence}]`));
+      }
+
       lines.push('\n💡 Run with output="detailed" for complete analysis and fix suggestions');
     }
 
@@ -507,12 +537,28 @@ export class ImportAnalyzerTool extends BaseTool {
       lines.push('      They might be used by external packages or could be removed');
     }
 
+    // "Not a function" call sites
+    const notCallable = results.notCallable || [];
+    if (notCallable.length > 0) {
+      lines.push('\n🚫 NOT-A-FUNCTION CALLS');
+      lines.push('────────────────────────');
+      lines.push('  Calls to a value that is not callable, by confidence');
+      lines.push('  (high = resolved via import/export graph; medium = local shape; low = best-effort).');
+      [...notCallable]
+        .sort((a, b) => confidenceRank(a.confidence) - confidenceRank(b.confidence))
+        .forEach((f) => {
+          lines.push(`\n  [${f.confidence}] ${f.file}:${f.line}:${f.column ?? 0}`);
+          lines.push(`    ${f.callee}() → ${f.reason}`);
+        });
+    }
+
     // Summary and recommendations
     lines.push('\n📋 RECOMMENDATIONS');
     lines.push('──────────────────');
 
     const totalIssues = results.fileNotFoundImports.length +
-                       Object.values(results.missingExports).reduce((sum, arr) => sum + arr.length, 0);
+                       Object.values(results.missingExports).reduce((sum, arr) => sum + arr.length, 0) +
+                       notCallable.length;
 
     if (totalIssues === 0) {
       lines.push('✅ Your import/export structure looks good!');
@@ -530,6 +576,10 @@ export class ImportAnalyzerTool extends BaseTool {
       if (results.circularDependencies && results.circularDependencies.length > 0) {
         lines.push(`  3. Refactor ${results.circularDependencies.length} circular dependency chain(s)`);
       }
+
+      if (notCallable.length > 0) {
+        lines.push(`  4. Investigate ${notCallable.length} "not a function" call site(s) — start with high-confidence ones`);
+      }
     }
 
     return lines.join('\n');
@@ -548,6 +598,7 @@ class ImportExportAnalyzer {
     this.imports = [];
     this.exports = new Map();
     this.dependencies = new Map(); // For circular dependency detection
+    this.moduleInfos = new Map();  // relKey → { ast, info } for the callable check
   }
 
   async loadIgnoreFile() {
@@ -941,6 +992,43 @@ class ImportExportAnalyzer {
     return unusedExports;
   }
 
+  /**
+   * Detect "<x> is not a function" / "<obj>.<method> is not a function" call
+   * sites by resolving each callee through the import/export graph and local
+   * bindings (see ./importAnalysis/callableChecker.js). Returns a flat list of
+   * findings, each tagged with a confidence (high|medium|low).
+   * @returns {Array<{file,line,column,callee,reason,confidence}>}
+   */
+  findNotCallable() {
+    const infoByKey = new Map();
+    for (const [key, { info }] of this.moduleInfos) infoByKey.set(key, info);
+
+    // Resolve an import source relative to the OWNING module's key, against the
+    // set of files we actually analyzed (sync; no fs — keys are project-relative
+    // POSIX paths from getRelativePath).
+    const resolveFrom = (ownerKey, source) => {
+      if (!source || !source.startsWith('.')) return null; // external/bare
+      const base = path.posix.normalize(path.posix.join(path.posix.dirname(ownerKey), source));
+      const candidates = ['', '.js', '.mjs', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts', '/index.jsx', '/index.tsx'];
+      for (const ext of candidates) {
+        const cand = base + ext;
+        if (infoByKey.has(cand)) return infoByKey.get(cand);
+      }
+      return null;
+    };
+    const resolve = (owner, source) => resolveFrom(owner.__key, source);
+
+    const findings = [];
+    for (const [key, { ast, info }] of this.moduleInfos) {
+      try {
+        findings.push(...analyzeCalls({ ast, info, file: key, resolve }));
+      } catch (error) {
+        this.logger?.warn?.('Callable check failed for file', { file: key, error: error.message });
+      }
+    }
+    return findings;
+  }
+
   async analyze(mode = 'full') {
     this.logger?.info('Starting import analysis', { mode, rootDir: this.rootDir });
 
@@ -960,6 +1048,17 @@ class ImportExportAnalyzer {
 
         const fileExports = this.parseExports(content);
         this.exports.set(relativeFile, fileExports);
+
+        // AST-level module info for the "not a function" call check (full/fix).
+        if (mode === 'full' || mode === 'fix') {
+          const ext = path.extname(file);
+          const ast = parseModule(content, { ts: ext === '.ts' || ext === '.tsx' });
+          if (ast) {
+            const info = collectModuleInfo(ast);
+            info.__key = relativeFile;
+            this.moduleInfos.set(relativeFile, { ast, info });
+          }
+        }
       } catch (error) {
         // Skip files with errors
         this.logger?.warn('Error parsing file', { file, error: error.message });
@@ -1042,6 +1141,7 @@ class ImportExportAnalyzer {
       this.logger?.info('Running full analysis');
       results.circularDependencies = this.findCircularDependencies();
       results.unusedExports = this.findUnusedExports();
+      results.notCallable = this.findNotCallable();
     }
 
     this.logger?.info('Analysis complete', {

package/src/tools/openaiFunctionSchemas.js

@@ -22,6 +22,8 @@
  * remains tool-agnostic.
  */
 
+import { applyMustHaveCapabilities } from '../utilities/mustHaveCapabilities.js';
+
 export const OPENAI_FUNCTION_SCHEMAS = [
   // TaskManager — actions-array with flat task fields per action.
   // Field names mirror the tool's system-prompt protocol (src/tools/taskManagerTool.js
@@ -1009,16 +1011,23 @@ export const OPENAI_FUNCTION_SCHEMAS = [
  * Keeps the model's tool list minimal — it sees only what the agent actually
  * has access to, which also reduces prompt size and ambiguity.
  *
+ * Must-have tools (taskmanager always; jobdone in AGENT mode) are force-added
+ * to any explicit capability list, mirroring how the system-prompt builder
+ * force-injects `help`. An empty list still means "full catalog" (which already
+ * contains them), so we only augment a non-empty list.
+ *
  * @param {string[]} capabilities - Agent capabilities (matches tool ids)
+ * @param {string} [mode] - Agent mode ('agent' | 'chat'); gates jobdone.
  * @returns {Array} Function schemas the agent is allowed to invoke
  */
-export function getToolSchemasForAgent(capabilities = []) {
+export function getToolSchemasForAgent(capabilities = [], mode) {
   if (!Array.isArray(capabilities) || capabilities.length === 0) {
     // Agent has no capability list — give it the full catalog rather than
     // leaving it tool-less. Matches the CLI's existing "include all" fallback.
     return OPENAI_FUNCTION_SCHEMAS;
   }
-  const allowed = new Set(capabilities.map(c => String(c).toLowerCase()));
+  const effective = applyMustHaveCapabilities(capabilities, mode);
+  const allowed = new Set(effective.map(c => String(c).toLowerCase()));
   return OPENAI_FUNCTION_SCHEMAS.filter(s => allowed.has(s.name.toLowerCase()));
 }
 

package/src/tools/userPromptTool.js

@@ -24,7 +24,58 @@ class UserPromptTool extends BaseTool {
     // Tool metadata
     this.requiresProject = false;
     this.isAsync = false; // Blocks until user responds
-    this.timeout = 5 * 60 * 1000; // 5 minute timeout
+    this.timeout = 5 * 60 * 1000; // fallback default (5 min) when estimation yields nothing
+  }
+
+  // Timeout estimation bounds (a human answering a modal). A "closed" question
+  // (options only, no free text) is quick to click; an "open" one (free text)
+  // takes longer to type. Summed, then clamped so we never nag too fast or wait
+  // absurdly long by default.
+  static TIMEOUT_CLOSED_MS = 60 * 1000;   // 1 min per closed question
+  static TIMEOUT_OPEN_MS = 3 * 60 * 1000; // 3 min per open (free-text) question
+  static TIMEOUT_FLOOR_MS = 2 * 60 * 1000;
+  static TIMEOUT_CAP_MS = 15 * 60 * 1000;
+
+  /**
+   * Estimate a timeout from the question mix: 1 min per closed question, 3 min
+   * per open (free-text) one, clamped to [floor, cap].
+   * @param {Array} questions
+   * @returns {number} milliseconds
+   */
+  _estimateTimeoutMs(questions) {
+    const list = Array.isArray(questions) ? questions : [];
+    let ms = 0;
+    for (const q of list) {
+      const isOpen = q?.allowFreeText !== false; // free text allowed => "open"
+      ms += isOpen ? UserPromptTool.TIMEOUT_OPEN_MS : UserPromptTool.TIMEOUT_CLOSED_MS;
+    }
+    if (ms <= 0) return this.timeout; // no questions parsed yet → default
+    return Math.max(UserPromptTool.TIMEOUT_FLOOR_MS, Math.min(UserPromptTool.TIMEOUT_CAP_MS, ms));
+  }
+
+  /**
+   * Resolve the effective timeout for a prompt. Precedence:
+   *   1. explicit per-call override (params.timeoutMs / params.timeout, minutes-agnostic ms)
+   *   2. per-agent tool config (context.toolConfig.userprompt-style: { strategy, fixedMinutes })
+   *   3. estimated default (1 min closed / 3 min open, clamped)
+   * Returns `null` to mean "no auto-timeout" (strategy: 'none').
+   * @param {Object} params
+   * @param {Object} [toolConfig]
+   * @returns {number|null}
+   */
+  _resolveTimeoutMs(params, toolConfig) {
+    const explicit = Number(params?.timeoutMs ?? params?.timeout);
+    if (Number.isFinite(explicit) && explicit > 0) return explicit;
+
+    const cfg = (toolConfig && typeof toolConfig === 'object') ? toolConfig : {};
+    const strategy = cfg.strategy || 'estimated';
+    if (strategy === 'none') return null;
+    if (strategy === 'fixed') {
+      const mins = Number(cfg.fixedMinutes);
+      if (Number.isFinite(mins) && mins > 0) return mins * 60 * 1000;
+      return this.timeout;
+    }
+    return this._estimateTimeoutMs(params?.questions);
   }
 
   /**
@@ -133,7 +184,10 @@ The user's responses will be returned as a formatted message containing:
 BEHAVIOR:
 - Agent execution PAUSES while waiting for user response
 - User sees a modal with the questions in the chat interface
-- Default timeout: 5 minutes (then resumes with timeout error)
+- Timeout is estimated from the questions (~1 min per options-only question,
+  ~3 min per free-text question, clamped 2-15 min) unless the agent/user
+  overrides it. Pass "timeoutMs" to set an explicit timeout; on timeout the
+  agent resumes with a timeout error.
 - Use sparingly - only when user input is truly necessary
     `;
   }
@@ -228,6 +282,9 @@ BEHAVIOR:
     const promptService = getPromptService(this.logger);
     let agent = null;
 
+    // Resolve the timeout: explicit override → per-agent tool config → estimate.
+    const resolvedTimeout = this._resolveTimeoutMs(params, context.toolConfig);
+
     try {
       // Create prompt request
       const { requestInfo, promise } = promptService.createPromptRequest(
@@ -236,7 +293,7 @@ BEHAVIOR:
           message: params.message,
           questions: params.questions
         },
-        { timeout: this.timeout }
+        { timeout: resolvedTimeout }
       );
 
       // Block scheduling while waiting for user input.
@@ -323,23 +380,12 @@ BEHAVIOR:
         result.response
       );
 
-      // CRITICAL FIX: In CHAT mode, tool results alone don't trigger processing
-      // Queue the user's response as a user message to ensure continuation
-      if (agent && this.agentPool && agent.mode === 'chat') {
-        this.logger?.info('[UserPromptTool] CHAT mode - queueing response as user message to trigger continuation', {
-          agentId,
-          mode: agent.mode
-        });
-
-        // Queue the formatted response as a user message
-        await this.agentPool.addUserMessage(agentId, {
-          role: 'user',
-          content: `[User Response to Agent Prompt]\n\n${formattedResponse}`,
-          type: 'prompt-response',
-          promptRequestId: requestInfo.requestId,
-          timestamp: new Date().toISOString()
-        });
-      }
+      // NOTE: CHAT-mode continuation used to require queueing the response as a
+      // synthetic user message, because tool results alone didn't re-schedule a
+      // CHAT agent. That's no longer needed — shouldAgentBeActive now activates
+      // CHAT agents on queued tool results, so this tool's own result continues
+      // the agent naturally (see agentActivityService.js). Returning the result
+      // is sufficient for both CHAT and AGENT modes.
 
       return {
         success: true,

package/src/tools/webTool.js

@@ -145,6 +145,23 @@ import { BROWSER_CONFIG, KNOWN_SITES } from '../utilities/stealthConstants.js';
 // Credential vault for secure authentication
 import { getCredentialVault } from '../services/credentialVault.js';
 
+/**
+ * Actions that simulate genuine human input (and therefore warrant a human-like
+ * pacing delay under stealth). Read/observe actions — snapshot, extract-*,
+ * get-source, get-console, get-field-values, evaluate, screenshot, wait* — emit
+ * NO input events, so a human delay after them buys zero stealth and only adds
+ * latency. Scoping the per-action delay to this set keeps 'maximum' stealth
+ * believable on the steps that matter while making observation steps fast.
+ */
+const HUMAN_PACED_ACTIONS = new Set([
+  'click', 'type', 'press', 'hover', 'scroll', 'select', 'submit', 'navigate', 'mouse-move',
+]);
+
+/** True iff an action should incur a human-pacing delay (under humanMode). */
+function isHumanPacedAction(action) {
+  return HUMAN_PACED_ACTIONS.has(action?.type || action?.action);
+}
+
 class WebTool extends BaseTool {
   constructor(config = {}, logger = null) {
     super(config, logger);
@@ -160,6 +177,11 @@ class WebTool extends BaseTool {
 
     // Tab tracking: Map<agentId, Map<tabName, tabInfo>>
     this.agentTabs = new Map();
+    // Per-agent "current tab" — the tab that top-level actions and bare
+    // switch-tab target. Lets an agent keep interacting with an already-open
+    // page (no reload) instead of re-opening a tab (which wipes page state
+    // like a chatbot conversation). agentId → tabName.
+    this.agentActiveTab = new Map();
 
     // Content offload (web-content → document memory). Large fetched content
     // is persisted + indexed instead of dumped into the conversation; the
@@ -326,6 +348,21 @@ it. Pass "pinned": false to unpin.
 - Navigation: navigate, wait-for, wait (time-based delay)
 - Input: click, type, press, hover, scroll, select, submit
 - Extract: extract-text, extract-links, get-source, screenshot, get-field-values, evaluate
+- Observe (preferred): snapshot — returns the page's interactive elements as a
+  compact role+name list (cheaper and more reliable than screenshots/get-source).
+
+## EFFICIENT MULTI-STEP INTERACTION (IMPORTANT — avoids reloading the page)
+To keep interacting with a page you already opened (a chatbot conversation, a
+multi-step form, anything stateful), DO NOT call open-tab with a url again —
+that RELOADS the page and wipes its in-memory state. Instead:
+- Open ONCE: \`{"type":"open-tab","name":"chat","url":"https://…","nestedActions":[…]}\`
+- Then each subsequent turn, reuse the SAME tab WITHOUT a url:
+  \`{"type":"switch-tab","name":"chat","nestedActions":[{"type":"type","selector":"#input","text":"hi"},{"type":"click","selector":"#send"},{"type":"snapshot"}]}\`
+- Top-level actions also run on the current tab, e.g.
+  \`{"toolId":"web","operation":"interactive","actions":[{"type":"snapshot"}]}\`.
+Use \`snapshot\` to see what's on the page; prefer stable selectors / visible text.
+Leave stealthLevel at the default ('standard', headless = fast); only set
+'maximum' (visible browser, slower) if a site actively blocks automation.
 
 ## FORM FILLING WORKFLOW (RECOMMENDED)
 
@@ -823,7 +860,12 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         case 'interactive':
           result = await this.interactive(params.actions, {
             stealthLevel: effectiveStealthLevel,
-            humanMode: params.humanMode !== false, // Default true for anti-detection
+            // Human-like delays only matter for anti-bot stealth and add real
+            // latency to every action. Default them OFF for speed; enable
+            // automatically under 'maximum' stealth, or when explicitly set.
+            humanMode: params.humanMode !== undefined
+              ? params.humanMode !== false
+              : effectiveStealthLevel === 'maximum',
             agentId,
             context
           });
@@ -1570,27 +1612,50 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
               agentId, action.name, action.url, headless,
               action.nestedActions || action.actions, context, { humanMode }
             );
+            // The opened tab becomes the active tab for subsequent top-level
+            // actions / bare switch-tab.
+            if (actionResult?.success !== false && action.name) {
+              this.agentActiveTab.set(agentId, action.name);
+            }
             break;
 
           case 'close-tab':
             actionResult = await this.closeTab(agentId, action.name);
+            if (this.agentActiveTab.get(agentId) === action.name) {
+              this.agentActiveTab.delete(agentId);
+            }
             break;
 
           case 'switch-tab':
-            actionResult = await this.switchTab(agentId, action.name);
+            // switch-tab may carry nestedActions — run them on the target tab
+            // WITHOUT reloading it (the key to multi-step interaction that
+            // preserves in-page state).
+            actionResult = await this.switchTab(
+              agentId, action.name, action.nestedActions || action.actions, context
+            );
             break;
 
           case 'list-tabs':
             actionResult = await this.listTabs(agentId);
             break;
 
-          default:
-            // For actions that need a tab context, we need to specify which tab
-            // For now, we'll skip these at the top level
-            actionResult = {
-              success: false,
-              error: `Action ${actionType} must be executed within a tab context (use open-tab with nestedActions)`
-            };
+          default: {
+            // A non-tab action at the top level (type/click/evaluate/snapshot/…)
+            // runs against the agent's ACTIVE tab — so the agent doesn't have to
+            // re-open (and reload) a tab just to interact with the open page.
+            const activeName = this.agentActiveTab.get(agentId);
+            const tabsMap = this.agentTabs.get(agentId);
+            const activeTab = activeName && tabsMap ? tabsMap.get(activeName) : null;
+            if (!activeTab) {
+              actionResult = {
+                success: false,
+                error: `Action '${actionType}' has no active tab to run on. Open a tab first with open-tab, or nest the action inside open-tab/switch-tab.`
+              };
+            } else {
+              const { results: oneResults } = await this._runActionsOnTab(activeTab, [action], context);
+              actionResult = oneResults[0];
+            }
+          }
         }
 
         results.push({
@@ -2151,7 +2216,8 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
 
         results.push(actionEntry);
         existingTab.lastActivity = Date.now();
-        if (humanMode) await humanWait('action');
+        // Pace only genuine input actions — observation steps need no delay.
+        if (humanMode && isHumanPacedAction(nestedAction)) await humanWait('action');
       }
 
       const failedActions = results.filter(r => r.success === false);
@@ -2368,8 +2434,9 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         results.push(actionEntry);
         tabInfo.lastActivity = Date.now();
 
-        // Human-like delay between actions
-        if (humanMode) {
+        // Human-like delay between actions — only for genuine input actions
+        // (observation steps emit no input events, so pacing them is dead time).
+        if (humanMode && isHumanPacedAction(action)) {
           await humanWait('action');
         }
       }
@@ -2721,6 +2788,48 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         return { success: true, html };
       }
 
+      case 'snapshot':
+      case 'accessibility-snapshot': {
+        // Token-efficient structured observation: the accessibility tree pruned
+        // to interactive/semantic elements (role + accessible name), instead of
+        // a screenshot or full HTML. Lets the agent reason about — and act on —
+        // elements by role/name (the modern agent-browser pattern), which is far
+        // cheaper and more reliable than pixels or raw DOM.
+        try {
+          const tree = await page.accessibility.snapshot({ interestingOnly: true });
+          const INTERACTIVE = new Set([
+            'button', 'link', 'textbox', 'searchbox', 'combobox', 'checkbox',
+            'radio', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'tab',
+            'switch', 'slider', 'option', 'listbox', 'textfield', 'spinbutton',
+          ]);
+          const elements = [];
+          const walk = (node) => {
+            if (!node) return;
+            const role = node.role;
+            const name = (node.name || '').trim();
+            if (INTERACTIVE.has(role) || (role === 'heading' && name)) {
+              const el = { role, name: name.slice(0, 120) };
+              if (node.value != null && node.value !== '') el.value = String(node.value).slice(0, 80);
+              if (node.checked != null) el.checked = node.checked;
+              if (node.disabled) el.disabled = true;
+              elements.push(el);
+            }
+            for (const child of (node.children || [])) walk(child);
+          };
+          walk(tree);
+          const max = Number.isInteger(action.limit) && action.limit > 0 ? action.limit : 150;
+          return {
+            success: true,
+            url: page.url(),
+            elementCount: elements.length,
+            elements: elements.slice(0, max),
+            ...(elements.length > max && { truncated: elements.length - max })
+          };
+        } catch (snapErr) {
+          return { success: false, error: `Snapshot failed: ${snapErr.message}` };
+        }
+      }
+
       case 'get-console':
         return {
           success: true,
@@ -3285,7 +3394,7 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
    * @param {string} tabName - Tab name to switch to
    * @returns {Promise<Object>} Result
    */
-  async switchTab(agentId, tabName) {
+  async switchTab(agentId, tabName, nestedActions = null, context = {}) {
     const agentTabsMap = this.agentTabs.get(agentId);
     if (!agentTabsMap || !agentTabsMap.has(tabName)) {
       throw new Error(`Tab '${tabName}' not found for agent ${agentId}`);
@@ -3293,6 +3402,24 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
 
     const tabInfo = agentTabsMap.get(tabName);
     tabInfo.lastActivity = Date.now();
+    this.agentActiveTab.set(agentId, tabName);
+
+    // If actions are attached, run them on this tab WITHOUT navigating — this is
+    // how an agent continues a multi-step interaction (e.g. a chatbot turn) on
+    // an already-loaded page instead of re-opening it (which would reload and
+    // wipe the page's in-memory state).
+    if (Array.isArray(nestedActions) && nestedActions.length > 0) {
+      const { results, failed } = await this._runActionsOnTab(tabInfo, nestedActions, context);
+      const currentUrl = (tabInfo.page?.url?.() ) || tabInfo.url;
+      return {
+        success: failed === 0,
+        tabName,
+        url: currentUrl,
+        actionsExecuted: results.length,
+        results,
+        ...(failed > 0 && { warning: `${failed} of ${results.length} action(s) failed` })
+      };
+    }
 
     return {
       success: true,
@@ -3302,6 +3429,53 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
     };
   }
 
+  /**
+   * Run a list of actions against an already-open tab's page WITHOUT navigating,
+   * collecting per-action JS/network/HTTP/console errors (mirrors the per-action
+   * diagnostics openTab attaches). Shared by switch-tab's nestedActions and by
+   * top-level actions that target the active tab. This is the path that lets an
+   * agent keep interacting with a loaded page — no reload, so in-page state
+   * (a chatbot conversation, a multi-step form) survives across turns.
+   *
+   * @param {object} tabInfo  Stored tab record ({ page, pageErrors, ... }).
+   * @param {Array}  actions
+   * @param {object} [context]
+   * @returns {Promise<{results: Array, failed: number}>}
+   */
+  async _runActionsOnTab(tabInfo, actions, context = {}) {
+    const results = [];
+    const { humanMode = false } = tabInfo;
+    for (const action of (actions || [])) {
+      const preJs = (tabInfo.pageErrors || []).length;
+      const preNet = (tabInfo.networkFailures || []).length;
+      const preHttp = (tabInfo.httpErrors || []).length;
+      const preCon = (tabInfo.consoleMessages || []).filter(m => m.type === 'error').length;
+
+      let actionResult;
+      try {
+        actionResult = await this.executeTabAction(tabInfo.page, action, tabInfo, context);
+      } catch (err) {
+        actionResult = { success: false, error: err.message };
+      }
+
+      const entry = { action: action.type || action.action, ...actionResult };
+      const dJs = WebTool._dedupeErrors((tabInfo.pageErrors || []).slice(preJs).map(e => e.message));
+      const dNet = WebTool._dedupeErrors((tabInfo.networkFailures || []).slice(preNet).map(f => `${f.method} ${f.url} → ${f.errorText}`));
+      const dHttp = WebTool._dedupeErrors((tabInfo.httpErrors || []).slice(preHttp).map(e => `${e.method} ${e.url} → ${e.status}`));
+      const dCon = WebTool._dedupeErrors((tabInfo.consoleMessages || []).filter(m => m.type === 'error').slice(preCon).map(e => e.text));
+      if (dJs.length) entry.jsErrors = dJs;
+      if (dNet.length) entry.networkFailures = dNet;
+      if (dHttp.length) entry.httpErrors = dHttp;
+      if (dCon.length) entry.consoleErrors = dCon;
+
+      results.push(entry);
+      tabInfo.lastActivity = Date.now();
+      // Pace only genuine input actions — observation steps need no delay.
+      if (humanMode && isHumanPacedAction(action)) await humanWait('action');
+    }
+    return { results, failed: results.filter(r => r.success === false).length };
+  }
+
   /**
    * List all active tabs for an agent
    * @param {string} agentId - Agent identifier