@browserbasehq/orca 3.0.2-zod360 → 3.0.2-zod370

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.2-zod360";
+    STAGEHAND_VERSION = "3.0.2-zod370";
   }
 });
 
@@ -7935,15 +7935,12 @@ __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
@@ -7960,252 +7957,8 @@ var import_process2 = __toESM(require("process"));
 // lib/utils.ts
 init_sdkErrors();
 var import_genai = require("@google/genai");
-var import_zod2 = require("zod");
-var import_v3 = __toESM(require("zod/v3"));
-
-// lib/v3/zodCompat.ts
 var import_zod = require("zod");
-var isZod4Schema = (schema) => typeof schema._zod !== "undefined";
-var isZod3Schema = (schema) => !isZod4Schema(schema);
-function ZodToJsonSchema(schema) {
-  const _def = schema._def;
-  if (!_def) {
-    return { type: "null" };
-  }
-  const typeName = _def.typeName;
-  switch (typeName) {
-    case "ZodObject": {
-      const shape = typeof _def.shape === "function" ? _def.shape() : _def.shape;
-      const properties = {};
-      const required = [];
-      for (const [key, value] of Object.entries(shape)) {
-        properties[key] = ZodToJsonSchema(value);
-        const valueDef = value._def;
-        if ((valueDef == null ? void 0 : valueDef.typeName) !== "ZodOptional") {
-          required.push(key);
-        }
-      }
-      return {
-        type: "object",
-        properties,
-        required,
-        additionalProperties: _def.unknownKeys === "passthrough"
-      };
-    }
-    case "ZodArray": {
-      const itemType = _def.type;
-      return {
-        type: "array",
-        items: ZodToJsonSchema(itemType)
-      };
-    }
-    case "ZodString": {
-      const result = { type: "string" };
-      const checks = _def.checks;
-      if (checks) {
-        for (const check of checks) {
-          if (check.kind === "url") {
-            result.format = "url";
-            break;
-          }
-        }
-      }
-      return result;
-    }
-    case "ZodNumber":
-      return { type: "number" };
-    case "ZodBoolean":
-      return { type: "boolean" };
-    case "ZodOptional":
-      return ZodToJsonSchema(_def.innerType);
-    case "ZodNullable": {
-      const innerSchema = ZodToJsonSchema(_def.innerType);
-      return __spreadProps(__spreadValues({}, innerSchema), {
-        nullable: true
-      });
-    }
-    case "ZodEnum":
-      return {
-        type: "string",
-        enum: _def.values
-      };
-    case "ZodLiteral":
-      return {
-        type: typeof _def.value,
-        const: _def.value
-      };
-    case "ZodUnion":
-      return {
-        anyOf: _def.options.map((opt) => ZodToJsonSchema(opt))
-      };
-    default:
-      console.warn(`Unknown Zod type: ${typeName}`);
-      return { type: "null" };
-  }
-}
-function toJsonSchema(schema) {
-  if (!isZod4Schema(schema)) {
-    const result = __spreadValues({
-      $schema: "http://json-schema.org/draft-07/schema#"
-    }, ZodToJsonSchema(schema));
-    return result;
-  }
-  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) {
@@ -8226,150 +7979,152 @@ function decorateGeminiSchema(geminiSchema, zodSchema2) {
   return geminiSchema;
 }
 function toGeminiSchema(zodSchema2) {
-  var _a, _b;
-  const normalizedSchema = zodSchema2;
   const zodType = getZodType(zodSchema2);
   switch (zodType) {
     case "array": {
-      const element = (_a = getArrayElement(zodSchema2)) != null ? _a : import_zod2.z.any();
+      const arraySchema = zodSchema2;
+      const element = arraySchema._zod.def.element;
       return decorateGeminiSchema(
         {
           type: import_genai.Type.ARRAY,
-          items: toGeminiSchema(element)
+          items: toGeminiSchema(element != null ? element : import_zod.z.any())
         },
-        normalizedSchema
+        zodSchema2
       );
     }
     case "object": {
       const properties = {};
       const required = [];
-      const shape = getObjectShape(zodSchema2);
-      if (shape) {
-        Object.entries(shape).forEach(
-          ([key, value]) => {
-            properties[key] = toGeminiSchema(value);
-            if (getZodType(value) !== "optional") {
-              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,
           properties,
           required: required.length > 0 ? required : void 0
         },
-        normalizedSchema
+        zodSchema2
       );
     }
     case "string":
+    case "url":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING
         },
-        normalizedSchema
+        zodSchema2
       );
     case "number":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.NUMBER
         },
-        normalizedSchema
+        zodSchema2
       );
     case "boolean":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.BOOLEAN
         },
-        normalizedSchema
+        zodSchema2
       );
     case "enum": {
-      const values = getEnumValues(zodSchema2);
+      const enumSchema = zodSchema2;
+      const values = Object.values(enumSchema._zod.def.entries);
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
           enum: values
         },
-        normalizedSchema
+        zodSchema2
       );
     }
     case "default":
     case "nullable":
     case "optional": {
-      const innerType = (_b = getInnerType(zodSchema2)) != null ? _b : import_zod2.z.any();
+      const wrapperSchema = zodSchema2;
+      const innerType = wrapperSchema._zod.def.innerType;
       const innerSchema = toGeminiSchema(innerType);
       return decorateGeminiSchema(
         __spreadProps(__spreadValues({}, innerSchema), {
           nullable: true
         }),
-        normalizedSchema
+        zodSchema2
       );
     }
     case "literal": {
-      const values = getLiteralValues(zodSchema2);
+      const literalSchema = zodSchema2;
+      const values = literalSchema._zod.def.values;
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
           enum: values
         },
-        normalizedSchema
+        zodSchema2
       );
     }
     case "pipe": {
-      const endpoints = getPipeEndpoints(zodSchema2);
-      if (endpoints.in) {
-        return toGeminiSchema(endpoints.in);
-      }
-      return decorateGeminiSchema(
-        {
-          type: import_genai.Type.STRING
-        },
-        normalizedSchema
-      );
+      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(
         {
-          type: import_genai.Type.STRING
+          type: import_genai.Type.OBJECT,
+          nullable: true
         },
-        normalizedSchema
+        zodSchema2
       );
   }
 }
 function getZodType(schema) {
-  var _a, _b, _c, _d, _e, _f, _g;
+  var _a, _b;
   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";
+  if ((_b = (_a = schemaWithDef._zod) == null ? void 0 : _a.def) == null ? void 0 : _b.type) {
+    return schemaWithDef._zod.def.type;
   }
-  return (_g = TYPE_NAME_MAP[rawType]) != null ? _g : rawType;
+  throw new Error(
+    `Unable to determine Zod schema type. Schema: ${JSON.stringify(schema)}`
+  );
 }
 function transformSchema(schema, currentPath) {
+  var _a, _b;
+  if (isKind(schema, "url")) {
+    const transformed = makeIdStringSchema(schema);
+    return [transformed, [{ segments: [] }]];
+  }
   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";
+    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, "object")) {
-    const shape = getObjectShape(schema);
+    const objectSchema = schema;
+    const shape = objectSchema._zod.def.shape;
     if (!shape) {
       return [schema, []];
     }
     const newShape = {};
     const urlPaths = [];
     let changed = false;
-    for (const key of Object.keys(shape)) {
+    const shapeKeys = Object.keys(shape);
+    for (const key of shapeKeys) {
       const child = shape[key];
       const [transformedChild, childPaths] = transformSchema(child, [
         ...currentPath,
@@ -8379,21 +8134,21 @@ function transformSchema(schema, currentPath) {
         changed = true;
       }
       newShape[key] = transformedChild;
-      childPaths.forEach((cp) => {
-        urlPaths.push({ segments: [key, ...cp.segments] });
-      });
+      if (childPaths.length > 0) {
+        for (const cp of childPaths) {
+          urlPaths.push({ segments: [key, ...cp.segments] });
+        }
+      }
     }
     if (changed) {
-      const factory6 = getZFactory(schema);
-      return [
-        factory6.object(newShape),
-        urlPaths
-      ];
+      const newSchema = import_zod.z.object(newShape);
+      return [newSchema, urlPaths];
     }
     return [schema, urlPaths];
   }
   if (isKind(schema, "array")) {
-    const itemType = getArrayElement(schema);
+    const arraySchema = schema;
+    const itemType = arraySchema._zod.def.element;
     if (!itemType) {
       return [schema, []];
     }
@@ -8401,20 +8156,19 @@ function transformSchema(schema, currentPath) {
       ...currentPath,
       "*"
     ]);
+    const changed = transformedItem !== itemType;
     const arrayPaths = childPaths.map((cp) => ({
       segments: ["*", ...cp.segments]
     }));
-    if (transformedItem !== itemType) {
-      const factory6 = getZFactory(schema);
-      return [
-        factory6.array(transformedItem),
-        arrayPaths
-      ];
+    if (changed) {
+      const newSchema = import_zod.z.array(transformedItem);
+      return [newSchema, arrayPaths];
     }
     return [schema, arrayPaths];
   }
   if (isKind(schema, "union")) {
-    const unionOptions = getUnionOptions(schema);
+    const unionSchema = schema;
+    const unionOptions = unionSchema._zod.def.options;
     if (!unionOptions || unionOptions.length === 0) {
       return [schema, []];
     }
@@ -8433,95 +8187,76 @@ function transformSchema(schema, currentPath) {
       allPaths = [...allPaths, ...childPaths];
     });
     if (changed) {
-      const factory6 = getZFactory(schema);
       return [
-        factory6.union(
-          newOptions
-        ),
+        import_zod.z.union(newOptions),
         allPaths
       ];
     }
     return [schema, allPaths];
   }
   if (isKind(schema, "intersection")) {
-    const { left, right } = getIntersectionSides(schema);
-    if (!left || !right) {
+    const intersectionSchema = schema;
+    const leftType = intersectionSchema._zod.def.left;
+    const rightType = intersectionSchema._zod.def.right;
+    if (!leftType || !rightType) {
       return [schema, []];
     }
-    const [newLeft, leftPaths] = transformSchema(left, [
+    const [left, leftPaths] = transformSchema(leftType, [
       ...currentPath,
       "intersection_left"
     ]);
-    const [newRight, rightPaths] = transformSchema(right, [
+    const [right, rightPaths] = transformSchema(rightType, [
       ...currentPath,
       "intersection_right"
     ]);
-    const changed = newLeft !== left || newRight !== right;
+    const changed = left !== leftType || right !== rightType;
     const allPaths = [...leftPaths, ...rightPaths];
     if (changed) {
-      const factory6 = getZFactory(schema);
-      return [
-        factory6.intersection(
-          newLeft,
-          newRight
-        ),
-        allPaths
-      ];
+      return [import_zod.z.intersection(left, right), allPaths];
     }
     return [schema, allPaths];
   }
   if (isKind(schema, "optional")) {
-    const innerType = getInnerType(schema);
+    const optionalSchema = schema;
+    const innerType = optionalSchema._zod.def.innerType;
     if (!innerType) {
       return [schema, []];
     }
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [
-        inner.optional(),
-        innerPaths
-      ];
+      return [import_zod.z.optional(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
   if (isKind(schema, "nullable")) {
-    const innerType = getInnerType(schema);
+    const nullableSchema = schema;
+    const innerType = nullableSchema._zod.def.innerType;
     if (!innerType) {
       return [schema, []];
     }
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [
-        inner.nullable(),
-        innerPaths
-      ];
+      return [import_zod.z.nullable(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
-  if (isKind(schema, "pipe") && isZod4Schema(schema)) {
-    const { in: inSchema, out: outSchema } = getPipeEndpoints(schema);
+  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];
-    if (newIn !== inSchema || newOut !== outSchema) {
-      const result = import_zod2.z.pipe(
-        newIn,
-        newOut
-      );
+    const changed = newIn !== inSchema || newOut !== outSchema;
+    if (changed) {
+      const result = import_zod.z.pipe(newIn, newOut);
       return [result, allPaths];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, "effects")) {
-    const baseSchema = getEffectsBaseSchema(schema);
-    if (!baseSchema) {
-      return [schema, []];
-    }
-    return transformSchema(baseSchema, currentPath);
-  }
   return [schema, []];
 }
 function injectUrls(obj, path7, idToUrlMapping) {
@@ -8577,8 +8312,7 @@ function makeIdStringSchema(orig) {
   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;
-  const factory6 = getZFactory(orig);
-  return factory6.string().regex(ID_PATTERN).describe(composed);
+  return import_zod.z.string().regex(ID_PATTERN).describe(composed);
 }
 var providerEnvVarMap = {
   openai: "OPENAI_API_KEY",
@@ -8624,7 +8358,7 @@ function jsonSchemaToZod(schema) {
         for (const key in schema.properties) {
           shape[key] = jsonSchemaToZod(schema.properties[key]);
         }
-        let zodObject = import_zod2.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 }),
@@ -8637,37 +8371,30 @@ function jsonSchemaToZod(schema) {
         }
         return zodObject;
       } else {
-        return import_zod2.z.object({});
+        return import_zod.z.object({});
       }
     case "array":
       if (schema.items) {
-        let zodArray = import_zod2.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_zod2.z.array(import_zod2.z.any());
+        return import_zod.z.array(import_zod.z.any());
       }
     case "string": {
       if (schema.enum) {
-        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();
+        return import_zod.z.string().refine((val) => schema.enum.includes(val));
       }
+      let zodString = import_zod.z.string();
       if (schema.description) {
         zodString = zodString.describe(schema.description);
       }
       return zodString;
     }
     case "number": {
-      let zodNumber = import_zod2.z.number();
+      let zodNumber = import_zod.z.number();
       if (schema.minimum !== void 0) {
         zodNumber = zodNumber.min(schema.minimum);
       }
@@ -8680,14 +8407,14 @@ function jsonSchemaToZod(schema) {
       return zodNumber;
     }
     case "boolean": {
-      let zodBoolean = import_zod2.z.boolean();
+      let zodBoolean = import_zod.z.boolean();
       if (schema.description) {
         zodBoolean = zodBoolean.describe(schema.description);
       }
       return zodBoolean;
     }
     default:
-      return import_zod2.z.any();
+      return import_zod.z.any();
   }
 }
 
@@ -9689,7 +9416,7 @@ var CacheStorage = class _CacheStorage {
 };
 
 // lib/inference.ts
-var import_zod3 = require("zod");
+var import_zod2 = require("zod");
 
 // lib/prompt.ts
 function buildUserInstructionsString(userProvidedInstructions) {
@@ -9948,11 +9675,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_zod3.z.object({
-      progress: import_zod3.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_zod3.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."
       )
     });
@@ -10110,20 +9837,20 @@ function observe(_0) {
   }) {
     var _a, _b, _c, _d, _e, _f;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const observeSchema = import_zod3.z.object({
-      elements: import_zod3.z.array(
-        import_zod3.z.object({
-          elementId: import_zod3.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_zod3.z.string().describe(
+          description: import_zod2.z.string().describe(
             "a description of the accessible element and its purpose"
           ),
-          method: import_zod3.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_zod3.z.array(
-            import_zod3.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."
             )
           )
@@ -10223,20 +9950,20 @@ function act(_0) {
   }) {
     var _a, _b, _c, _d;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const actSchema = import_zod3.z.object({
-      elementId: import_zod3.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_zod3.z.string().describe("a description of the accessible element and its purpose"),
-      method: import_zod3.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_zod3.z.array(
-        import_zod3.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_zod3.z.boolean()
+      twoStep: import_zod2.z.boolean()
     });
     const messages = [
       buildActSystemPrompt(userProvidedInstructions),
@@ -10323,12 +10050,12 @@ function act(_0) {
 init_logger();
 
 // lib/v3/types/public/methods.ts
-var import_zod4 = require("zod");
-var defaultExtractSchema = import_zod4.z.object({
-  extraction: import_zod4.z.string()
+var import_zod3 = require("zod");
+var defaultExtractSchema = import_zod3.z.object({
+  extraction: import_zod3.z.string()
 });
-var pageTextSchema = import_zod4.z.object({
-  pageText: import_zod4.z.string()
+var pageTextSchema = import_zod3.z.object({
+  pageText: import_zod3.z.string()
 });
 var V3FunctionName = /* @__PURE__ */ ((V3FunctionName2) => {
   V3FunctionName2["ACT"] = "ACT";
@@ -11342,7 +11069,7 @@ var ActHandler = class {
 // lib/v3/handlers/extractHandler.ts
 init_logger();
 init_snapshot();
-var import_zod5 = require("zod");
+var import_zod4 = require("zod");
 init_sdkErrors();
 function transformUrlStringsToNumericIds(schema) {
   const [finalSchema, urlPaths] = transformSchema(schema, []);
@@ -11364,7 +11091,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, _d;
+        var _a, _b, _c, _e;
         const noArgs = !instruction && !schema;
         if (noArgs) {
           const focusSelector2 = (_a = selector == null ? void 0 : selector.replace(/^xpath=/i, "")) != null ? _a : "";
@@ -11395,11 +11122,9 @@ var ExtractHandler = class {
           auxiliary: instruction ? { instruction: { value: instruction, type: "string" } } : void 0
         });
         const baseSchema = schema != null ? schema : defaultExtractSchema;
-        const isObjectSchema = getZodType(baseSchema) === "object";
+        const isObjectSchema = !!((_c = baseSchema._def) == null ? void 0 : _c.shape);
         const WRAP_KEY = "value";
-        const objectSchema = isObjectSchema ? baseSchema : import_zod5.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,
@@ -11410,14 +11135,14 @@ var ExtractHandler = class {
           logger: v3Logger,
           logInferenceToFile: this.logInferenceToFile
         });
-        const _c = extractionResponse, {
+        const _d = extractionResponse, {
           metadata: { completed },
           prompt_tokens,
           completion_tokens,
           reasoning_tokens = 0,
           cached_input_tokens = 0,
           inference_time_ms
-        } = _c, rest = __objRest(_c, [
+        } = _d, rest = __objRest(_d, [
           "metadata",
           "prompt_tokens",
           "completion_tokens",
@@ -11442,7 +11167,7 @@ var ExtractHandler = class {
             }
           }
         });
-        (_d = this.onMetrics) == null ? void 0 : _d.call(
+        (_e = this.onMetrics) == null ? void 0 : _e.call(
           this,
           "EXTRACT" /* EXTRACT */,
           prompt_tokens,
@@ -11467,14 +11192,12 @@ 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
+          );
+        })
       ]);
     });
   }
@@ -11598,11 +11321,11 @@ var ObserveHandler = class {
 
 // lib/v3/agent/tools/v3-goto.ts
 var import_ai = require("ai");
-var import_zod6 = require("zod");
+var import_zod5 = require("zod");
 var createGotoTool = (v3) => (0, import_ai.tool)({
   description: "Navigate to a specific URL",
-  inputSchema: import_zod6.z.object({
-    url: import_zod6.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;
@@ -11630,11 +11353,11 @@ var createGotoTool = (v3) => (0, import_ai.tool)({
 
 // lib/v3/agent/tools/v3-act.ts
 var import_ai2 = require("ai");
-var import_zod7 = require("zod");
+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_zod7.z.object({
-    action: import_zod7.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"'
     )
   }),
@@ -11675,10 +11398,10 @@ var createActTool = (v3, executionModel) => (0, import_ai2.tool)({
 
 // lib/v3/agent/tools/v3-screenshot.ts
 var import_ai3 = require("ai");
-var import_zod8 = require("zod");
+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_zod8.z.object({}),
+  inputSchema: import_zod7.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11702,11 +11425,11 @@ var createScreenshotTool = (v3) => (0, import_ai3.tool)({
 
 // lib/v3/agent/tools/v3-wait.ts
 var import_ai4 = require("ai");
-var import_zod9 = require("zod");
+var import_zod8 = require("zod");
 var createWaitTool = (v3) => (0, import_ai4.tool)({
   description: "Wait for a specified time",
-  inputSchema: import_zod9.z.object({
-    timeMs: import_zod9.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({
@@ -11730,11 +11453,11 @@ var createWaitTool = (v3) => (0, import_ai4.tool)({
 
 // lib/v3/agent/tools/v3-navback.ts
 var import_ai5 = require("ai");
-var import_zod10 = require("zod");
+var import_zod9 = require("zod");
 var createNavBackTool = (v3) => (0, import_ai5.tool)({
   description: "Navigate back to the previous page",
-  inputSchema: import_zod10.z.object({
-    reasoningText: import_zod10.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({
@@ -11754,12 +11477,12 @@ var createNavBackTool = (v3) => (0, import_ai5.tool)({
 
 // lib/v3/agent/tools/v3-close.ts
 var import_ai6 = require("ai");
-var import_zod11 = require("zod");
+var import_zod10 = require("zod");
 var createCloseTool = () => (0, import_ai6.tool)({
   description: "Complete the task and close",
-  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")
+  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 };
@@ -11768,10 +11491,10 @@ var createCloseTool = () => (0, import_ai6.tool)({
 
 // lib/v3/agent/tools/v3-ariaTree.ts
 var import_ai7 = require("ai");
-var import_zod12 = require("zod");
+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_zod12.z.object({}),
+  inputSchema: import_zod11.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11799,17 +11522,17 @@ ${result.content}` }]
 
 // lib/v3/agent/tools/v3-fillform.ts
 var import_ai8 = require("ai");
-var import_zod13 = require("zod");
+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_zod13.z.object({
-    fields: import_zod13.z.array(
-      import_zod13.z.object({
-        action: import_zod13.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_zod13.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")
   }),
@@ -11853,12 +11576,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_zod14 = require("zod");
+var import_zod13 = require("zod");
 var createScrollTool = (v3) => (0, import_ai9.tool)({
   description: "Scroll the page",
-  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")
+  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({
@@ -11890,19 +11613,19 @@ var createScrollTool = (v3) => (0, import_ai9.tool)({
 
 // lib/v3/agent/tools/v3-extract.ts
 var import_ai10 = require("ai");
-var import_zod15 = require("zod");
+var import_zod14 = require("zod");
 function evaluateZodSchema(schemaStr, logger) {
   var _a;
   try {
     const fn = new Function("z", `return ${schemaStr}`);
-    return fn(import_zod15.z);
+    return fn(import_zod14.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_zod15.z.any();
+    return import_zod14.z.any();
   }
 }
 var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
@@ -11924,9 +11647,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_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() })")
+  inputSchema: import_zod14.z.object({
+    instruction: import_zod14.z.string(),
+    schema: import_zod14.z.string().optional().describe("Zod schema as code, e.g. z.object({ title: z.string() })")
   }),
   execute: (_0) => __async(null, [_0], function* ({ instruction, schema }) {
     var _a;
@@ -12338,6 +12061,7 @@ init_sdkErrors();
 // lib/v3/agent/AnthropicCUAClient.ts
 init_sdkErrors();
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var import_zod15 = require("zod");
 
 // lib/v3/agent/AgentClient.ts
 var AgentClient = class {
@@ -12840,19 +12564,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 schema = tool12.inputSchema;
-            if (!schema) {
-              return {
-                name,
-                description: tool12.description,
-                input_schema: {
-                  type: "object",
-                  properties: {},
-                  required: []
-                }
-              };
-            }
-            const jsonSchema2 = toJsonSchema(schema);
+            const jsonSchema2 = import_zod15.z.toJSONSchema(tool12.inputSchema);
             const inputSchema = {
               type: "object",
               properties: jsonSchema2.properties || {},
@@ -13718,6 +13430,7 @@ init_sdkErrors();
 
 // lib/v3/agent/utils/googleCustomToolHandler.ts
 var import_genai2 = require("@google/genai");
+var import_zod16 = require("zod");
 function executeGoogleCustomTool(toolName, toolArgs, tools, functionCall, logger) {
   return __async(this, null, function* () {
     try {
@@ -13785,11 +13498,7 @@ function convertToolSetToFunctionDeclarations(tools) {
 }
 function convertToolToFunctionDeclaration(name, tool12) {
   try {
-    const schema = tool12.inputSchema;
-    if (!schema) {
-      return null;
-    }
-    const jsonSchema2 = toJsonSchema(schema);
+    const jsonSchema2 = import_zod16.z.toJSONSchema(tool12.inputSchema);
     const parameters = convertJsonSchemaToGoogleParameters(jsonSchema2);
     return {
       name,
@@ -16460,6 +16169,7 @@ var AISdkClient = class extends LLMClient {
 
 // lib/v3/llm/AnthropicClient.ts
 var import_sdk3 = __toESM(require("@anthropic-ai/sdk"));
+var import_zod17 = require("zod");
 init_sdkErrors();
 var AnthropicClient = class extends LLMClient {
   constructor({
@@ -16570,7 +16280,7 @@ var AnthropicClient = class extends LLMClient {
       });
       let toolDefinition;
       if (options.response_model) {
-        const jsonSchema2 = toJsonSchema(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",
@@ -16702,6 +16412,7 @@ var extractSchemaProperties = (jsonSchema2) => {
 
 // lib/v3/llm/CerebrasClient.ts
 var import_openai2 = __toESM(require("openai"));
+var import_zod18 = require("zod");
 init_sdkErrors();
 var CerebrasClient = class extends LLMClient {
   constructor({
@@ -16764,7 +16475,7 @@ var CerebrasClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = toJsonSchema(options.response_model.schema);
+        const jsonSchema2 = import_zod18.z.toJSONSchema(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -17290,6 +17001,7 @@ ${firstPartText.text}`;
 
 // lib/v3/llm/GroqClient.ts
 var import_openai3 = __toESM(require("openai"));
+var import_zod19 = require("zod");
 init_sdkErrors();
 var GroqClient = class extends LLMClient {
   constructor({
@@ -17352,7 +17064,7 @@ var GroqClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = toJsonSchema(options.response_model.schema);
+        const jsonSchema2 = import_zod19.z.toJSONSchema(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -17510,7 +17222,8 @@ var GroqClient = class extends LLMClient {
 
 // lib/v3/llm/OpenAIClient.ts
 var import_openai4 = __toESM(require("openai"));
-var import_zod16 = require("openai/helpers/zod");
+var import_zod20 = require("openai/helpers/zod");
+var import_zod21 = require("zod");
 init_sdkErrors();
 var OpenAIClient = class extends LLMClient {
   constructor({
@@ -17617,12 +17330,12 @@ ${JSON.stringify(
         };
         options.messages.push(screenshotMessage);
       }
-      let responseFormat;
+      let responseFormat = void 0;
       if (options.response_model) {
         if (this.modelName.startsWith("o1") || this.modelName.startsWith("o3")) {
           try {
             const parsedSchema = JSON.stringify(
-              toJsonSchema(options.response_model.schema)
+              import_zod21.z.toJSONSchema(options.response_model.schema)
             );
             options.messages.push({
               role: "user",
@@ -17647,19 +17360,11 @@ ${parsedSchema}
             }
             throw error;
           }
-        } else if (isZod4Schema(options.response_model.schema)) {
-          responseFormat = (0, import_zod16.zodResponseFormat)(
+        } else {
+          responseFormat = (0, import_zod20.zodResponseFormat)(
             options.response_model.schema,
             options.response_model.name
           );
-        } else {
-          responseFormat = {
-            type: "json_schema",
-            json_schema: {
-              name: options.response_model.name,
-              schema: toJsonSchema(options.response_model.schema)
-            }
-          };
         }
       }
       const _d = __spreadProps(__spreadValues({}, optionsWithoutImageAndRequestId), {
@@ -17982,9 +17687,9 @@ var import_provider9 = require("@ai-sdk/provider");
 var import_provider10 = require("@ai-sdk/provider");
 var import_provider11 = require("@ai-sdk/provider");
 var z42 = __toESM(require("zod/v4"), 1);
+var import_v3 = require("zod/v3");
 var import_v32 = require("zod/v3");
 var import_v33 = require("zod/v3");
-var import_v34 = require("zod/v3");
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
@@ -18801,7 +18506,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_v33.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"]
     }));
@@ -19290,18 +18995,18 @@ function parseRecordDef(def, refs) {
       currentPath: [...refs.currentPath, "additionalProperties"]
     }))) != null ? _a : refs.allowedAdditionalProperties
   };
-  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === import_v34.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_v34.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_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)) {
+  } 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
@@ -19627,73 +19332,73 @@ var parseReadonlyDef = (def, refs) => {
 };
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case import_v32.ZodFirstPartyTypeKind.ZodString:
+    case import_v3.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodNumber:
+    case import_v3.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef(def);
-    case import_v32.ZodFirstPartyTypeKind.ZodObject:
+    case import_v3.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodBigInt:
+    case import_v3.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef(def);
-    case import_v32.ZodFirstPartyTypeKind.ZodBoolean:
+    case import_v3.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef();
-    case import_v32.ZodFirstPartyTypeKind.ZodDate:
+    case import_v3.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodUndefined:
+    case import_v3.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef();
-    case import_v32.ZodFirstPartyTypeKind.ZodNull:
+    case import_v3.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef();
-    case import_v32.ZodFirstPartyTypeKind.ZodArray:
+    case import_v3.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v32.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case import_v3.ZodFirstPartyTypeKind.ZodUnion:
+    case import_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodIntersection:
+    case import_v3.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodTuple:
+    case import_v3.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodRecord:
+    case import_v3.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodLiteral:
+    case import_v3.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef(def);
-    case import_v32.ZodFirstPartyTypeKind.ZodEnum:
+    case import_v3.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef(def);
-    case import_v32.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case import_v3.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case import_v32.ZodFirstPartyTypeKind.ZodNullable:
+    case import_v3.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodOptional:
+    case import_v3.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodMap:
+    case import_v3.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodSet:
+    case import_v3.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodLazy:
+    case import_v3.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case import_v32.ZodFirstPartyTypeKind.ZodPromise:
+    case import_v3.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v32.ZodFirstPartyTypeKind.ZodNever:
+    case import_v3.ZodFirstPartyTypeKind.ZodNaN:
+    case import_v3.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef();
-    case import_v32.ZodFirstPartyTypeKind.ZodEffects:
+    case import_v3.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodAny:
+    case import_v3.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef();
-    case import_v32.ZodFirstPartyTypeKind.ZodUnknown:
+    case import_v3.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef();
-    case import_v32.ZodFirstPartyTypeKind.ZodDefault:
+    case import_v3.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodBranded:
+    case import_v3.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodReadonly:
+    case import_v3.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodCatch:
+    case import_v3.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodPipeline:
+    case import_v3.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case import_v32.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v32.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v32.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);
@@ -19860,11 +19565,11 @@ function zod4Schema(zodSchema2, options) {
     }
   );
 }
-function isZod4Schema2(zodSchema2) {
+function isZod4Schema(zodSchema2) {
   return "_zod" in zodSchema2;
 }
 function zodSchema(zodSchema2, options) {
-  if (isZod4Schema2(zodSchema2)) {
+  if (isZod4Schema(zodSchema2)) {
     return zod4Schema(zodSchema2, options);
   } else {
     return zod3Schema(zodSchema2, options);
@@ -39432,7 +39137,7 @@ var CdpConnection = class _CdpConnection {
       yield this.send("Target.setAutoAttach", {
         autoAttach: true,
         flatten: true,
-        waitForDebuggerOnStart: false,
+        waitForDebuggerOnStart: true,
         filter: [
           { type: "worker", exclude: true },
           { type: "shared_worker", exclude: true },
@@ -39615,15 +39320,12 @@ init_logger();
 // lib/v3/dom/build/scriptV3Content.ts
 var v3ScriptContent = '(()=>{function b(_={}){let S=n=>{let{hostToRoot:l}=n,m=t=>{let o=[];if(t instanceof Document)return t.documentElement&&o.push(t.documentElement),o;if(t instanceof ShadowRoot||t instanceof DocumentFragment)return o.push(...Array.from(t.children)),o;if(t instanceof Element){o.push(...Array.from(t.children));let a=t.shadowRoot;a&&o.push(...Array.from(a.children));let r=l.get(t);return r&&o.push(...Array.from(r.children)),o}return o},v=t=>{let o=[],a=[...m(t)];for(;a.length;){let r=a.shift();o.push(r),a.push(...m(r))}return o},y=t=>{let o=String(t||"").trim();if(!o)return null;let a=o.replace(/^xpath=/i,""),r=[];{let e=0;for(;e<a.length;){let d="child";a.startsWith("//",e)?(d="desc",e+=2):a[e]==="/"&&(d="child",e+=1);let h=e;for(;e<a.length&&a[e]!=="/";)e++;let u=a.slice(h,e).trim();if(!u)continue;let p=u.match(/^(.*?)(\\[(\\d+)\\])?$/u),i=(p?.[1]??u).trim(),c=p?.[3]?Math.max(1,Number(p[3])):null,R=i===""?"*":i.toLowerCase();r.push({axis:d,raw:u,tag:R,index:c})}}n.debug&&console.info("[v3-piercer][resolve] start",{url:location.href,steps:r.map(e=>({axis:e.axis,raw:e.raw,tag:e.tag,index:e.index}))});let g=[document];for(let e of r){let d=e.index,h=null;for(let u of g){let p=e.axis==="child"?m(u):v(u),i=[];for(let c of p)(e.tag==="*"||c.localName===e.tag)&&i.push(c);if(n.debug&&console.info("[v3-piercer][resolve] step",{axis:e.axis,tag:e.tag,index:d,poolCount:p.length,matchesCount:i.length}),!!i.length){if(d!=null){let c=d-1;h=c>=0&&c<i.length?i[c]:null}else h=i[0];if(h)break}}if(!h)return n.debug&&console.info("[v3-piercer][resolve] no-match",{step:e.raw}),null;g=[h]}let E=g.length?g[0]:null;return n.debug&&console.info("[v3-piercer][resolve] done",{found:!!E,tag:E?.localName??""}),E};window.__stagehandV3__={getClosedRoot:t=>l.get(t),stats:()=>({installed:!0,url:location.href,isTop:window.top===window,open:n.openCount,closed:n.closedCount}),resolveSimpleXPath:y}},f=Element.prototype.attachShadow;if(f.__v3Patched&&f.__v3State){f.__v3State.debug=!0,S(f.__v3State);return}let s={hostToRoot:new WeakMap,openCount:0,closedCount:0,debug:!0},x=f,w=function(n){let l=n?.mode??"open",m=x.call(this,n);try{s.hostToRoot.set(this,m),l==="closed"?s.closedCount++:s.openCount++,s.debug&&console.info("[v3-piercer] attachShadow",{tag:this.tagName?.toLowerCase()??"",mode:l,url:location.href})}catch{}return m};if(w.__v3Patched=!0,w.__v3State=s,Object.defineProperty(Element.prototype,"attachShadow",{configurable:!0,writable:!0,value:w}),_.tagExisting)try{let n=document.createTreeWalker(document,NodeFilter.SHOW_ELEMENT);for(;n.nextNode();){let l=n.currentNode;l.shadowRoot&&(s.hostToRoot.set(l,l.shadowRoot),s.openCount++)}}catch{}window.__stagehandV3Injected=!0,S(s),s.debug&&console.info("[v3-piercer] installed",{url:location.href,isTop:window.top===window,readyState:document.readyState})}b({debug:!0,tagExisting:!1});})();\n';
 
-// lib/v3/dom/build/reRenderScriptContent.ts
-var reRenderScriptContent = '(()=>{function s(){try{let o=window.__stagehandV3__;if(!o||typeof o.getClosedRoot!="function")return;let t=[],r=document.createTreeWalker(document,NodeFilter.SHOW_ELEMENT);for(;r.nextNode();){let e=r.currentNode,n=e.tagName?.toLowerCase()??"";if(!n.includes("-")||typeof customElements?.get!="function"||!customElements.get(n))continue;let c=!!e.shadowRoot,i=!!o.getClosedRoot(e);c||i||t.push(e)}for(let e of t)try{let n=e.cloneNode(!0);e.replaceWith(n)}catch{}o.stats&&t.length&&console.info("[v3-piercer] rerender",{count:t.length})}catch(o){console.info("[v3-piercer] rerender error",{message:String(o??"")})}}s();})();\n';
-
 // lib/v3/understudy/piercer.ts
 function installV3PiercerIntoSession(session) {
   return __async(this, null, function* () {
     var _a, _b;
-    const pageEnabled = yield session.send("Page.enable").then(() => true).catch(() => false);
-    if (!pageEnabled) return false;
+    yield session.send("Page.enable").catch(() => {
+    });
     yield session.send("Runtime.enable").catch(() => {
     });
     try {
@@ -39633,7 +39335,7 @@ function installV3PiercerIntoSession(session) {
       );
     } catch (e) {
       const msg = String((_b = (_a = e == null ? void 0 : e.message) != null ? _a : e) != null ? _b : "");
-      if (msg.includes("Session with given id not found")) return false;
+      if (msg.includes("Session with given id not found")) return;
     }
     yield session.send("Runtime.evaluate", {
       expression: v3ScriptContent,
@@ -39641,13 +39343,6 @@ function installV3PiercerIntoSession(session) {
       awaitPromise: true
     }).catch(() => {
     });
-    yield session.send("Runtime.evaluate", {
-      expression: reRenderScriptContent,
-      returnByValue: true,
-      awaitPromise: false
-    }).catch(() => {
-    });
-    return true;
   });
 }
 
@@ -39754,12 +39449,9 @@ var V3Context = class _V3Context {
   ensurePiercer(session) {
     return __async(this, null, function* () {
       const key = this.sessionKey(session);
-      if (this._piercerInstalled.has(key)) return true;
-      const installed = yield installV3PiercerIntoSession(session);
-      if (installed) {
-        this._piercerInstalled.add(key);
-      }
-      return installed;
+      if (this._piercerInstalled.has(key)) return;
+      yield installV3PiercerIntoSession(session);
+      this._piercerInstalled.add(key);
     });
   }
   /** Mark a page target as the most-recent one (active). */
@@ -39897,7 +39589,11 @@ var V3Context = class _V3Context {
       this.conn.on(
         "Target.attachedToTarget",
         (evt) => __async(this, null, function* () {
-          yield this.onAttachedToTarget(evt.targetInfo, evt.sessionId);
+          yield this.onAttachedToTarget(
+            evt.targetInfo,
+            evt.sessionId,
+            evt.waitingForDebugger === true
+          );
         })
       );
       this.conn.on(
@@ -39950,20 +39646,29 @@ var V3Context = class _V3Context {
    *   if the parent is known; otherwise stage until parent `frameAttached`.
    * - Resume the target only after listeners are wired.
    */
-  onAttachedToTarget(info, sessionId) {
+  onAttachedToTarget(info, sessionId, waitingForDebugger) {
     return __async(this, null, function* () {
       var _a;
       const session = this.conn.getSession(sessionId);
       if (!session) return;
       if (this._sessionInit.has(sessionId)) return;
       this._sessionInit.add(sessionId);
+      const pageEnabled = yield session.send("Page.enable").then(() => true).catch(() => false);
+      if (!pageEnabled) {
+        if (waitingForDebugger) {
+          yield session.send("Runtime.runIfWaitingForDebugger").catch(() => {
+          });
+        }
+        return;
+      }
+      yield session.send("Page.setLifecycleEventsEnabled", { enabled: true }).catch(() => {
+      });
       yield session.send("Runtime.runIfWaitingForDebugger").catch(() => {
       });
       executionContexts.attachSession(session);
-      const piercerReady = yield this.ensurePiercer(session);
-      if (!piercerReady) return;
-      yield session.send("Page.setLifecycleEventsEnabled", { enabled: true }).catch(() => {
+      yield session.send("Runtime.enable").catch(() => {
       });
+      yield this.ensurePiercer(session);
       if (isTopLevelPage(info)) {
         const page = yield Page.create(
           this.conn,
@@ -39987,6 +39692,10 @@ var V3Context = class _V3Context {
         page.seedCurrentUrl((_a = pendingSeedUrl != null ? pendingSeedUrl : info.url) != null ? _a : "");
         this._pushActive(info.targetId);
         this.installFrameEventBridges(sessionId, page);
+        if (waitingForDebugger) {
+          yield session.send("Runtime.runIfWaitingForDebugger").catch(() => {
+          });
+        }
         return;
       }
       try {
@@ -40014,13 +39723,51 @@ var V3Context = class _V3Context {
           owner.adoptOopifSession(session, childMainId);
           this.sessionOwnerPage.set(sessionId, owner);
           this.installFrameEventBridges(sessionId, owner);
-          void executionContexts.waitForMainWorld(session, childMainId).catch(() => {
-          });
         } else {
           this.pendingOopifByMainFrame.set(childMainId, sessionId);
         }
       } catch (e) {
       }
+      if (info.type === "iframe" && !waitingForDebugger) {
+        try {
+          yield session.send("Page.setLifecycleEventsEnabled", { enabled: true }).catch(() => {
+          });
+          const loadWait = new Promise((resolve2) => {
+            const handler = (evt) => {
+              if (evt.name === "load") {
+                session.off("Page.lifecycleEvent", handler);
+                resolve2();
+              }
+            };
+            session.on("Page.lifecycleEvent", handler);
+          });
+          yield session.send("Runtime.evaluate", {
+            expression: "location.reload()",
+            returnByValue: true,
+            awaitPromise: false
+          }).catch(() => {
+          });
+          yield Promise.race([
+            loadWait,
+            new Promise((r) => setTimeout(r, 3e3))
+          ]);
+          yield this.ensurePiercer(session);
+        } catch (e) {
+          v3Logger({
+            category: "ctx",
+            message: "child reload attempt failed (continuing)",
+            level: 2,
+            auxiliary: {
+              sessionId: { value: String(sessionId), type: "string" },
+              err: { value: String(e), type: "string" }
+            }
+          });
+        }
+      }
+      if (waitingForDebugger) {
+        yield session.send("Runtime.runIfWaitingForDebugger").catch(() => {
+        });
+      }
     });
   }
   /**
@@ -40205,6 +39952,7 @@ function resolveModel(model) {
 
 // lib/v3/api.ts
 var import_fetch_cookie = __toESM(require("fetch-cookie"));
+var import_zod22 = require("zod");
 init_version();
 var StagehandAPIClient = class {
   constructor({ apiKey, projectId, logger }) {
@@ -40299,7 +40047,7 @@ var StagehandAPIClient = class {
       options,
       frameId
     }) {
-      const jsonSchema2 = zodSchema2 ? toJsonSchema(zodSchema2) : void 0;
+      const jsonSchema2 = zodSchema2 ? import_zod22.z.toJSONSchema(zodSchema2) : void 0;
       const args = {
         schema: jsonSchema2,
         instruction,
@@ -41839,14 +41587,14 @@ function isObserveResult(v) {
 
 // lib/v3Evaluator.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var import_zod17 = require("zod");
+var import_zod23 = require("zod");
 init_sdkErrors();
 import_dotenv2.default.config();
-var EvaluationSchema = import_zod17.z.object({
-  evaluation: import_zod17.z.enum(["YES", "NO"]),
-  reasoning: import_zod17.z.string()
+var EvaluationSchema = import_zod23.z.object({
+  evaluation: import_zod23.z.enum(["YES", "NO"]),
+  reasoning: import_zod23.z.string()
 });
-var BatchEvaluationSchema = import_zod17.z.array(EvaluationSchema);
+var BatchEvaluationSchema = import_zod23.z.array(EvaluationSchema);
 var V3Evaluator = class {
   constructor(v3, modelName, modelClientOptions) {
     this.silentLogger = () => {
@@ -42137,15 +41885,12 @@ 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