@browserbasehq/orca 3.0.3-patch → 3.0.3-zod-1

package/dist/index.js

@@ -85,7 +85,7 @@ var __async = (__this, __arguments, generator) => {
 var STAGEHAND_VERSION;
 var init_version = __esm({
   "lib/version.ts"() {
-    STAGEHAND_VERSION = "3.0.3-patch";
+    STAGEHAND_VERSION = "3.0.3-zod-1";
   }
 });
 
@@ -7935,12 +7935,15 @@ __export(v3_exports, {
   getZodType: () => getZodType,
   injectUrls: () => injectUrls,
   isRunningInBun: () => isRunningInBun,
+  isZod3Schema: () => isZod3Schema,
+  isZod4Schema: () => isZod4Schema,
   jsonSchemaToZod: () => jsonSchemaToZod,
   loadApiKeyFromEnv: () => loadApiKeyFromEnv,
   modelToAgentProviderMap: () => modelToAgentProviderMap,
   pageTextSchema: () => pageTextSchema,
   providerEnvVarMap: () => providerEnvVarMap,
   toGeminiSchema: () => toGeminiSchema,
+  toJsonSchema: () => toJsonSchema,
   transformSchema: () => transformSchema,
   trimTrailingTextNode: () => trimTrailingTextNode,
   validateZodSchema: () => validateZodSchema
@@ -7957,8 +7960,174 @@ var import_process2 = __toESM(require("process"));
 // lib/utils.ts
 init_sdkErrors();
 var import_genai = require("@google/genai");
-var import_v3 = require("zod/v3");
+var import_zod2 = require("zod");
+var import_v3 = __toESM(require("zod/v3"));
+
+// lib/v3/zodCompat.ts
+var import_zod = require("zod");
+var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
+var isZod4Schema = (schema) => typeof schema._zod !== "undefined";
+var isZod3Schema = (schema) => !isZod4Schema(schema);
+function toJsonSchema(schema) {
+  if (!isZod4Schema(schema)) {
+    return (0, import_zod_to_json_schema.default)(schema);
+  }
+  const zodWithJsonSchema = import_zod.z;
+  if (zodWithJsonSchema.toJSONSchema) {
+    return zodWithJsonSchema.toJSONSchema(schema);
+  }
+  throw new Error("Zod v4 toJSONSchema method not found");
+}
+
+// lib/utils.ts
 var ID_PATTERN = /^\d+-\d+$/;
+var zFactories = {
+  v4: import_zod2.z,
+  v3: import_v3.default
+};
+function getZFactory(schema) {
+  return isZod4Schema(schema) ? zFactories.v4 : zFactories.v3;
+}
+var TYPE_NAME_MAP = {
+  ZodString: "string",
+  string: "string",
+  ZodNumber: "number",
+  number: "number",
+  ZodBoolean: "boolean",
+  boolean: "boolean",
+  ZodObject: "object",
+  object: "object",
+  ZodArray: "array",
+  array: "array",
+  ZodUnion: "union",
+  union: "union",
+  ZodIntersection: "intersection",
+  intersection: "intersection",
+  ZodOptional: "optional",
+  optional: "optional",
+  ZodNullable: "nullable",
+  nullable: "nullable",
+  ZodLiteral: "literal",
+  literal: "literal",
+  ZodEnum: "enum",
+  enum: "enum",
+  ZodDefault: "default",
+  default: "default",
+  ZodEffects: "effects",
+  effects: "effects",
+  pipe: "pipe"
+};
+function getZ4Def(schema) {
+  var _a;
+  return (_a = schema._zod) == null ? void 0 : _a.def;
+}
+function getZ4Bag(schema) {
+  var _a;
+  return (_a = schema._zod) == null ? void 0 : _a.bag;
+}
+function getZ3Def(schema) {
+  return schema._def;
+}
+function getObjectShape(schema) {
+  var _a, _b;
+  const z4Shape = (_a = getZ4Def(schema)) == null ? void 0 : _a.shape;
+  if (z4Shape) {
+    return z4Shape;
+  }
+  const z3Shape = (_b = getZ3Def(schema)) == null ? void 0 : _b.shape;
+  if (!z3Shape) {
+    return void 0;
+  }
+  if (typeof z3Shape === "function") {
+    return z3Shape();
+  }
+  return z3Shape;
+}
+function getArrayElement(schema) {
+  var _a, _b, _c;
+  return (_c = (_a = getZ4Def(schema)) == null ? void 0 : _a.element) != null ? _c : (_b = getZ3Def(schema)) == null ? void 0 : _b.type;
+}
+function getInnerType(schema) {
+  var _a, _b, _c;
+  return (_c = (_a = getZ4Def(schema)) == null ? void 0 : _a.innerType) != null ? _c : (_b = getZ3Def(schema)) == null ? void 0 : _b.innerType;
+}
+function getUnionOptions(schema) {
+  var _a, _b;
+  const z4Options = (_a = getZ4Def(schema)) == null ? void 0 : _a.options;
+  if (Array.isArray(z4Options)) {
+    return z4Options;
+  }
+  const z3Options = (_b = getZ3Def(schema)) == null ? void 0 : _b.options;
+  return Array.isArray(z3Options) ? z3Options : void 0;
+}
+function getIntersectionSides(schema) {
+  const z4Def = getZ4Def(schema);
+  if ((z4Def == null ? void 0 : z4Def.left) || (z4Def == null ? void 0 : z4Def.right)) {
+    return {
+      left: z4Def == null ? void 0 : z4Def.left,
+      right: z4Def == null ? void 0 : z4Def.right
+    };
+  }
+  const z3Def = getZ3Def(schema);
+  return {
+    left: z3Def == null ? void 0 : z3Def.left,
+    right: z3Def == null ? void 0 : z3Def.right
+  };
+}
+function getEnumValues(schema) {
+  var _a, _b;
+  const z4Entries = (_a = getZ4Def(schema)) == null ? void 0 : _a.entries;
+  if (z4Entries && typeof z4Entries === "object") {
+    return Object.values(z4Entries);
+  }
+  const z3Values = (_b = getZ3Def(schema)) == null ? void 0 : _b.values;
+  return Array.isArray(z3Values) ? z3Values : void 0;
+}
+function getLiteralValues(schema) {
+  var _a, _b;
+  const z4Values = (_a = getZ4Def(schema)) == null ? void 0 : _a.values;
+  if (Array.isArray(z4Values)) {
+    return z4Values;
+  }
+  const value = (_b = getZ3Def(schema)) == null ? void 0 : _b.value;
+  return typeof value !== "undefined" ? [value] : [];
+}
+function getStringChecks(schema) {
+  var _a, _b;
+  const z4Checks = (_a = getZ4Def(schema)) == null ? void 0 : _a.checks;
+  if (Array.isArray(z4Checks)) {
+    return z4Checks;
+  }
+  const z3Checks = (_b = getZ3Def(schema)) == null ? void 0 : _b.checks;
+  return Array.isArray(z3Checks) ? z3Checks : [];
+}
+function getStringFormat(schema) {
+  var _a, _b, _c;
+  const bagFormat = (_a = getZ4Bag(schema)) == null ? void 0 : _a.format;
+  if (typeof bagFormat === "string") {
+    return bagFormat;
+  }
+  const z4Format = (_b = getZ4Def(schema)) == null ? void 0 : _b.format;
+  if (typeof z4Format === "string") {
+    return z4Format;
+  }
+  const z3Format = (_c = getZ3Def(schema)) == null ? void 0 : _c.format;
+  return typeof z3Format === "string" ? z3Format : void 0;
+}
+function getPipeEndpoints(schema) {
+  const z4Def = getZ4Def(schema);
+  if ((z4Def == null ? void 0 : z4Def.in) || (z4Def == null ? void 0 : z4Def.out)) {
+    return {
+      in: z4Def == null ? void 0 : z4Def.in,
+      out: z4Def == null ? void 0 : z4Def.out
+    };
+  }
+  return {};
+}
+function getEffectsBaseSchema(schema) {
+  var _a;
+  return (_a = getZ3Def(schema)) == null ? void 0 : _a.schema;
+}
 function validateZodSchema(schema, data) {
   const result = schema.safeParse(data);
   if (result.success) {
@@ -7979,118 +8148,150 @@ function decorateGeminiSchema(geminiSchema, zodSchema2) {
   return geminiSchema;
 }
 function toGeminiSchema(zodSchema2) {
+  var _a, _b;
+  const normalizedSchema = zodSchema2;
   const zodType = getZodType(zodSchema2);
   switch (zodType) {
-    case "ZodArray": {
+    case "array": {
+      const element = (_a = getArrayElement(zodSchema2)) != null ? _a : import_zod2.z.any();
       return decorateGeminiSchema(
         {
           type: import_genai.Type.ARRAY,
-          items: toGeminiSchema(
-            zodSchema2.element
-          )
+          items: toGeminiSchema(element)
         },
-        zodSchema2
+        normalizedSchema
       );
     }
-    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 shape = getObjectShape(zodSchema2);
+      if (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,
           properties,
           required: required.length > 0 ? required : void 0
         },
-        zodSchema2
+        normalizedSchema
       );
     }
-    case "ZodString":
+    case "string":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING
         },
-        zodSchema2
+        normalizedSchema
       );
-    case "ZodNumber":
+    case "number":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.NUMBER
         },
-        zodSchema2
+        normalizedSchema
       );
-    case "ZodBoolean":
+    case "boolean":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.BOOLEAN
         },
-        zodSchema2
+        normalizedSchema
       );
-    case "ZodEnum":
+    case "enum": {
+      const values = getEnumValues(zodSchema2);
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: zodSchema2._def.values
+          enum: values
         },
-        zodSchema2
+        normalizedSchema
       );
-    case "ZodDefault":
-    case "ZodNullable":
-    case "ZodOptional": {
-      const innerSchema = toGeminiSchema(zodSchema2._def.innerType);
+    }
+    case "default":
+    case "nullable":
+    case "optional": {
+      const innerType = (_b = getInnerType(zodSchema2)) != null ? _b : import_zod2.z.any();
+      const innerSchema = toGeminiSchema(innerType);
       return decorateGeminiSchema(
         __spreadProps(__spreadValues({}, innerSchema), {
           nullable: true
         }),
-        zodSchema2
+        normalizedSchema
       );
     }
-    case "ZodLiteral":
+    case "literal": {
+      const values = getLiteralValues(zodSchema2);
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: [zodSchema2._def.value]
+          enum: values
+        },
+        normalizedSchema
+      );
+    }
+    case "pipe": {
+      const endpoints = getPipeEndpoints(zodSchema2);
+      if (endpoints.in) {
+        return toGeminiSchema(endpoints.in);
+      }
+      return decorateGeminiSchema(
+        {
+          type: import_genai.Type.STRING
         },
-        zodSchema2
+        normalizedSchema
       );
+    }
+    // Standalone transforms and any unknown types fall through to default
     default:
       return decorateGeminiSchema(
         {
-          type: import_genai.Type.OBJECT,
-          nullable: true
+          type: import_genai.Type.STRING
         },
-        zodSchema2
+        normalizedSchema
       );
   }
 }
 function getZodType(schema) {
-  return schema._def.typeName;
+  var _a, _b, _c, _d, _e, _f, _g;
+  const schemaWithDef = schema;
+  const rawType = (_f = (_d = (_b = (_a = schemaWithDef._zod) == null ? void 0 : _a.def) == null ? void 0 : _b.type) != null ? _d : (_c = schemaWithDef._def) == null ? void 0 : _c.typeName) != null ? _f : (_e = schemaWithDef._def) == null ? void 0 : _e.type;
+  if (!rawType) {
+    return "unknown";
+  }
+  return (_g = TYPE_NAME_MAP[rawType]) != null ? _g : rawType;
 }
 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, "string")) {
+    const checks = getStringChecks(schema);
+    const format = getStringFormat(schema);
+    const hasUrlCheck = checks.some((check) => {
+      var _a, _b, _c, _d;
+      const candidate = check;
+      return candidate.kind === "url" || candidate.format === "url" || ((_b = (_a = candidate._zod) == null ? void 0 : _a.def) == null ? void 0 : _b.check) === "url" || ((_d = (_c = candidate._zod) == null ? void 0 : _c.def) == null ? void 0 : _d.format) === "url";
+    }) || 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 shape = getObjectShape(schema);
+    if (!shape) {
+      return [schema, []];
+    }
     const newShape = {};
     const urlPaths = [];
     let changed = false;
-    const shapeKeys = Object.keys(shape);
-    for (const key of shapeKeys) {
+    for (const key of Object.keys(shape)) {
       const child = shape[key];
       const [transformedChild, childPaths] = transformSchema(child, [
         ...currentPath,
@@ -8100,34 +8301,45 @@ function transformSchema(schema, currentPath) {
         changed = true;
       }
       newShape[key] = transformedChild;
-      if (childPaths.length > 0) {
-        for (const cp of childPaths) {
-          urlPaths.push({ segments: [key, ...cp.segments] });
-        }
-      }
+      childPaths.forEach((cp) => {
+        urlPaths.push({ segments: [key, ...cp.segments] });
+      });
     }
     if (changed) {
-      return [import_v3.z.object(newShape), urlPaths];
+      const factory6 = getZFactory(schema);
+      return [
+        factory6.object(newShape),
+        urlPaths
+      ];
     }
     return [schema, urlPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodArray)) {
-    const itemType = schema._def.type;
+  if (isKind(schema, "array")) {
+    const itemType = getArrayElement(schema);
+    if (!itemType) {
+      return [schema, []];
+    }
     const [transformedItem, childPaths] = transformSchema(itemType, [
       ...currentPath,
       "*"
     ]);
-    const changed = transformedItem !== itemType;
     const arrayPaths = childPaths.map((cp) => ({
       segments: ["*", ...cp.segments]
     }));
-    if (changed) {
-      return [import_v3.z.array(transformedItem), arrayPaths];
+    if (transformedItem !== itemType) {
+      const factory6 = getZFactory(schema);
+      return [
+        factory6.array(transformedItem),
+        arrayPaths
+      ];
     }
     return [schema, arrayPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodUnion)) {
-    const unionOptions = schema._def.options;
+  if (isKind(schema, "union")) {
+    const unionOptions = getUnionOptions(schema);
+    if (!unionOptions || unionOptions.length === 0) {
+      return [schema, []];
+    }
     const newOptions = [];
     let changed = false;
     let allPaths = [];
@@ -8143,54 +8355,94 @@ function transformSchema(schema, currentPath) {
       allPaths = [...allPaths, ...childPaths];
     });
     if (changed) {
+      const factory6 = getZFactory(schema);
       return [
-        import_v3.z.union(newOptions),
+        factory6.union(
+          newOptions
+        ),
         allPaths
       ];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodIntersection)) {
-    const leftType = schema._def.left;
-    const rightType = schema._def.right;
-    const [left, leftPaths] = transformSchema(leftType, [
+  if (isKind(schema, "intersection")) {
+    const { left, right } = getIntersectionSides(schema);
+    if (!left || !right) {
+      return [schema, []];
+    }
+    const [newLeft, leftPaths] = transformSchema(left, [
       ...currentPath,
       "intersection_left"
     ]);
-    const [right, rightPaths] = transformSchema(rightType, [
+    const [newRight, rightPaths] = transformSchema(right, [
       ...currentPath,
       "intersection_right"
     ]);
-    const changed = left !== leftType || right !== rightType;
+    const changed = newLeft !== left || newRight !== right;
     const allPaths = [...leftPaths, ...rightPaths];
     if (changed) {
-      return [import_v3.z.intersection(left, right), allPaths];
+      const factory6 = getZFactory(schema);
+      return [
+        factory6.intersection(
+          newLeft,
+          newRight
+        ),
+        allPaths
+      ];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodOptional)) {
-    const innerType = schema._def.innerType;
+  if (isKind(schema, "optional")) {
+    const innerType = getInnerType(schema);
+    if (!innerType) {
+      return [schema, []];
+    }
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_v3.z.optional(inner), innerPaths];
+      return [
+        inner.optional(),
+        innerPaths
+      ];
     }
     return [schema, innerPaths];
   }
-  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodNullable)) {
-    const innerType = schema._def.innerType;
+  if (isKind(schema, "nullable")) {
+    const innerType = getInnerType(schema);
+    if (!innerType) {
+      return [schema, []];
+    }
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_v3.z.nullable(inner), innerPaths];
+      return [
+        inner.nullable(),
+        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") && isZod4Schema(schema)) {
+    const { in: inSchema, out: outSchema } = getPipeEndpoints(schema);
+    if (!inSchema || !outSchema) {
+      return [schema, []];
+    }
+    const [newIn, inPaths] = transformSchema(inSchema, currentPath);
+    const [newOut, outPaths] = transformSchema(outSchema, currentPath);
+    const allPaths = [...inPaths, ...outPaths];
+    if (newIn !== inSchema || newOut !== outSchema) {
+      const result = import_zod2.z.pipe(
+        newIn,
+        newOut
+      );
+      return [result, allPaths];
     }
-    return [schema, basePaths];
+    return [schema, allPaths];
+  }
+  if (isKind(schema, "effects")) {
+    const baseSchema = getEffectsBaseSchema(schema);
+    if (!baseSchema) {
+      return [schema, []];
+    }
+    return transformSchema(baseSchema, currentPath);
   }
   return [schema, []];
 }
@@ -8236,17 +8488,19 @@ function injectUrls(obj, path7, 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);
+  const factory6 = getZFactory(orig);
+  return factory6.string().regex(ID_PATTERN).describe(composed);
 }
 var providerEnvVarMap = {
   openai: "OPENAI_API_KEY",
@@ -8292,7 +8546,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_zod2.z.object(shape);
         if (schema.required && Array.isArray(schema.required)) {
           const requiredFields = schema.required.reduce(
             (acc, field) => __spreadProps(__spreadValues({}, acc), { [field]: true }),
@@ -8305,30 +8559,37 @@ function jsonSchemaToZod(schema) {
         }
         return zodObject;
       } else {
-        return import_v3.z.object({});
+        return import_zod2.z.object({});
       }
     case "array":
       if (schema.items) {
-        let zodArray = import_v3.z.array(jsonSchemaToZod(schema.items));
+        let zodArray = import_zod2.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_zod2.z.array(import_zod2.z.any());
       }
     case "string": {
       if (schema.enum) {
-        return import_v3.z.string().refine((val) => schema.enum.includes(val));
+        return import_zod2.z.string().refine((val) => schema.enum.includes(val));
+      }
+      let zodString = import_zod2.z.string();
+      if (schema.format === "uri" || schema.format === "url") {
+        zodString = zodString.url();
+      } else if (schema.format === "email") {
+        zodString = zodString.email();
+      } else if (schema.format === "uuid") {
+        zodString = zodString.uuid();
       }
-      let zodString = import_v3.z.string();
       if (schema.description) {
         zodString = zodString.describe(schema.description);
       }
       return zodString;
     }
     case "number": {
-      let zodNumber = import_v3.z.number();
+      let zodNumber = import_zod2.z.number();
       if (schema.minimum !== void 0) {
         zodNumber = zodNumber.min(schema.minimum);
       }
@@ -8341,14 +8602,14 @@ function jsonSchemaToZod(schema) {
       return zodNumber;
     }
     case "boolean": {
-      let zodBoolean = import_v3.z.boolean();
+      let zodBoolean = import_zod2.z.boolean();
       if (schema.description) {
         zodBoolean = zodBoolean.describe(schema.description);
       }
       return zodBoolean;
     }
     default:
-      return import_v3.z.any();
+      return import_zod2.z.any();
   }
 }
 
@@ -9350,7 +9611,7 @@ var CacheStorage = class _CacheStorage {
 };
 
 // lib/inference.ts
-var import_v32 = require("zod/v3");
+var import_zod3 = require("zod");
 
 // lib/prompt.ts
 function buildUserInstructionsString(userProvidedInstructions) {
@@ -9609,11 +9870,11 @@ function extract(_0) {
     logInferenceToFile = false
   }) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
-    const metadataSchema = import_v32.z.object({
-      progress: import_v32.z.string().describe(
+    const metadataSchema = import_zod3.z.object({
+      progress: import_zod3.z.string().describe(
         "progress of what has been extracted so far, as concise as possible"
       ),
-      completed: import_v32.z.boolean().describe(
+      completed: import_zod3.z.boolean().describe(
         "true if the goal is now accomplished. Use this conservatively, only when sure that the goal has been completed."
       )
     });
@@ -9771,20 +10032,20 @@ function observe(_0) {
   }) {
     var _a, _b, _c, _d, _e, _f;
     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_zod3.z.object({
+      elements: import_zod3.z.array(
+        import_zod3.z.object({
+          elementId: import_zod3.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_zod3.z.string().describe(
             "a description of the accessible element and its purpose"
           ),
-          method: import_v32.z.string().describe(
+          method: import_zod3.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_zod3.z.array(
+            import_zod3.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."
             )
           )
@@ -9884,20 +10145,20 @@ function act(_0) {
   }) {
     var _a, _b, _c, _d;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const actSchema = import_v32.z.object({
-      elementId: import_v32.z.string().describe(
+    const actSchema = import_zod3.z.object({
+      elementId: import_zod3.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_zod3.z.string().describe("a description of the accessible element and its purpose"),
+      method: import_zod3.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_zod3.z.array(
+        import_zod3.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_zod3.z.boolean()
     });
     const messages = [
       buildActSystemPrompt(userProvidedInstructions),
@@ -9984,12 +10245,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_zod4 = require("zod");
+var defaultExtractSchema = import_zod4.z.object({
+  extraction: import_zod4.z.string()
 });
-var pageTextSchema = import_v33.z.object({
-  pageText: import_v33.z.string()
+var pageTextSchema = import_zod4.z.object({
+  pageText: import_zod4.z.string()
 });
 var V3FunctionName = /* @__PURE__ */ ((V3FunctionName2) => {
   V3FunctionName2["ACT"] = "ACT";
@@ -11003,7 +11264,7 @@ var ActHandler = class {
 // lib/v3/handlers/extractHandler.ts
 init_logger();
 init_snapshot();
-var import_v34 = require("zod/v3");
+var import_zod5 = require("zod");
 init_sdkErrors();
 function transformUrlStringsToNumericIds(schema) {
   const [finalSchema, urlPaths] = transformSchema(schema, []);
@@ -11025,7 +11286,7 @@ var ExtractHandler = class {
       const { instruction, schema, page, selector, timeout, model } = params;
       const llmClient = this.resolveLlmClient(model);
       const doExtract = () => __async(this, null, function* () {
-        var _a, _b, _c, _e;
+        var _a, _b, _d;
         const noArgs = !instruction && !schema;
         if (noArgs) {
           const focusSelector2 = (_a = selector == null ? void 0 : selector.replace(/^xpath=/i, "")) != null ? _a : "";
@@ -11056,9 +11317,11 @@ var ExtractHandler = class {
           auxiliary: instruction ? { instruction: { value: instruction, type: "string" } } : void 0
         });
         const baseSchema = schema != null ? schema : defaultExtractSchema;
-        const isObjectSchema = !!((_c = baseSchema._def) == null ? void 0 : _c.shape);
+        const isObjectSchema = getZodType(baseSchema) === "object";
         const WRAP_KEY = "value";
-        const objectSchema = isObjectSchema ? baseSchema : import_v34.z.object({ [WRAP_KEY]: baseSchema });
+        const objectSchema = isObjectSchema ? baseSchema : import_zod5.z.object({
+          [WRAP_KEY]: baseSchema
+        });
         const [transformedSchema, urlFieldPaths] = transformUrlStringsToNumericIds(objectSchema);
         const extractionResponse = yield extract({
           instruction,
@@ -11069,14 +11332,14 @@ var ExtractHandler = class {
           logger: v3Logger,
           logInferenceToFile: this.logInferenceToFile
         });
-        const _d = extractionResponse, {
+        const _c = extractionResponse, {
           metadata: { completed },
           prompt_tokens,
           completion_tokens,
           reasoning_tokens = 0,
           cached_input_tokens = 0,
           inference_time_ms
-        } = _d, rest = __objRest(_d, [
+        } = _c, rest = __objRest(_c, [
           "metadata",
           "prompt_tokens",
           "completion_tokens",
@@ -11101,7 +11364,7 @@ var ExtractHandler = class {
             }
           }
         });
-        (_e = this.onMetrics) == null ? void 0 : _e.call(
+        (_d = this.onMetrics) == null ? void 0 : _d.call(
           this,
           "EXTRACT" /* EXTRACT */,
           prompt_tokens,
@@ -11126,12 +11389,14 @@ var ExtractHandler = class {
       if (!timeout) return doExtract();
       return yield Promise.race([
         doExtract(),
-        new Promise((_, reject) => {
-          setTimeout(
-            () => reject(new Error(`extract() timed out after ${timeout}ms`)),
-            timeout
-          );
-        })
+        new Promise(
+          (_, reject) => {
+            setTimeout(
+              () => reject(new Error(`extract() timed out after ${timeout}ms`)),
+              timeout
+            );
+          }
+        )
       ]);
     });
   }
@@ -11255,11 +11520,11 @@ var ObserveHandler = class {
 
 // lib/v3/agent/tools/v3-goto.ts
 var import_ai = require("ai");
-var import_v35 = require("zod/v3");
+var import_zod6 = 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_zod6.z.object({
+    url: import_zod6.z.string().describe("The URL to navigate to")
   }),
   execute: (_0) => __async(null, [_0], function* ({ url }) {
     var _a;
@@ -11287,11 +11552,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_zod7 = 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_zod7.z.object({
+    action: import_zod7.z.string().describe(
       'Describe what to click or type, e.g. "click the Login button" or "type "John" into the first name input"'
     )
   }),
@@ -11332,10 +11597,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_zod8 = 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_zod8.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11359,11 +11624,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_zod9 = 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_zod9.z.object({
+    timeMs: import_zod9.z.number().describe("Time in milliseconds")
   }),
   execute: (_0) => __async(null, [_0], function* ({ timeMs }) {
     v3.logger({
@@ -11387,11 +11652,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_zod10 = 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_zod10.z.object({
+    reasoningText: import_zod10.z.string().describe("Why you're going back")
   }),
   execute: () => __async(null, null, function* () {
     v3.logger({
@@ -11411,12 +11676,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_zod11 = 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_zod11.z.object({
+    reasoning: import_zod11.z.string().describe("Summary of what was accomplished"),
+    taskComplete: import_zod11.z.boolean().describe("Whether the task was completed successfully")
   }),
   execute: (_0) => __async(null, [_0], function* ({ reasoning, taskComplete }) {
     return { success: true, reasoning, taskComplete };
@@ -11425,10 +11690,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_zod12 = 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_zod12.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11456,17 +11721,17 @@ ${result.content}` }]
 
 // lib/v3/agent/tools/v3-fillform.ts
 var import_ai8 = require("ai");
-var import_v312 = require("zod/v3");
+var import_zod13 = 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_zod13.z.object({
+    fields: import_zod13.z.array(
+      import_zod13.z.object({
+        action: import_zod13.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_zod13.z.string().describe("Text to type into the target")
       })
     ).min(1, "Provide at least one field to fill")
   }),
@@ -11510,12 +11775,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_zod14 = 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_zod14.z.object({
+    pixels: import_zod14.z.number().describe("Number of pixels to scroll up or down"),
+    direction: import_zod14.z.enum(["up", "down"]).describe("Direction to scroll")
   }),
   execute: (_0) => __async(null, [_0], function* ({ pixels, direction }) {
     v3.logger({
@@ -11547,19 +11812,19 @@ 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_zod15 = require("zod");
 function evaluateZodSchema(schemaStr, logger) {
   var _a;
   try {
     const fn = new Function("z", `return ${schemaStr}`);
-    return fn(import_v314.z);
+    return fn(import_zod15.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_v314.z.any();
+    return import_zod15.z.any();
   }
 }
 var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
@@ -11581,9 +11846,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_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() })")
+  inputSchema: import_zod15.z.object({
+    instruction: import_zod15.z.string(),
+    schema: import_zod15.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;
@@ -11995,7 +12260,6 @@ init_sdkErrors();
 // lib/v3/agent/AnthropicCUAClient.ts
 init_sdkErrors();
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var import_zod_to_json_schema = require("zod-to-json-schema");
 
 // lib/v3/agent/AgentClient.ts
 var AgentClient = class {
@@ -12498,7 +12762,8 @@ 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 schema = tool12.inputSchema;
+            const jsonSchema2 = toJsonSchema(schema);
             const inputSchema = {
               type: "object",
               properties: jsonSchema2.properties || {},
@@ -13364,7 +13629,6 @@ init_sdkErrors();
 
 // lib/v3/agent/utils/googleCustomToolHandler.ts
 var import_genai2 = require("@google/genai");
-var import_zod_to_json_schema2 = require("zod-to-json-schema");
 function executeGoogleCustomTool(toolName, toolArgs, tools, functionCall, logger) {
   return __async(this, null, function* () {
     try {
@@ -13432,7 +13696,8 @@ function convertToolSetToFunctionDeclarations(tools) {
 }
 function convertToolToFunctionDeclaration(name, tool12) {
   try {
-    const jsonSchema2 = (0, import_zod_to_json_schema2.zodToJsonSchema)(tool12.inputSchema);
+    const schema = tool12.inputSchema;
+    const jsonSchema2 = toJsonSchema(schema);
     const parameters = convertJsonSchemaToGoogleParameters(jsonSchema2);
     return {
       name,
@@ -16103,7 +16368,6 @@ 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");
 init_sdkErrors();
 var AnthropicClient = class extends LLMClient {
   constructor({
@@ -16214,7 +16478,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 = toJsonSchema(options.response_model.schema);
         const { properties: schemaProperties, required: schemaRequired } = extractSchemaProperties(jsonSchema2);
         toolDefinition = {
           name: "print_extracted_data",
@@ -16346,7 +16610,6 @@ 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");
 init_sdkErrors();
 var CerebrasClient = class extends LLMClient {
   constructor({
@@ -16409,7 +16672,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 = toJsonSchema(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -16935,7 +17198,6 @@ ${firstPartText.text}`;
 
 // lib/v3/llm/GroqClient.ts
 var import_openai3 = __toESM(require("openai"));
-var import_zod_to_json_schema5 = require("zod-to-json-schema");
 init_sdkErrors();
 var GroqClient = class extends LLMClient {
   constructor({
@@ -16998,7 +17260,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 = toJsonSchema(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -17156,8 +17418,6 @@ 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"));
 init_sdkErrors();
 var OpenAIClient = class extends LLMClient {
   constructor({
@@ -17264,12 +17524,12 @@ ${JSON.stringify(
         };
         options.messages.push(screenshotMessage);
       }
-      let responseFormat = void 0;
+      let responseFormat;
       if (options.response_model) {
         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)
+              toJsonSchema(options.response_model.schema)
             );
             options.messages.push({
               role: "user",
@@ -17295,10 +17555,13 @@ ${parsedSchema}
             throw error;
           }
         } else {
-          responseFormat = (0, import_zod.zodResponseFormat)(
-            options.response_model.schema,
-            options.response_model.name
-          );
+          responseFormat = {
+            type: "json_schema",
+            json_schema: {
+              name: options.response_model.name,
+              schema: toJsonSchema(options.response_model.schema)
+            }
+          };
         }
       }
       const _d = __spreadProps(__spreadValues({}, optionsWithoutImageAndRequestId), {
@@ -17479,7 +17742,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.8/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");
@@ -17616,14 +17879,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.8/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_v32 = require("zod/v3");
+var import_v33 = require("zod/v3");
+var import_v34 = require("zod/v3");
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
@@ -18440,7 +18703,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_v33.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, __spreadProps(__spreadValues({}, refs), {
       currentPath: [...refs.currentPath, "items"]
     }));
@@ -18929,18 +19192,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_v34.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_v34.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_v34.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v34.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
     const _b2 = parseBrandedDef(
       def.keyType._def,
       refs
@@ -19266,73 +19529,73 @@ var parseReadonlyDef = (def, refs) => {
 };
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case import_v315.ZodFirstPartyTypeKind.ZodString:
+    case import_v32.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodNumber:
+    case import_v32.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodObject:
+    case import_v32.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodBigInt:
+    case import_v32.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodBoolean:
+    case import_v32.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodDate:
+    case import_v32.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodUndefined:
+    case import_v32.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodNull:
+    case import_v32.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodArray:
+    case import_v32.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v315.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case import_v32.ZodFirstPartyTypeKind.ZodUnion:
+    case import_v32.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodIntersection:
+    case import_v32.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodTuple:
+    case import_v32.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodRecord:
+    case import_v32.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodLiteral:
+    case import_v32.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodEnum:
+    case import_v32.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case import_v32.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case import_v315.ZodFirstPartyTypeKind.ZodNullable:
+    case import_v32.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodOptional:
+    case import_v32.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodMap:
+    case import_v32.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodSet:
+    case import_v32.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodLazy:
+    case import_v32.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case import_v315.ZodFirstPartyTypeKind.ZodPromise:
+    case import_v32.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v315.ZodFirstPartyTypeKind.ZodNever:
+    case import_v32.ZodFirstPartyTypeKind.ZodNaN:
+    case import_v32.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodEffects:
+    case import_v32.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodAny:
+    case import_v32.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodUnknown:
+    case import_v32.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef();
-    case import_v315.ZodFirstPartyTypeKind.ZodDefault:
+    case import_v32.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodBranded:
+    case import_v32.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodReadonly:
+    case import_v32.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodCatch:
+    case import_v32.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodPipeline:
+    case import_v32.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case import_v315.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v315.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v315.ZodFirstPartyTypeKind.ZodSymbol:
+    case import_v32.ZodFirstPartyTypeKind.ZodFunction:
+    case import_v32.ZodFirstPartyTypeKind.ZodVoid:
+    case import_v32.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)(typeName);
@@ -19419,7 +19682,7 @@ var getRefs = (options) => {
     )
   });
 };
-var zodToJsonSchema7 = (schema, options) => {
+var zodToJsonSchema2 = (schema, options) => {
   var _a;
   const refs = getRefs(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
@@ -19464,7 +19727,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 = zodToJsonSchema2;
 function zod3Schema(zodSchema2, options) {
   var _a;
   const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
@@ -19499,11 +19762,11 @@ function zod4Schema(zodSchema2, options) {
     }
   );
 }
-function isZod4Schema(zodSchema2) {
+function isZod4Schema2(zodSchema2) {
   return "_zod" in zodSchema2;
 }
 function zodSchema(zodSchema2, options) {
-  if (isZod4Schema(zodSchema2)) {
+  if (isZod4Schema2(zodSchema2)) {
     return zod4Schema(zodSchema2, options);
   } else {
     return zod3Schema(zodSchema2, options);
@@ -19556,7 +19819,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.8/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");
@@ -23946,7 +24209,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.8/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");
@@ -26985,7 +27248,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.8/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");
@@ -28537,7 +28800,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.8/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");
@@ -29857,7 +30120,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.8/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");
@@ -30609,7 +30872,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.8/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");
@@ -34832,7 +35095,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.8/node_modules/@ai-sdk/azure/dist/index.mjs
 var azureOpenaiTools = {
   codeInterpreter: codeInterpreter2,
   fileSearch: fileSearch2,
@@ -34937,7 +35200,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.8/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");
@@ -35819,7 +36082,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.8/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";
@@ -35871,7 +36134,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.8/node_modules/@ai-sdk/togetherai/dist/index.mjs
 var import_v483 = require("zod/v4");
 var TogetherAIImageModel = class {
   constructor(modelId, config) {
@@ -36002,7 +36265,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.8/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");
@@ -36785,7 +37048,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.8/node_modules/@ai-sdk/deepseek/dist/index.mjs
 var import_provider52 = require("@ai-sdk/provider");
 var import_v488 = require("zod/v4");
 var buildDeepseekMetadata = (usage) => {
@@ -36875,7 +37138,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.8/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");
@@ -37305,7 +37568,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.8/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");
@@ -39844,7 +40107,6 @@ 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"));
 init_version();
 var StagehandAPIClient = class {
   constructor({ apiKey, projectId, logger }) {
@@ -39939,7 +40201,7 @@ var StagehandAPIClient = class {
       options,
       frameId
     }) {
-      const jsonSchema2 = zodSchema2 ? (0, import_zod_to_json_schema7.default)(zodSchema2) : void 0;
+      const jsonSchema2 = zodSchema2 ? toJsonSchema(zodSchema2) : void 0;
       const args = {
         schema: jsonSchema2,
         instruction,
@@ -41479,14 +41741,14 @@ function isObserveResult(v) {
 
 // lib/v3Evaluator.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var import_v318 = require("zod/v3");
+var import_zod16 = require("zod");
 init_sdkErrors();
 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_zod16.z.object({
+  evaluation: import_zod16.z.enum(["YES", "NO"]),
+  reasoning: import_zod16.z.string()
 });
-var BatchEvaluationSchema = import_v318.z.array(EvaluationSchema);
+var BatchEvaluationSchema = import_zod16.z.array(EvaluationSchema);
 var V3Evaluator = class {
   constructor(v3, modelName, modelClientOptions) {
     this.silentLogger = () => {
@@ -41777,12 +42039,15 @@ I'm providing ${screenshots.length} screenshots showing the progression of the t
   getZodType,
   injectUrls,
   isRunningInBun,
+  isZod3Schema,
+  isZod4Schema,
   jsonSchemaToZod,
   loadApiKeyFromEnv,
   modelToAgentProviderMap,
   pageTextSchema,
   providerEnvVarMap,
   toGeminiSchema,
+  toJsonSchema,
   transformSchema,
   trimTrailingTextNode,
   validateZodSchema