@auto-ai/agent 2.1.103 → 2.1.105

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

@@ -1,117 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-const literalTuna = z.literal("tuna");
-const literalTunaCustomMessage = z.literal("tuna", {
-  message: "That's not a tuna",
-});
-const literalFortyTwo = z.literal(42);
-const literalTrue = z.literal(true);
-
-test("passing validations", () => {
-  literalTuna.parse("tuna");
-  literalFortyTwo.parse(42);
-  literalTrue.parse(true);
-});
-
-test("failing validations", () => {
-  expect(() => literalTuna.parse("shark")).toThrow();
-  expect(() => literalFortyTwo.parse(43)).toThrow();
-  expect(() => literalTrue.parse(false)).toThrow();
-});
-
-test("invalid_literal should have `input` field with data", () => {
-  const data = "shark";
-  const result = literalTuna.safeParse(data);
-
-  const issue = result.error!.issues[0];
-  expect(issue.code).toBe("invalid_value");
-  expect(issue).toMatchInlineSnapshot(`
-    {
-      "code": "invalid_value",
-      "message": "Invalid input: expected "tuna"",
-      "path": [],
-      "values": [
-        "tuna",
-      ],
-    }
-  `);
-});
-
-test("invalid_literal should return default message", () => {
-  const data = "shark";
-  const result = literalTuna.safeParse(data);
-
-  const issue = result.error!.issues[0];
-  expect(issue.message).toEqual(`Invalid input: expected \"tuna\"`);
-});
-
-test("invalid_literal should return custom message", () => {
-  const data = "shark";
-  const result = literalTunaCustomMessage.safeParse(data);
-
-  const issue = result.error!.issues[0];
-  expect(issue.message).toEqual(`That's not a tuna`);
-});
-
-test("literal default error message", () => {
-  const result = z.literal("Tuna").safeParse("Trout");
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "invalid_value",
-        "values": [
-          "Tuna"
-        ],
-        "path": [],
-        "message": "Invalid input: expected \\"Tuna\\""
-      }
-    ]]
-  `);
-});
-
-test("literal bigint default error message", () => {
-  const result = z.literal(BigInt(12)).safeParse(BigInt(13));
-  expect(result.success).toBe(false);
-
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].message).toEqual(`Invalid input: expected 12n`);
-});
-
-test(".value getter", () => {
-  expect(z.literal("tuna").value).toEqual("tuna");
-  expect(() => z.literal([1, 2, 3]).value).toThrow();
-});
-
-test("readonly", () => {
-  const a = ["asdf"] as const;
-  z.literal(a);
-});
-
-test("literal pattern", () => {
-  expect(z.literal(1.1)._zod.pattern).toMatchInlineSnapshot(`/\\^\\(1\\\\\\.1\\)\\$/`);
-
-  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1.1")).toMatchInlineSnapshot(`
-    {
-      "data": "1.1",
-      "success": true,
-    }
-  `);
-  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1n1")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_format",
-        "format": "template_literal",
-        "pattern": "^(1\\\\.1)$",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

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

@@ -1,29 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("Georgian locale uses 'ველი' instead of 'სტრინგი'", () => {
-  // Save original error map to restore later if needed, though tests are usually isolated or we can reset
-  // const originalErrorMap = z.getErrorMap(); // z.getErrorMap might not exist, but let's assume isolation or just set it
-
-  z.setErrorMap(z.locales.ka().localeError);
-
-  // Test 1: Invalid type (Expected string, received number)
-  const stringSchema = z.string();
-  const numberResult = stringSchema.safeParse(123);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    // Expected: "არასწორი შეყვანა: მოსალოდნელი ველი, მიღებული რიცხვი"
-    expect(numberResult.error.issues[0].message).toBe("არასწორი შეყვანა: მოსალოდნელი ველი, მიღებული რიცხვი");
-  }
-
-  // Test 2: Invalid base64
-  const base64Schema = z.string().base64();
-  const base64Result = base64Schema.safeParse("not base64!");
-  expect(base64Result.success).toBe(false);
-  if (!base64Result.success) {
-    // Expected: "არასწორი base64-კოდირებული ველი"
-    // "არასწორი ${FormatDictionary[_issue.format] ?? issue.format}"
-    // FormatDictionary['base64'] is "base64-კოდირებული ველი"
-    expect(base64Result.error.issues[0].message).toBe("არასწორი base64-კოდირებული ველი");
-  }
-});

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

@@ -1,24 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("Romanian locale uses 'șir' instead of 'string'", () => {
-  z.setErrorMap(z.locales.ro().localeError);
-
-  // Test 1: Invalid type (Expected string, received number)
-  const stringSchema = z.string();
-  const numberResult = stringSchema.safeParse(123);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    // Expected: "Intrare invalidă: așteptat șir, primit număr"
-    expect(numberResult.error.issues[0].message).toBe("Intrare invalidă: așteptat șir, primit număr");
-  }
-
-  // Test 2: Invalid base64
-  const base64Schema = z.string().base64();
-  const base64Result = base64Schema.safeParse("not base64!");
-  expect(base64Result.success).toBe(false);
-  if (!base64Result.success) {
-    // Expected: "Format invalid: șir codat base64"
-    expect(base64Result.error.issues[0].message).toBe("Format invalid: șir codat base64");
-  }
-});

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

@@ -1,330 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const stringMap = z.map(z.string(), z.string());
-type stringMap = z.infer<typeof stringMap>;
-
-const minTwo = stringMap.min(2);
-const maxTwo = stringMap.max(2);
-const justTwo = stringMap.size(2);
-const nonEmpty = stringMap.nonempty();
-const nonEmptyMax = stringMap.nonempty().max(2);
-
-test("type inference", () => {
-  expectTypeOf<stringMap>().toEqualTypeOf<Map<string, string>>();
-});
-
-test("valid parse", () => {
-  const result = stringMap.safeParse(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(true);
-  expect(result.data).toMatchInlineSnapshot(`
-    Map {
-      "first" => "foo",
-      "second" => "bar",
-    }
-  `);
-});
-
-test("valid parse: size-related methods", () => {
-  expect(() => {
-    minTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    minTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-        ["e", "f"],
-      ])
-    );
-    maxTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    maxTwo.parse(new Map([["a", "b"]]));
-    justTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    nonEmpty.parse(new Map([["a", "b"]]));
-    nonEmptyMax.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-  }).not.toThrow();
-
-  const sizeZeroResult = stringMap.parse(new Map());
-  expect(sizeZeroResult.size).toBe(0);
-
-  const sizeTwoResult = minTwo.parse(
-    new Map([
-      ["a", "b"],
-      ["c", "d"],
-    ])
-  );
-  expect(sizeTwoResult.size).toBe(2);
-});
-
-test("failing when parsing empty map in nonempty ", () => {
-  const result = nonEmpty.safeParse(new Map());
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_small");
-});
-
-test("failing when map is bigger than max() ", () => {
-  const result = maxTwo.safeParse(
-    new Map([
-      ["a", "b"],
-      ["c", "d"],
-      ["e", "f"],
-    ])
-  );
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_big");
-});
-
-test("valid parse async", async () => {
-  const asyncMap = z.map(
-    z.string().refine(async () => false, "bad key"),
-    z.string().refine(async () => false, "bad value")
-  );
-  const result = await asyncMap.safeParseAsync(new Map([["first", "foo"]]));
-  expect(result.success).toEqual(false);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "first"
-        ],
-        "message": "bad key"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "first"
-        ],
-        "message": "bad value"
-      }
-    ]]
-  `);
-});
-
-test("throws when a Set is given", () => {
-  const result = stringMap.safeParse(new Set([]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual("invalid_type");
-  }
-});
-
-test("throws when the given map has invalid key and invalid input", () => {
-  const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error).toMatchInlineSnapshot(`
-      [ZodError: [
-        {
-          "expected": "string",
-          "code": "invalid_type",
-          "path": [
-            42
-          ],
-          "message": "Invalid input: expected string, received number"
-        },
-        {
-          "expected": "string",
-          "code": "invalid_type",
-          "path": [
-            42
-          ],
-          "message": "Invalid input: expected string, received symbol"
-        }
-      ]]
-    `);
-  }
-});
-
-test("throws when the given map has multiple invalid entries", () => {
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-
-  const result = stringMap.safeParse(
-    new Map([
-      [1, "foo"],
-      ["bar", 2],
-    ] as [any, any][]) as Map<any, any>
-  );
-
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [
-            1,
-          ],
-        },
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [
-            "bar",
-          ],
-        },
-      ]
-    `);
-  }
-});
-
-test("dirty", async () => {
-  const map = z.map(
-    z.string().refine((val) => val === val.toUpperCase(), {
-      message: "Keys must be uppercase",
-    }),
-    z.string()
-  );
-  const result = await map.spa(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error).toMatchInlineSnapshot(`
-      [ZodError: [
-        {
-          "code": "custom",
-          "path": [
-            "first"
-          ],
-          "message": "Keys must be uppercase"
-        },
-        {
-          "code": "custom",
-          "path": [
-            "second"
-          ],
-          "message": "Keys must be uppercase"
-        }
-      ]]
-    `);
-  }
-});
-
-test("map with object keys", () => {
-  const map = z.map(
-    z.object({
-      name: z.string(),
-      age: z.number(),
-    }),
-    z.string()
-  );
-  const data = new Map([
-    [{ name: "John", age: 30 }, "foo"],
-    [{ name: "Jane", age: 25 }, "bar"],
-  ]);
-  const result = map.safeParse(data);
-  expect(result.success).toEqual(true);
-  expect(result.data!).toEqual(data);
-
-  const badData = new Map([["bad", "foo"]]);
-  const badResult = map.safeParse(badData);
-  expect(badResult.success).toEqual(false);
-  expect(badResult.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "object",
-        "code": "invalid_type",
-        "path": [
-          "bad"
-        ],
-        "message": "Invalid input: expected object, received string"
-      }
-    ]]
-  `);
-});
-
-test("min/max", async () => {
-  const schema = stringMap.min(4).max(5);
-
-  const r1 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-      ["d", "d"],
-    ])
-  );
-  expect(r1.success).toEqual(true);
-
-  const r2 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-    ])
-  );
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "inclusive": true,
-        "message": "Too small: expected map to have >=4 entries",
-        "minimum": 4,
-        "origin": "map",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r3 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-      ["d", "d"],
-      ["e", "e"],
-      ["f", "f"],
-    ])
-  );
-  expect(r3.success).toEqual(false);
-  expect(r3.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "inclusive": true,
-        "maximum": 5,
-        "message": "Too big: expected map to have <=5 entries",
-        "origin": "map",
-        "path": [],
-      },
-    ]
-  `);
-});

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

@@ -1,21 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-const schema = z.nan();
-
-test("passing validations", () => {
-  schema.parse(Number.NaN);
-  schema.parse(Number("Not a number"));
-  expectTypeOf<typeof schema._output>().toEqualTypeOf<number>();
-});
-
-test("failing validations", () => {
-  expect(() => schema.parse(5)).toThrow();
-  expect(() => schema.parse("John")).toThrow();
-  expect(() => schema.parse(true)).toThrow();
-  expect(() => schema.parse(null)).toThrow();
-  expect(() => schema.parse(undefined)).toThrow();
-  expect(() => schema.parse({})).toThrow();
-  expect(() => schema.parse([])).toThrow();
-});

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

@@ -1,168 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("nested refinements", () => {
-  const zodSchema = z
-    .object({
-      password: z.string().min(1),
-      nested: z
-        .object({
-          confirm: z
-            .string()
-            .min(1)
-            .refine((value) => value.length > 2, {
-              message: "Confirm length should be > 2",
-            }),
-        })
-        .refine(
-          (data) => {
-            return data.confirm === "bar";
-          },
-          {
-            path: ["confirm"],
-            error: 'Value must be "bar"',
-          }
-        ),
-    })
-    .refine(
-      (data) => {
-        return data.nested.confirm === data.password;
-      },
-      {
-        path: ["nested", "confirm"],
-        error: "Password and confirm must match",
-      }
-    );
-
-  const DATA = {
-    password: "bar",
-    nested: { confirm: "" },
-  };
-  expect(zodSchema.safeParse(DATA)).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "string",
-        "code": "too_small",
-        "minimum": 1,
-        "inclusive": true,
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Too small: expected string to have >=1 characters"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Confirm length should be > 2"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Value must be \\"bar\\""
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Password and confirm must match"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  expect(zodSchema.safeParse(DATA, { jitless: true })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "string",
-        "code": "too_small",
-        "minimum": 1,
-        "inclusive": true,
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Too small: expected string to have >=1 characters"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Confirm length should be > 2"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Value must be \\"bar\\""
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Password and confirm must match"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  expect(zodSchema["~standard"].validate(DATA)).toMatchInlineSnapshot(`
-    {
-      "issues": [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected string to have >=1 characters",
-          "minimum": 1,
-          "origin": "string",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Confirm length should be > 2",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Value must be "bar"",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Password and confirm must match",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-      ],
-    }
-  `);
-});