@quanta-intellect/vessel-browser 0.1.68 → 0.1.69

package/out/main/index.js

@@ -65,6 +65,7 @@ const defaults = {
   domainPolicy: { allowedDomains: [], blockedDomains: [] },
   downloadPath: "",
   telemetryEnabled: true,
+  defaultSearchEngine: "duckduckgo",
   premium: {
     status: "free",
     customerId: "",
@@ -3754,6 +3755,24 @@ const VERIFICATION_API = process.env.VESSEL_PREMIUM_API || "https://vesselpremiu
 const FREE_TOOL_ITERATION_LIMIT = 50;
 const REVALIDATION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 const OFFLINE_GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1e3;
+const MAX_API_ERROR_LOG_LENGTH = 300;
+async function readApiErrorDetail(res) {
+  try {
+    const text = (await res.text()).trim();
+    if (!text) return "";
+    try {
+      const data = JSON.parse(text);
+      const detail = data.error || data.message;
+      if (typeof detail === "string" && detail.trim()) {
+        return detail.trim().slice(0, MAX_API_ERROR_LOG_LENGTH);
+      }
+    } catch {
+    }
+    return text.slice(0, MAX_API_ERROR_LOG_LENGTH);
+  } catch {
+    return "";
+  }
+}
 const PREMIUM_TOOLS = /* @__PURE__ */ new Set([
   "screenshot",
   "save_session",
@@ -3843,7 +3862,12 @@ async function verifySubscription(identifier) {
       body: JSON.stringify({ identifier: verificationIdentifier })
     });
     if (!res.ok) {
-      logger$f.warn("Verification API returned a non-OK status:", res.status);
+      const detail = await readApiErrorDetail(res);
+      logger$f.warn(
+        "Verification API returned a non-OK status:",
+        res.status,
+        detail
+      );
       return current;
     }
     const data = await res.json();
@@ -6326,7 +6350,7 @@ class AnthropicProvider {
             });
             continue;
           }
-          const argSummary = [tb.input.url, tb.input.text, tb.input.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
+          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 : ""}>>
 `);
@@ -6517,11 +6541,52 @@ const SAFE_TOOL_ALIASES = {
   scroll_up: "scroll",
   read: "read_page",
   read_current_page: "read_page",
-  scan_page: "read_page"
+  scan_page: "read_page",
+  save_bookmark: "save_bookmark",
+  bookmark: "save_bookmark",
+  bookmark_page: "save_bookmark",
+  bookmark_url: "save_bookmark",
+  add_bookmark: "save_bookmark",
+  create_bookmark: "save_bookmark"
 };
+const CANONICAL_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "archive_bookmark",
+  "click",
+  "create_bookmark_folder",
+  "current_tab",
+  "go_back",
+  "go_forward",
+  "inspect_element",
+  "list_bookmarks",
+  "navigate",
+  "open_bookmark",
+  "organize_bookmark",
+  "read_page",
+  "save_bookmark",
+  "scroll",
+  "search",
+  "type_text"
+]);
+function repeatedTokenMatch(value, token) {
+  if (value === token) return true;
+  if (token.length === 0 || value.length <= token.length) return false;
+  if (value.length % token.length !== 0) return false;
+  return token.repeat(value.length / token.length) === value;
+}
 function normalizeToolAlias(name) {
   const normalized = name.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
-  return SAFE_TOOL_ALIASES[normalized] ?? name;
+  const direct = SAFE_TOOL_ALIASES[normalized] ?? normalized;
+  if (CANONICAL_TOOL_NAMES.has(direct)) return direct;
+  const knownTokens = [
+    ...Object.keys(SAFE_TOOL_ALIASES),
+    ...CANONICAL_TOOL_NAMES
+  ];
+  for (const token of knownTokens) {
+    if (repeatedTokenMatch(normalized, token)) {
+      return SAFE_TOOL_ALIASES[token] ?? token;
+    }
+  }
+  return name;
 }
 function parseModelSizeInBillions(model) {
   const match = model.toLowerCase().match(/(?:^|[:/_\-\s])(\d+(?:\.\d+)?)b(?:$|[:/_\-\s])/i);
@@ -6845,8 +6910,62 @@ function scalarArgsForTool(name, scalar) {
     const mode = trimmed.replace(/^["']|["']$/g, "").toLowerCase();
     if (mode) return { mode };
   }
+  if (name === "save_bookmark") {
+    const url = toLikelyUrl(trimmed);
+    if (url) return { url };
+    const lastSpace = trimmed.lastIndexOf(" ");
+    if (lastSpace > 0) {
+      const maybeUrl = toLikelyUrl(trimmed.slice(lastSpace + 1));
+      if (maybeUrl) return { url: maybeUrl, title: trimmed.slice(0, lastSpace).replace(/^["']|["']$/g, "") };
+    }
+  }
+  return null;
+}
+function firstStringArg(args, keys) {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
   return null;
 }
+function normalizeElementTargetArgs(args) {
+  const normalized = { ...args };
+  if (typeof normalized.index === "string" && /^\d+$/.test(normalized.index.trim())) {
+    normalized.index = Number(normalized.index.trim());
+  }
+  if (typeof normalized.selector !== "string" || !normalized.selector.trim()) {
+    const selector = firstStringArg(normalized, [
+      "cssSelector",
+      "css_selector",
+      "querySelector",
+      "query_selector"
+    ]);
+    if (selector) normalized.selector = selector;
+  }
+  if (typeof normalized.text !== "string" || !normalized.text.trim()) {
+    const text = firstStringArg(normalized, [
+      "label",
+      "title",
+      "name",
+      "target",
+      "element",
+      "linkText",
+      "link_text",
+      "ariaLabel",
+      "aria_label"
+    ]);
+    if (text) normalized.text = text;
+  }
+  return normalized;
+}
+function hasElementTarget(args) {
+  return typeof args.index === "number" || typeof args.selector === "string" && args.selector.trim().length > 0 || typeof args.text === "string" && args.text.trim().length > 0;
+}
+function isTargetlessClickArgs(args) {
+  return !hasElementTarget(normalizeElementTargetArgs(args));
+}
 function tryParseJsonWithCommonRepairs(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return {};
@@ -6900,7 +7019,10 @@ function parseToolArgsWithRepair(name, argsJson) {
   return scalarArgs ? { args: scalarArgs, repaired: true } : null;
 }
 function coerceToolArgsForExecution(name, args) {
-  const coerced = { ...args };
+  let coerced = { ...args };
+  if (name === "click" || name === "inspect_element" || name === "scroll_to_element") {
+    coerced = normalizeElementTargetArgs(coerced);
+  }
   if (name === "search") {
     if (typeof coerced.query !== "string" || !coerced.query.trim()) {
       if (typeof coerced.text === "string" && coerced.text.trim()) {
@@ -6921,6 +7043,25 @@ function coerceToolArgsForExecution(name, args) {
       }
     }
   }
+  if (name === "save_bookmark") {
+    if (typeof coerced.url !== "string" || !coerced.url.trim()) {
+      if (typeof coerced.link === "string" && coerced.link.trim()) {
+        coerced.url = coerced.link.trim();
+      } else if (typeof coerced.href === "string" && coerced.href.trim()) {
+        coerced.url = coerced.href.trim();
+      }
+    }
+    if (typeof coerced.folderName !== "string" || !coerced.folderName.trim()) {
+      if (typeof coerced.folder === "string" && coerced.folder.trim()) {
+        coerced.folderName = coerced.folder.trim();
+      } else if (typeof coerced.category === "string" && coerced.category.trim()) {
+        coerced.folderName = coerced.category.trim();
+      }
+    }
+    if (coerced.folderName && typeof coerced.createFolderIfMissing === "undefined") {
+      coerced.createFolderIfMissing = true;
+    }
+  }
   return coerced;
 }
 function canonicalizeArgsForTool(name, args) {
@@ -6937,6 +7078,24 @@ function canonicalizeArgsForTool(name, args) {
   }
   return canonical;
 }
+function unsupportedToolHint(name) {
+  const normalized = name.trim().toLowerCase().replace(/[.\s/-]+/g, "_");
+  const BOOKMARK_NAMES = [
+    "organize_bookmark",
+    "organize_bookmarks",
+    "manage_bookmark",
+    "manage_bookmarks",
+    "add_to_bookmarks",
+    "save_to_bookmarks",
+    "bookmark_link",
+    "save_link",
+    "store_bookmark"
+  ];
+  if (BOOKMARK_NAMES.includes(normalized) || /bookmark|save.*link|organize/.test(normalized)) {
+    return `Error: "${name}" is not a supported tool. Use save_bookmark to save a page as a bookmark, or create_bookmark_folder to create a folder. Example: save_bookmark with {"url": "...", "title": "...", "folderName": "..."}`;
+  }
+  return `Error: ${name} is not a supported tool. Choose one of the available browser tools instead.`;
+}
 function resolveToolCallName(rawName, args, availableToolNames) {
   const aliased = normalizeToolAlias(rawName);
   if (availableToolNames.has(aliased)) return aliased;
@@ -7241,6 +7400,7 @@ class OpenAICompatProvider {
           );
           if (recoveredToolCalls.length > 0) {
             toolCalls = recoveredToolCalls;
+            if (textAccum.trim()) onChunk("<<erase_prev>>");
           } else {
             const narratedToolCalls = recoverNarratedActionToolCalls(
               textAccum,
@@ -7248,6 +7408,7 @@ class OpenAICompatProvider {
             );
             if (narratedToolCalls.length > 0) {
               toolCalls = narratedToolCalls;
+              if (textAccum.trim()) onChunk("<<erase_prev>>");
             }
           }
         }
@@ -7314,6 +7475,25 @@ class OpenAICompatProvider {
         compactRecoveryCount = 0;
         const iterationToolResultPreviews = [];
         for (const tc of toolCalls) {
+          if (!availableToolNames.has(tc.name)) {
+            const hint = unsupportedToolHint(tc.name);
+            onChunk(`
+<<tool:${tc.name}:⚠ unsupported>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: hint
+            });
+            compactCorrectionCount += 1;
+            if (compactCorrectionCount >= 2) {
+              messages.push({
+                role: "user",
+                content: `[System] You are calling unsupported tools. Stop inventing tool names. Use the supported tools you were given and take the next concrete step.`
+              });
+            }
+            continue;
+          }
           if (malformedToolCalls.has(tc.id)) {
             onChunk(`
 <<tool:${tc.name}:⚠ invalid args>>
@@ -7340,25 +7520,23 @@ class OpenAICompatProvider {
           }
           args = repairedArgs.args;
           args = coerceToolArgsForExecution(tc.name, args);
-          if (!availableToolNames.has(tc.name)) {
+          const toolSignature = stableToolSignature(tc.name, args);
+          if (this.agentToolProfile === "compact" && tc.name === "click" && isTargetlessClickArgs(args)) {
             onChunk(`
-<<tool:unsupported_tool:⚠ unsupported>>
+<<tool:${tc.name}:⚠ missing target>>
 `);
             messages.push({
               role: "tool",
               tool_call_id: tc.id,
-              content: `Error: ${tc.name} is not a supported tool. Choose one of the available browser tools instead.`
+              content: `Error: click requires an element target. Use click with {"index": N} from the latest read_page result, or {"text": "exact visible link/button text"}. If you do not have a current result index, call read_page(mode="results_only") first and then click one listed result.`
+            });
+            messages.push({
+              role: "user",
+              content: `[System] Your last click had no target. Do not call click with empty arguments. Refresh the page state with read_page(mode="results_only") if needed, then click exactly one result by index or exact visible text.`
             });
             compactCorrectionCount += 1;
-            if (compactCorrectionCount >= 2) {
-              messages.push({
-                role: "user",
-                content: `[System] You are calling unsupported tools. Stop inventing tool names. Use the supported tools you were given and take the next concrete step.`
-              });
-            }
             continue;
           }
-          const toolSignature = stableToolSignature(tc.name, args);
           const neverSuppressDuplicate = [
             "read_page",
             "current_tab",
@@ -10579,6 +10757,14 @@ function pruneToolsForContext(tools, pageType, query = "", options = {}) {
     return description !== tool.description ? { ...tool, description } : tool;
   });
 }
+const SEARCH_ENGINE_PRESETS = {
+  duckduckgo: { label: "DuckDuckGo", url: "https://duckduckgo.com/?q=" },
+  google: { label: "Google", url: "https://www.google.com/search?q=" },
+  bing: { label: "Bing", url: "https://www.bing.com/search?q=" },
+  brave: { label: "Brave Search", url: "https://search.brave.com/search?q=" },
+  ecosia: { label: "Ecosia", url: "https://www.ecosia.org/search?q=" },
+  kagi: { label: "Kagi", url: "https://kagi.com/search?q=" }
+};
 function trimText(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -14966,8 +15152,19 @@ function buildCommonSearchUrlShortcut(currentUrl, rawQuery) {
     appliedFilters: existingParam ? [`updated ${existingParam} query`] : []
   };
 }
-function buildSearchShortcut(currentUrl, rawQuery) {
-  return buildHuggingFaceSearchShortcut(currentUrl, rawQuery) ?? buildCommonSearchUrlShortcut(currentUrl, rawQuery);
+function buildDefaultEngineShortcut(rawQuery) {
+  const settings2 = loadSettings();
+  const engineId = settings2.defaultSearchEngine ?? "duckduckgo";
+  if (engineId === "none") return null;
+  const preset = SEARCH_ENGINE_PRESETS[engineId];
+  if (!preset) return null;
+  const query = normalizeSearchQuery(rawQuery);
+  if (!query) return null;
+  return {
+    url: preset.url + encodeURIComponent(query),
+    source: "default search engine",
+    appliedFilters: []
+  };
 }
 async function locateSearchTarget(wc, explicitSelector) {
   if (explicitSelector) {
@@ -15020,7 +15217,7 @@ async function locateSearchTarget(wc, explicitSelector) {
           const seen = new Set();
           const ordered = [];
           const specific = document.querySelectorAll(
-            'input[type="search"], input[name="q"], input[name="query"], input[name="search"], input[role="searchbox"], input[aria-label*="search" i], input[placeholder*="search" i]'
+            'input[type="search"], input[name="q"], input[name="query"], input[name="search"], input[role="searchbox"], input[aria-label*="search" i], input[placeholder*="search" i], textarea[name="q"], textarea[name="query"], textarea[name="search"], textarea[role="searchbox"], textarea[aria-label*="search" i], textarea[placeholder*="search" i]'
           );
           specific.forEach((el) => {
             if (!seen.has(el)) {
@@ -15028,7 +15225,7 @@ async function locateSearchTarget(wc, explicitSelector) {
               ordered.push(el);
             }
           });
-          document.querySelectorAll('input[type="text"], input:not([type])').forEach((el) => {
+          document.querySelectorAll('input[type="text"], input:not([type]), textarea').forEach((el) => {
             if (seen.has(el)) return;
             const scope = nearestSearchScope(el);
             if (!scope) return;
@@ -15039,9 +15236,10 @@ async function locateSearchTarget(wc, explicitSelector) {
         }
 
         function scoreInput(el) {
-          if (!(el instanceof HTMLInputElement)) return -1;
+          if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) return -1;
           if (isDisabled(el) || !isVisible(el)) return -1;
-          const type = normalize(el.getAttribute("type") || el.type);
+          const isTextarea = el instanceof HTMLTextAreaElement;
+          const type = isTextarea ? "text" : normalize(el.getAttribute("type") || el.type);
           if (type && !["search", "text", ""].includes(type)) return -1;
 
           let score = 0;
@@ -15188,16 +15386,19 @@ async function searchPage(wc, args) {
   if (looksLikeCurrentSiteNameQuery(query, wc.getURL(), wc.getTitle() || "")) {
     return `Error: "${query}" looks like the current site's name, not a product query. You are already on ${wc.getURL()}. Open a section like staff picks/new releases or search for actual book titles, authors, or genres instead.`;
   }
+  const runShortcut = async (shortcut) => {
+    const beforeUrl2 = wc.getURL();
+    await loadPermittedUrl(wc, shortcut.url);
+    await waitForPotentialNavigation(wc, beforeUrl2, 4e3);
+    const afterUrl2 = wc.getURL();
+    const applied = shortcut.appliedFilters.length > 0 ? ` (${shortcut.appliedFilters.join(", ")})` : "";
+    const destination = shortcut.section ? ` ${shortcut.section}` : "";
+    return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}${await getPostSearchSummary(wc)}`;
+  };
   if (typeof args.selector !== "string") {
-    const shortcut = buildSearchShortcut(wc.getURL(), query);
+    const shortcut = buildHuggingFaceSearchShortcut(wc.getURL(), query) ?? buildCommonSearchUrlShortcut(wc.getURL(), query);
     if (shortcut) {
-      const beforeUrl2 = wc.getURL();
-      await loadPermittedUrl(wc, shortcut.url);
-      await waitForPotentialNavigation(wc, beforeUrl2, 4e3);
-      const afterUrl2 = wc.getURL();
-      const applied = shortcut.appliedFilters.length > 0 ? ` (${shortcut.appliedFilters.join(", ")})` : "";
-      const destination = shortcut.section ? ` ${shortcut.section}` : "";
-      return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}${await getPostSearchSummary(wc)}`;
+      return runShortcut(shortcut);
     }
   }
   const searchInfo = await locateSearchTarget(
@@ -15208,6 +15409,12 @@ async function searchPage(wc, args) {
     return pageBusyError("search");
   }
   if (!searchInfo?.selector) {
+    if (typeof args.selector !== "string") {
+      const fallback = buildDefaultEngineShortcut(query);
+      if (fallback) {
+        return runShortcut(fallback);
+      }
+    }
     return 'Error: Could not find a visible search input. Try read_page(mode="visible_only") or provide a selector.';
   }
   const fillResult = await setElementValue(wc, searchInfo.selector, query);
@@ -23387,6 +23594,21 @@ class AgentRuntime {
   }
   setApprovalMode(mode) {
     this.state.supervisor.approvalMode = mode;
+    if (mode === "auto" && !this.state.supervisor.paused) {
+      const approvals = this.state.supervisor.pendingApprovals;
+      if (approvals.length > 0) {
+        const actionIds = new Set(approvals.map((approval) => approval.actionId));
+        this.state.supervisor.pendingApprovals = [];
+        this.state.actions = this.state.actions.map(
+          (action) => actionIds.has(action.id) ? { ...action, status: "running", error: void 0 } : action
+        );
+        for (const approval of approvals) {
+          const resolve = this.pendingResolvers.get(approval.id);
+          this.pendingResolvers.delete(approval.id);
+          resolve?.(true);
+        }
+      }
+    }
     this.emit();
     return this.getState();
   }
@@ -24285,6 +24507,11 @@ function closeSplash(splash, delayMs = 0) {
 }
 const logger = createLogger("Bootstrap");
 let runtime = null;
+function configureUserAgent() {
+  const originalUA = electron.session.defaultSession.getUserAgent();
+  const maskedUA = originalUA.replace(/ Electron\/[^\s]+/, "") + " Vessel/" + electron.app.getVersion();
+  electron.session.defaultSession.setUserAgent(maskedUA);
+}
 function checkWritableUserData(userDataPath) {
   const issues = [];
   try {
@@ -24348,6 +24575,7 @@ Action: Open Settings (Ctrl+,) to choose a different port, then save to restart
   });
 }
 async function bootstrap() {
+  configureUserAgent();
   const splash = createSplashWindow();
   const settings2 = loadSettings();
   const userDataPath = electron.app.getPath("userData");