@quanta-intellect/vessel-browser 0.1.145 → 0.1.146

package/out/main/index.js

@@ -682,15 +682,6 @@ function loadTrustedAppURL(wc, url) {
   }
   return wc.loadURL(parsed.toString());
 }
-const urlSafety = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  assertPermittedNavigationURL,
-  assertSafeURL,
-  isSafeNavigationURL,
-  loadInternalDataURL,
-  loadPermittedNavigationURL,
-  loadTrustedAppURL
-}, Symbol.toStringTag, { value: "Module" }));
 const MAX_CUSTOM_HISTORY = 50;
 const READER_MODE_DATA_URL_PREFIX = "data:text/html;charset=utf-8,";
 const logger$B = createLogger("Tab");
@@ -7806,6 +7797,96 @@ function isClickReadLoop(names) {
   }
   return clickReadPairs >= 2;
 }
+const CLICK_READ_LOOP_SUPPRESS_THRESHOLD = 3;
+function classifyClickFailure(output) {
+  if (/Error\[hidden\]/i.test(output)) return "hidden";
+  if (/Error\[stale-index\]/i.test(output)) return "stale";
+  if (/^\s*Error:/i.test(output)) return "other";
+  return null;
+}
+function buildClickReadLoopIntervention(strikes, lastClickFailureKind) {
+  if (strikes <= 0) return null;
+  if (strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD) {
+    const lines = [
+      `Error: Suppressed repeated click — you have alternated click and read_page ${strikes} times without making progress and the clicks are not landing.`,
+      `Stop calling click. Instead do one of: scroll (scroll or scroll_to_element) to load more of the page then read_page to refresh, inspect_element on a specific indexed result, or answer from the results already visible in the conversation.`
+    ];
+    if (lastClickFailureKind === "hidden") {
+      lines.push(
+        `The last click target was hidden / not laid out — scrolling toward it first usually reveals it.`
+      );
+    } else if (lastClickFailureKind === "stale") {
+      lines.push(
+        `The last click target was stale — refresh page state with read_page and choose a currently listed target before clicking again.`
+      );
+    }
+    return { kind: "suppress", message: lines.join("\n") };
+  }
+  if (strikes >= 2) {
+    const lines = [
+      `[System] You are alternating between click and read_page without advancing the task, and the last click did not complete.`,
+      `The click result already includes a page snapshot, so do not read_page after every click.`
+    ];
+    if (lastClickFailureKind === "hidden") {
+      lines.push(
+        `The click failed on a hidden element — call scroll (scroll or scroll_to_element) to reveal it, then read_page to refresh visible elements, before clicking again.`
+      );
+    } else if (lastClickFailureKind === "stale") {
+      lines.push(
+        `The click failed on a stale element index — call read_page to refresh current indexes before clicking again.`
+      );
+    } else {
+      lines.push(
+        `If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
+      );
+    }
+    return { kind: "nudge", message: lines.join("\n") };
+  }
+  return {
+    kind: "nudge",
+    message: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates, so do not read_page after every click. If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
+  };
+}
+class ClickReadLoopGuard {
+  recentToolNames = [];
+  strikes = 0;
+  lastClickFailureKind = null;
+  beforeTool(toolName) {
+    if (toolName === "click" && this.strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD && isClickReadLoop(this.recentToolNames)) {
+      return buildClickReadLoopIntervention(
+        this.strikes,
+        this.lastClickFailureKind
+      );
+    }
+    return null;
+  }
+  afterToolResult(toolName, output, succeeded) {
+    if (toolName === "click") {
+      this.lastClickFailureKind = succeeded ? null : classifyClickFailure(output);
+    }
+    this.recentToolNames.push(toolName);
+    if (this.recentToolNames.length > 8) this.recentToolNames.shift();
+    if (toolName === "click" && succeeded) {
+      this.strikes = 0;
+      return null;
+    }
+    if (toolName !== "click" && toolName !== "read_page") {
+      this.strikes = 0;
+      return null;
+    }
+    if (isClickReadLoop(this.recentToolNames) && this.lastClickFailureKind) {
+      this.strikes += 1;
+      if (this.strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD) {
+        return null;
+      }
+      return buildClickReadLoopIntervention(
+        this.strikes,
+        this.lastClickFailureKind
+      );
+    }
+    return null;
+  }
+}
 const TERMINAL_TOOL_RESULT = "__VESSEL_TERMINAL_TOOL_RESULT__";
 const logger$w = createLogger("PromptCache");
 function shortHash(value) {
@@ -7966,8 +8047,7 @@ class AnthropicProvider {
     try {
       const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
-      const recentToolNames = [];
-      let clickReadLoopNudged = false;
+      const clickReadLoopGuard = new ClickReadLoopGuard();
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         const stream = this.client.messages.stream(
@@ -8074,6 +8154,7 @@ class AnthropicProvider {
           break;
         }
         const toolResults = [];
+        const loopNudges = [];
         for (const tb of toolUseBlocks) {
           if (tb._malformedArgs !== void 0) {
             onChunk(`
@@ -8087,6 +8168,19 @@ class AnthropicProvider {
             });
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(tb.name);
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: tb.id,
+              content: clickLoopPreflight.message,
+              is_error: true
+            });
+            continue;
+          }
           const argSummary = [tb.input.url, tb.input.query, tb.input.text, tb.input.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
           onChunk(`
 <<tool:${tb.name}${argSummary ? ":" + argSummary : ""}>>
@@ -8101,6 +8195,7 @@ class AnthropicProvider {
           if (result === TERMINAL_TOOL_RESULT) {
             return;
           }
+          const toolSucceeded = !/^Error:/i.test(result.trim());
           let parsedRich = null;
           try {
             const parsed = JSON.parse(result);
@@ -8132,16 +8227,18 @@ class AnthropicProvider {
               content: result
             });
           }
-          recentToolNames.push(tb.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            tb.name,
+            result,
+            toolSucceeded
+          );
+          if (clickLoopIntervention?.kind === "nudge") {
+            loopNudges.push(clickLoopIntervention.message);
+          }
         }
         messages.push({ role: "user", content: toolResults });
-        if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
-          clickReadLoopNudged = true;
-          messages.push({
-            role: "user",
-            content: `You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates — you do not need read_page after every click. If you need detail on a specific element, use inspect_element instead. If you have enough context, proceed with the next action directly.`
-          });
+        for (const nudge of loopNudges) {
+          messages.push({ role: "user", content: nudge });
         }
       }
       if (iterationsUsed >= maxIterations) {
@@ -9432,10 +9529,9 @@ class OpenAICompatProvider {
       let highlightCompletionRecoveryCount = 0;
       let compactCorrectionCount = 0;
       const recentCompactToolSignatures = [];
-      const recentToolNames = [];
       const successfulToolNames = [];
       const searchLoopGuard = new SearchLoopGuard(isSearchContextResettingTool);
-      let clickReadLoopNudged = false;
+      const clickReadLoopGuard = new ClickReadLoopGuard();
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         let textAccum = "";
@@ -9725,6 +9821,19 @@ class OpenAICompatProvider {
             }
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(tc.name);
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: clickLoopPreflight.message
+            });
+            compactCorrectionCount += 1;
+            continue;
+          }
           const argSummary = [args.url, args.query, args.text, args.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
           onChunk(`
 <<tool:${tc.name}${argSummary ? ":" + argSummary : ""}>>
@@ -9762,15 +9871,11 @@ class OpenAICompatProvider {
             searchToolQuery,
             toolSucceeded
           );
-          recentToolNames.push(tc.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
-          if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
-            clickReadLoopNudged = true;
-            messages.push({
-              role: "user",
-              content: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates — you do not need read_page after every click. If you need detail on a specific element, use inspect_element instead. If you have enough context, proceed with the next action directly.`
-            });
-          }
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            tc.name,
+            toolContent,
+            toolSucceeded
+          );
           compactCorrectionCount = 0;
           iterationToolResultPreviews.push(toolContent);
           messages.push({
@@ -9778,6 +9883,9 @@ class OpenAICompatProvider {
             tool_call_id: tc.id,
             content: toolContent
           });
+          if (clickLoopIntervention?.kind === "nudge") {
+            messages.push({ role: "user", content: clickLoopIntervention.message });
+          }
         }
         const followUpReminder = followUpReminderForProfile(
           this.agentToolProfile,
@@ -10449,12 +10557,25 @@ function buildCodexFlightPriceEvidenceRecoveryInput(userMessage, assistantText,
     ]
   };
 }
-function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview, failedClickCount = 1) {
+function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview, failedClickCount = 1, errorOutput = "") {
   const stateReminder = buildLatestStateReminder(latestToolResultPreview);
+  const clickFailureKind = classifyClickFailure(errorOutput);
   const lines = [
-    `[System] The previous click did not complete${attemptedTarget ? ` for ${attemptedTarget}` : ""}.`,
-    `Take the next step yourself: try a different target, refresh the page state with read_page, call inspect_element on the intended element, or answer from the results already visible in the conversation. Do not ask the user to inspect or click the result for you.`
+    `[System] The previous click did not complete${attemptedTarget ? ` for ${attemptedTarget}` : ""}.`
   ];
+  if (clickFailureKind === "hidden") {
+    lines.push(
+      `The click target was hidden / not laid out (collapsed, lazy-loaded, or virtual-scroll). Call scroll or scroll_to_element toward it to reveal it, then read_page to refresh visible elements, before clicking again — or inspect_element on the intended index, or answer from the results already visible. Do not ask the user to inspect or click the result for you.`
+    );
+  } else if (clickFailureKind === "stale") {
+    lines.push(
+      `The click target was stale — the page changed since the last snapshot. Call read_page to refresh current indexes, then choose a currently listed target, inspect_element on the intended element, or answer from the results already visible. Do not ask the user to inspect or click the result for you.`
+    );
+  } else {
+    lines.push(
+      `Take the next step yourself: try a different target, refresh the page state with read_page, call inspect_element on the intended element, or answer from the results already visible in the conversation. Do not ask the user to inspect or click the result for you.`
+    );
+  }
   if (failedClickCount >= 2) {
     lines.push(
       `You have already had multiple failed clicks without making page progress. Do not keep clicking similar search result titles. Use the latest read_page/search result text to answer, or inspect a specific indexed result/control only if essential.`
@@ -10665,8 +10786,7 @@ class CodexProvider {
     let flightPriceEvidenceRecoveryCount = 0;
     let correctionCount = 0;
     const recentToolSignatures = [];
-    const recentToolNames = [];
-    let clickReadLoopNudged = false;
+    const clickReadLoopGuard = new ClickReadLoopGuard();
     let latestToolResultPreview = null;
     let failedClickCountSinceProgress = 0;
     const searchLoopGuard = new SearchLoopGuard(isRealProgressTool);
@@ -10822,6 +10942,22 @@ ${latestToolResultPreview || ""}`
             correctionCount += 1;
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(
+            prepared.prepared.name
+          );
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            const suppressed = createCodexToolOutput(
+              prepared.prepared.callId,
+              clickLoopPreflight.message
+            );
+            currentInput.push(suppressed);
+            latestToolResultPreview = previewToolResult(suppressed.output);
+            correctionCount += 1;
+            continue;
+          }
           const output = await executePreparedCodexFunctionCall(
             prepared.prepared,
             onChunk,
@@ -10849,7 +10985,8 @@ ${latestToolResultPreview || ""}`
               buildCodexFailedClickRecoveryInput(
                 summarizeToolArg(prepared.prepared.args),
                 latestToolResultPreview,
-                failedClickCountSinceProgress
+                failedClickCountSinceProgress,
+                outputText
               )
             );
           }
@@ -10857,17 +10994,16 @@ ${latestToolResultPreview || ""}`
           if (recentToolSignatures.length > 4) {
             recentToolSignatures.shift();
           }
-          recentToolNames.push(prepared.prepared.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
-          if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
-            clickReadLoopNudged = true;
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            prepared.prepared.name,
+            outputText,
+            toolSucceeded
+          );
+          if (clickLoopIntervention?.kind === "nudge") {
             currentInput.push({
               type: "message",
               role: "user",
-              content: [{
-                type: "input_text",
-                text: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates, so do not read_page after every click. If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
-              }]
+              content: [{ type: "input_text", text: clickLoopIntervention.message }]
             });
           }
           correctionCount = 0;
@@ -12091,8 +12227,7 @@ function pageBusyError(action) {
   return `Error: Page is still busy; ${action} timed out waiting for page scripts. Retry in a moment.`;
 }
 async function loadPermittedUrl(wc, url) {
-  const { assertPermittedNavigationURL: assertPermittedNavigationURL2 } = await Promise.resolve().then(() => urlSafety);
-  assertPermittedNavigationURL2(url);
+  assertPermittedNavigationURL(url);
   await wc.loadURL(url);
 }
 async function executePageScript(wc, script, options) {
@@ -16432,6 +16567,60 @@ async function clickElement(wc, selector) {
         }));
       }
 
+      // Sum offsetTop up the offsetParent chain until reaching "container",
+      // giving the element's vertical position within that scroll container.
+      function offsetTopWithin(el, container) {
+        let top = 0;
+        let node = el;
+        while (node && node !== container) {
+          top += node.offsetTop || 0;
+          node = node.offsetParent;
+        }
+        return top;
+      }
+
+      function nearestScrollableAncestor(el) {
+        let node = el.parentElement;
+        while (node) {
+          if (node instanceof HTMLElement) {
+            const style = window.getComputedStyle(node);
+            if (
+              (style.overflowY === "auto" || style.overflowY === "scroll") &&
+              node.scrollHeight > node.clientHeight
+            ) {
+              return node;
+            }
+          }
+          node = node.parentElement;
+        }
+        return null;
+      }
+
+      // Wait for the element to gain a non-zero layout box, polling for up to
+      // maxFrames animation frames. Lazy / virtual-scroll renderers
+      // (content-visibility, intersection-triggered list items) often lay out
+      // a frame or two after the scroller moves. Falls back to setTimeout when
+      // the window is hidden (requestAnimationFrame does not fire then).
+      function waitForBox(el, maxFrames) {
+        return new Promise((resolve) => {
+          let frames = 0;
+          const rafAvailable =
+            typeof requestAnimationFrame === "function" &&
+            document.visibilityState === "visible";
+          const schedule = rafAvailable
+            ? (cb) => requestAnimationFrame(cb)
+            : (cb) => setTimeout(cb, 16);
+          const check = () => {
+            const r = el.getBoundingClientRect();
+            if (r.width > 0 && r.height > 0) return resolve(true);
+            if (frames >= maxFrames) return resolve(false);
+            frames += 1;
+            schedule(check);
+          };
+          check();
+        });
+      }
+
       const el = document.querySelector(${JSON.stringify(selector)});
       if (!el) return { error: "Error[stale-index]: Element not found — the page may have changed. Call read_page to refresh." };
 
@@ -16439,21 +16628,26 @@ async function clickElement(wc, selector) {
         el.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
       }
 
-      await new Promise((resolve) => {
-        let settled = false;
-        const finish = () => {
-          if (settled) return;
-          settled = true;
-          resolve(undefined);
-        };
-        if (
-          typeof requestAnimationFrame === "function" &&
-          document.visibilityState === "visible"
-        ) {
-          requestAnimationFrame(() => finish());
+      // Give the renderer a brief grace to lay the element out after the
+      // initial scroll. Already-visible elements resolve on the first check.
+      let revealed = await waitForBox(el, 4);
+
+      // scrollIntoView is a no-op on zero-rect elements (collapsed, lazy, or
+      // virtual-scroll content). Force the nearest scrollable ancestor to bring
+      // the element's offset position into view, then wait longer for the
+      // renderer to produce a layout box. This recovers many hidden targets
+      // without the model having to scroll manually.
+      if (!revealed) {
+        const scroller = nearestScrollableAncestor(el);
+        if (scroller) {
+          const targetTop = offsetTopWithin(el, scroller) - scroller.clientHeight / 2;
+          scroller.scrollTop = Math.max(0, targetTop);
         }
-        setTimeout(finish, 32);
-      });
+        if (el instanceof HTMLElement) {
+          el.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
+        }
+        revealed = await waitForBox(el, 24);
+      }
 
       const rect = el.getBoundingClientRect();
       if (rect.width <= 0 || rect.height <= 0) {
@@ -18016,9 +18210,13 @@ Go back and select a different product.`;
   const clickText = `Clicked: ${elInfo.text}${tagLabel}`;
   const clickResult = await clickElement(wc, selector);
   if (clickResult.startsWith("Error:")) return clickResult;
-  await waitForPotentialNavigation$1(wc, beforeUrl);
+  const initialNavigationWaitMs = /DOM activation/i.test(clickResult) && !elInfo.href ? 800 : void 0;
+  await waitForPotentialNavigation$1(wc, beforeUrl, initialNavigationWaitMs);
   const afterUrl = wc.getURL();
   if (afterUrl !== beforeUrl) {
+    if (/DOM activation/i.test(clickResult)) {
+      return `${clickText} -> ${afterUrl} (recovered via DOM activation)`;
+    }
     return `${clickText} -> ${afterUrl}`;
   }
   const overlayHint = await detectPostClickOverlay(wc);
@@ -18045,6 +18243,9 @@ ${overlayHint}`;
     }
     return `${clickText} (${clickResult})${await buildCartSuccessSuffix(wc, beforeUrl)}`;
   }
+  if (/DOM activation/i.test(clickResult) && (!elInfo.href || elInfo.target === "_blank")) {
+    return `${clickText} (${clickResult})`;
+  }
   const activationResult = await activateElement(wc, selector);
   if (!activationResult.startsWith("Error:")) {
     await waitForPotentialNavigation$1(wc, beforeUrl);
@@ -23847,6 +24048,9 @@ All open tabs: ${allTabs.map((t) => `${t.id === activeTabId ? "→ " : ""}${t.ti
         let isError = false;
         try {
           output = await executeAction(name, args, actionCtx);
+          if (/^\s*Error:/i.test(output)) {
+            isError = true;
+          }
           if (provider.agentToolProfile === "compact") {
             runtime2.updateTaskTracker(name, output);
             const trackerCtx = runtime2.getTaskTrackerContext();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@quanta-intellect/vessel-browser",
   "mcpName": "io.github.unmodeled-tyler/vessel-browser",
-  "version": "0.1.145",
+  "version": "0.1.146",
   "description": "AI-native web browser runtime for autonomous agents with human supervision",
   "main": "./out/main/index.js",
   "bin": {