@browserbasehq/orca 3.0.0-preview.7 → 3.0.0-test.1

package/dist/index.js

@@ -3102,6 +3102,11 @@ var init_deepLocator = __esm({
           return (yield this.real()).sendClickEvent(options);
         });
       }
+      setInputFiles(files) {
+        return __async(this, null, function* () {
+          return (yield this.real()).setInputFiles(files);
+        });
+      }
       first() {
         return this.nth(0);
       }
@@ -6290,7 +6295,7 @@ var import_path5 = __toESM(require("path"));
 var import_process2 = __toESM(require("process"));
 
 // lib/version.ts
-var STAGEHAND_VERSION = "3.0.0-preview.7";
+var STAGEHAND_VERSION = "3.0.0-test.1";
 
 // lib/v3/types/public/sdkErrors.ts
 var StagehandError = class extends Error {
@@ -6515,7 +6520,7 @@ var StagehandShadowSegmentNotFoundError = class extends StagehandError {
 
 // lib/utils.ts
 var import_genai = require("@google/genai");
-var import_v3 = require("zod/v3");
+var import_zod = require("zod");
 var ID_PATTERN = /^\d+-\d+$/;
 function validateZodSchema(schema, data) {
   const result = schema.safeParse(data);
@@ -6539,28 +6544,28 @@ function decorateGeminiSchema(geminiSchema, zodSchema2) {
 function toGeminiSchema(zodSchema2) {
   const zodType = getZodType(zodSchema2);
   switch (zodType) {
-    case "ZodArray": {
+    case "array": {
+      const arraySchema = zodSchema2;
+      const element = arraySchema._zod.def.element;
       return decorateGeminiSchema(
         {
           type: import_genai.Type.ARRAY,
-          items: toGeminiSchema(
-            zodSchema2.element
-          )
+          items: toGeminiSchema(element != null ? element : import_zod.z.any())
         },
         zodSchema2
       );
     }
-    case "ZodObject": {
+    case "object": {
       const properties = {};
       const required = [];
-      Object.entries(zodSchema2.shape).forEach(
-        ([key, value]) => {
-          properties[key] = toGeminiSchema(value);
-          if (getZodType(value) !== "ZodOptional") {
-            required.push(key);
-          }
+      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);
         }
-      );
+      });
       return decorateGeminiSchema(
         {
           type: import_genai.Type.OBJECT,
@@ -6570,39 +6575,45 @@ function toGeminiSchema(zodSchema2) {
         zodSchema2
       );
     }
-    case "ZodString":
+    case "string":
+    case "url":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING
         },
         zodSchema2
       );
-    case "ZodNumber":
+    case "number":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.NUMBER
         },
         zodSchema2
       );
-    case "ZodBoolean":
+    case "boolean":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.BOOLEAN
         },
         zodSchema2
       );
-    case "ZodEnum":
+    case "enum": {
+      const enumSchema = zodSchema2;
+      const values = Object.values(enumSchema._zod.def.entries);
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: zodSchema2._def.values
+          enum: values
         },
         zodSchema2
       );
-    case "ZodDefault":
-    case "ZodNullable":
-    case "ZodOptional": {
-      const innerSchema = toGeminiSchema(zodSchema2._def.innerType);
+    }
+    case "default":
+    case "nullable":
+    case "optional": {
+      const wrapperSchema = zodSchema2;
+      const innerType = wrapperSchema._zod.def.innerType;
+      const innerSchema = toGeminiSchema(innerType);
       return decorateGeminiSchema(
         __spreadProps(__spreadValues({}, innerSchema), {
           nullable: true
@@ -6610,14 +6621,23 @@ function toGeminiSchema(zodSchema2) {
         zodSchema2
       );
     }
-    case "ZodLiteral":
+    case "literal": {
+      const literalSchema = zodSchema2;
+      const values = literalSchema._zod.def.values;
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: [zodSchema2._def.value]
+          enum: values
         },
         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(
         {
@@ -6629,21 +6649,40 @@ function toGeminiSchema(zodSchema2) {
   }
 }
 function getZodType(schema) {
-  return schema._def.typeName;
+  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)}`
+  );
 }
 function transformSchema(schema, currentPath) {
   var _a, _b;
-  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 (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 (hasUrlCheck) {
       return [makeIdStringSchema(schema), [{ segments: [] }]];
     }
     return [schema, []];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodObject)) {
-    const shape = schema._def.shape();
+  if (isKind(schema, "object")) {
+    const objectSchema = schema;
+    const shape = objectSchema._zod.def.shape;
+    if (!shape) {
+      return [schema, []];
+    }
     const newShape = {};
     const urlPaths = [];
     let changed = false;
@@ -6665,12 +6704,17 @@ function transformSchema(schema, currentPath) {
       }
     }
     if (changed) {
-      return [import_v3.z.object(newShape), urlPaths];
+      const newSchema = import_zod.z.object(newShape);
+      return [newSchema, urlPaths];
     }
     return [schema, urlPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodArray)) {
-    const itemType = schema._def.type;
+  if (isKind(schema, "array")) {
+    const arraySchema = schema;
+    const itemType = arraySchema._zod.def.element;
+    if (!itemType) {
+      return [schema, []];
+    }
     const [transformedItem, childPaths] = transformSchema(itemType, [
       ...currentPath,
       "*"
@@ -6680,12 +6724,17 @@ function transformSchema(schema, currentPath) {
       segments: ["*", ...cp.segments]
     }));
     if (changed) {
-      return [import_v3.z.array(transformedItem), arrayPaths];
+      const newSchema = import_zod.z.array(transformedItem);
+      return [newSchema, arrayPaths];
     }
     return [schema, arrayPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodUnion)) {
-    const unionOptions = schema._def.options;
+  if (isKind(schema, "union")) {
+    const unionSchema = schema;
+    const unionOptions = unionSchema._zod.def.options;
+    if (!unionOptions || unionOptions.length === 0) {
+      return [schema, []];
+    }
     const newOptions = [];
     let changed = false;
     let allPaths = [];
@@ -6702,15 +6751,19 @@ function transformSchema(schema, currentPath) {
     });
     if (changed) {
       return [
-        import_v3.z.union(newOptions),
+        import_zod.z.union(newOptions),
         allPaths
       ];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodIntersection)) {
-    const leftType = schema._def.left;
-    const rightType = schema._def.right;
+  if (isKind(schema, "intersection")) {
+    const intersectionSchema = schema;
+    const leftType = intersectionSchema._zod.def.left;
+    const rightType = intersectionSchema._zod.def.right;
+    if (!leftType || !rightType) {
+      return [schema, []];
+    }
     const [left, leftPaths] = transformSchema(leftType, [
       ...currentPath,
       "intersection_left"
@@ -6722,33 +6775,50 @@ function transformSchema(schema, currentPath) {
     const changed = left !== leftType || right !== rightType;
     const allPaths = [...leftPaths, ...rightPaths];
     if (changed) {
-      return [import_v3.z.intersection(left, right), allPaths];
+      return [import_zod.z.intersection(left, right), allPaths];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodOptional)) {
-    const innerType = schema._def.innerType;
+  if (isKind(schema, "optional")) {
+    const optionalSchema = schema;
+    const innerType = optionalSchema._zod.def.innerType;
+    if (!innerType) {
+      return [schema, []];
+    }
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_v3.z.optional(inner), innerPaths];
+      return [import_zod.z.optional(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodNullable)) {
-    const innerType = schema._def.innerType;
+  if (isKind(schema, "nullable")) {
+    const nullableSchema = schema;
+    const innerType = nullableSchema._zod.def.innerType;
+    if (!innerType) {
+      return [schema, []];
+    }
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_v3.z.nullable(inner), innerPaths];
+      return [import_zod.z.nullable(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
-  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];
+  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];
     }
-    return [schema, basePaths];
+    return [schema, allPaths];
   }
   return [schema, []];
 }
@@ -6794,17 +6864,18 @@ function injectUrls(obj, path6, idToUrlMapping) {
   }
 }
 function isKind(s, kind) {
-  return s._def.typeName === kind;
+  try {
+    return getZodType(s) === kind;
+  } catch (e) {
+    return false;
+  }
 }
 function makeIdStringSchema(orig) {
-  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 : ""
-  );
+  var _a;
+  const userDesc = (_a = orig.description) != null ? _a : "";
   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_v3.z.string().regex(ID_PATTERN).describe(composed);
+  return import_zod.z.string().regex(ID_PATTERN).describe(composed);
 }
 var providerEnvVarMap = {
   openai: "OPENAI_API_KEY",
@@ -6850,7 +6921,7 @@ function jsonSchemaToZod(schema) {
         for (const key in schema.properties) {
           shape[key] = jsonSchemaToZod(schema.properties[key]);
         }
-        let zodObject = import_v3.z.object(shape);
+        let zodObject = import_zod.z.object(shape);
         if (schema.required && Array.isArray(schema.required)) {
           const requiredFields = schema.required.reduce(
             (acc, field) => __spreadProps(__spreadValues({}, acc), { [field]: true }),
@@ -6863,30 +6934,30 @@ function jsonSchemaToZod(schema) {
         }
         return zodObject;
       } else {
-        return import_v3.z.object({});
+        return import_zod.z.object({});
       }
     case "array":
       if (schema.items) {
-        let zodArray = import_v3.z.array(jsonSchemaToZod(schema.items));
+        let zodArray = import_zod.z.array(jsonSchemaToZod(schema.items));
         if (schema.description) {
           zodArray = zodArray.describe(schema.description);
         }
         return zodArray;
       } else {
-        return import_v3.z.array(import_v3.z.any());
+        return import_zod.z.array(import_zod.z.any());
       }
     case "string": {
       if (schema.enum) {
-        return import_v3.z.string().refine((val) => schema.enum.includes(val));
+        return import_zod.z.string().refine((val) => schema.enum.includes(val));
       }
-      let zodString = import_v3.z.string();
+      let zodString = import_zod.z.string();
       if (schema.description) {
         zodString = zodString.describe(schema.description);
       }
       return zodString;
     }
     case "number": {
-      let zodNumber = import_v3.z.number();
+      let zodNumber = import_zod.z.number();
       if (schema.minimum !== void 0) {
         zodNumber = zodNumber.min(schema.minimum);
       }
@@ -6899,14 +6970,14 @@ function jsonSchemaToZod(schema) {
       return zodNumber;
     }
     case "boolean": {
-      let zodBoolean = import_v3.z.boolean();
+      let zodBoolean = import_zod.z.boolean();
       if (schema.description) {
         zodBoolean = zodBoolean.describe(schema.description);
       }
       return zodBoolean;
     }
     default:
-      return import_v3.z.any();
+      return import_zod.z.any();
   }
 }
 
@@ -7827,7 +7898,7 @@ var CacheStorage = class _CacheStorage {
 };
 
 // lib/inference.ts
-var import_v32 = require("zod/v3");
+var import_zod2 = require("zod");
 
 // lib/prompt.ts
 function buildUserInstructionsString(userProvidedInstructions) {
@@ -8086,11 +8157,11 @@ function extract(_0) {
     logInferenceToFile = false
   }) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
-    const metadataSchema = import_v32.z.object({
-      progress: import_v32.z.string().describe(
+    const metadataSchema = import_zod2.z.object({
+      progress: import_zod2.z.string().describe(
         "progress of what has been extracted so far, as concise as possible"
       ),
-      completed: import_v32.z.boolean().describe(
+      completed: import_zod2.z.boolean().describe(
         "true if the goal is now accomplished. Use this conservatively, only when sure that the goal has been completed."
       )
     });
@@ -8240,20 +8311,20 @@ function observe(_0) {
   }) {
     var _a, _b, _c, _d;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const observeSchema = import_v32.z.object({
-      elements: import_v32.z.array(
-        import_v32.z.object({
-          elementId: import_v32.z.string().describe(
+    const observeSchema = import_zod2.z.object({
+      elements: import_zod2.z.array(
+        import_zod2.z.object({
+          elementId: import_zod2.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_v32.z.string().describe(
+          description: import_zod2.z.string().describe(
             "a description of the accessible element and its purpose"
           ),
-          method: import_v32.z.string().describe(
+          method: import_zod2.z.string().describe(
             "the candidate method/action to interact with the element. Select one of the available Playwright interaction methods."
           ),
-          arguments: import_v32.z.array(
-            import_v32.z.string().describe(
+          arguments: import_zod2.z.array(
+            import_zod2.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."
             )
           )
@@ -8347,20 +8418,20 @@ function act(_0) {
   }) {
     var _a, _b;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const actSchema = import_v32.z.object({
-      elementId: import_v32.z.string().describe(
+    const actSchema = import_zod2.z.object({
+      elementId: import_zod2.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_v32.z.string().describe("a description of the accessible element and its purpose"),
-      method: import_v32.z.string().describe(
+      description: import_zod2.z.string().describe("a description of the accessible element and its purpose"),
+      method: import_zod2.z.string().describe(
         "the candidate method/action to interact with the element. Select one of the available Playwright interaction methods."
       ),
-      arguments: import_v32.z.array(
-        import_v32.z.string().describe(
+      arguments: import_zod2.z.array(
+        import_zod2.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_v32.z.boolean()
+      twoStep: import_zod2.z.boolean()
     });
     const messages = [
       buildActSystemPrompt(userProvidedInstructions),
@@ -8441,12 +8512,12 @@ function act(_0) {
 init_logger();
 
 // lib/v3/types/public/methods.ts
-var import_v33 = require("zod/v3");
-var defaultExtractSchema = import_v33.z.object({
-  extraction: import_v33.z.string()
+var import_zod3 = require("zod");
+var defaultExtractSchema = import_zod3.z.object({
+  extraction: import_zod3.z.string()
 });
-var pageTextSchema = import_v33.z.object({
-  pageText: import_v33.z.string()
+var pageTextSchema = import_zod3.z.object({
+  pageText: import_zod3.z.string()
 });
 var V3FunctionName = /* @__PURE__ */ ((V3FunctionName2) => {
   V3FunctionName2["ACT"] = "ACT";
@@ -9429,7 +9500,7 @@ var ActHandler = class {
 // lib/v3/handlers/extractHandler.ts
 init_logger();
 init_snapshot();
-var import_v34 = require("zod/v3");
+var import_zod4 = require("zod");
 function transformUrlStringsToNumericIds(schema) {
   const [finalSchema, urlPaths] = transformSchema(schema, []);
   return [finalSchema, urlPaths];
@@ -9483,7 +9554,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_v34.z.object({ [WRAP_KEY]: baseSchema });
+        const objectSchema = isObjectSchema ? baseSchema : import_zod4.z.object({ [WRAP_KEY]: baseSchema });
         const [transformedSchema, urlFieldPaths] = transformUrlStringsToNumericIds(objectSchema);
         const extractionResponse = yield extract({
           instruction,
@@ -9670,11 +9741,11 @@ var ObserveHandler = class {
 
 // lib/v3/agent/tools/v3-goto.ts
 var import_ai = require("ai");
-var import_v35 = require("zod/v3");
+var import_zod5 = require("zod");
 var createGotoTool = (v3) => (0, import_ai.tool)({
   description: "Navigate to a specific URL",
-  inputSchema: import_v35.z.object({
-    url: import_v35.z.string().describe("The URL to navigate to")
+  inputSchema: import_zod5.z.object({
+    url: import_zod5.z.string().describe("The URL to navigate to")
   }),
   execute: (_0) => __async(null, [_0], function* ({ url }) {
     var _a;
@@ -9702,11 +9773,11 @@ var createGotoTool = (v3) => (0, import_ai.tool)({
 
 // lib/v3/agent/tools/v3-act.ts
 var import_ai2 = require("ai");
-var import_v36 = require("zod/v3");
+var import_zod6 = require("zod");
 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_v36.z.object({
-    action: import_v36.z.string().describe(
+  inputSchema: import_zod6.z.object({
+    action: import_zod6.z.string().describe(
       'Describe what to click or type, e.g. "click the Login button" or "type "John" into the first name input"'
     )
   }),
@@ -9747,10 +9818,10 @@ var createActTool = (v3, executionModel) => (0, import_ai2.tool)({
 
 // lib/v3/agent/tools/v3-screenshot.ts
 var import_ai3 = require("ai");
-var import_v37 = require("zod/v3");
+var import_zod7 = require("zod");
 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_v37.z.object({}),
+  inputSchema: import_zod7.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -9774,11 +9845,11 @@ var createScreenshotTool = (v3) => (0, import_ai3.tool)({
 
 // lib/v3/agent/tools/v3-wait.ts
 var import_ai4 = require("ai");
-var import_v38 = require("zod/v3");
+var import_zod8 = require("zod");
 var createWaitTool = (v3) => (0, import_ai4.tool)({
   description: "Wait for a specified time",
-  inputSchema: import_v38.z.object({
-    timeMs: import_v38.z.number().describe("Time in milliseconds")
+  inputSchema: import_zod8.z.object({
+    timeMs: import_zod8.z.number().describe("Time in milliseconds")
   }),
   execute: (_0) => __async(null, [_0], function* ({ timeMs }) {
     v3.logger({
@@ -9802,11 +9873,11 @@ var createWaitTool = (v3) => (0, import_ai4.tool)({
 
 // lib/v3/agent/tools/v3-navback.ts
 var import_ai5 = require("ai");
-var import_v39 = require("zod/v3");
+var import_zod9 = require("zod");
 var createNavBackTool = (v3) => (0, import_ai5.tool)({
   description: "Navigate back to the previous page",
-  inputSchema: import_v39.z.object({
-    reasoningText: import_v39.z.string().describe("Why you're going back")
+  inputSchema: import_zod9.z.object({
+    reasoningText: import_zod9.z.string().describe("Why you're going back")
   }),
   execute: () => __async(null, null, function* () {
     v3.logger({
@@ -9826,12 +9897,12 @@ var createNavBackTool = (v3) => (0, import_ai5.tool)({
 
 // lib/v3/agent/tools/v3-close.ts
 var import_ai6 = require("ai");
-var import_v310 = require("zod/v3");
+var import_zod10 = require("zod");
 var createCloseTool = () => (0, import_ai6.tool)({
   description: "Complete the task and close",
-  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")
+  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")
   }),
   execute: (_0) => __async(null, [_0], function* ({ reasoning, taskComplete }) {
     return { success: true, reasoning, taskComplete };
@@ -9840,10 +9911,10 @@ var createCloseTool = () => (0, import_ai6.tool)({
 
 // lib/v3/agent/tools/v3-ariaTree.ts
 var import_ai7 = require("ai");
-var import_v311 = require("zod/v3");
+var import_zod11 = require("zod");
 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_v311.z.object({}),
+  inputSchema: import_zod11.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -9871,17 +9942,17 @@ ${result.content}` }]
 
 // lib/v3/agent/tools/v3-fillform.ts
 var import_ai8 = require("ai");
-var import_v312 = require("zod/v3");
+var import_zod12 = require("zod");
 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_v312.z.object({
-    fields: import_v312.z.array(
-      import_v312.z.object({
-        action: import_v312.z.string().describe(
+  inputSchema: import_zod12.z.object({
+    fields: import_zod12.z.array(
+      import_zod12.z.object({
+        action: import_zod12.z.string().describe(
           'Description of typing action, e.g. "type foo into the email field"'
         ),
-        value: import_v312.z.string().describe("Text to type into the target")
+        value: import_zod12.z.string().describe("Text to type into the target")
       })
     ).min(1, "Provide at least one field to fill")
   }),
@@ -9925,12 +9996,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_v313 = require("zod/v3");
+var import_zod13 = require("zod");
 var createScrollTool = (v3) => (0, import_ai9.tool)({
   description: "Scroll the page",
-  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")
+  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")
   }),
   execute: (_0) => __async(null, [_0], function* ({ pixels, direction }) {
     v3.logger({
@@ -9962,12 +10033,12 @@ var createScrollTool = (v3) => (0, import_ai9.tool)({
 
 // lib/v3/agent/tools/v3-extract.ts
 var import_ai10 = require("ai");
-var import_v314 = require("zod/v3");
+var import_zod14 = require("zod");
 function evaluateZodSchema(schemaStr, logger) {
   var _a;
   try {
     const fn = new Function("z", `return ${schemaStr}`);
-    return fn(import_v314.z);
+    return fn(import_zod14.z);
   } catch (e) {
     logger == null ? void 0 : logger({
       category: "agent",
@@ -9981,10 +10052,10 @@ function evaluateZodSchema(schemaStr, logger) {
 }
 var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
   description: "Extract structured data. Optionally provide an instruction and Zod schema.",
-  inputSchema: import_v314.z.object({
-    instruction: import_v314.z.string().optional(),
-    schema: import_v314.z.string().optional().describe("Zod schema as code, e.g. z.object({ title: z.string() })"),
-    selector: import_v314.z.string().optional()
+  inputSchema: import_zod14.z.object({
+    instruction: import_zod14.z.string().optional(),
+    schema: import_zod14.z.string().optional().describe("Zod schema as code, e.g. z.object({ title: z.string() })"),
+    selector: import_zod14.z.string().optional()
   }),
   execute: (_0) => __async(null, [_0], function* ({ instruction, schema, selector }) {
     var _a;
@@ -10386,7 +10457,7 @@ init_snapshot();
 
 // lib/v3/agent/AnthropicCUAClient.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var import_zod_to_json_schema = require("zod-to-json-schema");
+var import_zod15 = require("zod");
 
 // lib/v3/agent/AgentClient.ts
 var AgentClient = class {
@@ -10889,7 +10960,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 = (0, import_zod_to_json_schema.zodToJsonSchema)(tool12.inputSchema);
+            const jsonSchema2 = import_zod15.z.toJSONSchema(tool12.inputSchema);
             const inputSchema = {
               type: "object",
               properties: jsonSchema2.properties || {},
@@ -11753,7 +11824,7 @@ var import_genai3 = require("@google/genai");
 
 // lib/v3/agent/utils/googleCustomToolHandler.ts
 var import_genai2 = require("@google/genai");
-var import_zod_to_json_schema2 = require("zod-to-json-schema");
+var import_zod16 = require("zod");
 function executeGoogleCustomTool(toolName, toolArgs, tools, functionCall, logger) {
   return __async(this, null, function* () {
     try {
@@ -11821,7 +11892,7 @@ function convertToolSetToFunctionDeclarations(tools) {
 }
 function convertToolToFunctionDeclaration(name, tool12) {
   try {
-    const jsonSchema2 = (0, import_zod_to_json_schema2.zodToJsonSchema)(tool12.inputSchema);
+    const jsonSchema2 = import_zod16.z.toJSONSchema(tool12.inputSchema);
     const parameters = convertJsonSchemaToGoogleParameters(jsonSchema2);
     return {
       name,
@@ -14478,7 +14549,7 @@ var AISdkClient = class extends LLMClient {
 
 // lib/v3/llm/AnthropicClient.ts
 var import_sdk3 = __toESM(require("@anthropic-ai/sdk"));
-var import_zod_to_json_schema3 = require("zod-to-json-schema");
+var import_zod17 = require("zod");
 var AnthropicClient = class extends LLMClient {
   constructor({
     modelName,
@@ -14588,7 +14659,7 @@ var AnthropicClient = class extends LLMClient {
       });
       let toolDefinition;
       if (options.response_model) {
-        const jsonSchema2 = (0, import_zod_to_json_schema3.zodToJsonSchema)(options.response_model.schema);
+        const jsonSchema2 = import_zod17.z.toJSONSchema(options.response_model.schema);
         const { properties: schemaProperties, required: schemaRequired } = extractSchemaProperties(jsonSchema2);
         toolDefinition = {
           name: "print_extracted_data",
@@ -14720,7 +14791,7 @@ var extractSchemaProperties = (jsonSchema2) => {
 
 // lib/v3/llm/CerebrasClient.ts
 var import_openai2 = __toESM(require("openai"));
-var import_zod_to_json_schema4 = require("zod-to-json-schema");
+var import_zod18 = require("zod");
 var CerebrasClient = class extends LLMClient {
   constructor({
     modelName,
@@ -14782,7 +14853,7 @@ var CerebrasClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = (0, import_zod_to_json_schema4.zodToJsonSchema)(options.response_model.schema);
+        const jsonSchema2 = import_zod18.z.toJSONSchema(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -15307,7 +15378,7 @@ ${firstPartText.text}`;
 
 // lib/v3/llm/GroqClient.ts
 var import_openai3 = __toESM(require("openai"));
-var import_zod_to_json_schema5 = require("zod-to-json-schema");
+var import_zod19 = require("zod");
 var GroqClient = class extends LLMClient {
   constructor({
     modelName,
@@ -15369,7 +15440,7 @@ var GroqClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = (0, import_zod_to_json_schema5.zodToJsonSchema)(options.response_model.schema);
+        const jsonSchema2 = import_zod19.z.toJSONSchema(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -15527,8 +15598,8 @@ var GroqClient = class extends LLMClient {
 
 // lib/v3/llm/OpenAIClient.ts
 var import_openai4 = __toESM(require("openai"));
-var import_zod = require("openai/helpers/zod");
-var import_zod_to_json_schema6 = __toESM(require("zod-to-json-schema"));
+var import_zod20 = require("openai/helpers/zod");
+var import_zod21 = require("zod");
 var OpenAIClient = class extends LLMClient {
   constructor({
     modelName,
@@ -15639,7 +15710,7 @@ ${JSON.stringify(
         if (this.modelName.startsWith("o1") || this.modelName.startsWith("o3")) {
           try {
             const parsedSchema = JSON.stringify(
-              (0, import_zod_to_json_schema6.default)(options.response_model.schema)
+              import_zod21.z.toJSONSchema(options.response_model.schema)
             );
             options.messages.push({
               role: "user",
@@ -15665,7 +15736,7 @@ ${parsedSchema}
             throw error;
           }
         } else {
-          responseFormat = (0, import_zod.zodResponseFormat)(
+          responseFormat = (0, import_zod20.zodResponseFormat)(
             options.response_model.schema,
             options.response_model.name
           );
@@ -15849,7 +15920,7 @@ ${parsedSchema}
   }
 };
 
-// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@3.25.67/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@4.1.12/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");
@@ -15986,14 +16057,14 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@3.25.67/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@4.1.12/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_v315 = require("zod/v3");
-var import_v316 = require("zod/v3");
-var import_v317 = require("zod/v3");
+var import_v3 = require("zod/v3");
+var import_v32 = require("zod/v3");
+var import_v33 = require("zod/v3");
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
@@ -16810,7 +16881,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_v316.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_v32.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, __spreadProps(__spreadValues({}, refs), {
       currentPath: [...refs.currentPath, "items"]
     }));
@@ -17299,18 +17370,18 @@ function parseRecordDef(def, refs) {
       currentPath: [...refs.currentPath, "additionalProperties"]
     }))) != null ? _a : refs.allowedAdditionalProperties
   };
-  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === import_v317.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === import_v33.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_v317.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodEnum) {
     return __spreadProps(__spreadValues({}, schema), {
       propertyNames: {
         enum: def.keyType._def.values
       }
     });
-  } 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)) {
+  } 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)) {
     const _b2 = parseBrandedDef(
       def.keyType._def,
       refs
@@ -17636,73 +17707,73 @@ var parseReadonlyDef = (def, refs) => {
 };
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case import_v315.ZodFirstPartyTypeKind.ZodString:
+    case import_v3.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodNumber:
+    case import_v3.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodObject:
+    case import_v3.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodBigInt:
+    case import_v3.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodBoolean:
+    case import_v3.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodDate:
+    case import_v3.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodUndefined:
+    case import_v3.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodNull:
+    case import_v3.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodArray:
+    case import_v3.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v315.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case import_v3.ZodFirstPartyTypeKind.ZodUnion:
+    case import_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodIntersection:
+    case import_v3.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodTuple:
+    case import_v3.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodRecord:
+    case import_v3.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodLiteral:
+    case import_v3.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodEnum:
+    case import_v3.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case import_v3.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodNullable:
+    case import_v3.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodOptional:
+    case import_v3.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodMap:
+    case import_v3.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodSet:
+    case import_v3.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodLazy:
+    case import_v3.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case import_v315.ZodFirstPartyTypeKind.ZodPromise:
+    case import_v3.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v315.ZodFirstPartyTypeKind.ZodNever:
+    case import_v3.ZodFirstPartyTypeKind.ZodNaN:
+    case import_v3.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodEffects:
+    case import_v3.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodAny:
+    case import_v3.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodUnknown:
+    case import_v3.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodDefault:
+    case import_v3.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodBranded:
+    case import_v3.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodReadonly:
+    case import_v3.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodCatch:
+    case import_v3.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodPipeline:
+    case import_v3.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v315.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v315.ZodFirstPartyTypeKind.ZodSymbol:
+    case import_v3.ZodFirstPartyTypeKind.ZodFunction:
+    case import_v3.ZodFirstPartyTypeKind.ZodVoid:
+    case import_v3.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)(typeName);
@@ -17789,7 +17860,7 @@ var getRefs = (options) => {
     )
   });
 };
-var zodToJsonSchema7 = (schema, options) => {
+var zodToJsonSchema = (schema, options) => {
   var _a;
   const refs = getRefs(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
@@ -17834,7 +17905,7 @@ var zodToJsonSchema7 = (schema, options) => {
   combined.$schema = "http://json-schema.org/draft-07/schema#";
   return combined;
 };
-var zod_to_json_schema_default = zodToJsonSchema7;
+var zod_to_json_schema_default = zodToJsonSchema;
 function zod3Schema(zodSchema2, options) {
   var _a;
   const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
@@ -17926,7 +17997,7 @@ function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
 
-// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@3.25.67/node_modules/@ai-sdk/openai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@4.1.12/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");
@@ -22316,7 +22387,7 @@ function createOpenAI(options = {}) {
 }
 var openai = createOpenAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+anthropic@2.0.34_zod@3.25.67/node_modules/@ai-sdk/anthropic/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+anthropic@2.0.34_zod@4.1.12/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");
@@ -25355,7 +25426,7 @@ function createAnthropic(options = {}) {
 }
 var anthropic = createAnthropic();
 
-// ../../node_modules/.pnpm/@ai-sdk+google@2.0.23_zod@3.25.67/node_modules/@ai-sdk/google/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+google@2.0.23_zod@4.1.12/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");
@@ -26907,7 +26978,7 @@ function createGoogleGenerativeAI(options = {}) {
 }
 var google = createGoogleGenerativeAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.22_zod@3.25.67/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.22_zod@4.1.12/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");
@@ -28227,7 +28298,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@3.25.67/node_modules/@ai-sdk/xai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+xai@2.0.26_zod@4.1.12/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");
@@ -28979,7 +29050,7 @@ function createXai(options = {}) {
 }
 var xai = createXai();
 
-// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@3.25.67/node_modules/@ai-sdk/openai/dist/internal/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@4.1.12/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");
@@ -33202,7 +33273,7 @@ function mapWebSearchOutput2(action) {
   }
 }
 
-// ../../node_modules/.pnpm/@ai-sdk+azure@2.0.54_zod@3.25.67/node_modules/@ai-sdk/azure/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+azure@2.0.54_zod@4.1.12/node_modules/@ai-sdk/azure/dist/index.mjs
 var azureOpenaiTools = {
   codeInterpreter: codeInterpreter2,
   fileSearch: fileSearch2,
@@ -33307,7 +33378,7 @@ function createAzure(options = {}) {
 }
 var azure = createAzure();
 
-// ../../node_modules/.pnpm/@ai-sdk+groq@2.0.24_zod@3.25.67/node_modules/@ai-sdk/groq/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+groq@2.0.24_zod@4.1.12/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");
@@ -34189,7 +34260,7 @@ function createGroq(options = {}) {
 }
 var groq = createGroq();
 
-// ../../node_modules/.pnpm/@ai-sdk+cerebras@1.0.25_zod@3.25.67/node_modules/@ai-sdk/cerebras/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+cerebras@1.0.25_zod@4.1.12/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";
@@ -34241,7 +34312,7 @@ function createCerebras(options = {}) {
 }
 var cerebras = createCerebras();
 
-// ../../node_modules/.pnpm/@ai-sdk+togetherai@1.0.23_zod@3.25.67/node_modules/@ai-sdk/togetherai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+togetherai@1.0.23_zod@4.1.12/node_modules/@ai-sdk/togetherai/dist/index.mjs
 var import_v483 = require("zod/v4");
 var TogetherAIImageModel = class {
   constructor(modelId, config) {
@@ -34372,7 +34443,7 @@ function createTogetherAI(options = {}) {
 }
 var togetherai = createTogetherAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+mistral@2.0.19_zod@3.25.67/node_modules/@ai-sdk/mistral/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+mistral@2.0.19_zod@4.1.12/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");
@@ -35155,7 +35226,7 @@ function createMistral(options = {}) {
 }
 var mistral = createMistral();
 
-// ../../node_modules/.pnpm/@ai-sdk+deepseek@1.0.23_zod@3.25.67/node_modules/@ai-sdk/deepseek/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+deepseek@1.0.23_zod@4.1.12/node_modules/@ai-sdk/deepseek/dist/index.mjs
 var import_provider52 = require("@ai-sdk/provider");
 var import_v488 = require("zod/v4");
 var buildDeepseekMetadata = (usage) => {
@@ -35245,7 +35316,7 @@ function createDeepSeek(options = {}) {
 }
 var deepseek = createDeepSeek();
 
-// ../../node_modules/.pnpm/@ai-sdk+perplexity@2.0.13_zod@3.25.67/node_modules/@ai-sdk/perplexity/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+perplexity@2.0.13_zod@4.1.12/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");
@@ -35675,7 +35746,7 @@ function createPerplexity(options = {}) {
 }
 var perplexity = createPerplexity();
 
-// ../../node_modules/.pnpm/ollama-ai-provider-v2@1.5.0_zod@3.25.67/node_modules/ollama-ai-provider-v2/dist/index.mjs
+// ../../node_modules/.pnpm/ollama-ai-provider-v2@1.5.0_zod@4.1.12/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");
@@ -38110,7 +38181,7 @@ function resolveModel(model) {
 
 // lib/v3/api.ts
 var import_fetch_cookie = __toESM(require("fetch-cookie"));
-var import_zod_to_json_schema7 = __toESM(require("zod-to-json-schema"));
+var import_zod22 = require("zod");
 var StagehandAPIClient = class {
   constructor({ apiKey, projectId, logger }) {
     this.apiKey = apiKey;
@@ -38204,7 +38275,7 @@ var StagehandAPIClient = class {
       options,
       frameId
     }) {
-      const jsonSchema2 = zodSchema2 ? (0, import_zod_to_json_schema7.default)(zodSchema2) : void 0;
+      const jsonSchema2 = zodSchema2 ? import_zod22.z.toJSONSchema(zodSchema2) : void 0;
       const args = {
         schema: jsonSchema2,
         instruction,
@@ -38438,7 +38509,7 @@ var _V3 = class _V3 {
     this.verbose = 1;
     this._history = [];
     this.apiClient = null;
-    this.v3Metrics = {
+    this.stagehandMetrics = {
       actPromptTokens: 0,
       actCompletionTokens: 0,
       actInferenceTimeMs: 0,
@@ -38546,7 +38617,7 @@ var _V3 = class _V3 {
    * Returning a Promise future-proofs async aggregation/storage.
    */
   get metrics() {
-    return Promise.resolve(this.v3Metrics);
+    return Promise.resolve(this.stagehandMetrics);
   }
   resolveLlmClient(model) {
     if (!model) {
@@ -38625,32 +38696,32 @@ var _V3 = class _V3 {
   updateMetrics(functionName, promptTokens, completionTokens, inferenceTimeMs) {
     switch (functionName) {
       case "ACT" /* ACT */:
-        this.v3Metrics.actPromptTokens += promptTokens;
-        this.v3Metrics.actCompletionTokens += completionTokens;
-        this.v3Metrics.actInferenceTimeMs += inferenceTimeMs;
+        this.stagehandMetrics.actPromptTokens += promptTokens;
+        this.stagehandMetrics.actCompletionTokens += completionTokens;
+        this.stagehandMetrics.actInferenceTimeMs += inferenceTimeMs;
         break;
       case "EXTRACT" /* EXTRACT */:
-        this.v3Metrics.extractPromptTokens += promptTokens;
-        this.v3Metrics.extractCompletionTokens += completionTokens;
-        this.v3Metrics.extractInferenceTimeMs += inferenceTimeMs;
+        this.stagehandMetrics.extractPromptTokens += promptTokens;
+        this.stagehandMetrics.extractCompletionTokens += completionTokens;
+        this.stagehandMetrics.extractInferenceTimeMs += inferenceTimeMs;
         break;
       case "OBSERVE" /* OBSERVE */:
-        this.v3Metrics.observePromptTokens += promptTokens;
-        this.v3Metrics.observeCompletionTokens += completionTokens;
-        this.v3Metrics.observeInferenceTimeMs += inferenceTimeMs;
+        this.stagehandMetrics.observePromptTokens += promptTokens;
+        this.stagehandMetrics.observeCompletionTokens += completionTokens;
+        this.stagehandMetrics.observeInferenceTimeMs += inferenceTimeMs;
         break;
       case "AGENT" /* AGENT */:
-        this.v3Metrics.agentPromptTokens += promptTokens;
-        this.v3Metrics.agentCompletionTokens += completionTokens;
-        this.v3Metrics.agentInferenceTimeMs += inferenceTimeMs;
+        this.stagehandMetrics.agentPromptTokens += promptTokens;
+        this.stagehandMetrics.agentCompletionTokens += completionTokens;
+        this.stagehandMetrics.agentInferenceTimeMs += inferenceTimeMs;
         break;
     }
     this.updateTotalMetrics(promptTokens, completionTokens, inferenceTimeMs);
   }
   updateTotalMetrics(promptTokens, completionTokens, inferenceTimeMs) {
-    this.v3Metrics.totalPromptTokens += promptTokens;
-    this.v3Metrics.totalCompletionTokens += completionTokens;
-    this.v3Metrics.totalInferenceTimeMs += inferenceTimeMs;
+    this.stagehandMetrics.totalPromptTokens += promptTokens;
+    this.stagehandMetrics.totalCompletionTokens += completionTokens;
+    this.stagehandMetrics.totalInferenceTimeMs += inferenceTimeMs;
   }
   _immediateShutdown(reason) {
     return __async(this, null, function* () {
@@ -39590,13 +39661,13 @@ function isObserveResult(v) {
 
 // lib/v3Evaluator.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var import_v318 = require("zod/v3");
+var import_zod23 = require("zod");
 import_dotenv2.default.config();
-var EvaluationSchema = import_v318.z.object({
-  evaluation: import_v318.z.enum(["YES", "NO"]),
-  reasoning: import_v318.z.string()
+var EvaluationSchema = import_zod23.z.object({
+  evaluation: import_zod23.z.enum(["YES", "NO"]),
+  reasoning: import_zod23.z.string()
 });
-var BatchEvaluationSchema = import_v318.z.array(EvaluationSchema);
+var BatchEvaluationSchema = import_zod23.z.array(EvaluationSchema);
 var V3Evaluator = class {
   constructor(v3, modelName, modelClientOptions) {
     this.silentLogger = () => {