@browserbasehq/stagehand 3.0.7-alpha-5e337135056e0c4be59099b1919c2df741b27fea → 3.0.7-alpha-4d71162beb119635b69b17637564a2bbd0e373e7

package/dist/index.js

@@ -179,7 +179,7 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
 var STAGEHAND_VERSION;
 var init_version = __esm({
   "lib/version.ts"() {
-    STAGEHAND_VERSION = "3.0.7-alpha-5e337135056e0c4be59099b1919c2df741b27fea";
+    STAGEHAND_VERSION = "3.0.7-alpha-4d71162beb119635b69b17637564a2bbd0e373e7";
   }
 });
 
@@ -14790,11 +14790,11 @@ var require_bignumber = __commonJS({
         return n > 0 || n === i2 ? i2 : i2 - 1;
       }
       function coeffToString(a) {
-        var s2, z69, i2 = 1, j = a.length, r2 = a[0] + "";
+        var s2, z71, i2 = 1, j = a.length, r2 = a[0] + "";
         for (; i2 < j; ) {
           s2 = a[i2++] + "";
-          z69 = LOG_BASE - s2.length;
-          for (; z69--; s2 = "0" + s2) ;
+          z71 = LOG_BASE - s2.length;
+          for (; z71--; s2 = "0" + s2) ;
           r2 += s2;
         }
         for (j = r2.length; r2.charCodeAt(--j) === 48; ) ;
@@ -14827,15 +14827,15 @@ var require_bignumber = __commonJS({
       function toExponential(str, e2) {
         return (str.length > 1 ? str.charAt(0) + "." + str.slice(1) : str) + (e2 < 0 ? "e" : "e+") + e2;
       }
-      function toFixedPoint(str, e2, z69) {
+      function toFixedPoint(str, e2, z71) {
         var len, zs;
         if (e2 < 0) {
-          for (zs = z69 + "."; ++e2; zs += z69) ;
+          for (zs = z71 + "."; ++e2; zs += z71) ;
           str = zs + str;
         } else {
           len = str.length;
           if (++e2 > len) {
-            for (zs = z69, e2 -= len; --e2; zs += z69) ;
+            for (zs = z71, e2 -= len; --e2; zs += z71) ;
             str += zs;
           } else if (e2 < len) {
             str = str.slice(0, e2) + "." + str.slice(e2);
@@ -26435,14 +26435,38 @@ var init_page = __esm({
               }));
               return;
             }
+            const isLetter = /^[a-zA-Z]$/.test(ch);
+            const isDigit = /^[0-9]$/.test(ch);
+            let key = ch;
+            let code = "";
+            let windowsVirtualKeyCode;
+            if (isLetter) {
+              key = ch;
+              code = `Key${ch.toUpperCase()}`;
+              windowsVirtualKeyCode = ch.toUpperCase().charCodeAt(0);
+            } else if (isDigit) {
+              key = ch;
+              code = `Digit${ch}`;
+              windowsVirtualKeyCode = ch.charCodeAt(0);
+            } else if (ch === " ") {
+              key = " ";
+              code = "Space";
+              windowsVirtualKeyCode = 32;
+            }
             const down = {
               type: "keyDown",
+              key,
+              code: code || void 0,
               text: ch,
-              unmodifiedText: ch
+              unmodifiedText: ch,
+              windowsVirtualKeyCode
             };
             yield this.mainSession.send("Input.dispatchKeyEvent", down);
             yield this.mainSession.send("Input.dispatchKeyEvent", {
-              type: "keyUp"
+              type: "keyUp",
+              key,
+              code: code || void 0,
+              windowsVirtualKeyCode
             });
           });
           const pressBackspace = () => __async(this, null, function* () {
@@ -26634,10 +26658,11 @@ var init_page = __esm({
           });
         });
       }
-      /** Normalize modifier key names to match CDP expectations */
+      /** Normalize key names to match CDP expectations */
       normalizeModifierKey(key) {
-        const normalized = key.toLowerCase();
-        switch (normalized) {
+        const lower2 = key.toLowerCase();
+        switch (lower2) {
+          // Modifier keys
           case "cmd":
           case "command":
             return this.isMacOS() ? "Meta" : "Control";
@@ -26645,11 +26670,56 @@ var init_page = __esm({
           case "windows":
             return "Meta";
           case "ctrl":
+          case "control":
             return "Control";
           case "option":
+          case "alt":
             return "Alt";
           case "shift":
             return "Shift";
+          case "meta":
+            return "Meta";
+          // Action keys
+          case "enter":
+          case "return":
+            return "Enter";
+          case "esc":
+          case "escape":
+            return "Escape";
+          case "backspace":
+            return "Backspace";
+          case "tab":
+            return "Tab";
+          case "space":
+          case "spacebar":
+            return " ";
+          case "delete":
+          case "del":
+            return "Delete";
+          // Arrow keys
+          case "left":
+          case "arrowleft":
+            return "ArrowLeft";
+          case "right":
+          case "arrowright":
+            return "ArrowRight";
+          case "up":
+          case "arrowup":
+            return "ArrowUp";
+          case "down":
+          case "arrowdown":
+            return "ArrowDown";
+          // Navigation keys
+          case "home":
+            return "Home";
+          case "end":
+            return "End";
+          case "pageup":
+          case "pgup":
+            return "PageUp";
+          case "pagedown":
+          case "pgdn":
+            return "PageDown";
           default:
             return key;
         }
@@ -30682,10 +30752,10 @@ var ObserveHandler = class {
   }
 };
 
-// lib/v3/agent/tools/v3-goto.ts
+// lib/v3/agent/tools/goto.ts
 var import_ai = require("ai");
 var import_zod5 = require("zod");
-var createGotoTool = (v3) => (0, import_ai.tool)({
+var gotoTool = (v3) => (0, import_ai.tool)({
   description: "Navigate to a specific URL",
   inputSchema: import_zod5.z.object({
     url: import_zod5.z.string().describe("The URL to navigate to")
@@ -30714,10 +30784,10 @@ var createGotoTool = (v3) => (0, import_ai.tool)({
   })
 });
 
-// lib/v3/agent/tools/v3-act.ts
+// lib/v3/agent/tools/act.ts
 var import_ai2 = require("ai");
 var import_zod6 = require("zod");
-var createActTool = (v3, executionModel) => (0, import_ai2.tool)({
+var actTool = (v3, executionModel) => (0, import_ai2.tool)({
   description: "Perform an action on the page (click, type). Provide a short, specific phrase that mentions the element type.",
   inputSchema: import_zod6.z.object({
     action: import_zod6.z.string().describe(
@@ -30759,10 +30829,10 @@ var createActTool = (v3, executionModel) => (0, import_ai2.tool)({
   })
 });
 
-// lib/v3/agent/tools/v3-screenshot.ts
+// lib/v3/agent/tools/screenshot.ts
 var import_ai3 = require("ai");
 var import_zod7 = require("zod");
-var createScreenshotTool = (v3) => (0, import_ai3.tool)({
+var screenshotTool = (v3) => (0, import_ai3.tool)({
   description: "Takes a screenshot (PNG) of the current page. Use this to quickly verify page state.",
   inputSchema: import_zod7.z.object({}),
   execute: () => __async(null, null, function* () {
@@ -30786,10 +30856,10 @@ var createScreenshotTool = (v3) => (0, import_ai3.tool)({
   })
 });
 
-// lib/v3/agent/tools/v3-wait.ts
+// lib/v3/agent/tools/wait.ts
 var import_ai4 = require("ai");
 var import_zod8 = require("zod");
-var createWaitTool = (v3) => (0, import_ai4.tool)({
+var waitTool = (v3) => (0, import_ai4.tool)({
   description: "Wait for a specified time",
   inputSchema: import_zod8.z.object({
     timeMs: import_zod8.z.number().describe("Time in milliseconds")
@@ -30814,10 +30884,10 @@ var createWaitTool = (v3) => (0, import_ai4.tool)({
   })
 });
 
-// lib/v3/agent/tools/v3-navback.ts
+// lib/v3/agent/tools/navback.ts
 var import_ai5 = require("ai");
 var import_zod9 = require("zod");
-var createNavBackTool = (v3) => (0, import_ai5.tool)({
+var navBackTool = (v3) => (0, import_ai5.tool)({
   description: "Navigate back to the previous page",
   inputSchema: import_zod9.z.object({
     reasoningText: import_zod9.z.string().describe("Why you're going back")
@@ -30838,10 +30908,10 @@ var createNavBackTool = (v3) => (0, import_ai5.tool)({
   })
 });
 
-// lib/v3/agent/tools/v3-close.ts
+// lib/v3/agent/tools/close.ts
 var import_ai6 = require("ai");
 var import_zod10 = require("zod");
-var createCloseTool = () => (0, import_ai6.tool)({
+var closeTool = () => (0, import_ai6.tool)({
   description: "Complete the task and close",
   inputSchema: import_zod10.z.object({
     reasoning: import_zod10.z.string().describe("Summary of what was accomplished"),
@@ -30852,10 +30922,10 @@ var createCloseTool = () => (0, import_ai6.tool)({
   })
 });
 
-// lib/v3/agent/tools/v3-ariaTree.ts
+// lib/v3/agent/tools/ariaTree.ts
 var import_ai7 = require("ai");
 var import_zod11 = require("zod");
-var createAriaTreeTool = (v3) => (0, import_ai7.tool)({
+var ariaTreeTool = (v3) => (0, import_ai7.tool)({
   description: "gets the accessibility (ARIA) hybrid tree text for the current page. use this to understand structure and content.",
   inputSchema: import_zod11.z.object({}),
   execute: () => __async(null, null, function* () {
@@ -30883,10 +30953,10 @@ ${result.content}` }]
   })
 });
 
-// lib/v3/agent/tools/v3-fillform.ts
+// lib/v3/agent/tools/fillform.ts
 var import_ai8 = require("ai");
 var import_zod12 = require("zod");
-var createFillFormTool = (v3, executionModel) => (0, import_ai8.tool)({
+var fillFormTool = (v3, executionModel) => (0, import_ai8.tool)({
   description: `\u{1F4DD} FORM FILL - MULTI-FIELD INPUT TOOL
 For any form with 2+ inputs/textareas. Faster than individual typing.`,
   inputSchema: import_zod12.z.object({
@@ -30937,32 +31007,114 @@ For any form with 2+ inputs/textareas. Faster than individual typing.`,
   })
 });
 
-// lib/v3/agent/tools/v3-scroll.ts
+// lib/v3/agent/tools/scroll.ts
 var import_ai9 = require("ai");
 var import_zod13 = require("zod");
-var createScrollTool = (v3) => (0, import_ai9.tool)({
-  description: "Scroll the page",
+
+// lib/v3/agent/utils/coordinateNormalization.ts
+var DEFAULT_VIEWPORT = { width: 1288, height: 711 };
+function isGoogleProvider(provider) {
+  if (!provider) return false;
+  return provider.toLowerCase().includes("google");
+}
+function normalizeGoogleCoordinates(x2, y) {
+  const clampedX = Math.min(999, Math.max(0, x2));
+  const clampedY = Math.min(999, Math.max(0, y));
+  return {
+    x: Math.floor(clampedX / 1e3 * DEFAULT_VIEWPORT.width),
+    y: Math.floor(clampedY / 1e3 * DEFAULT_VIEWPORT.height)
+  };
+}
+function processCoordinates(x2, y, provider) {
+  if (isGoogleProvider(provider)) {
+    return normalizeGoogleCoordinates(x2, y);
+  }
+  return { x: x2, y };
+}
+
+// lib/v3/agent/tools/scroll.ts
+var scrollTool = (v3) => (0, import_ai9.tool)({
+  description: "Scroll the page up or down by a percentage of the viewport height. Default is 80%, and what should be typically used for general page scrolling",
   inputSchema: import_zod13.z.object({
-    pixels: import_zod13.z.number().describe("Number of pixels to scroll up or down"),
-    direction: import_zod13.z.enum(["up", "down"]).describe("Direction to scroll")
+    direction: import_zod13.z.enum(["up", "down"]),
+    percentage: import_zod13.z.number().min(1).max(200).optional()
   }),
-  execute: (_0) => __async(null, [_0], function* ({ pixels, direction }) {
+  execute: (_0) => __async(null, [_0], function* ({ direction, percentage = 80 }) {
     v3.logger({
       category: "agent",
       message: `Agent calling tool: scroll`,
       level: 1,
       auxiliary: {
         arguments: {
-          value: JSON.stringify({ pixels, direction }),
+          value: JSON.stringify({ direction, percentage }),
           type: "object"
         }
       }
     });
     const page = yield v3.context.awaitActivePage();
     const { w, h: h2 } = yield page.mainFrame().evaluate("({ w: window.innerWidth, h: window.innerHeight })");
-    const cx = Math.max(0, Math.floor(w / 2));
-    const cy = Math.max(0, Math.floor(h2 / 2));
-    const deltaY = direction === "up" ? -Math.abs(pixels) : Math.abs(pixels);
+    const scrollDistance = Math.round(h2 * percentage / 100);
+    const cx = Math.floor(w / 2);
+    const cy = Math.floor(h2 / 2);
+    const deltaY = direction === "up" ? -scrollDistance : scrollDistance;
+    yield page.scroll(cx, cy, 0, deltaY);
+    v3.recordAgentReplayStep({
+      type: "scroll",
+      deltaX: 0,
+      deltaY,
+      anchor: { x: cx, y: cy }
+    });
+    return {
+      success: true,
+      message: `Scrolled ${percentage}% ${direction} (${scrollDistance}px)`,
+      scrolledPixels: scrollDistance
+    };
+  })
+});
+var scrollVisionTool = (v3, provider) => (0, import_ai9.tool)({
+  description: `Scroll the page up or down. For general page scrolling, no coordinates needed. Only provide coordinates when scrolling inside a nested scrollable element (e.g., a dropdown menu, modal with overflow, or scrollable sidebar). Default is 80%, and what should be typically used for general page scrolling`,
+  inputSchema: import_zod13.z.object({
+    direction: import_zod13.z.enum(["up", "down"]),
+    coordinates: import_zod13.z.array(import_zod13.z.number()).optional().describe(
+      "Only use coordinates for scrolling inside a nested scrollable element - provide (x, y) within that element"
+    ),
+    percentage: import_zod13.z.number().min(1).max(200).optional()
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ direction, coordinates, percentage = 80 }) {
+    const page = yield v3.context.awaitActivePage();
+    const { w, h: h2 } = yield page.mainFrame().evaluate("({ w: window.innerWidth, h: window.innerHeight })");
+    let cx;
+    let cy;
+    if (coordinates) {
+      const processed = processCoordinates(
+        coordinates[0],
+        coordinates[1],
+        provider
+      );
+      cx = processed.x;
+      cy = processed.y;
+    } else {
+      cx = Math.floor(w / 2);
+      cy = Math.floor(h2 / 2);
+    }
+    v3.logger({
+      category: "agent",
+      message: `Agent calling tool: scroll`,
+      level: 1,
+      auxiliary: {
+        arguments: {
+          value: JSON.stringify({
+            direction,
+            coordinates,
+            percentage,
+            processed: { cx, cy }
+          }),
+          type: "object"
+        }
+      }
+    });
+    const scrollDistance = Math.round(h2 * percentage / 100);
+    const deltaY = direction === "up" ? -scrollDistance : scrollDistance;
     yield page.scroll(cx, cy, 0, deltaY);
     v3.recordAgentReplayStep({
       type: "scroll",
@@ -30970,11 +31122,15 @@ var createScrollTool = (v3) => (0, import_ai9.tool)({
       deltaY,
       anchor: { x: cx, y: cy }
     });
-    return { success: true, pixels };
+    return {
+      success: true,
+      message: coordinates ? `Scrolled ${percentage}% ${direction} at (${cx}, ${cy})` : `Scrolled ${percentage}% ${direction}`,
+      scrolledPixels: scrollDistance
+    };
   })
 });
 
-// lib/v3/agent/tools/v3-extract.ts
+// lib/v3/agent/tools/extract.ts
 var import_ai10 = require("ai");
 var import_zod14 = require("zod");
 function evaluateZodSchema(schemaStr, logger) {
@@ -30991,7 +31147,7 @@ function evaluateZodSchema(schemaStr, logger) {
     return import_zod14.z.any();
   }
 }
-var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
+var extractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
   description: `Extract structured data from the current page based on a provided schema.
     
     USAGE GUIDELINES:
@@ -31026,25 +31182,677 @@ var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
   })
 });
 
+// lib/v3/agent/tools/click.ts
+var import_ai11 = require("ai");
+var import_zod15 = require("zod");
+function waitForTimeout(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var clickTool = (v3, provider) => (0, import_ai11.tool)({
+  description: "Click on an element using its coordinates (this is the most reliable way to click on an element, always use this over act, unless the element is not visible in the screenshot, but shown in ariaTree)",
+  inputSchema: import_zod15.z.object({
+    describe: import_zod15.z.string().describe(
+      "Describe the element to click on in a short, specific phrase that mentions the element type and a good visual description"
+    ),
+    coordinates: import_zod15.z.array(import_zod15.z.number()).describe("The (x, y) coordinates to click on")
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ describe, coordinates }) {
+    try {
+      const page = yield v3.context.awaitActivePage();
+      const processed = processCoordinates(
+        coordinates[0],
+        coordinates[1],
+        provider
+      );
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: click`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({ describe, coordinates, processed }),
+            type: "string"
+          }
+        }
+      });
+      yield page.click(processed.x, processed.y);
+      if (isGoogleProvider(provider)) {
+        yield waitForTimeout(1e3);
+      }
+      v3.recordAgentReplayStep({
+        type: "click",
+        instruction: describe,
+        playwrightArguments: { coordinates: [processed.x, processed.y] }
+      });
+      return {
+        success: true,
+        describe,
+        coordinates: [processed.x, processed.y]
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Error clicking: ${error.message}`
+      };
+    }
+  })
+});
+
+// lib/v3/agent/tools/type.ts
+var import_ai12 = require("ai");
+var import_zod16 = require("zod");
+function waitForTimeout2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var typeTool = (v3, provider) => (0, import_ai12.tool)({
+  description: "Type text into an element using its coordinates. This will click the element and then type the text into it (this is the most reliable way to type into an element, always use this over act, unless the element is not visible in the screenshot, but shown in ariaTree)",
+  inputSchema: import_zod16.z.object({
+    describe: import_zod16.z.string().describe(
+      "Describe the element to type into in a short, specific phrase that mentions the element type and a good visual description"
+    ),
+    text: import_zod16.z.string().describe("The text to type into the element"),
+    coordinates: import_zod16.z.array(import_zod16.z.number()).describe("The (x, y) coordinates to type into the element")
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ describe, coordinates, text }) {
+    try {
+      const page = yield v3.context.awaitActivePage();
+      const processed = processCoordinates(
+        coordinates[0],
+        coordinates[1],
+        provider
+      );
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: type`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({ describe, coordinates, processed, text }),
+            type: "string"
+          }
+        }
+      });
+      yield page.click(processed.x, processed.y);
+      if (isGoogleProvider(provider)) {
+        yield waitForTimeout2(1e3);
+      }
+      yield page.type(text);
+      v3.recordAgentReplayStep({
+        type: "type",
+        instruction: describe,
+        playwrightArguments: {
+          coordinates: [processed.x, processed.y],
+          text
+        }
+      });
+      return { success: true, describe, text };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Error typing: ${error.message}`
+      };
+    }
+  })
+});
+
+// lib/v3/agent/tools/dragAndDrop.ts
+var import_ai13 = require("ai");
+var import_zod17 = require("zod");
+var dragAndDropTool = (v3, provider) => (0, import_ai13.tool)({
+  description: "Drag and drop an element using its coordinates (this is the most reliable way to drag and drop an element, always use this over act, unless the element is not visible in the screenshot, but shown in ariaTree)",
+  inputSchema: import_zod17.z.object({
+    describe: import_zod17.z.string().describe("Describe the element to drag and drop"),
+    startCoordinates: import_zod17.z.array(import_zod17.z.number()).describe("The (x, y) coordinates to start the drag and drop from"),
+    endCoordinates: import_zod17.z.array(import_zod17.z.number()).describe("The (x, y) coordinates to end the drag and drop at")
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ describe, startCoordinates, endCoordinates }) {
+    try {
+      const page = yield v3.context.awaitActivePage();
+      const processedStart = processCoordinates(
+        startCoordinates[0],
+        startCoordinates[1],
+        provider
+      );
+      const processedEnd = processCoordinates(
+        endCoordinates[0],
+        endCoordinates[1],
+        provider
+      );
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: dragAndDrop`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({
+              describe,
+              startCoordinates,
+              endCoordinates,
+              processedStart,
+              processedEnd
+            }),
+            type: "string"
+          }
+        }
+      });
+      yield page.dragAndDrop(
+        processedStart.x,
+        processedStart.y,
+        processedEnd.x,
+        processedEnd.y
+      );
+      v3.recordAgentReplayStep({
+        type: "dragAndDrop",
+        instruction: describe,
+        playwrightArguments: {
+          startCoordinates: [processedStart.x, processedStart.y],
+          endCoordinates: [processedEnd.x, processedEnd.y]
+        }
+      });
+      return { success: true, describe };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Error dragging: ${error.message}`
+      };
+    }
+  })
+});
+
+// lib/v3/agent/tools/clickAndHold.ts
+var import_ai14 = require("ai");
+var import_zod18 = require("zod");
+var clickAndHoldTool = (v3, provider) => (0, import_ai14.tool)({
+  description: "Click and hold on an element using its coordinates",
+  inputSchema: import_zod18.z.object({
+    describe: import_zod18.z.string().describe(
+      "Describe the element to click on in a short, specific phrase that mentions the element type and a good visual description"
+    ),
+    duration: import_zod18.z.number().describe("The duration to hold the element in milliseconds"),
+    coordinates: import_zod18.z.array(import_zod18.z.number()).describe("The (x, y) coordinates to click on")
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ describe, coordinates, duration }) {
+    try {
+      const page = yield v3.context.awaitActivePage();
+      const processed = processCoordinates(
+        coordinates[0],
+        coordinates[1],
+        provider
+      );
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: clickAndHold`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({
+              describe,
+              coordinates,
+              processed,
+              duration
+            }),
+            type: "string"
+          }
+        }
+      });
+      yield page.dragAndDrop(
+        processed.x,
+        processed.y,
+        processed.x,
+        processed.y,
+        { delay: duration }
+      );
+      v3.recordAgentReplayStep({
+        type: "clickAndHold",
+        instruction: describe,
+        playwrightArguments: {
+          coordinates: [processed.x, processed.y],
+          duration
+        }
+      });
+      return { success: true, describe };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Error clicking and holding: ${error.message}`
+      };
+    }
+  })
+});
+
+// lib/v3/agent/tools/keys.ts
+var import_ai15 = require("ai");
+var import_zod19 = require("zod");
+var keysTool = (v3) => (0, import_ai15.tool)({
+  description: `Send keyboard input to the page without targeting a specific element. Unlike the type tool which clicks then types into coordinates, this sends keystrokes directly to wherever focus currently is.
+
+Use method="type" to enter text into the currently focused element. Preferred when: input is already focused, text needs to flow across multiple fields (e.g., verification codes)
+
+Use method="press" for navigation keys (Enter, Tab, Escape, Backspace, arrows) and keyboard shortcuts (Cmd+A, Ctrl+C, Shift+Tab).`,
+  inputSchema: import_zod19.z.object({
+    method: import_zod19.z.enum(["press", "type"]),
+    value: import_zod19.z.string().describe(
+      "The text to type, or the key/combo to press (Enter, Tab, Cmd+A)"
+    ),
+    repeat: import_zod19.z.number().optional()
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ method, value, repeat }) {
+    try {
+      const page = yield v3.context.awaitActivePage();
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: keys`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({ method, value, repeat }),
+            type: "string"
+          }
+        }
+      });
+      const times = Math.max(1, repeat != null ? repeat : 1);
+      if (method === "type") {
+        for (let i2 = 0; i2 < times; i2++) {
+          yield page.type(value, { delay: 100 });
+        }
+        v3.recordAgentReplayStep({
+          type: "keys",
+          instruction: `type "${value}"`,
+          playwrightArguments: { method, text: value, times }
+        });
+        return { success: true, method, value, times };
+      }
+      if (method === "press") {
+        for (let i2 = 0; i2 < times; i2++) {
+          yield page.keyPress(value, { delay: 100 });
+        }
+        v3.recordAgentReplayStep({
+          type: "keys",
+          instruction: `press ${value}`,
+          playwrightArguments: { method, keys: value, times }
+        });
+        return { success: true, method, value, times };
+      }
+      return { success: false, error: `Unsupported method: ${method}` };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  })
+});
+
+// lib/v3/agent/tools/fillFormVision.ts
+var import_ai16 = require("ai");
+var import_zod20 = require("zod");
+var fillFormVisionTool = (v3, provider) => (0, import_ai16.tool)({
+  description: `FORM FILL - SPECIALIZED MULTI-FIELD INPUT TOOL
+
+CRITICAL: Use this for ANY form with 2+ input fields (text inputs, textareas, etc.)
+IMPORTANT: Ensure the fields are visible within the current viewport
+
+WHY THIS TOOL EXISTS:
+- Forms are the #1 use case for multi-field input
+- Optimized specifically for input/textarea elements
+- 4-6x faster than individual typing actions
+
+Use fillFormVision: Pure form filling (inputs, textareas only)
+MANDATORY USE CASES (always use fillFormVision for these):
+- Registration forms: name, email, password fields
+- Contact forms: name, email, message fields
+- Checkout forms: address, payment info fields
+- Profile updates: multiple user data fields
+- Search filters: multiple criteria inputs`,
+  inputSchema: import_zod20.z.object({
+    fields: import_zod20.z.array(
+      import_zod20.z.object({
+        action: import_zod20.z.string().describe(
+          "Description of the typing action, e.g. 'type foo into the bar field'"
+        ),
+        value: import_zod20.z.string().describe("Text to type into the target field"),
+        coordinates: import_zod20.z.object({
+          x: import_zod20.z.number(),
+          y: import_zod20.z.number()
+        }).describe("Coordinates of the target field")
+      })
+    ).min(2, "Provide at least two fields to fill")
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ fields }) {
+    try {
+      const page = yield v3.context.awaitActivePage();
+      const processedFields = fields.map((field) => {
+        const processed = processCoordinates(
+          field.coordinates.x,
+          field.coordinates.y,
+          provider
+        );
+        return __spreadProps(__spreadValues({}, field), {
+          coordinates: { x: processed.x, y: processed.y }
+        });
+      });
+      v3.logger({
+        category: "agent",
+        message: `Agent calling tool: fillFormVision`,
+        level: 1,
+        auxiliary: {
+          arguments: {
+            value: JSON.stringify({ fields, processedFields }),
+            type: "string"
+          }
+        }
+      });
+      for (const field of processedFields) {
+        yield page.click(field.coordinates.x, field.coordinates.y);
+        yield page.type(field.value);
+        yield new Promise((resolve3) => setTimeout(resolve3, 100));
+      }
+      v3.recordAgentReplayStep({
+        type: "fillFormVision",
+        instruction: `Fill ${fields.length} form fields`,
+        playwrightArguments: processedFields
+      });
+      return {
+        success: true,
+        playwrightArguments: processedFields
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Error filling form: ${error.message}`
+      };
+    }
+  })
+});
+
+// lib/v3/agent/tools/think.ts
+var import_ai17 = require("ai");
+var import_zod21 = require("zod");
+var thinkTool = () => (0, import_ai17.tool)({
+  description: `Use this tool to think through complex problems or plan a sequence of steps. This is for internal reasoning only and doesn't perform any actions. Use this to:
+
+1. Plan a multi-step approach before taking action
+2. Break down complex tasks
+3. Reason through edge cases
+4. Evaluate options when you're unsure what to do next
+
+The output is only visible to you; use it to track your own reasoning process.`,
+  inputSchema: import_zod21.z.object({
+    reasoning: import_zod21.z.string().describe(
+      "Your step-by-step reasoning or planning process. Be as detailed as needed."
+    )
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ reasoning }) {
+    return {
+      acknowledged: true,
+      message: reasoning
+    };
+  })
+});
+
+// lib/v3/agent/tools/search.ts
+var import_ai18 = require("ai");
+var import_zod22 = require("zod");
+function performBraveSearch(query) {
+  return __async(this, null, function* () {
+    var _a4;
+    try {
+      const encodedQuery = encodeURIComponent(query);
+      const response = yield fetch(
+        `https://api.search.brave.com/res/v1/web/search?q=${encodedQuery}`,
+        {
+          method: "GET",
+          headers: {
+            Accept: "application/json",
+            "Accept-Encoding": "gzip",
+            "X-Subscription-Token": process.env.BRAVE_API_KEY
+          }
+        }
+      );
+      if (!response.ok) {
+        return {
+          error: `Brave API error: ${response.status} ${response.statusText}`,
+          data: { results: [] }
+        };
+      }
+      const data = yield response.json();
+      const results = [];
+      if (((_a4 = data == null ? void 0 : data.web) == null ? void 0 : _a4.results) && Array.isArray(data.web.results)) {
+        for (const item of data.web.results.slice(0, 5)) {
+          if (item.title && item.url) {
+            results.push({
+              title: item.title,
+              url: item.url,
+              description: item.description
+            });
+          }
+        }
+      }
+      return { data: { results } };
+    } catch (error) {
+      console.error("Search error", error);
+      return {
+        error: `Error performing search: ${error.message}`,
+        data: { results: [] }
+      };
+    }
+  });
+}
+var searchTool = (v3) => (0, import_ai18.tool)({
+  description: "Perform a web search and returns results. Use this tool when you need information from the web or when you are unsure of the exact URL you want to navigate to. This can be used to find the ideal entry point, resulting in a task that is easier to complete due to starting further in the process.",
+  inputSchema: import_zod22.z.object({
+    query: import_zod22.z.string().describe("The search query to look for on the web")
+  }),
+  execute: (_0) => __async(null, [_0], function* ({ query }) {
+    var _a4, _b, _c;
+    v3.logger({
+      category: "agent",
+      message: `Agent calling tool: search`,
+      level: 1,
+      auxiliary: {
+        arguments: {
+          value: JSON.stringify({ query }),
+          type: "string"
+        }
+      }
+    });
+    const result = yield performBraveSearch(query);
+    v3.recordAgentReplayStep({
+      type: "search",
+      instruction: query,
+      playwrightArguments: { query },
+      message: (_c = result.error) != null ? _c : `Found ${(_b = (_a4 = result.data) == null ? void 0 : _a4.results.length) != null ? _b : 0} results`
+    });
+    return __spreadProps(__spreadValues({}, result), {
+      timestamp: Date.now()
+    });
+  })
+});
+
 // lib/v3/agent/tools/index.ts
+function filterToolsByMode(tools, mode) {
+  const filtered = __spreadValues({}, tools);
+  if (mode === "hybrid") {
+    delete filtered.fillForm;
+    return filtered;
+  }
+  delete filtered.click;
+  delete filtered.type;
+  delete filtered.dragAndDrop;
+  delete filtered.clickAndHold;
+  delete filtered.fillFormVision;
+  return filtered;
+}
 function createAgentTools(v3, options) {
+  var _a4;
   const executionModel = options == null ? void 0 : options.executionModel;
-  return {
-    act: createActTool(v3, executionModel),
-    ariaTree: createAriaTreeTool(v3),
-    close: createCloseTool(),
-    extract: createExtractTool(v3, executionModel, options == null ? void 0 : options.logger),
-    fillForm: createFillFormTool(v3, executionModel),
-    goto: createGotoTool(v3),
-    navback: createNavBackTool(v3),
-    screenshot: createScreenshotTool(v3),
-    scroll: createScrollTool(v3),
-    wait: createWaitTool(v3)
+  const mode = (_a4 = options == null ? void 0 : options.mode) != null ? _a4 : "dom";
+  const provider = options == null ? void 0 : options.provider;
+  const allTools = {
+    act: actTool(v3, executionModel),
+    ariaTree: ariaTreeTool(v3),
+    click: clickTool(v3, provider),
+    clickAndHold: clickAndHoldTool(v3, provider),
+    close: closeTool(),
+    dragAndDrop: dragAndDropTool(v3, provider),
+    extract: extractTool(v3, executionModel, options == null ? void 0 : options.logger),
+    fillForm: fillFormTool(v3, executionModel),
+    fillFormVision: fillFormVisionTool(v3, provider),
+    goto: gotoTool(v3),
+    keys: keysTool(v3),
+    navback: navBackTool(v3),
+    screenshot: screenshotTool(v3),
+    scroll: mode === "hybrid" ? scrollVisionTool(v3, provider) : scrollTool(v3),
+    think: thinkTool(),
+    type: typeTool(v3, provider),
+    wait: waitTool(v3)
   };
+  if (process.env.BRAVE_API_KEY) {
+    allTools.search = searchTool(v3);
+  }
+  return filterToolsByMode(allTools, mode);
+}
+
+// lib/v3/agent/prompts/agentSystemPrompt.ts
+function buildAgentSystemPrompt(options) {
+  const {
+    url,
+    executionInstruction,
+    mode,
+    systemInstructions,
+    isBrowserbase = false
+  } = options;
+  const localeDate = (/* @__PURE__ */ new Date()).toLocaleDateString();
+  const isoDate = (/* @__PURE__ */ new Date()).toISOString();
+  const cdata = (text) => `<![CDATA[${text}]]>`;
+  const isHybridMode = mode === "hybrid";
+  const hasSearch = Boolean(process.env.BRAVE_API_KEY);
+  const searchToolLine = hasSearch ? `
+    <tool name="search">Perform a web search and return results. Prefer this over navigating to Google and searching within the page for reliability and efficiency.</tool>` : "";
+  const toolsSection = isHybridMode ? `<tools>
+    <tool name="screenshot">Take a compressed JPEG screenshot for quick visual context</tool>
+    <tool name="ariaTree">Get an accessibility (ARIA) hybrid tree for full page context</tool>
+    <tool name="click">Click on an element (PREFERRED - more reliable when element is visible in viewport)</tool>
+    <tool name="type">Type text into an element (PREFERRED - more reliable when element is visible in viewport)</tool>
+    <tool name="act">Perform a specific atomic action (click, type, etc.) - ONLY use when element is in ariaTree but NOT visible in screenshot. Less reliable but can interact with out-of-viewport elements.</tool>
+    <tool name="dragAndDrop">Drag and drop an element</tool>
+    <tool name="clickAndHold">Click and hold on an element</tool>
+    <tool name="keys">Press a keyboard key</tool>
+    <tool name="fillFormVision">Fill out a form using coordinates</tool>
+    <tool name="think">Think about the task</tool>
+    <tool name="extract">Extract structured data</tool>
+    <tool name="goto">Navigate to a URL</tool>
+    <tool name="wait|navback">Control timing and navigation</tool>
+    <tool name="scroll">Scroll the page x pixels up or down</tool>
+    ${searchToolLine}
+  </tools>` : `<tools>
+    <tool name="screenshot">Take a compressed JPEG screenshot for quick visual context</tool>
+    <tool name="ariaTree">Get an accessibility (ARIA) hybrid tree for full page context</tool>
+    <tool name="act">Perform a specific atomic action (click, type)</tool>
+    <tool name="keys">Press a keyboard key</tool>
+    <tool name="fillForm">Fill out a form</tool>
+    <tool name="think">Think about the task</tool>
+    <tool name="extract">Extract structured data</tool>
+    <tool name="goto">Navigate to a URL</tool>
+    <tool name="wait|navback">Control timing and navigation</tool>
+    <tool name="scroll">Scroll the page x pixels up or down</tool>
+    ${searchToolLine}
+  </tools>`;
+  const strategyItems = isHybridMode ? [
+    `<item>Tool selection priority: Use specific tools (click, type) when elements are visible in viewport for maximum reliability.</item>`,
+    `<item>Always use screenshot to get proper grounding of the coordinates you want to type/click into.</item>`,
+    `<item>When interacting with an input, always use the type tool to type into the input, over clicking and then typing into it.</item>`,
+    `<item>Use ariaTree as a secondary tool when elements aren't visible in screenshot or to get full page context.</item>`,
+    `<item>Only use act when element is in ariaTree but NOT visible in screenshot.</item>`
+  ] : [
+    `<item>Tool selection priority: Use act tool for all clicking and typing on a page.</item>`,
+    `<item>Always check ariaTree first to understand full page content without scrolling - it shows all elements including those below the fold.</item>`,
+    `<item>When interacting with an input, always use the act tool to type into the input, over clicking and then typing.</item>`,
+    `<item>If an element is present in the ariaTree, use act to interact with it directly - this eliminates the need to scroll.</item>`,
+    `<item>Use screenshot for visual confirmation when needed, but rely primarily on ariaTree for element detection.</item>`
+  ];
+  const strategySection = strategyItems.join("\n    ");
+  const commonStrategyItems = `
+    <item>CRITICAL: Use extract ONLY when the task explicitly requires structured data output (e.g., "get job listings", "extract product details"). For reading page content or understanding elements, always use ${isHybridMode ? "screenshot or ariaTree" : "ariaTree"} instead - it's faster and more reliable.</item>
+    <item>Keep actions atomic and verify outcomes before proceeding.</item>
+    <item>For each action, provide clear reasoning about why you're taking that step.</item>
+    <item>When you need to input text that could be entered character-by-character or through multiple separate inputs, prefer using the keys tool to type the entire sequence at once. This is more efficient for scenarios like verification codes split across multiple fields, or when virtual keyboards are present but direct typing would be faster.</item>
+    `;
+  const pageUnderstandingProtocol = isHybridMode ? `<page_understanding_protocol>
+    <step_1>
+      <title>UNDERSTAND THE PAGE</title>
+      <primary_tool>
+        <name>screenshot</name>
+        <usage>Visual confirmation when needed. Ideally after navigating to a new page.</usage>
+        </primary_tool>
+      <secondary_tool>
+        <name>ariaTree</name>
+        <usage>Get complete page context before taking actions</usage>
+        <benefit>Eliminates the need to scroll and provides full accessible content</benefit>
+      </secondary_tool>
+    </step_1>
+  </page_understanding_protocol>` : `<page_understanding_protocol>
+    <step_1>
+      <title>UNDERSTAND THE PAGE</title>
+      <primary_tool>
+        <name>ariaTree</name>
+        <usage>Get complete page context before taking actions</usage>
+        <benefit>Eliminates the need to scroll and provides full accessible content</benefit>
+        </primary_tool>
+      <secondary_tool>
+        <name>screenshot</name>
+        <usage>Visual confirmation when needed. Ideally after navigating to a new page.</usage>
+      </secondary_tool>
+    </step_1>
+  </page_understanding_protocol>`;
+  const roadblocksSection = isBrowserbase ? `<roadblocks>
+    <note>captchas, popups, etc.</note>
+    <captcha>If you see a captcha, use the wait tool. It will automatically be solved by our internal solver.</captcha>
+  </roadblocks>` : "";
+  const customInstructionsBlock = systemInstructions ? `<customInstructions>${cdata(systemInstructions)}</customInstructions>
+  ` : "";
+  return `<system>
+  <identity>You are a web automation assistant using browser automation tools to accomplish the user's goal.</identity>
+  ${customInstructionsBlock}<task>
+    <goal>${cdata(executionInstruction)}</goal>
+    <date display="local" iso="${isoDate}">${localeDate}</date>
+    <note>You may think the date is different due to knowledge cutoff, but this is the actual date.</note>
+  </task>
+  <page>
+    <startingUrl>you are starting your task on this url: ${url}</startingUrl>
+  </page>
+  <mindset>
+    <note>Be very intentional about your action. The initial instruction is very important, and slight variations of the actual goal can lead to failures.</note>
+    <importantNote>If something fails to meet a single condition of the task, move on from it rather than seeing if it meets other criteria. We only care that it meets all of it</importantNote>
+    <note>When the task is complete, do not seek more information; you have completed the task.</note>
+  </mindset>
+  <guidelines>
+    <item>Always start by understanding the current page state</item>
+    <item>Use the screenshot tool to verify page state when needed</item>
+    <item>Use appropriate tools for each action</item>
+    <item>When the task is complete, use the "close" tool with taskComplete: true</item>
+    <item>If the task cannot be completed, use "close" with taskComplete: false</item>
+  </guidelines>
+  ${pageUnderstandingProtocol}
+  <navigation>
+    <rule>If you are confident in the URL, navigate directly to it.</rule>
+    ${hasSearch ? `<rule>If you are not confident in the URL, use the search tool to find it.</rule>` : ``}
+  </navigation>
+  ${toolsSection}
+  <strategy>
+    ${strategySection}
+    ${commonStrategyItems}
+  </strategy>
+  ${roadblocksSection}
+  <completion>
+    <note>When you complete the task, explain any information that was found that was relevant to the original task.</note>
+    <examples>
+      <example>If you were asked for specific flights, list the flights you found.</example>
+      <example>If you were asked for information about a product, list the product information you were asked for.</example>
+    </examples>
+  </completion>
+</system>`;
 }
 
 // lib/v3/handlers/v3AgentHandler.ts
-var import_ai11 = require("ai");
+var import_ai19 = require("ai");
 
 // lib/v3/agent/utils/messageProcessing.ts
 function isToolMessage(message) {
@@ -31243,13 +32051,14 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var V3AgentHandler = class {
-  constructor(v3, logger, llmClient, executionModel, systemInstructions, mcpTools) {
+  constructor(v3, logger, llmClient, executionModel, systemInstructions, mcpTools, mode) {
     this.v3 = v3;
     this.logger = logger;
     this.llmClient = llmClient;
     this.executionModel = executionModel;
     this.systemInstructions = systemInstructions;
     this.mcpTools = mcpTools;
+    this.mode = mode != null ? mode : "dom";
   }
   prepareAgent(instructionOrOptions) {
     return __async(this, null, function* () {
@@ -31257,10 +32066,14 @@ var V3AgentHandler = class {
       try {
         const options = typeof instructionOrOptions === "string" ? { instruction: instructionOrOptions } : instructionOrOptions;
         const maxSteps = options.maxSteps || 20;
-        const systemPrompt = this.buildSystemPrompt(
-          options.instruction,
-          this.systemInstructions
-        );
+        const initialPageUrl = (yield this.v3.context.awaitActivePage()).url();
+        const systemPrompt = buildAgentSystemPrompt({
+          url: initialPageUrl,
+          executionInstruction: options.instruction,
+          mode: this.mode,
+          systemInstructions: this.systemInstructions,
+          isBrowserbase: this.v3.isBrowserbase
+        });
         const tools = this.createTools();
         const allTools = __spreadValues(__spreadValues({}, tools), this.mcpTools);
         const messages = ((_a4 = options.messages) == null ? void 0 : _a4.length) ? [...options.messages, { role: "user", content: options.instruction }] : [{ role: "user", content: options.instruction }];
@@ -31268,7 +32081,7 @@ var V3AgentHandler = class {
           throw new MissingLLMConfigurationError();
         }
         const baseModel = this.llmClient.getLanguageModel();
-        const wrappedModel = (0, import_ai11.wrapLanguageModel)({
+        const wrappedModel = (0, import_ai19.wrapLanguageModel)({
           model: baseModel,
           middleware: __spreadValues({
             transformParams: (_0) => __async(this, [_0], function* ({ params }) {
@@ -31277,7 +32090,6 @@ var V3AgentHandler = class {
             })
           }, SessionFileLogger.createLlmLoggingMiddleware(baseModel.modelId))
         });
-        const initialPageUrl = (yield this.v3.context.awaitActivePage()).url();
         return {
           options,
           maxSteps,
@@ -31339,14 +32151,16 @@ var V3AgentHandler = class {
           }
         }
         state.currentPageUrl = (yield this.v3.context.awaitActivePage()).url();
-        try {
-          yield this.captureAndEmitScreenshot();
-        } catch (e2) {
-          this.logger({
-            category: "agent",
-            message: `Warning: Failed to capture screenshot: ${getErrorMessage(e2)}`,
-            level: 1
-          });
+        if (process.env.EVALS === "true") {
+          try {
+            yield this.captureAndEmitScreenshot();
+          } catch (e2) {
+            this.logger({
+              category: "agent",
+              message: `Warning: Failed to capture screenshot: ${getErrorMessage(e2)}`,
+              level: 1
+            });
+          }
         }
       }
       if (userCallback) {
@@ -31356,8 +32170,11 @@ var V3AgentHandler = class {
   }
   execute(instructionOrOptions) {
     return __async(this, null, function* () {
+      var _a4;
       const startTime = Date.now();
-      const signal = typeof instructionOrOptions === "object" ? instructionOrOptions.signal : void 0;
+      const options = typeof instructionOrOptions === "object" ? instructionOrOptions : null;
+      const signal = options == null ? void 0 : options.signal;
+      const shouldHighlightCursor = (_a4 = options == null ? void 0 : options.highlightCursor) != null ? _a4 : this.mode === "hybrid";
       const state = {
         collectedReasoning: [],
         actions: [],
@@ -31368,7 +32185,7 @@ var V3AgentHandler = class {
       let messages = [];
       try {
         const {
-          options,
+          options: preparedOptions,
           maxSteps,
           systemPrompt,
           allTools,
@@ -31376,6 +32193,11 @@ var V3AgentHandler = class {
           wrappedModel,
           initialPageUrl
         } = yield this.prepareAgent(instructionOrOptions);
+        if (shouldHighlightCursor && this.mode === "hybrid") {
+          const page = yield this.v3.context.awaitActivePage();
+          yield page.enableCursorOverlay().catch(() => {
+          });
+        }
         messages = preparedMessages;
         state.currentPageUrl = initialPageUrl;
         const callbacks = instructionOrOptions.callbacks;
@@ -31403,7 +32225,7 @@ var V3AgentHandler = class {
           toolChoice: "auto",
           prepareStep: callbacks == null ? void 0 : callbacks.prepareStep,
           onStepFinish: this.createStepHandler(state, callbacks == null ? void 0 : callbacks.onStepFinish),
-          abortSignal: options.signal
+          abortSignal: preparedOptions.signal
         });
         return this.consolidateMetricsAndResult(
           startTime,
@@ -31437,6 +32259,9 @@ var V3AgentHandler = class {
   }
   stream(instructionOrOptions) {
     return __async(this, null, function* () {
+      var _a4;
+      const streamOptions = typeof instructionOrOptions === "object" ? instructionOrOptions : null;
+      const shouldHighlightCursor = (_a4 = streamOptions == null ? void 0 : streamOptions.highlightCursor) != null ? _a4 : this.mode === "hybrid";
       const {
         options,
         maxSteps,
@@ -31446,6 +32271,11 @@ var V3AgentHandler = class {
         wrappedModel,
         initialPageUrl
       } = yield this.prepareAgent(instructionOrOptions);
+      if (shouldHighlightCursor && this.mode === "hybrid") {
+        const page = yield this.v3.context.awaitActivePage();
+        yield page.enableCursorOverlay().catch(() => {
+        });
+      }
       const callbacks = instructionOrOptions.callbacks;
       const state = {
         collectedReasoning: [],
@@ -31500,11 +32330,11 @@ var V3AgentHandler = class {
           resolveResult(result);
         },
         onAbort: (event) => {
-          var _a4;
+          var _a5;
           if (callbacks == null ? void 0 : callbacks.onAbort) {
             callbacks.onAbort(event);
           }
-          const reason = ((_a4 = options.signal) == null ? void 0 : _a4.reason) ? String(options.signal.reason) : "Stream was aborted";
+          const reason = ((_a5 = options.signal) == null ? void 0 : _a5.reason) ? String(options.signal.reason) : "Stream was aborted";
           rejectResult(new AgentAbortError(reason));
         },
         abortSignal: options.signal
@@ -31552,41 +32382,14 @@ var V3AgentHandler = class {
       messages: fullMessages
     };
   }
-  buildSystemPrompt(executionInstruction, systemInstructions) {
-    if (systemInstructions) {
-      return `${systemInstructions}
-Your current goal: ${executionInstruction} when the task is complete, use the "close" tool with taskComplete: true`;
-    }
-    return `You are a web automation assistant using browser automation tools to accomplish the user's goal.
-
-Your task: ${executionInstruction}
-
-You have access to various browser automation tools. Use them step by step to complete the task.
-
-IMPORTANT GUIDELINES:
-1. Always start by understanding the current page state
-2. Use the screenshot tool to verify page state when needed
-3. Use appropriate tools for each action
-4. When the task is complete, use the "close" tool with taskComplete: true
-5. If the task cannot be completed, use "close" with taskComplete: false
-
-TOOLS OVERVIEW:
-- screenshot: Take a PNG screenshot for quick visual context (use sparingly)
-- ariaTree: Get an accessibility (ARIA) hybrid tree for full page context
-- act: Perform a specific atomic action (click, type, etc.)
-- extract: Extract structured data
-- goto: Navigate to a URL
-- wait/navback/refresh: Control timing and navigation
-- scroll: Scroll the page x pixels up or down
-
-STRATEGY:
-- Prefer ariaTree to understand the page before acting; use screenshot for confirmation.
-- Keep actions atomic and verify outcomes before proceeding.`;
-  }
   createTools() {
+    var _a4, _b, _c;
+    const provider = (_c = (_b = (_a4 = this.llmClient) == null ? void 0 : _a4.getLanguageModel) == null ? void 0 : _b.call(_a4)) == null ? void 0 : _c.provider;
     return createAgentTools(this.v3, {
       executionModel: this.executionModel,
-      logger: this.logger
+      logger: this.logger,
+      mode: this.mode,
+      provider
     });
   }
   handleStop(result, maxSteps) {
@@ -31595,7 +32398,7 @@ STRATEGY:
     if ((_a4 = lastStep == null ? void 0 : lastStep.toolCalls) == null ? void 0 : _a4.some((tc) => tc.toolName === "close")) {
       return true;
     }
-    return (0, import_ai11.stepCountIs)(maxSteps)(result);
+    return (0, import_ai19.stepCountIs)(maxSteps)(result);
   }
   /**
    * Capture a screenshot and emit it via the event bus
@@ -32077,8 +32880,8 @@ var AnthropicCUAClient = class extends AgentClient {
           betas: ["computer-use-2025-01-24"]
         };
         if (this.tools && Object.keys(this.tools).length > 0) {
-          const customTools = Object.entries(this.tools).map(([name, tool13]) => {
-            const schema = tool13.inputSchema;
+          const customTools = Object.entries(this.tools).map(([name, tool21]) => {
+            const schema = tool21.inputSchema;
             const jsonSchema3 = toJsonSchema(schema);
             const inputSchema = {
               type: "object",
@@ -32087,7 +32890,7 @@ var AnthropicCUAClient = class extends AgentClient {
             };
             return {
               name,
-              description: tool13.description,
+              description: tool21.description,
               input_schema: inputSchema
             };
           });
@@ -32205,13 +33008,13 @@ var AnthropicCUAClient = class extends AgentClient {
             let toolResult = "Tool executed successfully";
             if (this.tools && item.name in this.tools) {
               try {
-                const tool13 = this.tools[item.name];
+                const tool21 = this.tools[item.name];
                 logger({
                   category: "agent",
                   message: `Executing tool call: ${item.name} with args: ${JSON.stringify(item.input)}`,
                   level: 1
                 });
-                const result = yield tool13.execute(item.input, {
+                const result = yield tool21.execute(item.input, {
                   toolCallId: item.id,
                   messages: []
                 });
@@ -32733,13 +33536,13 @@ var OpenAICUAClient = class extends AgentClient {
           truncation: "auto"
         };
         if (this.tools && Object.keys(this.tools).length > 0) {
-          const customTools = Object.entries(this.tools).map(([name, tool13]) => ({
+          const customTools = Object.entries(this.tools).map(([name, tool21]) => ({
             type: "function",
             name,
             function: {
               name,
-              description: tool13.description,
-              parameters: tool13.inputSchema
+              description: tool21.description,
+              parameters: tool21.inputSchema
             }
           }));
           requestParams.tools = [
@@ -32879,14 +33682,14 @@ var OpenAICUAClient = class extends AgentClient {
             let toolResult = "Tool executed successfully";
             if (this.tools && item.name in this.tools) {
               try {
-                const tool13 = this.tools[item.name];
+                const tool21 = this.tools[item.name];
                 const args = JSON.parse(item.arguments);
                 logger({
                   category: "agent",
                   message: `Executing tool call: ${item.name} with args: ${item.arguments}`,
                   level: 1
                 });
-                const result = yield tool13.execute(args, {
+                const result = yield tool21.execute(args, {
                   toolCallId: item.call_id,
                   messages: []
                 });
@@ -33042,8 +33845,8 @@ function executeGoogleCustomTool(toolName, toolArgs, tools, functionCall, logger
         message: `Executing custom tool: ${toolName} with args: ${JSON.stringify(toolArgs)}`,
         level: 1
       });
-      const tool13 = tools[toolName];
-      const toolResult = yield tool13.execute(toolArgs, {
+      const tool21 = tools[toolName];
+      const toolResult = yield tool21.execute(toolArgs, {
         toolCallId: `tool_${Date.now()}`,
         messages: []
       });
@@ -33091,22 +33894,22 @@ function isCustomTool(functionCall, tools) {
 }
 function convertToolSetToFunctionDeclarations(tools) {
   const functionDeclarations = [];
-  for (const [name, tool13] of Object.entries(tools)) {
-    const functionDeclaration = convertToolToFunctionDeclaration(name, tool13);
+  for (const [name, tool21] of Object.entries(tools)) {
+    const functionDeclaration = convertToolToFunctionDeclaration(name, tool21);
     if (functionDeclaration) {
       functionDeclarations.push(functionDeclaration);
     }
   }
   return functionDeclarations;
 }
-function convertToolToFunctionDeclaration(name, tool13) {
+function convertToolToFunctionDeclaration(name, tool21) {
   try {
-    const schema = tool13.inputSchema;
+    const schema = tool21.inputSchema;
     const jsonSchema3 = toJsonSchema(schema);
     const parameters = convertJsonSchemaToGoogleParameters(jsonSchema3);
     return {
       name,
-      description: tool13.description || `Execute ${name}`,
+      description: tool21.description || `Execute ${name}`,
       parameters
     };
   } catch (error) {
@@ -36234,23 +37037,23 @@ function waitForWebSocketDebuggerUrl(port, timeoutMs) {
 init_sdkErrors();
 
 // lib/v3/llm/aisdk.ts
-var import_ai13 = require("ai");
+var import_ai21 = require("ai");
 var import_uuid5 = require("uuid");
 
 // lib/v3/llm/LLMClient.ts
-var import_ai12 = require("ai");
+var import_ai20 = require("ai");
 var AnnotatedScreenshotText = "This is a screenshot of the current page state with the elements annotated on it. Each element id is annotated with a number to the top left of it. Duplicate annotations at the same location are under each other vertically.";
 var LLMClient = class {
   constructor(modelName, userProvidedInstructions) {
-    this.generateObject = import_ai12.generateObject;
-    this.generateText = import_ai12.generateText;
-    this.streamText = import_ai12.streamText;
-    this.streamObject = import_ai12.streamObject;
-    this.generateImage = import_ai12.experimental_generateImage;
-    this.embed = import_ai12.embed;
-    this.embedMany = import_ai12.embedMany;
-    this.transcribe = import_ai12.experimental_transcribe;
-    this.generateSpeech = import_ai12.experimental_generateSpeech;
+    this.generateObject = import_ai20.generateObject;
+    this.generateText = import_ai20.generateText;
+    this.streamText = import_ai20.streamText;
+    this.streamObject = import_ai20.streamObject;
+    this.generateImage = import_ai20.experimental_generateImage;
+    this.embed = import_ai20.embed;
+    this.embedMany = import_ai20.embedMany;
+    this.transcribe = import_ai20.experimental_transcribe;
+    this.generateSpeech = import_ai20.experimental_generateSpeech;
     this.modelName = modelName;
     this.userProvidedInstructions = userProvidedInstructions;
   }
@@ -36362,7 +37165,7 @@ var AISdkClient = class extends LLMClient {
           prompt: promptPreview2
         });
         try {
-          objectResponse = yield (0, import_ai13.generateObject)({
+          objectResponse = yield (0, import_ai21.generateObject)({
             model: this.model,
             messages: formattedMessages,
             schema: options.response_model.schema,
@@ -36382,7 +37185,7 @@ var AISdkClient = class extends LLMClient {
             operation: "generateObject",
             output: `[error: ${err instanceof Error ? err.message : "unknown"}]`
           });
-          if (import_ai13.NoObjectGeneratedError.isInstance(err)) {
+          if (import_ai21.NoObjectGeneratedError.isInstance(err)) {
             (_g = this.logger) == null ? void 0 : _g.call(this, {
               category: "AISDK error",
               message: err.message,
@@ -36460,10 +37263,10 @@ var AISdkClient = class extends LLMClient {
       }
       const tools = {};
       if (options.tools && options.tools.length > 0) {
-        for (const tool13 of options.tools) {
-          tools[tool13.name] = {
-            description: tool13.description,
-            inputSchema: tool13.parameters
+        for (const tool21 of options.tools) {
+          tools[tool21.name] = {
+            description: tool21.description,
+            inputSchema: tool21.parameters
           };
         }
       }
@@ -36480,7 +37283,7 @@ var AISdkClient = class extends LLMClient {
       });
       let textResponse;
       try {
-        textResponse = yield (0, import_ai13.generateText)({
+        textResponse = yield (0, import_ai21.generateText)({
           model: this.model,
           messages: formattedMessages,
           tools: Object.keys(tools).length > 0 ? tools : void 0,
@@ -36662,14 +37465,14 @@ var AnthropicClient = class extends LLMClient {
         }
         formattedMessages.push(screenshotMessage);
       }
-      let anthropicTools2 = (_a4 = options.tools) == null ? void 0 : _a4.map((tool13) => {
+      let anthropicTools2 = (_a4 = options.tools) == null ? void 0 : _a4.map((tool21) => {
         return {
-          name: tool13.name,
-          description: tool13.description,
+          name: tool21.name,
+          description: tool21.description,
           input_schema: {
             type: "object",
-            properties: tool13.parameters.properties,
-            required: tool13.parameters.required
+            properties: tool21.parameters.properties,
+            required: tool21.parameters.required
           }
         };
       });
@@ -36856,15 +37659,15 @@ var CerebrasClient = class extends LLMClient {
           return __spreadProps(__spreadValues({}, baseMessage), { role: "user" });
         }
       });
-      let tools = (_a4 = options.tools) == null ? void 0 : _a4.map((tool13) => ({
+      let tools = (_a4 = options.tools) == null ? void 0 : _a4.map((tool21) => ({
         type: "function",
         function: {
-          name: tool13.name,
-          description: tool13.description,
+          name: tool21.name,
+          description: tool21.description,
           parameters: {
             type: "object",
-            properties: tool13.parameters.properties,
-            required: tool13.parameters.required
+            properties: tool21.parameters.properties,
+            required: tool21.parameters.required
           }
         }
       }));
@@ -37157,18 +37960,18 @@ ${firstPartText.text}`;
     }
     return [
       {
-        functionDeclarations: tools.map((tool13) => {
+        functionDeclarations: tools.map((tool21) => {
           let parameters = void 0;
-          if (tool13.parameters) {
+          if (tool21.parameters) {
             parameters = {
               type: import_genai4.Type.OBJECT,
-              properties: tool13.parameters.properties,
-              required: tool13.parameters.required
+              properties: tool21.parameters.properties,
+              required: tool21.parameters.required
             };
           }
           return {
-            name: tool13.name,
-            description: tool13.description,
+            name: tool21.name,
+            description: tool21.description,
             parameters
           };
         })
@@ -37444,15 +38247,15 @@ var GroqClient = class extends LLMClient {
           return __spreadProps(__spreadValues({}, baseMessage), { role: "user" });
         }
       });
-      let tools = (_a4 = options.tools) == null ? void 0 : _a4.map((tool13) => ({
+      let tools = (_a4 = options.tools) == null ? void 0 : _a4.map((tool21) => ({
         type: "function",
         function: {
-          name: tool13.name,
-          description: tool13.description,
+          name: tool21.name,
+          description: tool21.description,
           parameters: {
             type: "object",
-            properties: tool13.parameters.properties,
-            required: tool13.parameters.required
+            properties: tool21.parameters.properties,
+            required: tool21.parameters.required
           }
         }
       }));
@@ -37829,11 +38632,11 @@ ${parsedSchema}
         messages: formattedMessages,
         response_format: responseFormat,
         stream: false,
-        tools: (_e = options.tools) == null ? void 0 : _e.map((tool13) => ({
+        tools: (_e = options.tools) == null ? void 0 : _e.map((tool21) => ({
           function: {
-            name: tool13.name,
-            description: tool13.description,
-            parameters: tool13.parameters
+            name: tool21.name,
+            description: tool21.description,
+            parameters: tool21.parameters
           },
           type: "function"
         }))
@@ -38626,7 +39429,7 @@ var postToApi = (_0) => __async(null, [_0], function* ({
     throw handleFetchError({ error, url, requestBodyValues: body.values });
   }
 });
-function tool11(tool22) {
+function tool19(tool22) {
   return tool22;
 }
 function createProviderDefinedToolFactory({
@@ -38650,7 +39453,7 @@ function createProviderDefinedToolFactory({
       "onInputDelta",
       "onInputAvailable"
     ]);
-    return tool11({
+    return tool19({
       type: "provider-defined",
       id,
       name,
@@ -38685,7 +39488,7 @@ function createProviderDefinedToolFactoryWithOutputSchema({
       "onInputDelta",
       "onInputAvailable"
     ]);
-    return tool11({
+    return tool19({
       type: "provider-defined",
       id,
       name,
@@ -40499,21 +41302,21 @@ function prepareChatTools({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const openaiTools2 = [];
-  for (const tool13 of tools) {
-    switch (tool13.type) {
+  for (const tool21 of tools) {
+    switch (tool21.type) {
       case "function":
         openaiTools2.push({
           type: "function",
           function: {
-            name: tool13.name,
-            description: tool13.description,
-            parameters: tool13.inputSchema,
+            name: tool21.name,
+            description: tool21.description,
+            parameters: tool21.inputSchema,
             strict: structuredOutputs ? strictJsonSchema : void 0
           }
         });
         break;
       default:
-        toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
         break;
     }
   }
@@ -42829,22 +43632,22 @@ function prepareResponsesTools(_0) {
       return { tools: void 0, toolChoice: void 0, toolWarnings };
     }
     const openaiTools2 = [];
-    for (const tool13 of tools) {
-      switch (tool13.type) {
+    for (const tool21 of tools) {
+      switch (tool21.type) {
         case "function":
           openaiTools2.push({
             type: "function",
-            name: tool13.name,
-            description: tool13.description,
-            parameters: tool13.inputSchema,
+            name: tool21.name,
+            description: tool21.description,
+            parameters: tool21.inputSchema,
             strict: strictJsonSchema
           });
           break;
         case "provider-defined": {
-          switch (tool13.id) {
+          switch (tool21.id) {
             case "openai.file_search": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: fileSearchArgsSchema
               });
               openaiTools2.push({
@@ -42867,7 +43670,7 @@ function prepareResponsesTools(_0) {
             }
             case "openai.web_search_preview": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: webSearchPreviewArgsSchema
               });
               openaiTools2.push({
@@ -42879,7 +43682,7 @@ function prepareResponsesTools(_0) {
             }
             case "openai.web_search": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: webSearchArgsSchema
               });
               openaiTools2.push({
@@ -42892,7 +43695,7 @@ function prepareResponsesTools(_0) {
             }
             case "openai.code_interpreter": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: codeInterpreterArgsSchema
               });
               openaiTools2.push({
@@ -42903,7 +43706,7 @@ function prepareResponsesTools(_0) {
             }
             case "openai.image_generation": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: imageGenerationArgsSchema
               });
               openaiTools2.push({
@@ -42927,7 +43730,7 @@ function prepareResponsesTools(_0) {
           break;
         }
         default:
-          toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+          toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
           break;
       }
     }
@@ -43032,7 +43835,7 @@ var OpenAIResponsesLanguageModel = class {
       }
       function hasOpenAITool(id) {
         return (tools == null ? void 0 : tools.find(
-          (tool13) => tool13.type === "provider-defined" && tool13.id === id
+          (tool21) => tool21.type === "provider-defined" && tool21.id === id
         )) != null;
       }
       const topLogprobs = typeof (openaiOptions == null ? void 0 : openaiOptions.logprobs) === "number" ? openaiOptions == null ? void 0 : openaiOptions.logprobs : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? TOP_LOGPROBS_MAX : void 0;
@@ -43040,7 +43843,7 @@ var OpenAIResponsesLanguageModel = class {
         addInclude("message.output_text.logprobs");
       }
       const webSearchToolName = (_c = tools == null ? void 0 : tools.find(
-        (tool13) => tool13.type === "provider-defined" && (tool13.id === "openai.web_search" || tool13.id === "openai.web_search_preview")
+        (tool21) => tool21.type === "provider-defined" && (tool21.id === "openai.web_search" || tool21.id === "openai.web_search_preview")
       )) == null ? void 0 : _c.name;
       if (webSearchToolName) {
         addInclude("web_search_call.action.sources");
@@ -44894,7 +45697,7 @@ var postToApi2 = (_0) => __async(null, [_0], function* ({
     throw handleFetchError2({ error, url, requestBodyValues: body.values });
   }
 });
-function tool12(tool22) {
+function tool20(tool22) {
   return tool22;
 }
 function createProviderDefinedToolFactory2({
@@ -44918,7 +45721,7 @@ function createProviderDefinedToolFactory2({
       "onInputDelta",
       "onInputAvailable"
     ]);
-    return tool12({
+    return tool20({
       type: "provider-defined",
       id,
       name,
@@ -44953,7 +45756,7 @@ function createProviderDefinedToolFactoryWithOutputSchema2({
       "onInputDelta",
       "onInputAvailable"
     ]);
-    return tool12({
+    return tool20({
       type: "provider-defined",
       id,
       name,
@@ -46634,25 +47437,25 @@ function prepareTools({
   if (tools == null) {
     return { tools: void 0, toolConfig: void 0, toolWarnings };
   }
-  const hasFunctionTools = tools.some((tool13) => tool13.type === "function");
+  const hasFunctionTools = tools.some((tool21) => tool21.type === "function");
   const hasProviderDefinedTools = tools.some(
-    (tool13) => tool13.type === "provider-defined"
+    (tool21) => tool21.type === "provider-defined"
   );
   if (hasFunctionTools && hasProviderDefinedTools) {
-    const functionTools = tools.filter((tool13) => tool13.type === "function");
+    const functionTools = tools.filter((tool21) => tool21.type === "function");
     toolWarnings.push({
       type: "unsupported-tool",
-      tool: tools.find((tool13) => tool13.type === "function"),
+      tool: tools.find((tool21) => tool21.type === "function"),
       details: `Cannot mix function tools with provider-defined tools in the same request. Falling back to provider-defined tools only. The following function tools will be ignored: ${functionTools.map((t2) => t2.name).join(", ")}. Please use either function tools or provider-defined tools, but not both.`
     });
   }
   if (hasProviderDefinedTools) {
     const googleTools22 = [];
     const providerDefinedTools = tools.filter(
-      (tool13) => tool13.type === "provider-defined"
+      (tool21) => tool21.type === "provider-defined"
     );
-    providerDefinedTools.forEach((tool13) => {
-      switch (tool13.id) {
+    providerDefinedTools.forEach((tool21) => {
+      switch (tool21.id) {
         case "google.google_search":
           if (isGemini2orNewer) {
             googleTools22.push({ googleSearch: {} });
@@ -46660,8 +47463,8 @@ function prepareTools({
             googleTools22.push({
               googleSearchRetrieval: {
                 dynamicRetrievalConfig: {
-                  mode: tool13.args.mode,
-                  dynamicThreshold: tool13.args.dynamicThreshold
+                  mode: tool21.args.mode,
+                  dynamicThreshold: tool21.args.dynamicThreshold
                 }
               }
             });
@@ -46675,7 +47478,7 @@ function prepareTools({
           } else {
             toolWarnings.push({
               type: "unsupported-tool",
-              tool: tool13,
+              tool: tool21,
               details: "The URL context tool is not supported with other Gemini models than Gemini 2."
             });
           }
@@ -46686,18 +47489,18 @@ function prepareTools({
           } else {
             toolWarnings.push({
               type: "unsupported-tool",
-              tool: tool13,
+              tool: tool21,
               details: "The code execution tools is not supported with other Gemini models than Gemini 2."
             });
           }
           break;
         case "google.file_search":
           if (supportsFileSearch) {
-            googleTools22.push({ fileSearch: __spreadValues({}, tool13.args) });
+            googleTools22.push({ fileSearch: __spreadValues({}, tool21.args) });
           } else {
             toolWarnings.push({
               type: "unsupported-tool",
-              tool: tool13,
+              tool: tool21,
               details: "The file search tool is only supported with Gemini 2.5 models."
             });
           }
@@ -46708,22 +47511,22 @@ function prepareTools({
               retrieval: {
                 vertex_rag_store: {
                   rag_resources: {
-                    rag_corpus: tool13.args.ragCorpus
+                    rag_corpus: tool21.args.ragCorpus
                   },
-                  similarity_top_k: tool13.args.topK
+                  similarity_top_k: tool21.args.topK
                 }
               }
             });
           } else {
             toolWarnings.push({
               type: "unsupported-tool",
-              tool: tool13,
+              tool: tool21,
               details: "The RAG store tool is not supported with other Gemini models than Gemini 2."
             });
           }
           break;
         default:
-          toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+          toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
           break;
       }
     });
@@ -46734,17 +47537,17 @@ function prepareTools({
     };
   }
   const functionDeclarations = [];
-  for (const tool13 of tools) {
-    switch (tool13.type) {
+  for (const tool21 of tools) {
+    switch (tool21.type) {
       case "function":
         functionDeclarations.push({
-          name: tool13.name,
-          description: (_a4 = tool13.description) != null ? _a4 : "",
-          parameters: convertJSONSchemaToOpenAPISchema(tool13.inputSchema)
+          name: tool21.name,
+          description: (_a4 = tool21.description) != null ? _a4 : "",
+          parameters: convertJSONSchemaToOpenAPISchema(tool21.inputSchema)
         });
         break;
       default:
-        toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
         break;
     }
   }
@@ -46858,7 +47661,7 @@ var GoogleGenerativeAILanguageModel = class {
         schema: googleGenerativeAIProviderOptions
       });
       if ((tools == null ? void 0 : tools.some(
-        (tool13) => tool13.type === "provider-defined" && tool13.id === "google.vertex_rag_store"
+        (tool21) => tool21.type === "provider-defined" && tool21.id === "google.vertex_rag_store"
       )) && !this.config.provider.startsWith("google.vertex.")) {
         warnings.push({
           type: "other",
@@ -48720,23 +49523,23 @@ function prepareTools2(_0) {
       return { tools: void 0, toolChoice: void 0, toolWarnings, betas };
     }
     const anthropicTools2 = [];
-    for (const tool13 of tools) {
-      switch (tool13.type) {
+    for (const tool21 of tools) {
+      switch (tool21.type) {
         case "function": {
-          const cacheControl = validator3.getCacheControl(tool13.providerOptions, {
+          const cacheControl = validator3.getCacheControl(tool21.providerOptions, {
             type: "tool definition",
             canCache: true
           });
           anthropicTools2.push({
-            name: tool13.name,
-            description: tool13.description,
-            input_schema: tool13.inputSchema,
+            name: tool21.name,
+            description: tool21.description,
+            input_schema: tool21.inputSchema,
             cache_control: cacheControl
           });
           break;
         }
         case "provider-defined": {
-          switch (tool13.id) {
+          switch (tool21.id) {
             case "anthropic.code_execution_20250522": {
               betas.add("code-execution-2025-05-22");
               anthropicTools2.push({
@@ -48759,9 +49562,9 @@ function prepareTools2(_0) {
               anthropicTools2.push({
                 name: "computer",
                 type: "computer_20250124",
-                display_width_px: tool13.args.displayWidthPx,
-                display_height_px: tool13.args.displayHeightPx,
-                display_number: tool13.args.displayNumber,
+                display_width_px: tool21.args.displayWidthPx,
+                display_height_px: tool21.args.displayHeightPx,
+                display_number: tool21.args.displayNumber,
                 cache_control: void 0
               });
               break;
@@ -48771,9 +49574,9 @@ function prepareTools2(_0) {
               anthropicTools2.push({
                 name: "computer",
                 type: "computer_20241022",
-                display_width_px: tool13.args.displayWidthPx,
-                display_height_px: tool13.args.displayHeightPx,
-                display_number: tool13.args.displayNumber,
+                display_width_px: tool21.args.displayWidthPx,
+                display_height_px: tool21.args.displayHeightPx,
+                display_number: tool21.args.displayNumber,
                 cache_control: void 0
               });
               break;
@@ -48807,7 +49610,7 @@ function prepareTools2(_0) {
             }
             case "anthropic.text_editor_20250728": {
               const args = yield validateTypes2({
-                value: tool13.args,
+                value: tool21.args,
                 schema: textEditor_20250728ArgsSchema
               });
               anthropicTools2.push({
@@ -48847,7 +49650,7 @@ function prepareTools2(_0) {
             case "anthropic.web_fetch_20250910": {
               betas.add("web-fetch-2025-09-10");
               const args = yield validateTypes2({
-                value: tool13.args,
+                value: tool21.args,
                 schema: webFetch_20250910ArgsSchema
               });
               anthropicTools2.push({
@@ -48864,7 +49667,7 @@ function prepareTools2(_0) {
             }
             case "anthropic.web_search_20250305": {
               const args = yield validateTypes2({
-                value: tool13.args,
+                value: tool21.args,
                 schema: webSearch_20250305ArgsSchema
               });
               anthropicTools2.push({
@@ -48879,14 +49682,14 @@ function prepareTools2(_0) {
               break;
             }
             default: {
-              toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+              toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
               break;
             }
           }
           break;
         }
         default: {
-          toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+          toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
           break;
         }
       }
@@ -49845,7 +50648,7 @@ var AnthropicMessagesLanguageModel = class {
         betas.add("skills-2025-10-02");
         betas.add("files-api-2025-04-14");
         if (!(tools == null ? void 0 : tools.some(
-          (tool13) => tool13.type === "provider-defined" && tool13.id === "anthropic.code_execution_20250825"
+          (tool21) => tool21.type === "provider-defined" && tool21.id === "anthropic.code_execution_20250825"
         ))) {
           warnings.push({
             type: "other",
@@ -51683,24 +52486,24 @@ function prepareTools3({
   if (tools == null) {
     return { tools: void 0, toolConfig: void 0, toolWarnings };
   }
-  const hasFunctionTools = tools.some((tool13) => tool13.type === "function");
+  const hasFunctionTools = tools.some((tool21) => tool21.type === "function");
   const hasProviderDefinedTools = tools.some(
-    (tool13) => tool13.type === "provider-defined"
+    (tool21) => tool21.type === "provider-defined"
   );
   if (hasFunctionTools && hasProviderDefinedTools) {
     toolWarnings.push({
       type: "unsupported-tool",
-      tool: tools.find((tool13) => tool13.type === "function"),
+      tool: tools.find((tool21) => tool21.type === "function"),
       details: "Cannot mix function tools with provider-defined tools in the same request. Please use either function tools or provider-defined tools, but not both."
     });
   }
   if (hasProviderDefinedTools) {
     const googleTools22 = [];
     const providerDefinedTools = tools.filter(
-      (tool13) => tool13.type === "provider-defined"
+      (tool21) => tool21.type === "provider-defined"
     );
-    providerDefinedTools.forEach((tool13) => {
-      switch (tool13.id) {
+    providerDefinedTools.forEach((tool21) => {
+      switch (tool21.id) {
         case "google.google_search":
           if (isGemini2) {
             googleTools22.push({ googleSearch: {} });
@@ -51708,8 +52511,8 @@ function prepareTools3({
             googleTools22.push({
               googleSearchRetrieval: {
                 dynamicRetrievalConfig: {
-                  mode: tool13.args.mode,
-                  dynamicThreshold: tool13.args.dynamicThreshold
+                  mode: tool21.args.mode,
+                  dynamicThreshold: tool21.args.dynamicThreshold
                 }
               }
             });
@@ -51723,7 +52526,7 @@ function prepareTools3({
           } else {
             toolWarnings.push({
               type: "unsupported-tool",
-              tool: tool13,
+              tool: tool21,
               details: "The URL context tool is not supported with other Gemini models than Gemini 2."
             });
           }
@@ -51734,13 +52537,13 @@ function prepareTools3({
           } else {
             toolWarnings.push({
               type: "unsupported-tool",
-              tool: tool13,
+              tool: tool21,
               details: "The code execution tools is not supported with other Gemini models than Gemini 2."
             });
           }
           break;
         default:
-          toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+          toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
           break;
       }
     });
@@ -51751,17 +52554,17 @@ function prepareTools3({
     };
   }
   const functionDeclarations = [];
-  for (const tool13 of tools) {
-    switch (tool13.type) {
+  for (const tool21 of tools) {
+    switch (tool21.type) {
       case "function":
         functionDeclarations.push({
-          name: tool13.name,
-          description: (_a4 = tool13.description) != null ? _a4 : "",
-          parameters: convertJSONSchemaToOpenAPISchema2(tool13.inputSchema)
+          name: tool21.name,
+          description: (_a4 = tool21.description) != null ? _a4 : "",
+          parameters: convertJSONSchemaToOpenAPISchema2(tool21.inputSchema)
         });
         break;
       default:
-        toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
         break;
     }
   }
@@ -52884,16 +53687,16 @@ function prepareTools4({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const openaiCompatTools = [];
-  for (const tool13 of tools) {
-    if (tool13.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+  for (const tool21 of tools) {
+    if (tool21.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
     } else {
       openaiCompatTools.push({
         type: "function",
         function: {
-          name: tool13.name,
-          description: tool13.description,
-          parameters: tool13.inputSchema
+          name: tool21.name,
+          description: tool21.description,
+          parameters: tool21.inputSchema
         }
       });
     }
@@ -54238,16 +55041,16 @@ function prepareTools5({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const xaiTools = [];
-  for (const tool13 of tools) {
-    if (tool13.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+  for (const tool21 of tools) {
+    if (tool21.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
     } else {
       xaiTools.push({
         type: "function",
         function: {
-          name: tool13.name,
-          description: tool13.description,
-          parameters: tool13.inputSchema
+          name: tool21.name,
+          description: tool21.description,
+          parameters: tool21.inputSchema
         }
       });
     }
@@ -55247,21 +56050,21 @@ function prepareChatTools2({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const openaiTools2 = [];
-  for (const tool13 of tools) {
-    switch (tool13.type) {
+  for (const tool21 of tools) {
+    switch (tool21.type) {
       case "function":
         openaiTools2.push({
           type: "function",
           function: {
-            name: tool13.name,
-            description: tool13.description,
-            parameters: tool13.inputSchema,
+            name: tool21.name,
+            description: tool21.description,
+            parameters: tool21.inputSchema,
             strict: structuredOutputs ? strictJsonSchema : void 0
           }
         });
         break;
       default:
-        toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
         break;
     }
   }
@@ -57843,22 +58646,22 @@ function prepareResponsesTools2(_0) {
       return { tools: void 0, toolChoice: void 0, toolWarnings };
     }
     const openaiTools2 = [];
-    for (const tool13 of tools) {
-      switch (tool13.type) {
+    for (const tool21 of tools) {
+      switch (tool21.type) {
         case "function":
           openaiTools2.push({
             type: "function",
-            name: tool13.name,
-            description: tool13.description,
-            parameters: tool13.inputSchema,
+            name: tool21.name,
+            description: tool21.description,
+            parameters: tool21.inputSchema,
             strict: strictJsonSchema
           });
           break;
         case "provider-defined": {
-          switch (tool13.id) {
+          switch (tool21.id) {
             case "openai.file_search": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: fileSearchArgsSchema3
               });
               openaiTools2.push({
@@ -57881,7 +58684,7 @@ function prepareResponsesTools2(_0) {
             }
             case "openai.web_search_preview": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: webSearchPreviewArgsSchema2
               });
               openaiTools2.push({
@@ -57893,7 +58696,7 @@ function prepareResponsesTools2(_0) {
             }
             case "openai.web_search": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: webSearchArgsSchema2
               });
               openaiTools2.push({
@@ -57906,7 +58709,7 @@ function prepareResponsesTools2(_0) {
             }
             case "openai.code_interpreter": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: codeInterpreterArgsSchema2
               });
               openaiTools2.push({
@@ -57917,7 +58720,7 @@ function prepareResponsesTools2(_0) {
             }
             case "openai.image_generation": {
               const args = yield validateTypes({
-                value: tool13.args,
+                value: tool21.args,
                 schema: imageGenerationArgsSchema2
               });
               openaiTools2.push({
@@ -57941,7 +58744,7 @@ function prepareResponsesTools2(_0) {
           break;
         }
         default:
-          toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+          toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
           break;
       }
     }
@@ -58046,7 +58849,7 @@ var OpenAIResponsesLanguageModel2 = class {
       }
       function hasOpenAITool(id) {
         return (tools == null ? void 0 : tools.find(
-          (tool13) => tool13.type === "provider-defined" && tool13.id === id
+          (tool21) => tool21.type === "provider-defined" && tool21.id === id
         )) != null;
       }
       const topLogprobs = typeof (openaiOptions == null ? void 0 : openaiOptions.logprobs) === "number" ? openaiOptions == null ? void 0 : openaiOptions.logprobs : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? TOP_LOGPROBS_MAX2 : void 0;
@@ -58054,7 +58857,7 @@ var OpenAIResponsesLanguageModel2 = class {
         addInclude("message.output_text.logprobs");
       }
       const webSearchToolName = (_c = tools == null ? void 0 : tools.find(
-        (tool13) => tool13.type === "provider-defined" && (tool13.id === "openai.web_search" || tool13.id === "openai.web_search_preview")
+        (tool21) => tool21.type === "provider-defined" && (tool21.id === "openai.web_search" || tool21.id === "openai.web_search_preview")
       )) == null ? void 0 : _c.name;
       if (webSearchToolName) {
         addInclude("web_search_call.action.sources");
@@ -59277,13 +60080,13 @@ function prepareTools6({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const groqTools2 = [];
-  for (const tool13 of tools) {
-    if (tool13.type === "provider-defined") {
-      if (tool13.id === "groq.browser_search") {
+  for (const tool21 of tools) {
+    if (tool21.type === "provider-defined") {
+      if (tool21.id === "groq.browser_search") {
         if (!isBrowserSearchSupportedModel(modelId)) {
           toolWarnings.push({
             type: "unsupported-tool",
-            tool: tool13,
+            tool: tool21,
             details: `Browser search is only supported on the following models: ${getSupportedModelsString()}. Current model: ${modelId}`
           });
         } else {
@@ -59292,15 +60095,15 @@ function prepareTools6({
           });
         }
       } else {
-        toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
       }
     } else {
       groqTools2.push({
         type: "function",
         function: {
-          name: tool13.name,
-          description: tool13.description,
-          parameters: tool13.inputSchema
+          name: tool21.name,
+          description: tool21.description,
+          parameters: tool21.inputSchema
         }
       });
     }
@@ -60352,16 +61155,16 @@ function prepareTools7({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const mistralTools = [];
-  for (const tool13 of tools) {
-    if (tool13.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+  for (const tool21 of tools) {
+    if (tool21.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
     } else {
       mistralTools.push({
         type: "function",
         function: {
-          name: tool13.name,
-          description: tool13.description,
-          parameters: tool13.inputSchema
+          name: tool21.name,
+          description: tool21.description,
+          parameters: tool21.inputSchema
         }
       });
     }
@@ -60381,7 +61184,7 @@ function prepareTools7({
     case "tool":
       return {
         tools: mistralTools.filter(
-          (tool13) => tool13.function.name === toolChoice.toolName
+          (tool21) => tool21.function.name === toolChoice.toolName
         ),
         toolChoice: "any",
         toolWarnings
@@ -62164,10 +62967,10 @@ function prepareResponsesTools3({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const ollamaTools = [];
-  for (const tool13 of tools) {
-    switch (tool13.type) {
+  for (const tool21 of tools) {
+    switch (tool21.type) {
       case "function": {
-        let parameters = tool13.inputSchema;
+        let parameters = tool21.inputSchema;
         if (!parameters) {
           parameters = {
             type: "object",
@@ -62183,15 +62986,15 @@ function prepareResponsesTools3({
         ollamaTools.push({
           type: "function",
           function: {
-            name: tool13.name,
-            description: tool13.description,
+            name: tool21.name,
+            description: tool21.description,
             parameters
           }
         });
         break;
       }
       default:
-        toolWarnings.push({ type: "unsupported-tool", tool: tool13 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool21 });
         break;
     }
   }
@@ -62989,13 +63792,13 @@ var resolveTools = (clients, userTools) => __async(null, null, function* () {
       const clientTools = yield clientInstance.listTools({
         cursor: nextCursor
       });
-      for (const tool13 of clientTools.tools) {
-        tools[tool13.name] = {
-          description: tool13.description,
-          inputSchema: jsonSchemaToZod(tool13.inputSchema),
+      for (const tool21 of clientTools.tools) {
+        tools[tool21.name] = {
+          description: tool21.description,
+          inputSchema: jsonSchemaToZod(tool21.inputSchema),
           execute: (input) => __async(null, null, function* () {
             const result = yield clientInstance.callTool({
-              name: tool13.name,
+              name: tool21.name,
               arguments: input
             });
             return result;
@@ -63069,7 +63872,7 @@ init_response2();
 init_sdkErrors();
 
 // examples/external_clients/aisdk.ts
-var import_ai14 = require("ai");
+var import_ai22 = require("ai");
 var AISdkClient2 = class extends LLMClient {
   constructor({ model }) {
     super(model.modelId);
@@ -63131,7 +63934,7 @@ var AISdkClient2 = class extends LLMClient {
         }
       );
       if (options.response_model) {
-        const response2 = yield (0, import_ai14.generateObject)({
+        const response2 = yield (0, import_ai22.generateObject)({
           model: this.model,
           messages: formattedMessages,
           schema: options.response_model.schema
@@ -63154,7 +63957,7 @@ var AISdkClient2 = class extends LLMClient {
           inputSchema: rawTool.parameters
         };
       }
-      const response = yield (0, import_ai14.generateText)({
+      const response = yield (0, import_ai22.generateText)({
         model: this.model,
         messages: formattedMessages,
         tools
@@ -64488,7 +65291,7 @@ function validateExperimentalFeatures(options) {
 init_flowLogger();
 init_sdkErrors();
 var DEFAULT_MODEL_NAME = "openai/gpt-4.1-mini";
-var DEFAULT_VIEWPORT = { width: 1288, height: 711 };
+var DEFAULT_VIEWPORT2 = { width: 1288, height: 711 };
 function resolveModelConfiguration(model) {
   if (!model) {
     return { modelName: DEFAULT_MODEL_NAME };
@@ -64681,6 +65484,12 @@ var _V3 = class _V3 {
   get browserbaseDebugURL() {
     return this.browserbaseDebugUrl;
   }
+  /**
+   * Returns true if the browser is running on Browserbase.
+   */
+  get isBrowserbase() {
+    return this.state.kind === "BROWSERBASE";
+  }
   /**
    * Async property for metrics so callers can `await v3.metrics`.
    * When using API mode, fetches metrics from the API. Otherwise returns local metrics.
@@ -65022,7 +65831,7 @@ var _V3 = class _V3 {
             if (lbo.devtools) chromeFlags.push("--auto-open-devtools-for-tabs");
             if (lbo.locale) chromeFlags.push(`--lang=${lbo.locale}`);
             if (!lbo.viewport) {
-              lbo.viewport = DEFAULT_VIEWPORT;
+              lbo.viewport = DEFAULT_VIEWPORT2;
             }
             if (((_f = lbo.viewport) == null ? void 0 : _f.width) && ((_g = lbo.viewport) == null ? void 0 : _g.height)) {
               chromeFlags.push(
@@ -65647,7 +66456,8 @@ var _V3 = class _V3 {
         agentLlmClient,
         typeof (options == null ? void 0 : options.executionModel) === "string" ? options.executionModel : (_b = options == null ? void 0 : options.executionModel) == null ? void 0 : _b.modelName,
         options == null ? void 0 : options.systemPrompt,
-        tools
+        tools,
+        options == null ? void 0 : options.mode
       );
       const resolvedOptions = typeof instructionOrOptions === "string" ? { instruction: instructionOrOptions } : instructionOrOptions;
       if (resolvedOptions.page) {
@@ -65895,14 +66705,14 @@ function isObserveResult(v) {
 
 // lib/v3Evaluator.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var import_zod15 = require("zod");
+var import_zod23 = require("zod");
 init_sdkErrors();
 import_dotenv2.default.config();
-var EvaluationSchema = import_zod15.z.object({
-  evaluation: import_zod15.z.enum(["YES", "NO"]),
-  reasoning: import_zod15.z.string()
+var EvaluationSchema = import_zod23.z.object({
+  evaluation: import_zod23.z.enum(["YES", "NO"]),
+  reasoning: import_zod23.z.string()
 });
-var BatchEvaluationSchema = import_zod15.z.array(EvaluationSchema);
+var BatchEvaluationSchema = import_zod23.z.array(EvaluationSchema);
 var V3Evaluator = class {
   constructor(v3, modelName, modelClientOptions) {
     this.silentLogger = () => {