onbuzz 5.0.2 → 5.3.0

package/src/tools/webTool.js

@@ -119,6 +119,9 @@
 
 import { BaseTool } from './baseTool.js';
 import TagParser from '../utilities/tagParser.js';
+import { DocumentStore } from '../services/documents/documentStore.js';
+import { DocumentMemory } from '../services/documents/documentMemory.js';
+import { DocumentIndexer } from '../services/embeddings/indexers/documentIndexer.js';
 import path from 'path';
 import fs from 'fs/promises';
 import os from 'os';
@@ -142,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);
@@ -157,6 +177,18 @@ 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
+    // tool returns a compact handle + preview. Thresholds are config-tunable.
+    this.contentOffloadThreshold = config.contentOffloadThreshold ?? 4000; // chars
+    this.contentPreviewChars = config.contentPreviewChars ?? 800;
+    this._documentMemory = null; // lazy — embeddingService is attached late
 
     // Known search engines
     this.searchEngines = [
@@ -275,8 +307,31 @@ First FETCH the login page to identify form selectors, then authenticate:
 \`\`\`json
 {"toolId": "web", "operation": "fetch", "url": "https://example.com", "formats": ["title", "text", "links"]}
 \`\`\`
+LARGE PAGES ARE AUTO-SAVED: when a page is big, FETCH does NOT return the full
+text. It saves the content as a searchable "document" and returns a preview +
+a document handle (docId, lines) + a recallHint. To get the parts you need,
+add a "goal" so FETCH returns the most relevant passages immediately, then use
+RECALL (below) or read exact lines with the code-map tool's read-range:
+\`\`\`json
+{"toolId": "web", "operation": "fetch", "url": "https://example.com/long-article", "goal": "pricing tiers and limits"}
+\`\`\`
 
-3. INTERACTIVE - Browser automation
+3. RECALL - Semantic search over content you previously fetched (no browser)
+\`\`\`json
+{"toolId": "web", "operation": "recall", "query": "what are the rate limits?", "topK": 5}
+\`\`\`
+Optional "docId" restricts the search to one saved document. Each hit returns
+the matching passage plus its source docId and line range (lineStart/lineEnd)
+so you can read the full passage via code-map read-range.
+
+4. PIN - Keep an important saved document forever (never auto-evicted)
+\`\`\`json
+{"toolId": "web", "operation": "pin", "docId": "doc-...", "pinned": true}
+\`\`\`
+Pin a document you'll need long-term so retention-based cleanup never drops
+it. Pass "pinned": false to unpin.
+
+5. INTERACTIVE - Browser automation
 \`\`\`json
 {"toolId": "web", "operation": "interactive", "stealthLevel": "maximum", "actions": [
   {"type": "open-tab", "name": "main", "url": "https://example.com", "nestedActions": [
@@ -293,6 +348,21 @@ First FETCH the login page to identify form selectors, then authenticate:
 - 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)
 
@@ -744,10 +814,29 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
 
       // Ensure browser is initialized with the correct stealth level
       // Note: Each operation also calls ensureBrowser internally, but this pre-check
-      // ensures we don't unnecessarily restart the browser
-      await this.ensureBrowser({ stealthLevel: effectiveStealthLevel });
+      // ensures we don't unnecessarily restart the browser.
+      // `recall`/`pin` are pure document-memory operations — no browser
+      // needed, so we skip the (expensive) launch for them.
+      if (operation !== 'recall' && operation !== 'pin') {
+        await this.ensureBrowser({ stealthLevel: effectiveStealthLevel });
+      }
 
       switch (operation) {
+        case 'recall':
+          result = await this.recall(params.query, {
+            agentId,
+            docId: params.docId,
+            topK: params.topK,
+          });
+          break;
+
+        case 'pin':
+          result = await this.pinDocument(params.docId, {
+            agentId,
+            pinned: params.pinned !== undefined ? params.pinned : true,
+          });
+          break;
+
         case 'search':
           result = await this.search(params.query, {
             engine: params.engine || 'duckduckgo',
@@ -761,14 +850,22 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
           result = await this.fetch(params.url, {
             formats: params.formats || ['title', 'text'],
             stealthLevel: effectiveStealthLevel,
-            agentId
+            agentId,
+            // Optional: when the agent states what it's after, fetch returns
+            // the most relevant passages of large content immediately.
+            goal: params.goal
           });
           break;
 
         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
           });
@@ -844,6 +941,21 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         ...(result.title !== undefined && { title: result.title }),
         ...(result.text !== undefined && { text: result.text }),
         ...(result.url !== undefined && { url: result.url }),
+        // Content-offload handle (large fetches): hoist so the agent sees the
+        // document reference + recall guidance instead of an inline body.
+        ...(result.contentExternalized && { contentExternalized: true }),
+        ...(result.document !== undefined && { document: result.document }),
+        ...(result.textPreview !== undefined && { textPreview: result.textPreview }),
+        ...(result.recallHint !== undefined && { recallHint: result.recallHint }),
+        ...(result.relevantChunks !== undefined && { relevantChunks: result.relevantChunks }),
+        ...(result.htmlOmitted !== undefined && { htmlOmitted: result.htmlOmitted }),
+        // RECALL operation results.
+        ...(result.hits !== undefined && { hits: result.hits }),
+        ...(result.count !== undefined && { count: result.count }),
+        ...(result.query !== undefined && { query: result.query }),
+        ...(result.note !== undefined && { note: result.note }),
+        // PIN operation result.
+        ...(result.pinned !== undefined && { pinned: result.pinned }),
         ...(result.results !== undefined && { results: result.results }),
         ...(result.resultsCount !== undefined && { resultsCount: result.resultsCount }),
         ...(result.httpStatus !== undefined && { httpStatus: result.httpStatus }),
@@ -1173,8 +1285,167 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
    * @param {Object} options - Fetch options
    * @returns {Promise<Object>} Fetched content
    */
+  /**
+   * Lazy accessor for the per-tool DocumentMemory (store + index).
+   *
+   * Why lazy: the EmbeddingService is attached to aiService AFTER tool
+   * construction (mirrors MemoryTool._getMemoryIndexer). The DocumentStore
+   * works regardless of embeddings; the indexer no-ops when the service is
+   * missing/disabled, so content is always persisted (just not searchable
+   * until embeddings are configured).
+   *
+   * @returns {DocumentMemory}
+   * @private
+   */
+  _getDocumentMemory() {
+    if (this._documentMemory) return this._documentMemory;
+    const svc = this.aiService?.getEmbeddingService?.() || null;
+    const store = new DocumentStore({ logger: this.logger });
+    const indexer = new DocumentIndexer({ embeddingService: svc, logger: this.logger });
+    this._documentMemory = new DocumentMemory({ store, indexer, logger: this.logger });
+    return this._documentMemory;
+  }
+
+  /**
+   * Offload large fetched content to document memory and return a compact
+   * handle in place of the body. No-op (returns the result unchanged) when:
+   * there's no agentId, the content is below threshold, or persistence fails.
+   *
+   * The heavy `text`/`html` fields are replaced with a preview + a `document`
+   * handle (docId/lines/etc.) so the agent can recall passages semantically or
+   * read exact lines via code-map read-range — without the body ever entering
+   * the conversation (and thus surviving compaction).
+   *
+   * @param {object} result   The fetch result (mutated copy returned).
+   * @param {{agentId?: string, url: string, goal?: string}} ctx
+   * @returns {Promise<{externalized: boolean, result: object}>}
+   * @private
+   */
+  async _maybeOffload(result, { agentId, url, goal } = {}) {
+    const text = typeof result.text === 'string' ? result.text : null;
+    const html = typeof result.html === 'string' ? result.html : null;
+    const primary = text ?? html; // text is what agents reason over; prefer it
+    if (!agentId || !primary || primary.length < this.contentOffloadThreshold) {
+      return { externalized: false, result };
+    }
+
+    const mem = this._getDocumentMemory();
+    let handle;
+    try {
+      handle = await mem.remember(agentId, {
+        source: url,
+        title: result.title || url,
+        content: primary,
+      });
+    } catch (err) {
+      this.logger?.warn?.('[WebTool] content offload failed; returning inline', { url, error: err?.message });
+      return { externalized: false, result };
+    }
+
+    const out = { ...result };
+    if (text !== null) { delete out.text; out.textPreview = text.slice(0, this.contentPreviewChars); }
+    if (html !== null) { delete out.html; out.htmlOmitted = true; }
+    out.contentExternalized = true;
+    out.document = {
+      docId: handle.docId,
+      source: handle.source,
+      title: handle.title,
+      bytes: handle.bytes,
+      lines: handle.lines,
+      chunkCount: handle.chunkCount,
+      indexed: handle.indexed,
+      embeddingsEnabled: handle.embeddingsEnabled,
+    };
+    out.recallHint = handle.embeddingsEnabled
+      ? `Full content saved as document ${handle.docId} (${handle.lines} lines). Retrieve relevant passages by semantic recall over your saved documents, or read exact lines with code-map read-range on the saved file.`
+      : `Full content saved as document ${handle.docId} (${handle.lines} lines), but semantic recall is OFF — set an embeddings provider in Settings to enable search. You can still read it with code-map read-range.`;
+
+    // Goal-aware: surface the most relevant passages immediately so the common
+    // case is one round-trip (fetch → use), not fetch-then-recall.
+    if (goal && handle.embeddingsEnabled) {
+      try {
+        const recall = await mem.recall(agentId, goal, { topK: 3, docId: handle.docId });
+        out.relevantChunks = (recall.hits || []).map((h) => ({
+          lineStart: h.lineStart, lineEnd: h.lineEnd, text: h.text,
+        }));
+      } catch { /* best-effort */ }
+    }
+
+    return { externalized: true, result: out };
+  }
+
+  /**
+   * Semantic/hybrid recall over content this agent previously fetched (the
+   * `documents` surface). No browser involved.
+   *
+   * @param {string} query
+   * @param {object} options
+   * @param {string} options.agentId
+   * @param {string} [options.docId]  Restrict to a single saved document.
+   * @param {number} [options.topK=8]
+   * @returns {Promise<object>} { success, query, count, hits[], note? }
+   */
+  async recall(query, options = {}) {
+    const { agentId, docId, topK } = options;
+    if (!query || typeof query !== 'string' || query.trim().length === 0) {
+      return { success: false, error: 'A non-empty "query" is required for the recall operation' };
+    }
+    if (!agentId) {
+      return { success: false, error: 'recall requires an agent context' };
+    }
+
+    const mem = this._getDocumentMemory();
+    if (!mem.embeddingsEnabled) {
+      return {
+        success: true,
+        query,
+        count: 0,
+        hits: [],
+        note: 'Semantic recall is OFF — set an embeddings provider in Settings to search saved web documents. You can still read a known document by docId via code-map read-range.',
+      };
+    }
+
+    const res = await mem.recall(agentId, query, {
+      topK: typeof topK === 'number' && topK > 0 ? topK : 8,
+      ...(docId ? { docId } : {}),
+    });
+    const hits = (res.hits || []).map((h) => ({
+      docId: h.docId,
+      title: h.title,
+      source: h.source,
+      lineStart: h.lineStart,
+      lineEnd: h.lineEnd,
+      score: h.score,
+      text: h.text,
+    }));
+    return { success: true, query, count: hits.length, hits };
+  }
+
+  /**
+   * Pin (or unpin) a saved document so it is never evicted regardless of
+   * retention. Browserless.
+   *
+   * @param {string} docId
+   * @param {object} options  { agentId, pinned=true }
+   * @returns {Promise<object>} { success, docId, pinned } or { success:false, error }
+   */
+  async pinDocument(docId, options = {}) {
+    const { agentId, pinned = true } = options;
+    if (!docId || typeof docId !== 'string') {
+      return { success: false, error: 'A "docId" is required for the pin operation' };
+    }
+    if (!agentId) {
+      return { success: false, error: 'pin requires an agent context' };
+    }
+    const entry = await this._getDocumentMemory().pin(agentId, docId, pinned);
+    if (!entry) {
+      return { success: false, error: `No saved document with id "${docId}"` };
+    }
+    return { success: true, docId, pinned: !!entry.pinned };
+  }
+
   async fetch(url, options = {}) {
-    const { formats = ['title', 'text'], agentId, stealthLevel = 'standard' } = options;
+    const { formats = ['title', 'text'], agentId, stealthLevel = 'standard', goal } = options;
 
     // Validate URL before doing anything expensive
     if (!url || typeof url !== 'string' || url.trim().length === 0) {
@@ -1290,7 +1561,10 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
       if (stealthDowngradeNotice) {
         fetchResult.stealthNotice = stealthDowngradeNotice;
       }
-      return fetchResult;
+      // Offload large content to document memory (handle + preview instead of
+      // dumping the whole page into the conversation). No-op for small pages.
+      const { result: finalResult } = await this._maybeOffload(fetchResult, { agentId, url, goal });
+      return finalResult;
 
     } finally {
       try { await page.close(); } catch { /* swallow */ }
@@ -1338,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({
@@ -1919,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);
@@ -2136,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');
         }
       }
@@ -2489,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,
@@ -3053,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}`);
@@ -3061,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,
@@ -3070,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