@vellumai/assistant 0.4.26 → 0.4.30

package/src/tools/browser/auto-navigate.ts

@@ -5,11 +5,11 @@
  * so the NetworkRecorder captures the API surface without manual browsing.
  */
 
-import { getLogger } from '../../util/logger.js';
+import { getLogger } from "../../util/logger.js";
 
-const log = getLogger('auto-navigate');
+const log = getLogger("auto-navigate");
 
-const CDP_BASE = 'http://localhost:9222';
+const CDP_BASE = "http://localhost:9222";
 const MAX_PAGES = 10;
 const PAGE_WAIT_MS = 2500;
 const SCROLL_WAIT_MS = 1000;
@@ -18,17 +18,23 @@ const SCROLL_WAIT_MS = 1000;
 class MiniCDP {
   private ws: WebSocket | null = null;
   private nextId = 1;
-  private callbacks = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+  private callbacks = new Map<
+    number,
+    { resolve: (v: unknown) => void; reject: (e: Error) => void }
+  >();
 
   async connect(wsUrl: string): Promise<void> {
     return new Promise((resolve, reject) => {
       const ws = new WebSocket(wsUrl);
-      ws.onopen = () => { this.ws = ws; resolve(); };
+      ws.onopen = () => {
+        this.ws = ws;
+        resolve();
+      };
       ws.onerror = (e) => reject(new Error(`CDP error: ${e}`));
       ws.onclose = () => {
         this.ws = null;
         for (const [, cb] of this.callbacks) {
-          cb.reject(new Error('WebSocket closed'));
+          cb.reject(new Error("WebSocket closed"));
         }
         this.callbacks.clear();
       };
@@ -38,15 +44,22 @@ class MiniCDP {
           const cb = this.callbacks.get(msg.id);
           if (cb) {
             this.callbacks.delete(msg.id);
-            if (msg.error) { cb.reject(new Error(msg.error.message)); } else { cb.resolve(msg.result); }
+            if (msg.error) {
+              cb.reject(new Error(msg.error.message));
+            } else {
+              cb.resolve(msg.result);
+            }
           }
         }
       };
     });
   }
 
-  async send(method: string, params?: Record<string, unknown>): Promise<unknown> {
-    if (!this.ws) throw new Error('Not connected');
+  async send(
+    method: string,
+    params?: Record<string, unknown>,
+  ): Promise<unknown> {
+    if (!this.ws) throw new Error("Not connected");
     const id = this.nextId++;
     return new Promise((resolve, reject) => {
       this.callbacks.set(id, { resolve, reject });
@@ -54,11 +67,13 @@ class MiniCDP {
     });
   }
 
-  close() { this.ws?.close(); }
+  close() {
+    this.ws?.close();
+  }
 }
 
 export interface AutoNavProgress {
-  type: 'visiting' | 'discovered' | 'done';
+  type: "visiting" | "discovered" | "done";
   url?: string;
   pageNumber?: number;
   totalDiscovered?: number;
@@ -83,25 +98,34 @@ export async function autoNavigate(
   try {
     const res = await fetch(`${CDP_BASE}/json/list`);
     if (!res.ok) {
-      log.warn('CDP not available for auto-navigation');
+      log.warn("CDP not available for auto-navigation");
       return [];
     }
-    const targets = (await res.json()) as Array<{ type: string; url: string; webSocketDebuggerUrl: string }>;
-    const domainTab = targets.find(t => {
-      if (t.type !== 'page') return false;
+    const targets = (await res.json()) as Array<{
+      type: string;
+      url: string;
+      webSocketDebuggerUrl: string;
+    }>;
+    const domainTab = targets.find((t) => {
+      if (t.type !== "page") return false;
       try {
         const hostname = new URL(t.url).hostname;
-        return hostname === domain || hostname.endsWith('.' + domain);
-      } catch { return false; }
+        return hostname === domain || hostname.endsWith("." + domain);
+      } catch {
+        return false;
+      }
     });
-    wsUrl = domainTab?.webSocketDebuggerUrl ?? targets.find(t => t.type === 'page')?.webSocketDebuggerUrl ?? null;
+    wsUrl =
+      domainTab?.webSocketDebuggerUrl ??
+      targets.find((t) => t.type === "page")?.webSocketDebuggerUrl ??
+      null;
   } catch (err) {
-    log.warn({ err }, 'Failed to discover Chrome tabs');
+    log.warn({ err }, "Failed to discover Chrome tabs");
     return [];
   }
 
   if (!wsUrl) {
-    log.warn('No Chrome tab found for auto-navigation');
+    log.warn("No Chrome tab found for auto-navigation");
     return [];
   }
 
@@ -109,12 +133,12 @@ export async function autoNavigate(
   try {
     await cdp.connect(wsUrl);
   } catch (err) {
-    log.warn({ err }, 'Failed to connect CDP for auto-navigation');
+    log.warn({ err }, "Failed to connect CDP for auto-navigation");
     return [];
   }
 
-  await cdp.send('Page.bringToFront').catch(() => {});
-  await cdp.send('Page.enable').catch(() => {});
+  await cdp.send("Page.bringToFront").catch(() => {});
+  await cdp.send("Page.enable").catch(() => {});
 
   const rootUrl = `https://${domain}/`;
   const visited = new Set<string>();
@@ -122,19 +146,22 @@ export async function autoNavigate(
 
   // Navigate to the domain root first
   try {
-    onProgress?.({ type: 'visiting', url: rootUrl, pageNumber: 1 });
-    await cdp.send('Page.navigate', { url: rootUrl });
+    onProgress?.({ type: "visiting", url: rootUrl, pageNumber: 1 });
+    await cdp.send("Page.navigate", { url: rootUrl });
     await sleep(PAGE_WAIT_MS);
-    visited.add('/');
+    visited.add("/");
     visitedUrls.push(rootUrl);
-    log.info({ url: rootUrl }, 'Visited root page');
+    log.info({ url: rootUrl }, "Visited root page");
   } catch (err) {
-    log.warn({ err }, 'Failed to navigate to domain root');
+    log.warn({ err }, "Failed to navigate to domain root");
     cdp.close();
     return [];
   }
 
-  if (abortSignal?.aborted) { cdp.close(); return visitedUrls; }
+  if (abortSignal?.aborted) {
+    cdp.close();
+    return visitedUrls;
+  }
 
   // Scroll the root page to trigger lazy content
   await scrollPage(cdp);
@@ -144,8 +171,11 @@ export async function autoNavigate(
   let discoveredLinks = await discoverInternalLinks(cdp, domain);
   // Sort links: deeper paths first (more likely to be content pages), skip shallow nav links
   discoveredLinks = rankLinks(discoveredLinks);
-  onProgress?.({ type: 'discovered', totalDiscovered: discoveredLinks.length });
-  log.info({ count: discoveredLinks.length }, 'Discovered internal links from root');
+  onProgress?.({ type: "discovered", totalDiscovered: discoveredLinks.length });
+  log.info(
+    { count: discoveredLinks.length },
+    "Discovered internal links from root",
+  );
 
   // Visit discovered pages
   for (const link of discoveredLinks) {
@@ -154,11 +184,16 @@ export async function autoNavigate(
     if (visited.has(link.key)) continue;
 
     const url = link.url;
-    onProgress?.({ type: 'visiting', url, pageNumber: visited.size + 1, totalDiscovered: discoveredLinks.length });
-    log.info({ url }, 'Auto-navigate visiting page');
+    onProgress?.({
+      type: "visiting",
+      url,
+      pageNumber: visited.size + 1,
+      totalDiscovered: discoveredLinks.length,
+    });
+    log.info({ url }, "Auto-navigate visiting page");
 
     try {
-      await cdp.send('Page.navigate', { url });
+      await cdp.send("Page.navigate", { url });
       await sleep(PAGE_WAIT_MS);
       visited.add(link.key);
       visitedUrls.push(url);
@@ -174,20 +209,30 @@ export async function autoNavigate(
       // Discover more links from this page
       const newLinks = await discoverInternalLinks(cdp, domain);
       for (const nl of newLinks) {
-        if (!visited.has(nl.key) && !discoveredLinks.some(l => l.key === nl.key)) {
+        if (
+          !visited.has(nl.key) &&
+          !discoveredLinks.some((l) => l.key === nl.key)
+        ) {
           discoveredLinks.push(nl);
         }
       }
 
-      log.info({ url }, 'Auto-navigate page completed');
+      log.info({ url }, "Auto-navigate page completed");
     } catch (err) {
-      log.warn({ err, url }, 'Auto-navigate page failed');
+      log.warn({ err, url }, "Auto-navigate page failed");
     }
   }
 
   cdp.close();
-  onProgress?.({ type: 'done', visitedCount: visitedUrls.length, totalDiscovered: discoveredLinks.length });
-  log.info({ visited: visitedUrls.length, total: discoveredLinks.length + 1 }, 'Auto-navigation finished');
+  onProgress?.({
+    type: "done",
+    visitedCount: visitedUrls.length,
+    totalDiscovered: discoveredLinks.length,
+  });
+  log.info(
+    { visited: visitedUrls.length, total: discoveredLinks.length + 1 },
+    "Auto-navigation finished",
+  );
   return visitedUrls;
 }
 
@@ -202,24 +247,51 @@ interface DiscoveredLink {
 
 /** Paths that are typically navigation chrome, not content pages. */
 const SKIP_PATHS = [
-  '/home', '/login', '/signup', '/register', '/sign-up', '/sign-in',
-  '/help', '/support', '/contact', '/about', '/terms', '/privacy',
-  '/careers', '/press', '/blog', '/faq', '/sitemap',
+  "/home",
+  "/login",
+  "/signup",
+  "/register",
+  "/sign-up",
+  "/sign-in",
+  "/help",
+  "/support",
+  "/contact",
+  "/about",
+  "/terms",
+  "/privacy",
+  "/careers",
+  "/press",
+  "/blog",
+  "/faq",
+  "/sitemap",
 ];
 
 /** Path patterns that indicate high-value purchase/content flows. */
 const HIGH_VALUE_PATTERNS = [
-  /\/orders/i, /\/cart/i, /\/checkout/i, /\/account/i, /\/settings/i,
-  /\/store\//i, /\/restaurant\//i, /\/menu/i, /\/payment/i,
-  /\/profile/i, /\/history/i, /\/favorites/i, /\/saved/i,
-  /\/search/i, /\/category/i, /\/collection/i,
+  /\/orders/i,
+  /\/cart/i,
+  /\/checkout/i,
+  /\/account/i,
+  /\/settings/i,
+  /\/store\//i,
+  /\/restaurant\//i,
+  /\/menu/i,
+  /\/payment/i,
+  /\/profile/i,
+  /\/history/i,
+  /\/favorites/i,
+  /\/saved/i,
+  /\/search/i,
+  /\/category/i,
+  /\/collection/i,
 ];
 
 /** Sort links to prioritize purchase/content flows, deduplicate by pattern. */
 function rankLinks(links: DiscoveredLink[]): DiscoveredLink[] {
-  const filtered = links.filter(l => {
+  const filtered = links.filter((l) => {
     const path = new URL(l.url).pathname.toLowerCase();
-    if (SKIP_PATHS.some(skip => path === skip || path === skip + '/')) return false;
+    if (SKIP_PATHS.some((skip) => path === skip || path === skip + "/"))
+      return false;
     return true;
   });
 
@@ -229,7 +301,9 @@ function rankLinks(links: DiscoveredLink[]): DiscoveredLink[] {
   for (const link of filtered) {
     const parsed = new URL(link.url);
     // Collapse numeric/hash segments to find the pattern
-    const pathPattern = parsed.pathname.replace(/\/\d+/g, '/{id}').replace(/\/[a-f0-9]{8,}/gi, '/{id}');
+    const pathPattern = parsed.pathname
+      .replace(/\/\d+/g, "/{id}")
+      .replace(/\/[a-f0-9]{8,}/gi, "/{id}");
     const pattern = parsed.hostname + pathPattern;
     if (!byPattern.has(pattern)) {
       byPattern.set(pattern, link);
@@ -240,8 +314,8 @@ function rankLinks(links: DiscoveredLink[]): DiscoveredLink[] {
     const aPath = new URL(a.url).pathname.toLowerCase();
     const bPath = new URL(b.url).pathname.toLowerCase();
     // High-value paths first
-    const aHighValue = HIGH_VALUE_PATTERNS.some(p => p.test(aPath)) ? 1 : 0;
-    const bHighValue = HIGH_VALUE_PATTERNS.some(p => p.test(bPath)) ? 1 : 0;
+    const aHighValue = HIGH_VALUE_PATTERNS.some((p) => p.test(aPath)) ? 1 : 0;
+    const bHighValue = HIGH_VALUE_PATTERNS.some((p) => p.test(bPath)) ? 1 : 0;
     if (aHighValue !== bHighValue) return bHighValue - aHighValue;
     // Then by depth (deeper = more specific)
     return Math.min(b.depth, 4) - Math.min(a.depth, 4);
@@ -249,9 +323,12 @@ function rankLinks(links: DiscoveredLink[]): DiscoveredLink[] {
 }
 
 /** Extract internal links from the current page DOM, preserving subdomains. */
-async function discoverInternalLinks(cdp: MiniCDP, domain: string): Promise<DiscoveredLink[]> {
+async function discoverInternalLinks(
+  cdp: MiniCDP,
+  domain: string,
+): Promise<DiscoveredLink[]> {
   try {
-    const result = await cdp.send('Runtime.evaluate', {
+    const result = (await cdp.send("Runtime.evaluate", {
       expression: `
         (function() {
           const domain = ${JSON.stringify(domain)};
@@ -283,7 +360,7 @@ async function discoverInternalLinks(cdp: MiniCDP, domain: string): Promise<Disc
       `,
       awaitPromise: false,
       returnByValue: true,
-    }) as { result?: { value?: DiscoveredLink[] } };
+    })) as { result?: { value?: DiscoveredLink[] } };
     return result?.result?.value ?? [];
   } catch {
     return [];
@@ -294,10 +371,12 @@ async function discoverInternalLinks(cdp: MiniCDP, domain: string): Promise<Disc
 async function scrollPage(cdp: MiniCDP): Promise<void> {
   // Scroll in increments to trigger multiple lazy-load thresholds
   for (let i = 0; i < 3; i++) {
-    await cdp.send('Runtime.evaluate', {
-      expression: 'window.scrollBy(0, 600)',
-      awaitPromise: false,
-    }).catch(() => {});
+    await cdp
+      .send("Runtime.evaluate", {
+        expression: "window.scrollBy(0, 600)",
+        awaitPromise: false,
+      })
+      .catch(() => {});
     await sleep(500);
   }
 }
@@ -310,7 +389,7 @@ async function clickPageTabs(cdp: MiniCDP): Promise<void> {
   const selectors = [
     '[role="tab"]:not(:first-child)',
     '[role="tablist"] button:not(:first-child)',
-    'button[data-tab]',
+    "button[data-tab]",
     '[data-testid*="tab"]',
     'button[aria-expanded="false"]',
   ];
@@ -322,20 +401,22 @@ async function clickPageTabs(cdp: MiniCDP): Promise<void> {
 
   // Also try clicking purchase-flow buttons to trigger API calls
   // (Add to Cart, etc. — these fire API requests even if we don't complete the flow)
-  await clickByText(cdp, 'Add to Cart');
-  await clickByText(cdp, 'Add to Order');
-  await clickByText(cdp, 'Add Item');
+  await clickByText(cdp, "Add to Cart");
+  await clickByText(cdp, "Add to Order");
+  await clickByText(cdp, "Add Item");
 }
 
 /** Click a button by its visible text content. */
 async function clickByText(cdp: MiniCDP, text: string): Promise<boolean> {
   try {
-    const result = await cdp.send('Runtime.evaluate', {
+    const result = (await cdp.send("Runtime.evaluate", {
       expression: `
         (function() {
           const buttons = document.querySelectorAll('button, [role="button"]');
           for (const btn of buttons) {
-            if (btn.textContent && btn.textContent.trim().toLowerCase().includes(${JSON.stringify(text.toLowerCase())})) {
+            if (btn.textContent && btn.textContent.trim().toLowerCase().includes(${JSON.stringify(
+              text.toLowerCase(),
+            )})) {
               btn.scrollIntoView({ block: 'center' });
               btn.click();
               return true;
@@ -346,7 +427,7 @@ async function clickByText(cdp: MiniCDP, text: string): Promise<boolean> {
       `,
       awaitPromise: false,
       returnByValue: true,
-    }) as { result?: { value?: boolean } };
+    })) as { result?: { value?: boolean } };
     return result?.result?.value === true;
   } catch {
     return false;
@@ -355,7 +436,7 @@ async function clickByText(cdp: MiniCDP, text: string): Promise<boolean> {
 
 async function clickInPage(cdp: MiniCDP, selector: string): Promise<boolean> {
   try {
-    const result = await cdp.send('Runtime.evaluate', {
+    const result = (await cdp.send("Runtime.evaluate", {
       expression: `
         (function() {
           const el = document.querySelector(${JSON.stringify(selector)});
@@ -367,7 +448,7 @@ async function clickInPage(cdp: MiniCDP, selector: string): Promise<boolean> {
       `,
       awaitPromise: false,
       returnByValue: true,
-    }) as { result?: { value?: boolean } };
+    })) as { result?: { value?: boolean } };
     return result?.result?.value === true;
   } catch {
     return false;
@@ -375,5 +456,5 @@ async function clickInPage(cdp: MiniCDP, selector: string): Promise<boolean> {
 }
 
 function sleep(ms: number): Promise<void> {
-  return new Promise(r => setTimeout(r, ms));
+  return new Promise((r) => setTimeout(r, ms));
 }

package/src/tools/browser/browser-execution.ts

@@ -540,7 +540,9 @@ export async function executeBrowserSnapshot(
       }
       lines.push("");
       lines.push(
-        `${elements.length} interactive element${elements.length === 1 ? "" : "s"} found.`,
+        `${elements.length} interactive element${
+          elements.length === 1 ? "" : "s"
+        } found.`,
       );
     }
 
@@ -579,7 +581,9 @@ export async function executeBrowserScreenshot(
     };
 
     return {
-      content: `Screenshot captured (${buffer.length} bytes, ${fullPage ? "full page" : "viewport"})`,
+      content: `Screenshot captured (${buffer.length} bytes, ${
+        fullPage ? "full page" : "viewport"
+      })`,
       isError: false,
       contentBlocks: [imageBlock],
     };
@@ -672,7 +676,9 @@ export async function executeBrowserType(
       // with fallback to .innerText for contenteditable elements (preserves
       // visual line breaks from <br> and block elements, unlike textContent).
       const currentValue = (await page.evaluate(
-        `(() => { const el = document.querySelector(${JSON.stringify(selector!)}); if (!el) return ''; if (typeof el.value === 'string') return el.value; return el.innerText ?? ''; })()`,
+        `(() => { const el = document.querySelector(${JSON.stringify(
+          selector!,
+        )}); if (!el) return ''; if (typeof el.value === 'string') return el.value; return el.innerText ?? ''; })()`,
       )) as string;
       await page.fill(selector!, currentValue + text, { timeout: fillTimeout });
     }