@auto-ai/agent 2.1.103 → 2.1.105

package/tools-runtime/code-tool/node_modules/zod/src/v4/classic/tests/default.test.ts

@@ -1,409 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-
-test("basic defaults", () => {
-  expect(z.string().default("default").parse(undefined)).toBe("default");
-});
-
-test("default with optional", () => {
-  const schema = z.string().optional().default("default");
-  expect(schema.parse(undefined)).toBe("default");
-  expect(schema.unwrap().parse(undefined)).toBe(undefined);
-});
-
-test("default with transform", () => {
-  const stringWithDefault = z
-    .string()
-    .transform((val) => val.toUpperCase())
-    .default("default");
-  expect(stringWithDefault.parse(undefined)).toBe("default");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodPipe);
-  expect(stringWithDefault.unwrap().in).toBeInstanceOf(z.ZodString);
-  expect(stringWithDefault.unwrap().out).toBeInstanceOf(z.ZodTransform);
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("default on existing optional", () => {
-  const stringWithDefault = z.string().optional().default("asdf");
-  expect(stringWithDefault.parse(undefined)).toBe("asdf");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodOptional);
-  expect(stringWithDefault.unwrap().unwrap()).toBeInstanceOf(z.ZodString);
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("optional on default", () => {
-  const stringWithDefault = z.string().default("asdf").optional();
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string | undefined>();
-
-  expect(stringWithDefault.parse(undefined)).toBe("asdf");
-});
-
-// test("complex chain example", () => {
-//   const complex = z
-//     .string()
-//     .default("asdf")
-//     .transform((val) => val.toUpperCase())
-//     .default("qwer")
-//     .unwrap()
-//     .optional()
-//     .default("asdfasdf");
-
-//   expect(complex.parse(undefined)).toBe("asdfasdf");
-// });
-
-test("removeDefault", () => {
-  const stringWithRemovedDefault = z.string().default("asdf").removeDefault();
-
-  type out = z.output<typeof stringWithRemovedDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("apply default at output", () => {
-  const schema = z
-    .string()
-    .transform((_) => (Math.random() > 0 ? undefined : _))
-    .default("asdf");
-  expect(schema.parse("")).toEqual("asdf");
-});
-
-test("nested", () => {
-  const inner = z.string().default("asdf");
-  const outer = z.object({ inner }).default({
-    inner: "qwer",
-  });
-  type input = z.input<typeof outer>;
-  expectTypeOf<input>().toEqualTypeOf<{ inner?: string | undefined } | undefined>();
-  type out = z.output<typeof outer>;
-  expectTypeOf<out>().toEqualTypeOf<{ inner: string }>();
-  expect(outer.parse(undefined)).toEqual({ inner: "qwer" });
-  expect(outer.parse({})).toEqual({ inner: "asdf" });
-  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
-});
-
-test("chained defaults", () => {
-  const stringWithDefault = z.string().default("inner").default("outer");
-  const result = stringWithDefault.parse(undefined);
-  expect(result).toEqual("outer");
-});
-
-test("object optionality", () => {
-  const schema = z.object({
-    hi: z.string().default("hi"),
-  });
-  type schemaInput = z.input<typeof schema>;
-  type schemaOutput = z.output<typeof schema>;
-  expectTypeOf<schemaInput>().toEqualTypeOf<{ hi?: string | undefined }>();
-  expectTypeOf<schemaOutput>().toEqualTypeOf<{ hi: string }>();
-  expect(schema.parse({})).toEqual({
-    hi: "hi",
-  });
-});
-
-test("nested prefault/default", () => {
-  const a = z
-    .string()
-    .default("a")
-    .refine((val) => val.startsWith("a"));
-  const b = z
-    .string()
-    .refine((val) => val.startsWith("b"))
-    .default("b");
-  const c = z
-    .string()
-    .prefault("c")
-    .refine((val) => val.startsWith("c"));
-  const d = z
-    .string()
-    .refine((val) => val.startsWith("d"))
-    .prefault("d");
-
-  const obj = z.object({
-    a,
-    b,
-    c,
-    d,
-  });
-
-  expect(obj.safeParse({ a: "a1", b: "b1", c: "c1", d: "d1" })).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a1",
-        "b": "b1",
-        "c": "c1",
-        "d": "d1",
-      },
-      "success": true,
-    }
-  `);
-
-  expect(obj.safeParse({ a: "f", b: "f", c: "f", d: "f" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "a"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "b"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "c"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "d"
-        ],
-        "message": "Invalid input"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  expect(obj.safeParse({})).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a",
-        "b": "b",
-        "c": "c",
-        "d": "d",
-      },
-      "success": true,
-    }
-  `);
-
-  expect(obj.safeParse({ a: undefined, b: undefined, c: undefined, d: undefined })).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a",
-        "b": "b",
-        "c": "c",
-        "d": "d",
-      },
-      "success": true,
-    }
-  `);
-
-  const obj2 = z.object({
-    a: a.optional(),
-    b: b.optional(),
-    c: c.optional(),
-    d: d.optional(),
-  });
-  expect(obj2.safeParse({ a: undefined, b: undefined, c: undefined, d: undefined })).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a",
-        "b": "b",
-        "c": "c",
-        "d": "d",
-      },
-      "success": true,
-    }
-  `);
-
-  expect(a.parse(undefined)).toBe("a");
-  expect(b.parse(undefined)).toBe("b");
-  expect(c.parse(undefined)).toBe("c");
-  expect(d.parse(undefined)).toBe("d");
-});
-
-test("failing default", () => {
-  const a = z
-    .string()
-    .default("z")
-    .refine((val) => val.startsWith("a"));
-  const b = z
-    .string()
-    .refine((val) => val.startsWith("b"))
-    .default("z");
-  const c = z
-    .string()
-    .prefault("z")
-    .refine((val) => val.startsWith("c"));
-  const d = z
-    .string()
-    .refine((val) => val.startsWith("d"))
-    .prefault("z");
-
-  const obj = z.object({
-    a,
-    b,
-    c,
-    d,
-  });
-
-  expect(
-    obj.safeParse({
-      a: undefined,
-      b: undefined,
-      c: undefined,
-      d: undefined,
-    }).error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [
-          "a",
-        ],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [
-          "c",
-        ],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [
-          "d",
-        ],
-      },
-    ]
-  `);
-});
-
-test("partial should not clobber defaults", () => {
-  const objWithDefaults = z.object({
-    a: z.string().default("defaultA"),
-    b: z.string().default("defaultB"),
-    c: z.string().default("defaultC"),
-  });
-
-  const objPartialWithOneRequired = objWithDefaults.partial(); //.required({ a: true });
-
-  const test = objPartialWithOneRequired.parse({});
-  expect(test).toMatchInlineSnapshot(`
-    {
-      "a": "defaultA",
-      "b": "defaultB",
-      "c": "defaultC",
-    }
-  `);
-});
-
-test("defaulted object schema returns shallow clone", () => {
-  const schema = z
-    .object({
-      a: z.string(),
-    })
-    .default({ a: "x" });
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("defaulted array schema returns shallow clone", () => {
-  const schema = z.array(z.string()).default(["x"]);
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("defaulted Map schema returns shallow clone", () => {
-  const schema = z.map(z.string(), z.number()).default(new Map([["a", 1]]));
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("defaulted Set schema returns shallow clone", () => {
-  const schema = z.set(z.string()).default(new Set(["x"]));
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("mutations on defaulted Map do not affect subsequent parses", () => {
-  const schema = z.map(z.string(), z.number()).default(new Map());
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  result1.set("key1", 1);
-  result2.set("key2", 2);
-  expect(result1.size).toBe(1);
-  expect(result1.get("key1")).toBe(1);
-  expect(result1.has("key2")).toBe(false);
-  expect(result2.size).toBe(1);
-  expect(result2.get("key2")).toBe(2);
-  expect(result2.has("key1")).toBe(false);
-});
-
-test("mutations on defaulted Set do not affect subsequent parses", () => {
-  const schema = z.set(z.string()).default(new Set());
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  result1.add("item1");
-  result2.add("item2");
-  expect(result1.size).toBe(1);
-  expect(result1.has("item1")).toBe(true);
-  expect(result1.has("item2")).toBe(false);
-  expect(result2.size).toBe(1);
-  expect(result2.has("item2")).toBe(true);
-  expect(result2.has("item1")).toBe(false);
-});
-
-test("direction-aware defaults", () => {
-  const schema = z.string().default("hello");
-
-  // Forward direction (regular parse): defaults should be applied
-  expect(schema.parse(undefined)).toBe("hello");
-  expect(schema.parse("hello")).toBe("hello");
-
-  // Reverse direction (encode): defaults should NOT be applied, undefined should fail validation
-  expect(() => z.encode(schema, undefined as any)).toThrow();
-
-  // But valid values should still work in reverse
-  expect(z.safeEncode(schema, "world")).toMatchInlineSnapshot(`
-    {
-      "data": "world",
-      "success": true,
-    }
-  `);
-  expect(z.safeEncode(schema, undefined as any)).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

package/tools-runtime/code-tool/node_modules/zod/src/v4/classic/tests/describe-meta-checks.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as z from "../index.js";
-
-describe("z.describe() check", () => {
-  it("registers description in globalRegistry", () => {
-    const schema = z.string().check(z.describe("A string"));
-    expect(z.globalRegistry.get(schema)?.description).toBe("A string");
-  });
-});
-
-describe("z.meta() check", () => {
-  it("registers metadata in globalRegistry", () => {
-    const schema = z.number().check(z.meta({ title: "Age", description: "User's age" }));
-    const meta = z.globalRegistry.get(schema);
-    expect(meta?.title).toBe("Age");
-    expect(meta?.description).toBe("User's age");
-  });
-});
-
-describe("combined usage", () => {
-  it("works with multiple checks", () => {
-    const schema = z.string().check(z.describe("Email address"), z.meta({ title: "Email" }));
-    const meta = z.globalRegistry.get(schema);
-    expect(meta?.description).toBe("Email address");
-    expect(meta?.title).toBe("Email");
-  });
-});

package/tools-runtime/code-tool/node_modules/zod/src/v4/classic/tests/description.test.ts

@@ -1,32 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-const description = "a description";
-
-// test("passing `description` to schema should add a description", () => {
-//   expect(z.string({ description }).description).toEqual(description);
-//   expect(z.number({ description }).description).toEqual(description);
-//   expect(z.boolean({ description }).description).toEqual(description);
-// });
-
-test(".describe", () => {
-  expect(z.string().describe(description).description).toEqual(description);
-  expect(z.number().describe(description).description).toEqual(description);
-  expect(z.boolean().describe(description).description).toEqual(description);
-});
-
-test("adding description with z.globalRegistry", () => {
-  const schema = z.string();
-  z.core.globalRegistry.add(schema, { description });
-  z.core.globalRegistry.get(schema);
-  expect(schema.description).toEqual(description);
-});
-
-// in Zod 4 descriptions are not inherited
-// test("description should carry over to chained schemas", () => {
-//   const schema = z.string().describe(description);
-//   expect(schema.description).toEqual(description);
-//   expect(schema.optional().description).toEqual(description);
-//   expect(schema.optional().nullable().default("default").description).toEqual(description);
-// });

package/tools-runtime/code-tool/node_modules/zod/src/v4/classic/tests/detached-methods.test.ts

@@ -1,197 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-/**
- * Schema methods are exposed in a way that works when detached from the
- * schema instance — `const opt = schema.optional; opt()` must produce a
- * working `ZodOptional`, not a corrupt one. This pattern is used in real
- * code (e.g. `arr.map(schema.parse)`, `arr.map(schema.optional)`,
- * destructuring inside utility functions).
- *
- * This test caught a regression in colinhacks/zod#5870 where a memory
- * optimization moved methods to the prototype and made `this`-binding
- * required, silently breaking any detached usage.
- */
-
-const probeArgs: Record<string, unknown[]> = {
-  // ZodType
-  optional: [],
-  exactOptional: [],
-  nullable: [],
-  nullish: [],
-  array: [],
-  describe: ["x"],
-  brand: [],
-  readonly: [],
-  default: ["fallback"],
-  catch: ["fallback"],
-  // _ZodString
-  min: [1],
-  max: [10],
-  length: [5],
-  nonempty: [],
-  trim: [],
-  toLowerCase: [],
-  toUpperCase: [],
-  // ZodString format methods
-  email: [],
-  url: [],
-  uuid: [],
-  cuid: [],
-  cuid2: [],
-  ulid: [],
-  base64: [],
-  base64url: [],
-  ipv4: [],
-  ipv6: [],
-  // ZodNumber
-  int: [],
-  positive: [],
-  negative: [],
-  finite: [],
-};
-
-test("detached parse-family methods work without `this` binding", () => {
-  const schema = z.string();
-  const { parse, safeParse } = schema;
-
-  expect(parse("hello")).toBe("hello");
-  expect(safeParse("hello").success).toBe(true);
-});
-
-test("detached schema.optional() returns a working ZodOptional", () => {
-  const schema = z.string();
-  const opt = schema.optional;
-
-  const detached = opt();
-
-  expect(detached).toBeInstanceOf(z.ZodOptional);
-  expect(detached.safeParse("hello").success).toBe(true);
-  expect(detached.safeParse(undefined).success).toBe(true);
-  expect(detached.safeParse(123).success).toBe(false);
-});
-
-test("detached schema.nullable() returns a working ZodNullable", () => {
-  const schema = z.string();
-  const nul = schema.nullable;
-
-  const detached = nul();
-
-  expect(detached).toBeInstanceOf(z.ZodNullable);
-  expect(detached.safeParse("hello").success).toBe(true);
-  expect(detached.safeParse(null).success).toBe(true);
-  expect(detached.safeParse(123).success).toBe(false);
-});
-
-test("detached schema.array() returns a working ZodArray", () => {
-  const schema = z.string();
-  const arr = schema.array;
-
-  const detached = arr();
-
-  expect(detached).toBeInstanceOf(z.ZodArray);
-  expect(detached.safeParse(["a", "b"]).success).toBe(true);
-  expect(detached.safeParse([1, 2]).success).toBe(false);
-});
-
-test("detached schema.describe() returns a described schema", () => {
-  const schema = z.string();
-  const describe = schema.describe;
-
-  const described = describe("hello world");
-
-  expect(described.description).toBe("hello world");
-});
-
-test("detached refinement still validates", () => {
-  const schema = z.string();
-  const refine = schema.refine;
-
-  const refined = refine((s: string) => s.startsWith("x"), "must start with x");
-
-  expect(refined.safeParse("xhello").success).toBe(true);
-  expect(refined.safeParse("hello").success).toBe(false);
-});
-
-test("detached chained calls work — schema.optional then parse", () => {
-  const schema = z.string();
-  const opt = schema.optional;
-  const optionalSchema = opt();
-  const { parse } = optionalSchema;
-
-  expect(parse("hi")).toBe("hi");
-  expect(parse(undefined)).toBe(undefined);
-});
-
-test("detached parse can be called as a free function", () => {
-  const schema = z.string();
-  const parse = schema.parse;
-  const inputs = ["a", "b", "c"];
-
-  const results = inputs.map((v) => parse(v));
-
-  expect(results).toEqual(["a", "b", "c"]);
-});
-
-test("detached methods on z.number() work", () => {
-  const schema = z.number();
-
-  const min = schema.min;
-  const max = schema.max;
-  const positive = schema.positive;
-
-  expect(min(5).safeParse(3).success).toBe(false);
-  expect(max(5).safeParse(7).success).toBe(false);
-  expect(positive().safeParse(-1).success).toBe(false);
-});
-
-test("detached object methods work", () => {
-  const schema = z.object({ a: z.string(), b: z.number() });
-
-  const pick = schema.pick;
-  const omit = schema.omit;
-  const partial = schema.partial;
-  const extend = schema.extend;
-
-  expect(Object.keys(pick({ a: true })._zod.def.shape)).toEqual(["a"]);
-  expect(Object.keys(omit({ a: true })._zod.def.shape)).toEqual(["b"]);
-  expect(partial().safeParse({}).success).toBe(true);
-  const extended = extend({ c: z.boolean() });
-  expect(Object.keys(extended._zod.def.shape).sort()).toEqual(["a", "b", "c"]);
-});
-
-// Sweep across many builder methods at once. If any of them break with the
-// `const m = schema.foo; m(...)` pattern, this test will report which.
-test("broad sweep: detaching builder methods does not throw or produce a corrupt schema", () => {
-  const stringSchema = z.string();
-  const numberSchema = z.number();
-
-  const broken: Array<{ method: string; reason: string }> = [];
-
-  for (const [methodName, args] of Object.entries(probeArgs)) {
-    const target: any = methodName in stringSchema ? stringSchema : methodName in numberSchema ? numberSchema : null;
-    if (!target) continue;
-
-    const detached = target[methodName] as Function | undefined;
-    if (typeof detached !== "function") continue;
-
-    try {
-      const result = detached(...args);
-      // If the detached call returned a schema, sanity-check it parses
-      // its base type. (e.g. `optional()` should accept its inner type.)
-      if (result && typeof result === "object" && "_zod" in result && typeof (result as any).safeParse === "function") {
-        const probeValue = target === stringSchema ? "x" : 1;
-        const r = (result as any).safeParse(probeValue);
-        // success or a clean failure are both fine — we only fail on throw or
-        // on a schema with corrupt internal state (innerType undefined etc).
-        if (r === undefined || (typeof r === "object" && !("success" in r))) {
-          broken.push({ method: methodName, reason: "safeParse returned malformed result" });
-        }
-      }
-    } catch (err: any) {
-      broken.push({ method: methodName, reason: err?.message ?? String(err) });
-    }
-  }
-
-  expect(broken).toEqual([]);
-});