@browserbasehq/orca 3.0.1-zod4 → 3.0.2-test-cua-base-url

package/dist/index.js

@@ -7443,7 +7443,7 @@ var import_path5 = __toESM(require("path"));
 var import_process2 = __toESM(require("process"));
 
 // lib/version.ts
-var STAGEHAND_VERSION = "3.0.1-zod4";
+var STAGEHAND_VERSION = "3.0.2-test-cua-base-url";
 
 // lib/v3/types/public/sdkErrors.ts
 var StagehandError = class extends Error {
@@ -7668,7 +7668,7 @@ var StagehandShadowSegmentNotFoundError = class extends StagehandError {
 
 // lib/utils.ts
 var import_genai = require("@google/genai");
-var import_zod = require("zod");
+var import_v3 = require("zod/v3");
 var ID_PATTERN = /^\d+-\d+$/;
 function validateZodSchema(schema, data) {
   const result = schema.safeParse(data);
@@ -7692,28 +7692,28 @@ function decorateGeminiSchema(geminiSchema, zodSchema2) {
 function toGeminiSchema(zodSchema2) {
   const zodType = getZodType(zodSchema2);
   switch (zodType) {
-    case "array": {
-      const arraySchema = zodSchema2;
-      const element = arraySchema._zod.def.element;
+    case "ZodArray": {
       return decorateGeminiSchema(
         {
           type: import_genai.Type.ARRAY,
-          items: toGeminiSchema(element != null ? element : import_zod.z.any())
+          items: toGeminiSchema(
+            zodSchema2.element
+          )
         },
         zodSchema2
       );
     }
-    case "object": {
+    case "ZodObject": {
       const properties = {};
       const required = [];
-      const objectSchema = zodSchema2;
-      const shape = objectSchema._zod.def.shape;
-      Object.entries(shape).forEach(([key, value]) => {
-        properties[key] = toGeminiSchema(value);
-        if (getZodType(value) !== "optional") {
-          required.push(key);
+      Object.entries(zodSchema2.shape).forEach(
+        ([key, value]) => {
+          properties[key] = toGeminiSchema(value);
+          if (getZodType(value) !== "ZodOptional") {
+            required.push(key);
+          }
         }
-      });
+      );
       return decorateGeminiSchema(
         {
           type: import_genai.Type.OBJECT,
@@ -7723,45 +7723,39 @@ function toGeminiSchema(zodSchema2) {
         zodSchema2
       );
     }
-    case "string":
-    case "url":
+    case "ZodString":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING
         },
         zodSchema2
       );
-    case "number":
+    case "ZodNumber":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.NUMBER
         },
         zodSchema2
       );
-    case "boolean":
+    case "ZodBoolean":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.BOOLEAN
         },
         zodSchema2
       );
-    case "enum": {
-      const enumSchema = zodSchema2;
-      const values = Object.values(enumSchema._zod.def.entries);
+    case "ZodEnum":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: values
+          enum: zodSchema2._def.values
         },
         zodSchema2
       );
-    }
-    case "default":
-    case "nullable":
-    case "optional": {
-      const wrapperSchema = zodSchema2;
-      const innerType = wrapperSchema._zod.def.innerType;
-      const innerSchema = toGeminiSchema(innerType);
+    case "ZodDefault":
+    case "ZodNullable":
+    case "ZodOptional": {
+      const innerSchema = toGeminiSchema(zodSchema2._def.innerType);
       return decorateGeminiSchema(
         __spreadProps(__spreadValues({}, innerSchema), {
           nullable: true
@@ -7769,23 +7763,14 @@ function toGeminiSchema(zodSchema2) {
         zodSchema2
       );
     }
-    case "literal": {
-      const literalSchema = zodSchema2;
-      const values = literalSchema._zod.def.values;
+    case "ZodLiteral":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: values
+          enum: [zodSchema2._def.value]
         },
         zodSchema2
       );
-    }
-    case "pipe": {
-      const pipeSchema = zodSchema2;
-      const inSchema = pipeSchema._zod.def.in;
-      return toGeminiSchema(inSchema);
-    }
-    // Standalone transforms and any unknown types fall through to default
     default:
       return decorateGeminiSchema(
         {
@@ -7797,40 +7782,21 @@ function toGeminiSchema(zodSchema2) {
   }
 }
 function getZodType(schema) {
-  var _a, _b;
-  const schemaWithDef = schema;
-  if ((_b = (_a = schemaWithDef._zod) == null ? void 0 : _a.def) == null ? void 0 : _b.type) {
-    return schemaWithDef._zod.def.type;
-  }
-  throw new Error(
-    `Unable to determine Zod schema type. Schema: ${JSON.stringify(schema)}`
-  );
+  return schema._def.typeName;
 }
 function transformSchema(schema, currentPath) {
   var _a, _b;
-  if (isKind(schema, "url")) {
-    const transformed = makeIdStringSchema(schema);
-    return [transformed, [{ segments: [] }]];
-  }
-  if (isKind(schema, "string")) {
-    const stringSchema = schema;
-    const checks = stringSchema._zod.def.checks;
-    const format = (_a = stringSchema._zod.bag) == null ? void 0 : _a.format;
-    const hasUrlCheck = ((_b = checks == null ? void 0 : checks.some((check) => {
-      var _a2, _b2;
-      return ((_b2 = (_a2 = check._zod) == null ? void 0 : _a2.def) == null ? void 0 : _b2.check) === "url";
-    })) != null ? _b : false) || format === "url";
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodString)) {
+    const hasUrlCheck = (_b = (_a = schema._def.checks) == null ? void 0 : _a.some(
+      (check) => check.kind === "url"
+    )) != null ? _b : false;
     if (hasUrlCheck) {
       return [makeIdStringSchema(schema), [{ segments: [] }]];
     }
     return [schema, []];
   }
-  if (isKind(schema, "object")) {
-    const objectSchema = schema;
-    const shape = objectSchema._zod.def.shape;
-    if (!shape) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodObject)) {
+    const shape = schema._def.shape();
     const newShape = {};
     const urlPaths = [];
     let changed = false;
@@ -7852,17 +7818,12 @@ function transformSchema(schema, currentPath) {
       }
     }
     if (changed) {
-      const newSchema = import_zod.z.object(newShape);
-      return [newSchema, urlPaths];
+      return [import_v3.z.object(newShape), urlPaths];
     }
     return [schema, urlPaths];
   }
-  if (isKind(schema, "array")) {
-    const arraySchema = schema;
-    const itemType = arraySchema._zod.def.element;
-    if (!itemType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodArray)) {
+    const itemType = schema._def.type;
     const [transformedItem, childPaths] = transformSchema(itemType, [
       ...currentPath,
       "*"
@@ -7872,17 +7833,12 @@ function transformSchema(schema, currentPath) {
       segments: ["*", ...cp.segments]
     }));
     if (changed) {
-      const newSchema = import_zod.z.array(transformedItem);
-      return [newSchema, arrayPaths];
+      return [import_v3.z.array(transformedItem), arrayPaths];
     }
     return [schema, arrayPaths];
   }
-  if (isKind(schema, "union")) {
-    const unionSchema = schema;
-    const unionOptions = unionSchema._zod.def.options;
-    if (!unionOptions || unionOptions.length === 0) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodUnion)) {
+    const unionOptions = schema._def.options;
     const newOptions = [];
     let changed = false;
     let allPaths = [];
@@ -7899,19 +7855,15 @@ function transformSchema(schema, currentPath) {
     });
     if (changed) {
       return [
-        import_zod.z.union(newOptions),
+        import_v3.z.union(newOptions),
         allPaths
       ];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, "intersection")) {
-    const intersectionSchema = schema;
-    const leftType = intersectionSchema._zod.def.left;
-    const rightType = intersectionSchema._zod.def.right;
-    if (!leftType || !rightType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodIntersection)) {
+    const leftType = schema._def.left;
+    const rightType = schema._def.right;
     const [left, leftPaths] = transformSchema(leftType, [
       ...currentPath,
       "intersection_left"
@@ -7923,50 +7875,33 @@ function transformSchema(schema, currentPath) {
     const changed = left !== leftType || right !== rightType;
     const allPaths = [...leftPaths, ...rightPaths];
     if (changed) {
-      return [import_zod.z.intersection(left, right), allPaths];
+      return [import_v3.z.intersection(left, right), allPaths];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, "optional")) {
-    const optionalSchema = schema;
-    const innerType = optionalSchema._zod.def.innerType;
-    if (!innerType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodOptional)) {
+    const innerType = schema._def.innerType;
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_zod.z.optional(inner), innerPaths];
+      return [import_v3.z.optional(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
-  if (isKind(schema, "nullable")) {
-    const nullableSchema = schema;
-    const innerType = nullableSchema._zod.def.innerType;
-    if (!innerType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodNullable)) {
+    const innerType = schema._def.innerType;
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_zod.z.nullable(inner), innerPaths];
+      return [import_v3.z.nullable(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
-  if (isKind(schema, "pipe")) {
-    const pipeSchema = schema;
-    const inSchema = pipeSchema._zod.def.in;
-    const outSchema = pipeSchema._zod.def.out;
-    if (!inSchema || !outSchema) {
-      return [schema, []];
-    }
-    const [newIn, inPaths] = transformSchema(inSchema, currentPath);
-    const [newOut, outPaths] = transformSchema(outSchema, currentPath);
-    const allPaths = [...inPaths, ...outPaths];
-    const changed = newIn !== inSchema || newOut !== outSchema;
-    if (changed) {
-      const result = import_zod.z.pipe(newIn, newOut);
-      return [result, allPaths];
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodEffects)) {
+    const baseSchema = schema._def.schema;
+    const [newBaseSchema, basePaths] = transformSchema(baseSchema, currentPath);
+    if (newBaseSchema !== baseSchema) {
+      return [import_v3.z.effect(newBaseSchema, schema._def.effect), basePaths];
     }
-    return [schema, allPaths];
+    return [schema, basePaths];
   }
   return [schema, []];
 }
@@ -8012,18 +7947,17 @@ function injectUrls(obj, path6, idToUrlMapping) {
   }
 }
 function isKind(s, kind) {
-  try {
-    return getZodType(s) === kind;
-  } catch (e) {
-    return false;
-  }
+  return s._def.typeName === kind;
 }
 function makeIdStringSchema(orig) {
-  var _a;
-  const userDesc = (_a = orig.description) != null ? _a : "";
+  var _a, _b, _c;
+  const userDesc = (
+    // Zod ≥3.23 exposes .description directly; fall back to _def for older minor versions
+    (_c = (_b = orig.description) != null ? _b : (_a = orig._def) == null ? void 0 : _a.description) != null ? _c : ""
+  );
   const base = `This field must be the element-ID in the form 'frameId-backendId' (e.g. "0-432").`;
   const composed = userDesc.trim().length > 0 ? `${base} that follows this user-defined description: ${userDesc}` : base;
-  return import_zod.z.string().regex(ID_PATTERN).describe(composed);
+  return import_v3.z.string().regex(ID_PATTERN).describe(composed);
 }
 var providerEnvVarMap = {
   openai: "OPENAI_API_KEY",
@@ -8069,7 +8003,7 @@ function jsonSchemaToZod(schema) {
         for (const key in schema.properties) {
           shape[key] = jsonSchemaToZod(schema.properties[key]);
         }
-        let zodObject = import_zod.z.object(shape);
+        let zodObject = import_v3.z.object(shape);
         if (schema.required && Array.isArray(schema.required)) {
           const requiredFields = schema.required.reduce(
             (acc, field) => __spreadProps(__spreadValues({}, acc), { [field]: true }),
@@ -8082,30 +8016,30 @@ function jsonSchemaToZod(schema) {
         }
         return zodObject;
       } else {
-        return import_zod.z.object({});
+        return import_v3.z.object({});
       }
     case "array":
       if (schema.items) {
-        let zodArray = import_zod.z.array(jsonSchemaToZod(schema.items));
+        let zodArray = import_v3.z.array(jsonSchemaToZod(schema.items));
         if (schema.description) {
           zodArray = zodArray.describe(schema.description);
         }
         return zodArray;
       } else {
-        return import_zod.z.array(import_zod.z.any());
+        return import_v3.z.array(import_v3.z.any());
       }
     case "string": {
       if (schema.enum) {
-        return import_zod.z.string().refine((val) => schema.enum.includes(val));
+        return import_v3.z.string().refine((val) => schema.enum.includes(val));
       }
-      let zodString = import_zod.z.string();
+      let zodString = import_v3.z.string();
       if (schema.description) {
         zodString = zodString.describe(schema.description);
       }
       return zodString;
     }
     case "number": {
-      let zodNumber = import_zod.z.number();
+      let zodNumber = import_v3.z.number();
       if (schema.minimum !== void 0) {
         zodNumber = zodNumber.min(schema.minimum);
       }
@@ -8118,14 +8052,14 @@ function jsonSchemaToZod(schema) {
       return zodNumber;
     }
     case "boolean": {
-      let zodBoolean = import_zod.z.boolean();
+      let zodBoolean = import_v3.z.boolean();
       if (schema.description) {
         zodBoolean = zodBoolean.describe(schema.description);
       }
       return zodBoolean;
     }
     default:
-      return import_zod.z.any();
+      return import_v3.z.any();
   }
 }
 
@@ -9124,7 +9058,7 @@ var CacheStorage = class _CacheStorage {
 };
 
 // lib/inference.ts
-var import_zod2 = require("zod");
+var import_v32 = require("zod/v3");
 
 // lib/prompt.ts
 function buildUserInstructionsString(userProvidedInstructions) {
@@ -9383,11 +9317,11 @@ function extract(_0) {
     logInferenceToFile = false
   }) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
-    const metadataSchema = import_zod2.z.object({
-      progress: import_zod2.z.string().describe(
+    const metadataSchema = import_v32.z.object({
+      progress: import_v32.z.string().describe(
         "progress of what has been extracted so far, as concise as possible"
       ),
-      completed: import_zod2.z.boolean().describe(
+      completed: import_v32.z.boolean().describe(
         "true if the goal is now accomplished. Use this conservatively, only when sure that the goal has been completed."
       )
     });
@@ -9537,20 +9471,20 @@ function observe(_0) {
   }) {
     var _a, _b, _c, _d;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const observeSchema = import_zod2.z.object({
-      elements: import_zod2.z.array(
-        import_zod2.z.object({
-          elementId: import_zod2.z.string().describe(
+    const observeSchema = import_v32.z.object({
+      elements: import_v32.z.array(
+        import_v32.z.object({
+          elementId: import_v32.z.string().describe(
             "the ID string associated with the element. Never include surrounding square brackets. This field must follow the format of 'number-number'."
           ),
-          description: import_zod2.z.string().describe(
+          description: import_v32.z.string().describe(
             "a description of the accessible element and its purpose"
           ),
-          method: import_zod2.z.string().describe(
+          method: import_v32.z.string().describe(
             "the candidate method/action to interact with the element. Select one of the available Playwright interaction methods."
           ),
-          arguments: import_zod2.z.array(
-            import_zod2.z.string().describe(
+          arguments: import_v32.z.array(
+            import_v32.z.string().describe(
               "the arguments to pass to the method. For example, for a click, the arguments are empty, but for a fill, the arguments are the value to fill in."
             )
           )
@@ -9644,20 +9578,20 @@ function act(_0) {
   }) {
     var _a, _b;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const actSchema = import_zod2.z.object({
-      elementId: import_zod2.z.string().describe(
+    const actSchema = import_v32.z.object({
+      elementId: import_v32.z.string().describe(
         "the ID string associated with the element. Never include surrounding square brackets. This field must follow the format of 'number-number'."
       ),
-      description: import_zod2.z.string().describe("a description of the accessible element and its purpose"),
-      method: import_zod2.z.string().describe(
+      description: import_v32.z.string().describe("a description of the accessible element and its purpose"),
+      method: import_v32.z.string().describe(
         "the candidate method/action to interact with the element. Select one of the available Playwright interaction methods."
       ),
-      arguments: import_zod2.z.array(
-        import_zod2.z.string().describe(
+      arguments: import_v32.z.array(
+        import_v32.z.string().describe(
           "the arguments to pass to the method. For example, for a click, the arguments are empty, but for a fill, the arguments are the value to fill in."
         )
       ),
-      twoStep: import_zod2.z.boolean()
+      twoStep: import_v32.z.boolean()
     });
     const messages = [
       buildActSystemPrompt(userProvidedInstructions),
@@ -9738,12 +9672,12 @@ function act(_0) {
 init_logger();
 
 // lib/v3/types/public/methods.ts
-var import_zod3 = require("zod");
-var defaultExtractSchema = import_zod3.z.object({
-  extraction: import_zod3.z.string()
+var import_v33 = require("zod/v3");
+var defaultExtractSchema = import_v33.z.object({
+  extraction: import_v33.z.string()
 });
-var pageTextSchema = import_zod3.z.object({
-  pageText: import_zod3.z.string()
+var pageTextSchema = import_v33.z.object({
+  pageText: import_v33.z.string()
 });
 var V3FunctionName = /* @__PURE__ */ ((V3FunctionName2) => {
   V3FunctionName2["ACT"] = "ACT";
@@ -9766,6 +9700,7 @@ var SupportedPlaywrightAction = /* @__PURE__ */ ((SupportedPlaywrightAction2) =>
   SupportedPlaywrightAction2["NEXT_CHUNK"] = "nextChunk";
   SupportedPlaywrightAction2["PREV_CHUNK"] = "prevChunk";
   SupportedPlaywrightAction2["SELECT_OPTION_FROM_DROPDOWN"] = "selectOptionFromDropdown";
+  SupportedPlaywrightAction2["HOVER"] = "hover";
   return SupportedPlaywrightAction2;
 })(SupportedPlaywrightAction || {});
 
@@ -9876,7 +9811,8 @@ var METHOD_HANDLER_MAP = {
   nextChunk: scrollToNextChunk,
   prevChunk: scrollToPreviousChunk,
   selectOptionFromDropdown: selectOption,
-  selectOption
+  selectOption,
+  hover
 };
 function selectOption(ctx) {
   return __async(this, null, function* () {
@@ -10219,6 +10155,26 @@ function scrollByElementHeight(ctx, direction) {
     }
   });
 }
+function hover(ctx) {
+  return __async(this, null, function* () {
+    const { locator, xpath } = ctx;
+    try {
+      yield locator.hover();
+    } catch (e) {
+      v3Logger({
+        category: "action",
+        message: "error attempting to hover",
+        level: 0,
+        auxiliary: {
+          error: { value: e.message, type: "string" },
+          trace: { value: e.stack, type: "string" },
+          xpath: { value: xpath, type: "string" }
+        }
+      });
+      throw new UnderstudyCommandException(e.message);
+    }
+  });
+}
 function getFrameUrl(frame) {
   return __async(this, null, function* () {
     const url = yield frame.evaluate("location.href");
@@ -10726,7 +10682,7 @@ var ActHandler = class {
 // lib/v3/handlers/extractHandler.ts
 init_logger();
 init_snapshot();
-var import_zod4 = require("zod");
+var import_v34 = require("zod/v3");
 function transformUrlStringsToNumericIds(schema) {
   const [finalSchema, urlPaths] = transformSchema(schema, []);
   return [finalSchema, urlPaths];
@@ -10780,7 +10736,7 @@ var ExtractHandler = class {
         const baseSchema = schema != null ? schema : defaultExtractSchema;
         const isObjectSchema = !!((_c = baseSchema._def) == null ? void 0 : _c.shape);
         const WRAP_KEY = "value";
-        const objectSchema = isObjectSchema ? baseSchema : import_zod4.z.object({ [WRAP_KEY]: baseSchema });
+        const objectSchema = isObjectSchema ? baseSchema : import_v34.z.object({ [WRAP_KEY]: baseSchema });
         const [transformedSchema, urlFieldPaths] = transformUrlStringsToNumericIds(objectSchema);
         const extractionResponse = yield extract({
           instruction,
@@ -10967,11 +10923,11 @@ var ObserveHandler = class {
 
 // lib/v3/agent/tools/v3-goto.ts
 var import_ai = require("ai");
-var import_zod5 = require("zod");
+var import_v35 = require("zod/v3");
 var createGotoTool = (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")
+  inputSchema: import_v35.z.object({
+    url: import_v35.z.string().describe("The URL to navigate to")
   }),
   execute: (_0) => __async(null, [_0], function* ({ url }) {
     var _a;
@@ -10999,11 +10955,11 @@ var createGotoTool = (v3) => (0, import_ai.tool)({
 
 // lib/v3/agent/tools/v3-act.ts
 var import_ai2 = require("ai");
-var import_zod6 = require("zod");
+var import_v36 = require("zod/v3");
 var createActTool = (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(
+  inputSchema: import_v36.z.object({
+    action: import_v36.z.string().describe(
       'Describe what to click or type, e.g. "click the Login button" or "type "John" into the first name input"'
     )
   }),
@@ -11044,10 +11000,10 @@ var createActTool = (v3, executionModel) => (0, import_ai2.tool)({
 
 // lib/v3/agent/tools/v3-screenshot.ts
 var import_ai3 = require("ai");
-var import_zod7 = require("zod");
+var import_v37 = require("zod/v3");
 var createScreenshotTool = (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({}),
+  inputSchema: import_v37.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11071,11 +11027,11 @@ var createScreenshotTool = (v3) => (0, import_ai3.tool)({
 
 // lib/v3/agent/tools/v3-wait.ts
 var import_ai4 = require("ai");
-var import_zod8 = require("zod");
+var import_v38 = require("zod/v3");
 var createWaitTool = (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")
+  inputSchema: import_v38.z.object({
+    timeMs: import_v38.z.number().describe("Time in milliseconds")
   }),
   execute: (_0) => __async(null, [_0], function* ({ timeMs }) {
     v3.logger({
@@ -11099,11 +11055,11 @@ var createWaitTool = (v3) => (0, import_ai4.tool)({
 
 // lib/v3/agent/tools/v3-navback.ts
 var import_ai5 = require("ai");
-var import_zod9 = require("zod");
+var import_v39 = require("zod/v3");
 var createNavBackTool = (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")
+  inputSchema: import_v39.z.object({
+    reasoningText: import_v39.z.string().describe("Why you're going back")
   }),
   execute: () => __async(null, null, function* () {
     v3.logger({
@@ -11123,12 +11079,12 @@ var createNavBackTool = (v3) => (0, import_ai5.tool)({
 
 // lib/v3/agent/tools/v3-close.ts
 var import_ai6 = require("ai");
-var import_zod10 = require("zod");
+var import_v310 = require("zod/v3");
 var createCloseTool = () => (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"),
-    taskComplete: import_zod10.z.boolean().describe("Whether the task was completed successfully")
+  inputSchema: import_v310.z.object({
+    reasoning: import_v310.z.string().describe("Summary of what was accomplished"),
+    taskComplete: import_v310.z.boolean().describe("Whether the task was completed successfully")
   }),
   execute: (_0) => __async(null, [_0], function* ({ reasoning, taskComplete }) {
     return { success: true, reasoning, taskComplete };
@@ -11137,10 +11093,10 @@ var createCloseTool = () => (0, import_ai6.tool)({
 
 // lib/v3/agent/tools/v3-ariaTree.ts
 var import_ai7 = require("ai");
-var import_zod11 = require("zod");
+var import_v311 = require("zod/v3");
 var createAriaTreeTool = (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({}),
+  inputSchema: import_v311.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11168,17 +11124,17 @@ ${result.content}` }]
 
 // lib/v3/agent/tools/v3-fillform.ts
 var import_ai8 = require("ai");
-var import_zod12 = require("zod");
+var import_v312 = require("zod/v3");
 var createFillFormTool = (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({
-    fields: import_zod12.z.array(
-      import_zod12.z.object({
-        action: import_zod12.z.string().describe(
+  inputSchema: import_v312.z.object({
+    fields: import_v312.z.array(
+      import_v312.z.object({
+        action: import_v312.z.string().describe(
           'Description of typing action, e.g. "type foo into the email field"'
         ),
-        value: import_zod12.z.string().describe("Text to type into the target")
+        value: import_v312.z.string().describe("Text to type into the target")
       })
     ).min(1, "Provide at least one field to fill")
   }),
@@ -11222,12 +11178,12 @@ For any form with 2+ inputs/textareas. Faster than individual typing.`,
 
 // lib/v3/agent/tools/v3-scroll.ts
 var import_ai9 = require("ai");
-var import_zod13 = require("zod");
+var import_v313 = require("zod/v3");
 var createScrollTool = (v3) => (0, import_ai9.tool)({
   description: "Scroll the page",
-  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")
+  inputSchema: import_v313.z.object({
+    pixels: import_v313.z.number().describe("Number of pixels to scroll up or down"),
+    direction: import_v313.z.enum(["up", "down"]).describe("Direction to scroll")
   }),
   execute: (_0) => __async(null, [_0], function* ({ pixels, direction }) {
     v3.logger({
@@ -11259,19 +11215,19 @@ var createScrollTool = (v3) => (0, import_ai9.tool)({
 
 // lib/v3/agent/tools/v3-extract.ts
 var import_ai10 = require("ai");
-var import_zod14 = require("zod");
+var import_v314 = require("zod/v3");
 function evaluateZodSchema(schemaStr, logger) {
   var _a;
   try {
     const fn = new Function("z", `return ${schemaStr}`);
-    return fn(import_zod14.z);
+    return fn(import_v314.z);
   } catch (e) {
     logger == null ? void 0 : logger({
       category: "agent",
       message: `Failed to evaluate schema: ${(_a = e == null ? void 0 : e.message) != null ? _a : String(e)}`,
       level: 0
     });
-    return import_zod14.z.any();
+    return import_v314.z.any();
   }
 }
 var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
@@ -11293,9 +11249,9 @@ var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
     3. Extract arrays:
        instruction: "extract all product names and prices"
        schema: "z.object({ products: z.array(z.object({ name: z.string(), price: z.number() })) })"`,
-  inputSchema: import_zod14.z.object({
-    instruction: import_zod14.z.string(),
-    schema: import_zod14.z.string().optional().describe("Zod schema as code, e.g. z.object({ title: z.string() })")
+  inputSchema: import_v314.z.object({
+    instruction: import_v314.z.string(),
+    schema: import_v314.z.string().optional().describe("Zod schema as code, e.g. z.object({ title: z.string() })")
   }),
   execute: (_0) => __async(null, [_0], function* ({ instruction, schema }) {
     var _a;
@@ -11700,7 +11656,7 @@ init_snapshot();
 
 // lib/v3/agent/AnthropicCUAClient.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var import_zod15 = require("zod");
+var import_zod_to_json_schema = require("zod-to-json-schema");
 
 // lib/v3/agent/AgentClient.ts
 var AgentClient = class {
@@ -12203,7 +12159,7 @@ var AnthropicCUAClient = class extends AgentClient {
         };
         if (this.tools && Object.keys(this.tools).length > 0) {
           const customTools = Object.entries(this.tools).map(([name, tool12]) => {
-            const jsonSchema2 = import_zod15.z.toJSONSchema(tool12.inputSchema);
+            const jsonSchema2 = (0, import_zod_to_json_schema.zodToJsonSchema)(tool12.inputSchema);
             const inputSchema = {
               type: "object",
               properties: jsonSchema2.properties || {},
@@ -13067,7 +13023,7 @@ var import_genai3 = require("@google/genai");
 
 // lib/v3/agent/utils/googleCustomToolHandler.ts
 var import_genai2 = require("@google/genai");
-var import_zod16 = require("zod");
+var import_zod_to_json_schema2 = require("zod-to-json-schema");
 function executeGoogleCustomTool(toolName, toolArgs, tools, functionCall, logger) {
   return __async(this, null, function* () {
     try {
@@ -13135,7 +13091,7 @@ function convertToolSetToFunctionDeclarations(tools) {
 }
 function convertToolToFunctionDeclaration(name, tool12) {
   try {
-    const jsonSchema2 = import_zod16.z.toJSONSchema(tool12.inputSchema);
+    const jsonSchema2 = (0, import_zod_to_json_schema2.zodToJsonSchema)(tool12.inputSchema);
     const parameters = convertJsonSchemaToGoogleParameters(jsonSchema2);
     return {
       name,
@@ -13192,9 +13148,11 @@ var GoogleCUAClient = class extends AgentClient {
     this.environment = "ENVIRONMENT_BROWSER";
     this.tools = tools;
     this.apiKey = (clientOptions == null ? void 0 : clientOptions.apiKey) || process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY || "";
-    this.client = new import_genai3.GoogleGenAI({
+    this.baseURL = clientOptions == null ? void 0 : clientOptions.baseURL;
+    const genAIOptions = __spreadValues({
       apiKey: this.apiKey
-    });
+    }, this.baseURL ? { httpOptions: { baseUrl: this.baseURL } } : {});
+    this.client = new import_genai3.GoogleGenAI(genAIOptions);
     if ((clientOptions == null ? void 0 : clientOptions.environment) && typeof clientOptions.environment === "string") {
       this.environment = clientOptions.environment;
     }
@@ -13214,9 +13172,9 @@ var GoogleCUAClient = class extends AgentClient {
         }
       ]
     };
-    this.clientOptions = {
+    this.clientOptions = __spreadValues({
       apiKey: this.apiKey
-    };
+    }, this.baseURL ? { baseURL: this.baseURL } : {});
     if (this.tools && Object.keys(this.tools).length > 0) {
       this.updateGenerateContentConfig();
     }
@@ -15792,7 +15750,7 @@ var AISdkClient = class extends LLMClient {
 
 // lib/v3/llm/AnthropicClient.ts
 var import_sdk3 = __toESM(require("@anthropic-ai/sdk"));
-var import_zod17 = require("zod");
+var import_zod_to_json_schema3 = require("zod-to-json-schema");
 var AnthropicClient = class extends LLMClient {
   constructor({
     modelName,
@@ -15902,7 +15860,7 @@ var AnthropicClient = class extends LLMClient {
       });
       let toolDefinition;
       if (options.response_model) {
-        const jsonSchema2 = import_zod17.z.toJSONSchema(options.response_model.schema);
+        const jsonSchema2 = (0, import_zod_to_json_schema3.zodToJsonSchema)(options.response_model.schema);
         const { properties: schemaProperties, required: schemaRequired } = extractSchemaProperties(jsonSchema2);
         toolDefinition = {
           name: "print_extracted_data",
@@ -16034,7 +15992,7 @@ var extractSchemaProperties = (jsonSchema2) => {
 
 // lib/v3/llm/CerebrasClient.ts
 var import_openai2 = __toESM(require("openai"));
-var import_zod18 = require("zod");
+var import_zod_to_json_schema4 = require("zod-to-json-schema");
 var CerebrasClient = class extends LLMClient {
   constructor({
     modelName,
@@ -16096,7 +16054,7 @@ var CerebrasClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = import_zod18.z.toJSONSchema(options.response_model.schema);
+        const jsonSchema2 = (0, import_zod_to_json_schema4.zodToJsonSchema)(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -16621,7 +16579,7 @@ ${firstPartText.text}`;
 
 // lib/v3/llm/GroqClient.ts
 var import_openai3 = __toESM(require("openai"));
-var import_zod19 = require("zod");
+var import_zod_to_json_schema5 = require("zod-to-json-schema");
 var GroqClient = class extends LLMClient {
   constructor({
     modelName,
@@ -16683,7 +16641,7 @@ var GroqClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = import_zod19.z.toJSONSchema(options.response_model.schema);
+        const jsonSchema2 = (0, import_zod_to_json_schema5.zodToJsonSchema)(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -16841,8 +16799,8 @@ var GroqClient = class extends LLMClient {
 
 // lib/v3/llm/OpenAIClient.ts
 var import_openai4 = __toESM(require("openai"));
-var import_zod20 = require("openai/helpers/zod");
-var import_zod21 = require("zod");
+var import_zod = require("openai/helpers/zod");
+var import_zod_to_json_schema6 = __toESM(require("zod-to-json-schema"));
 var OpenAIClient = class extends LLMClient {
   constructor({
     modelName,
@@ -16953,7 +16911,7 @@ ${JSON.stringify(
         if (this.modelName.startsWith("o1") || this.modelName.startsWith("o3")) {
           try {
             const parsedSchema = JSON.stringify(
-              import_zod21.z.toJSONSchema(options.response_model.schema)
+              (0, import_zod_to_json_schema6.default)(options.response_model.schema)
             );
             options.messages.push({
               role: "user",
@@ -16979,7 +16937,7 @@ ${parsedSchema}
             throw error;
           }
         } else {
-          responseFormat = (0, import_zod20.zodResponseFormat)(
+          responseFormat = (0, import_zod.zodResponseFormat)(
             options.response_model.schema,
             options.response_model.name
           );
@@ -17163,7 +17121,7 @@ ${parsedSchema}
   }
 };
 
-// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@4.1.12/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@3.25.67/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 var import_provider = require("@ai-sdk/provider");
 var import_provider2 = require("@ai-sdk/provider");
 var import_provider3 = require("@ai-sdk/provider");
@@ -17300,14 +17258,14 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@4.1.12/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@3.25.67/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 var import_provider9 = require("@ai-sdk/provider");
 var import_provider10 = require("@ai-sdk/provider");
 var import_provider11 = require("@ai-sdk/provider");
 var z42 = __toESM(require("zod/v4"), 1);
-var import_v3 = require("zod/v3");
-var import_v32 = require("zod/v3");
-var import_v33 = require("zod/v3");
+var import_v315 = require("zod/v3");
+var import_v316 = require("zod/v3");
+var import_v317 = require("zod/v3");
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
@@ -18124,7 +18082,7 @@ function parseArrayDef(def, refs) {
   const res = {
     type: "array"
   };
-  if (((_a = def.type) == null ? void 0 : _a._def) && ((_c = (_b = def.type) == null ? void 0 : _b._def) == null ? void 0 : _c.typeName) !== import_v32.ZodFirstPartyTypeKind.ZodAny) {
+  if (((_a = def.type) == null ? void 0 : _a._def) && ((_c = (_b = def.type) == null ? void 0 : _b._def) == null ? void 0 : _c.typeName) !== import_v316.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, __spreadProps(__spreadValues({}, refs), {
       currentPath: [...refs.currentPath, "items"]
     }));
@@ -18613,18 +18571,18 @@ function parseRecordDef(def, refs) {
       currentPath: [...refs.currentPath, "additionalProperties"]
     }))) != null ? _a : refs.allowedAdditionalProperties
   };
-  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === import_v317.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
     const _a2 = parseStringDef(def.keyType._def, refs), { type } = _a2, keyType = __objRest(_a2, ["type"]);
     return __spreadProps(__spreadValues({}, schema), {
       propertyNames: keyType
     });
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v317.ZodFirstPartyTypeKind.ZodEnum) {
     return __spreadProps(__spreadValues({}, schema), {
       propertyNames: {
         enum: def.keyType._def.values
       }
     });
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v33.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v317.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v317.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
     const _b2 = parseBrandedDef(
       def.keyType._def,
       refs
@@ -18950,73 +18908,73 @@ var parseReadonlyDef = (def, refs) => {
 };
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case import_v3.ZodFirstPartyTypeKind.ZodString:
+    case import_v315.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodNumber:
+    case import_v315.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodObject:
+    case import_v315.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodBigInt:
+    case import_v315.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodBoolean:
+    case import_v315.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodDate:
+    case import_v315.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodUndefined:
+    case import_v315.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodNull:
+    case import_v315.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodArray:
+    case import_v315.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case import_v315.ZodFirstPartyTypeKind.ZodUnion:
+    case import_v315.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodIntersection:
+    case import_v315.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodTuple:
+    case import_v315.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodRecord:
+    case import_v315.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodLiteral:
+    case import_v315.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodEnum:
+    case import_v315.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case import_v315.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodNullable:
+    case import_v315.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodOptional:
+    case import_v315.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodMap:
+    case import_v315.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodSet:
+    case import_v315.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodLazy:
+    case import_v315.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case import_v3.ZodFirstPartyTypeKind.ZodPromise:
+    case import_v315.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v3.ZodFirstPartyTypeKind.ZodNever:
+    case import_v315.ZodFirstPartyTypeKind.ZodNaN:
+    case import_v315.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodEffects:
+    case import_v315.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodAny:
+    case import_v315.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodUnknown:
+    case import_v315.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodDefault:
+    case import_v315.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodBranded:
+    case import_v315.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodReadonly:
+    case import_v315.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodCatch:
+    case import_v315.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodPipeline:
+    case import_v315.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v3.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v3.ZodFirstPartyTypeKind.ZodSymbol:
+    case import_v315.ZodFirstPartyTypeKind.ZodFunction:
+    case import_v315.ZodFirstPartyTypeKind.ZodVoid:
+    case import_v315.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)(typeName);
@@ -19103,7 +19061,7 @@ var getRefs = (options) => {
     )
   });
 };
-var zodToJsonSchema = (schema, options) => {
+var zodToJsonSchema7 = (schema, options) => {
   var _a;
   const refs = getRefs(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
@@ -19148,7 +19106,7 @@ var zodToJsonSchema = (schema, options) => {
   combined.$schema = "http://json-schema.org/draft-07/schema#";
   return combined;
 };
-var zod_to_json_schema_default = zodToJsonSchema;
+var zod_to_json_schema_default = zodToJsonSchema7;
 function zod3Schema(zodSchema2, options) {
   var _a;
   const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
@@ -19240,7 +19198,7 @@ function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
 
-// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@4.1.12/node_modules/@ai-sdk/openai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@3.25.67/node_modules/@ai-sdk/openai/dist/index.mjs
 var import_provider12 = require("@ai-sdk/provider");
 var import_v4 = require("zod/v4");
 var import_provider13 = require("@ai-sdk/provider");
@@ -23630,7 +23588,7 @@ function createOpenAI(options = {}) {
 }
 var openai = createOpenAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+anthropic@2.0.34_zod@4.1.12/node_modules/@ai-sdk/anthropic/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+anthropic@2.0.34_zod@3.25.67/node_modules/@ai-sdk/anthropic/dist/index.mjs
 var import_provider20 = require("@ai-sdk/provider");
 var import_provider21 = require("@ai-sdk/provider");
 var import_v421 = require("zod/v4");
@@ -26669,7 +26627,7 @@ function createAnthropic(options = {}) {
 }
 var anthropic = createAnthropic();
 
-// ../../node_modules/.pnpm/@ai-sdk+google@2.0.23_zod@4.1.12/node_modules/@ai-sdk/google/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+google@2.0.23_zod@3.25.67/node_modules/@ai-sdk/google/dist/index.mjs
 var import_provider24 = require("@ai-sdk/provider");
 var import_v437 = require("zod/v4");
 var import_v438 = require("zod/v4");
@@ -28221,7 +28179,7 @@ function createGoogleGenerativeAI(options = {}) {
 }
 var google = createGoogleGenerativeAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.22_zod@4.1.12/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.22_zod@3.25.67/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
 var import_provider27 = require("@ai-sdk/provider");
 var import_v446 = require("zod/v4");
 var import_provider28 = require("@ai-sdk/provider");
@@ -29541,7 +29499,7 @@ var openaiCompatibleImageResponseSchema = import_v453.z.object({
   data: import_v453.z.array(import_v453.z.object({ b64_json: import_v453.z.string() }))
 });
 
-// ../../node_modules/.pnpm/@ai-sdk+xai@2.0.26_zod@4.1.12/node_modules/@ai-sdk/xai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+xai@2.0.26_zod@3.25.67/node_modules/@ai-sdk/xai/dist/index.mjs
 var import_provider32 = require("@ai-sdk/provider");
 var import_v454 = require("zod/v4");
 var import_provider33 = require("@ai-sdk/provider");
@@ -30293,7 +30251,7 @@ function createXai(options = {}) {
 }
 var xai = createXai();
 
-// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@4.1.12/node_modules/@ai-sdk/openai/dist/internal/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@3.25.67/node_modules/@ai-sdk/openai/dist/internal/index.mjs
 var import_provider35 = require("@ai-sdk/provider");
 var import_v457 = require("zod/v4");
 var import_provider36 = require("@ai-sdk/provider");
@@ -34516,7 +34474,7 @@ function mapWebSearchOutput2(action) {
   }
 }
 
-// ../../node_modules/.pnpm/@ai-sdk+azure@2.0.54_zod@4.1.12/node_modules/@ai-sdk/azure/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+azure@2.0.54_zod@3.25.67/node_modules/@ai-sdk/azure/dist/index.mjs
 var azureOpenaiTools = {
   codeInterpreter: codeInterpreter2,
   fileSearch: fileSearch2,
@@ -34621,7 +34579,7 @@ function createAzure(options = {}) {
 }
 var azure = createAzure();
 
-// ../../node_modules/.pnpm/@ai-sdk+groq@2.0.24_zod@4.1.12/node_modules/@ai-sdk/groq/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+groq@2.0.24_zod@3.25.67/node_modules/@ai-sdk/groq/dist/index.mjs
 var import_provider43 = require("@ai-sdk/provider");
 var import_provider44 = require("@ai-sdk/provider");
 var import_v477 = require("zod/v4");
@@ -35503,7 +35461,7 @@ function createGroq(options = {}) {
 }
 var groq = createGroq();
 
-// ../../node_modules/.pnpm/@ai-sdk+cerebras@1.0.25_zod@4.1.12/node_modules/@ai-sdk/cerebras/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+cerebras@1.0.25_zod@3.25.67/node_modules/@ai-sdk/cerebras/dist/index.mjs
 var import_provider47 = require("@ai-sdk/provider");
 var import_v482 = require("zod/v4");
 var VERSION8 = true ? "1.0.25" : "0.0.0-test";
@@ -35555,7 +35513,7 @@ function createCerebras(options = {}) {
 }
 var cerebras = createCerebras();
 
-// ../../node_modules/.pnpm/@ai-sdk+togetherai@1.0.23_zod@4.1.12/node_modules/@ai-sdk/togetherai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+togetherai@1.0.23_zod@3.25.67/node_modules/@ai-sdk/togetherai/dist/index.mjs
 var import_v483 = require("zod/v4");
 var TogetherAIImageModel = class {
   constructor(modelId, config) {
@@ -35686,7 +35644,7 @@ function createTogetherAI(options = {}) {
 }
 var togetherai = createTogetherAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+mistral@2.0.19_zod@4.1.12/node_modules/@ai-sdk/mistral/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+mistral@2.0.19_zod@3.25.67/node_modules/@ai-sdk/mistral/dist/index.mjs
 var import_provider48 = require("@ai-sdk/provider");
 var import_v484 = require("zod/v4");
 var import_provider49 = require("@ai-sdk/provider");
@@ -36469,7 +36427,7 @@ function createMistral(options = {}) {
 }
 var mistral = createMistral();
 
-// ../../node_modules/.pnpm/@ai-sdk+deepseek@1.0.23_zod@4.1.12/node_modules/@ai-sdk/deepseek/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+deepseek@1.0.23_zod@3.25.67/node_modules/@ai-sdk/deepseek/dist/index.mjs
 var import_provider52 = require("@ai-sdk/provider");
 var import_v488 = require("zod/v4");
 var buildDeepseekMetadata = (usage) => {
@@ -36559,7 +36517,7 @@ function createDeepSeek(options = {}) {
 }
 var deepseek = createDeepSeek();
 
-// ../../node_modules/.pnpm/@ai-sdk+perplexity@2.0.13_zod@4.1.12/node_modules/@ai-sdk/perplexity/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+perplexity@2.0.13_zod@3.25.67/node_modules/@ai-sdk/perplexity/dist/index.mjs
 var import_provider53 = require("@ai-sdk/provider");
 var import_v489 = require("zod/v4");
 var import_provider54 = require("@ai-sdk/provider");
@@ -36989,7 +36947,7 @@ function createPerplexity(options = {}) {
 }
 var perplexity = createPerplexity();
 
-// ../../node_modules/.pnpm/ollama-ai-provider-v2@1.5.0_zod@4.1.12/node_modules/ollama-ai-provider-v2/dist/index.mjs
+// ../../node_modules/.pnpm/ollama-ai-provider-v2@1.5.0_zod@3.25.67/node_modules/ollama-ai-provider-v2/dist/index.mjs
 var import_provider55 = require("@ai-sdk/provider");
 var import_v490 = require("zod/v4");
 var import_v491 = require("zod/v4");
@@ -39529,7 +39487,7 @@ function resolveModel(model) {
 
 // lib/v3/api.ts
 var import_fetch_cookie = __toESM(require("fetch-cookie"));
-var import_zod22 = require("zod");
+var import_zod_to_json_schema7 = __toESM(require("zod-to-json-schema"));
 var StagehandAPIClient = class {
   constructor({ apiKey, projectId, logger }) {
     this.apiKey = apiKey;
@@ -39623,7 +39581,7 @@ var StagehandAPIClient = class {
       options,
       frameId
     }) {
-      const jsonSchema2 = zodSchema2 ? import_zod22.z.toJSONSchema(zodSchema2) : void 0;
+      const jsonSchema2 = zodSchema2 ? (0, import_zod_to_json_schema7.default)(zodSchema2) : void 0;
       const args = {
         schema: jsonSchema2,
         instruction,
@@ -41108,13 +41066,13 @@ function isObserveResult(v) {
 
 // lib/v3Evaluator.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var import_zod23 = require("zod");
+var import_v318 = require("zod/v3");
 import_dotenv2.default.config();
-var EvaluationSchema = import_zod23.z.object({
-  evaluation: import_zod23.z.enum(["YES", "NO"]),
-  reasoning: import_zod23.z.string()
+var EvaluationSchema = import_v318.z.object({
+  evaluation: import_v318.z.enum(["YES", "NO"]),
+  reasoning: import_v318.z.string()
 });
-var BatchEvaluationSchema = import_zod23.z.array(EvaluationSchema);
+var BatchEvaluationSchema = import_v318.z.array(EvaluationSchema);
 var V3Evaluator = class {
   constructor(v3, modelName, modelClientOptions) {
     this.silentLogger = () => {