@auto-ai/agent 2.1.104 → 2.1.105

package/tools-runtime/code-tool/node_modules/zod/src/v4/core/tests/locales/es.test.ts

@@ -1,181 +0,0 @@
-import { expect, test } from "vitest";
-import { z } from "../../../../index.js";
-import es from "../../../locales/es.js";
-
-test("Spanish locale - type name translations in too_small errors", () => {
-  z.config(es());
-
-  // Test string type translation
-  const stringSchema = z.string().min(5);
-  const stringResult = stringSchema.safeParse("abc");
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe(
-      "Demasiado pequeño: se esperaba que texto tuviera >=5 caracteres"
-    );
-  }
-
-  // Test number type translation
-  const numberSchema = z.number().min(10);
-  const numberResult = numberSchema.safeParse(5);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Demasiado pequeño: se esperaba que número fuera >=10");
-  }
-
-  // Test array type translation
-  const arraySchema = z.array(z.string()).min(3);
-  const arrayResult = arraySchema.safeParse(["a", "b"]);
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe(
-      "Demasiado pequeño: se esperaba que arreglo tuviera >=3 elementos"
-    );
-  }
-
-  // Test set type translation
-  const setSchema = z.set(z.string()).min(2);
-  const setResult = setSchema.safeParse(new Set(["a"]));
-  expect(setResult.success).toBe(false);
-  if (!setResult.success) {
-    expect(setResult.error.issues[0].message).toBe("Demasiado pequeño: se esperaba que conjunto tuviera >=2 elementos");
-  }
-});
-
-test("Spanish locale - type name translations in too_big errors", () => {
-  z.config(es());
-
-  // Test string type translation
-  const stringSchema = z.string().max(3);
-  const stringResult = stringSchema.safeParse("abcde");
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que texto tuviera <=3 caracteres");
-  }
-
-  // Test number type translation
-  const numberSchema = z.number().max(10);
-  const numberResult = numberSchema.safeParse(15);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que número fuera <=10");
-  }
-
-  // Test array type translation
-  const arraySchema = z.array(z.string()).max(2);
-  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que arreglo tuviera <=2 elementos");
-  }
-});
-
-test("Spanish locale - type name translations in invalid_type errors", () => {
-  z.config(es());
-
-  // Test string expected, number received
-  const stringSchema = z.string();
-  const stringResult = stringSchema.safeParse(123);
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Entrada inválida: se esperaba texto, recibido número");
-  }
-
-  // Test number expected, string received
-  const numberSchema = z.number();
-  const numberResult = numberSchema.safeParse("abc");
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Entrada inválida: se esperaba número, recibido texto");
-  }
-
-  // Test boolean expected, null received
-  const booleanSchema = z.boolean();
-  const booleanResult = booleanSchema.safeParse(null);
-  expect(booleanResult.success).toBe(false);
-  if (!booleanResult.success) {
-    expect(booleanResult.error.issues[0].message).toBe("Entrada inválida: se esperaba booleano, recibido nulo");
-  }
-
-  // Test array expected, object received
-  const arraySchema = z.array(z.string());
-  const arrayResult = arraySchema.safeParse({});
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Entrada inválida: se esperaba arreglo, recibido objeto");
-  }
-});
-
-test("Spanish locale - fallback for unknown type names", () => {
-  z.config(es());
-
-  // Test with a type that's not in the TypeNames dictionary
-  // This will test the fallback behavior
-  const dateSchema = z.date().min(new Date("2025-01-01"));
-  const dateResult = dateSchema.safeParse(new Date("2024-01-01"));
-  expect(dateResult.success).toBe(false);
-  if (!dateResult.success) {
-    // Should use "fecha" since we included it in TypeNames
-    expect(dateResult.error.issues[0].message).toContain("fecha");
-  }
-});
-
-test("Spanish locale - other error cases", () => {
-  z.config(es());
-
-  // Test invalid_element with tuple
-  const tupleSchema = z.tuple([z.string(), z.number()]);
-  const tupleResult = tupleSchema.safeParse(["abc", "not a number"]);
-  expect(tupleResult.success).toBe(false);
-  if (!tupleResult.success) {
-    expect(tupleResult.error.issues[0].message).toContain("Entrada inválida");
-  }
-
-  // Test invalid_value with enum
-  const enumSchema = z.enum(["a", "b"]);
-  const enumResult = enumSchema.safeParse("c");
-  expect(enumResult.success).toBe(false);
-  if (!enumResult.success) {
-    expect(enumResult.error.issues[0].message).toBe('Opción inválida: se esperaba una de "a"|"b"');
-  }
-
-  // Test not_multiple_of
-  const multipleSchema = z.number().multipleOf(3);
-  const multipleResult = multipleSchema.safeParse(10);
-  expect(multipleResult.success).toBe(false);
-  if (!multipleResult.success) {
-    expect(multipleResult.error.issues[0].message).toBe("Número inválido: debe ser múltiplo de 3");
-  }
-
-  // Test unrecognized_keys
-  const strictSchema = z.object({ a: z.string() }).strict();
-  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
-  expect(strictResult.success).toBe(false);
-  if (!strictResult.success) {
-    expect(strictResult.error.issues[0].message).toBe('Llave desconocida: "b"');
-  }
-
-  // Test invalid_union
-  const unionSchema = z.union([z.string(), z.number()]);
-  const unionResult = unionSchema.safeParse(true);
-  expect(unionResult.success).toBe(false);
-  if (!unionResult.success) {
-    expect(unionResult.error.issues[0].message).toBe("Entrada inválida");
-  }
-
-  // Test invalid_format with regex
-  const regexSchema = z.string().regex(/^[a-z]+$/);
-  const regexResult = regexSchema.safeParse("ABC123");
-  expect(regexResult.success).toBe(false);
-  if (!regexResult.success) {
-    expect(regexResult.error.issues[0].message).toBe("Cadena inválida: debe coincidir con el patrón /^[a-z]+$/");
-  }
-
-  // Test invalid_format with startsWith
-  const startsWithSchema = z.string().startsWith("hello");
-  const startsWithResult = startsWithSchema.safeParse("world");
-  expect(startsWithResult.success).toBe(false);
-  if (!startsWithResult.success) {
-    expect(startsWithResult.error.issues[0].message).toBe('Cadena inválida: debe comenzar con "hello"');
-  }
-});

package/tools-runtime/code-tool/node_modules/zod/src/v4/core/tests/locales/fr.test.ts

@@ -1,72 +0,0 @@
-import { expect, test } from "vitest";
-import { z } from "../../../../index.js";
-import fr from "../../../locales/fr.js";
-
-test("French locale - type name translations in too_small errors", () => {
-  z.config(fr());
-
-  const stringResult = z.string().min(5).safeParse("abc");
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Trop petit : chaîne doit avoir >=5 caractères");
-  }
-
-  const numberResult = z.number().min(10).safeParse(5);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Trop petit : nombre doit être >=10");
-  }
-
-  const arrayResult = z.array(z.string()).min(3).safeParse(["a", "b"]);
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Trop petit : tableau doit avoir >=3 éléments");
-  }
-
-  const setResult = z
-    .set(z.string())
-    .min(2)
-    .safeParse(new Set(["a"]));
-  expect(setResult.success).toBe(false);
-  if (!setResult.success) {
-    expect(setResult.error.issues[0].message).toBe("Trop petit : ensemble doit avoir >=2 éléments");
-  }
-});
-
-test("French locale - type name translations in too_big errors", () => {
-  z.config(fr());
-
-  const stringResult = z.string().max(3).safeParse("abcde");
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Trop grand : chaîne doit avoir <=3 caractères");
-  }
-
-  const numberResult = z.number().max(10).safeParse(15);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Trop grand : nombre doit être <=10");
-  }
-
-  const arrayResult = z.array(z.string()).max(2).safeParse(["a", "b", "c"]);
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Trop grand : tableau doit avoir <=2 éléments");
-  }
-});
-
-test("French locale - type name translations in invalid_type errors", () => {
-  z.config(fr());
-
-  const stringResult = z.string().safeParse(123);
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Entrée invalide : chaîne attendu, nombre reçu");
-  }
-
-  const arrayResult = z.array(z.string()).safeParse({});
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Entrée invalide : tableau attendu, objet reçu");
-  }
-});

package/tools-runtime/code-tool/node_modules/zod/src/v4/core/tests/locales/he.test.ts

@@ -1,379 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { z } from "../../../../index.js";
-import he from "../../../locales/he.js";
-
-describe("Hebrew localization", () => {
-  beforeEach(() => {
-    z.config(he());
-  });
-
-  describe("too_small errors with definite article and gendered verbs", () => {
-    test("string type (feminine - צריכה)", () => {
-      const schema = z.string().min(3);
-      const result = schema.safeParse("ab");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קצר מדי: המחרוזת צריכה להכיל 3 תווים או יותר");
-      }
-    });
-
-    test("number type (masculine - צריך)", () => {
-      const schema = z.number().min(10);
-      const result = schema.safeParse(5);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול או שווה ל-10");
-      }
-    });
-
-    test("array type (masculine - צריך)", () => {
-      const schema = z.array(z.string()).min(1);
-      const result = schema.safeParse([]);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קטן מדי: המערך צריך להכיל לפחות פריט אחד");
-      }
-    });
-
-    test("set type (feminine - צריכה)", () => {
-      const schema = z.set(z.string()).min(2);
-      const result = schema.safeParse(new Set(["a"]));
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קטן מדי: הקבוצה (Set) צריכה להכיל 2 פריטים או יותר");
-      }
-    });
-  });
-
-  describe("too_big errors with definite article and gendered verbs", () => {
-    test("string type (feminine - צריכה)", () => {
-      const schema = z.string().max(3);
-      const result = schema.safeParse("abcde");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("ארוך מדי: המחרוזת צריכה להכיל 3 תווים או פחות");
-      }
-    });
-
-    test("number type (masculine - צריך)", () => {
-      const schema = z.number().max(365);
-      const result = schema.safeParse(400);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן או שווה ל-365");
-      }
-    });
-
-    test("array max", () => {
-      const schema = z.array(z.string()).max(2);
-      const result = schema.safeParse(["a", "b", "c"]);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("גדול מדי: המערך צריך להכיל 2 פריטים או פחות");
-      }
-    });
-  });
-
-  describe("invalid_type errors with definite article and gendered verbs", () => {
-    test("string expected (feminine), number received", () => {
-      const schema = z.string();
-      const result = schema.safeParse(123);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מחרוזת, התקבל מספר");
-      }
-    });
-
-    test("number expected (masculine), string received", () => {
-      const schema = z.number();
-      const result = schema.safeParse("abc");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מספר, התקבל מחרוזת");
-      }
-    });
-
-    test("boolean expected (masculine), null received", () => {
-      const schema = z.boolean();
-      const result = schema.safeParse(null);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות ערך בוליאני, התקבל ערך ריק (null)");
-      }
-    });
-
-    test("array expected (masculine), object received", () => {
-      const schema = z.array(z.string());
-      const result = schema.safeParse({});
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מערך, התקבל אובייקט");
-      }
-    });
-
-    test("object expected (masculine), array received", () => {
-      const schema = z.object({ a: z.string() });
-      const result = schema.safeParse([]);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות אובייקט, התקבל מערך");
-      }
-    });
-
-    test("function expected (feminine), string received", () => {
-      const schema = z.function();
-      const result = schema.safeParse("not a function");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות פונקציה, התקבל מחרוזת");
-      }
-    });
-  });
-
-  describe("gendered verbs consistency", () => {
-    test("feminine types use צריכה", () => {
-      const feminineTypes = [
-        { schema: z.string().min(5), input: "abc" },
-        { schema: z.set(z.string()).min(2), input: new Set(["a"]) },
-      ];
-
-      for (const { schema, input } of feminineTypes) {
-        const result = schema.safeParse(input);
-        expect(result.success).toBe(false);
-        if (!result.success) {
-          expect(result.error.issues[0].message).toContain("צריכה");
-        }
-      }
-    });
-
-    test("masculine types use צריך", () => {
-      const masculineTypes = [
-        { schema: z.number().min(10), input: 5 },
-        { schema: z.array(z.string()).min(2), input: ["a"] },
-      ];
-
-      for (const { schema, input } of masculineTypes) {
-        const result = schema.safeParse(input);
-        expect(result.success).toBe(false);
-        if (!result.success) {
-          expect(result.error.issues[0].message).toContain("צריך");
-        }
-      }
-    });
-  });
-
-  describe("invalid_value with enum", () => {
-    test("single value", () => {
-      const schema = z.enum(["a"]);
-      const result = schema.safeParse("b");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('ערך לא תקין: הערך חייב להיות "a"');
-      }
-    });
-
-    test("two values", () => {
-      const schema = z.enum(["a", "b"]);
-      const result = schema.safeParse("c");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('ערך לא תקין: האפשרויות המתאימות הן "a" או "b"');
-      }
-    });
-
-    test("multiple values", () => {
-      const schema = z.enum(["a", "b", "c"]);
-      const result = schema.safeParse("d");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('ערך לא תקין: האפשרויות המתאימות הן "a", "b" או "c"');
-      }
-    });
-  });
-
-  describe("other error types", () => {
-    test("not_multiple_of", () => {
-      const schema = z.number().multipleOf(3);
-      const result = schema.safeParse(10);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("מספר לא תקין: חייב להיות מכפלה של 3");
-      }
-    });
-
-    test("unrecognized_keys - single key", () => {
-      const schema = z.object({ a: z.string() }).strict();
-      const result = schema.safeParse({ a: "test", b: "extra" });
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('מפתח לא מזוהה: "b"');
-      }
-    });
-
-    test("unrecognized_keys - multiple keys", () => {
-      const schema = z.object({ a: z.string() }).strict();
-      const result = schema.safeParse({ a: "test", b: "extra", c: "more" });
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('מפתחות לא מזוהים: "b", "c"');
-      }
-    });
-
-    test("invalid_union", () => {
-      const schema = z.union([z.string(), z.number()]);
-      const result = schema.safeParse(true);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין");
-      }
-    });
-
-    test("invalid_key in object", () => {
-      const schema = z.record(z.number(), z.string());
-      const result = schema.safeParse({ notANumber: "value" });
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("שדה לא תקין באובייקט");
-      }
-    });
-  });
-
-  describe("invalid_format with string checks", () => {
-    test("startsWith", () => {
-      const schema = z.string().startsWith("hello");
-      const result = schema.safeParse("world");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('המחרוזת חייבת להתחיל ב "hello"');
-      }
-    });
-
-    test("endsWith", () => {
-      const schema = z.string().endsWith("world");
-      const result = schema.safeParse("hello");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('המחרוזת חייבת להסתיים ב "world"');
-      }
-    });
-
-    test("includes", () => {
-      const schema = z.string().includes("test");
-      const result = schema.safeParse("hello world");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('המחרוזת חייבת לכלול "test"');
-      }
-    });
-
-    test("regex", () => {
-      const schema = z.string().regex(/^[a-z]+$/);
-      const result = schema.safeParse("ABC123");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("המחרוזת חייבת להתאים לתבנית /^[a-z]+$/");
-      }
-    });
-  });
-
-  describe("invalid_format with common formats", () => {
-    test("email", () => {
-      const schema = z.string().email();
-      const result = schema.safeParse("not-an-email");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("כתובת אימייל לא תקינה");
-      }
-    });
-
-    test("url", () => {
-      const schema = z.string().url();
-      const result = schema.safeParse("not-a-url");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("כתובת רשת לא תקינה");
-      }
-    });
-
-    test("uuid", () => {
-      const schema = z.string().uuid();
-      const result = schema.safeParse("not-a-uuid");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("UUID לא תקין");
-      }
-    });
-  });
-
-  describe("tuple validation", () => {
-    test("invalid element type in tuple shows full error message", () => {
-      const schema = z.tuple([z.string(), z.number()]);
-      const result = schema.safeParse(["abc", "not a number"]);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מספר, התקבל מחרוזת");
-      }
-    });
-  });
-
-  describe("inclusive vs exclusive bounds", () => {
-    test("inclusive minimum (>=)", () => {
-      const schema = z.number().min(10);
-      const result = schema.safeParse(5);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול או שווה ל-10");
-      }
-    });
-
-    test("exclusive minimum (>)", () => {
-      const schema = z.number().gt(10);
-      const result = schema.safeParse(10);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול מ-10");
-      }
-    });
-
-    test("inclusive maximum (<=)", () => {
-      const schema = z.number().max(10);
-      const result = schema.safeParse(15);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן או שווה ל-10");
-      }
-    });
-
-    test("exclusive maximum (<)", () => {
-      const schema = z.number().lt(10);
-      const result = schema.safeParse(10);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן מ-10");
-      }
-    });
-  });
-
-  describe("all type names with definite article", () => {
-    test("verifies all type translations are correct", () => {
-      const types = [
-        { schema: z.string(), expected: "מחרוזת", input: 123 },
-        { schema: z.number(), expected: "מספר", input: "abc" },
-        { schema: z.boolean(), expected: "ערך בוליאני", input: "abc" },
-        { schema: z.bigint(), expected: "BigInt", input: "abc" },
-        { schema: z.date(), expected: "תאריך", input: "abc" },
-        { schema: z.array(z.any()), expected: "מערך", input: "abc" },
-        { schema: z.object({}), expected: "אובייקט", input: "abc" },
-        { schema: z.function(), expected: "פונקציה", input: "abc" },
-      ];
-
-      for (const { schema, expected, input } of types) {
-        const result = schema.safeParse(input);
-        expect(result.success).toBe(false);
-        if (!result.success) {
-          expect(result.error.issues[0].message).toContain(expected);
-        }
-      }
-    });
-  });
-});