agent-relay 4.0.12 → 4.0.14

package/node_modules/@relaycast/types/node_modules/zod/src/v4/core/standard-schema.ts

@@ -1,159 +0,0 @@
-/** The Standard interface. */
-export interface StandardTypedV1<Input = unknown, Output = Input> {
-  /** The Standard properties. */
-  readonly "~standard": StandardTypedV1.Props<Input, Output>;
-}
-
-export declare namespace StandardTypedV1 {
-  /** The Standard properties interface. */
-  export interface Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** Inferred types associated with the schema. */
-    readonly types?: Types<Input, Output> | undefined;
-  }
-
-  /** The Standard types interface. */
-  export interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-  }
-
-  /** Infers the input type of a Standard. */
-  export type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-
-  /** Infers the output type of a Standard. */
-  export type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-
-/** The Standard Schema interface. */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-
-export declare namespace StandardSchemaV1 {
-  /** The Standard Schema properties interface. */
-  export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-    /** Validates unknown input values. */
-    readonly validate: (
-      value: unknown,
-      options?: StandardSchemaV1.Options | undefined
-    ) => Result<Output> | Promise<Result<Output>>;
-  }
-
-  /** The result interface of the validate function. */
-  export type Result<Output> = SuccessResult<Output> | FailureResult;
-
-  /** The result interface if validation succeeds. */
-  export interface SuccessResult<Output> {
-    /** The typed output value. */
-    readonly value: Output;
-    /** The absence of issues indicates success. */
-    readonly issues?: undefined;
-  }
-
-  export interface Options {
-    /** Implicit support for additional vendor-specific parameters, if needed. */
-    readonly libraryOptions?: Record<string, unknown> | undefined;
-  }
-
-  /** The result interface if validation fails. */
-  export interface FailureResult {
-    /** The issues of failed validation. */
-    readonly issues: ReadonlyArray<Issue>;
-  }
-
-  /** The issue interface of the failure output. */
-  export interface Issue {
-    /** The error message of the issue. */
-    readonly message: string;
-    /** The path of the issue, if any. */
-    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-  }
-
-  /** The path segment interface of the issue. */
-  export interface PathSegment {
-    /** The key representing a path segment. */
-    readonly key: PropertyKey;
-  }
-
-  /** The Standard types interface. */
-  export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
-
-  /** Infers the input type of a Standard. */
-  export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-
-  /** Infers the output type of a Standard. */
-  export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
-}
-
-/** The Standard JSON Schema interface. */
-export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard JSON Schema properties. */
-  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
-}
-
-export declare namespace StandardJSONSchemaV1 {
-  /** The Standard JSON Schema properties interface. */
-  export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-    /** Methods for generating the input/output JSON Schema. */
-    readonly jsonSchema: Converter;
-  }
-
-  /** The Standard JSON Schema converter interface. */
-  export interface Converter {
-    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
-    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
-    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
-    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
-  }
-
-  /** The target version of the generated JSON Schema.
-   *
-   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
-   *
-   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
-   *
-   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
-   */
-  export type Target =
-    | "draft-2020-12"
-    | "draft-07"
-    | "openapi-3.0"
-    // Accepts any string for future targets while preserving autocomplete
-    | ({} & string);
-
-  /** The options for the input/output methods. */
-  export interface Options {
-    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
-    readonly target: Target;
-
-    /** Implicit support for additional vendor-specific parameters, if needed. */
-    readonly libraryOptions?: Record<string, unknown> | undefined;
-  }
-
-  /** The Standard types interface. */
-  export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
-
-  /** Infers the input type of a Standard. */
-  export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-
-  /** Infers the output type of a Standard. */
-  export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
-}
-
-export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input>
-  extends StandardSchemaV1.Props<Input, Output>,
-    StandardJSONSchemaV1.Props<Input, Output> {}
-
-/**
- * An interface that combines StandardJSONSchema and StandardSchema.
- */
-export interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
-  "~standard": StandardSchemaWithJSONProps<Input, Output>;
-}

package/node_modules/@relaycast/types/node_modules/zod/src/v4/core/tests/extend.test.ts

@@ -1,59 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("safeExtend chaining preserves and overrides properties", () => {
-  const schema1 = z.object({
-    email: z.string(),
-  });
-
-  const schema2 = schema1.safeExtend({
-    email: schema1.shape.email.check(z.email()),
-  });
-
-  const schema3 = schema2.safeExtend({
-    email: schema2.shape.email.or(z.literal("")),
-  });
-
-  schema3.parse({ email: "test@example.com" });
-});
-
-test("extend with constructor field in shape", () => {
-  const baseSchema = z.object({
-    name: z.string(),
-  });
-
-  const extendedSchema = baseSchema.extend({
-    constructor: z.string(),
-    age: z.number(),
-  });
-
-  const result = extendedSchema.parse({
-    name: "John",
-    constructor: "Person",
-    age: 30,
-  });
-
-  expect(result).toEqual({
-    name: "John",
-    constructor: "Person",
-    age: 30,
-  });
-
-  const testCases = [
-    { name: "Test", constructor: 123, age: 25 },
-    { name: "Test", constructor: null, age: 25 },
-    { name: "Test", constructor: true, age: 25 },
-    { name: "Test", constructor: {}, age: 25 },
-  ];
-
-  for (const testCase of testCases) {
-    const anyConstructorSchema = baseSchema.extend({
-      constructor: z.any(),
-      age: z.number(),
-    });
-
-    expect(() => anyConstructorSchema.parse(testCase)).not.toThrow();
-    const parsed = anyConstructorSchema.parse(testCase);
-    expect(parsed).toEqual(testCase);
-  }
-});

package/node_modules/@relaycast/types/node_modules/zod/src/v4/core/tests/index.test.ts

@@ -1,46 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v3";
-
-test("test", () => {
-  expect(true).toBe(true);
-});
-
-test("test2", () => {
-  expect(() => z.string().parse(234)).toThrowErrorMatchingInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "invalid_type",
-        "expected": "string",
-        "received": "number",
-        "path": [],
-        "message": "Expected string, received number"
-      }
-    ]]
-  `);
-});
-
-test("async validation", async () => {
-  const testTuple = z
-    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
-    .refine(async () => true);
-  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
-
-  const val = await testTuple.parseAsync(["asdf", 1234]);
-  expect(val).toEqual(val);
-
-  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "invalid_type",
-        "expected": "number",
-        "received": "string",
-        "path": [
-          1
-        ],
-        "message": "Expected number, received string"
-      }
-    ]]
-  `);
-});

package/node_modules/@relaycast/types/node_modules/zod/src/v4/core/tests/locales/be.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it } from "vitest";
-import be from "../../../locales/be.js";
-
-describe("Belarusian localization", () => {
-  const localeError = be().localeError;
-
-  describe("pluralization rules", () => {
-    for (const { type, cases } of TEST_CASES) {
-      describe(`${type} pluralization`, () => {
-        for (const { count, expected } of cases) {
-          it(`correctly pluralizes ${count} ${type}`, () => {
-            const error = localeError({
-              code: "too_small",
-              minimum: count,
-              type: "number",
-              inclusive: true,
-              path: [],
-              origin: type,
-              input: count - 1,
-            });
-            expect(error).toContain(expected);
-          });
-        }
-      });
-    }
-
-    it("handles negative numbers correctly", () => {
-      const error = localeError({
-        code: "too_small",
-        minimum: -2,
-        type: "number",
-        inclusive: true,
-        path: [],
-        origin: "array",
-        input: -3,
-      });
-      expect(error).toContain("-2 элементы");
-    });
-
-    it("handles zero correctly", () => {
-      const error = localeError({
-        code: "too_small",
-        minimum: 0,
-        type: "number",
-        inclusive: true,
-        path: [],
-        origin: "array",
-        input: -1,
-      });
-      expect(error).toContain("0 элементаў");
-    });
-
-    it("handles bigint values correctly", () => {
-      const error = localeError({
-        code: "too_small",
-        minimum: BigInt(21),
-        type: "number",
-        inclusive: true,
-        path: [],
-        origin: "array",
-        input: BigInt(20),
-      });
-      expect(error).toContain("21 элемент");
-    });
-  });
-});
-
-const TEST_CASES = [
-  {
-    type: "array",
-    cases: [
-      { count: 1, expected: "1 элемент" },
-      { count: 2, expected: "2 элементы" },
-      { count: 5, expected: "5 элементаў" },
-      { count: 11, expected: "11 элементаў" },
-      { count: 21, expected: "21 элемент" },
-      { count: 22, expected: "22 элементы" },
-      { count: 25, expected: "25 элементаў" },
-      { count: 101, expected: "101 элемент" },
-      { count: 111, expected: "111 элементаў" },
-    ],
-  },
-  {
-    type: "set",
-    cases: [
-      { count: 1, expected: "1 элемент" },
-      { count: 2, expected: "2 элементы" },
-      { count: 5, expected: "5 элементаў" },
-      { count: 11, expected: "11 элементаў" },
-      { count: 21, expected: "21 элемент" },
-      { count: 22, expected: "22 элементы" },
-      { count: 25, expected: "25 элементаў" },
-      { count: 101, expected: "101 элемент" },
-      { count: 111, expected: "111 элементаў" },
-    ],
-  },
-  {
-    type: "string",
-    cases: [
-      { count: 1, expected: "1 сімвал" },
-      { count: 2, expected: "2 сімвалы" },
-      { count: 5, expected: "5 сімвалаў" },
-      { count: 11, expected: "11 сімвалаў" },
-      { count: 21, expected: "21 сімвал" },
-      { count: 22, expected: "22 сімвалы" },
-      { count: 25, expected: "25 сімвалаў" },
-    ],
-  },
-  {
-    type: "file",
-    cases: [
-      { count: 0, expected: "0 байтаў" },
-      { count: 1, expected: "1 байт" },
-      { count: 2, expected: "2 байты" },
-      { count: 5, expected: "5 байтаў" },
-      { count: 11, expected: "11 байтаў" },
-      { count: 21, expected: "21 байт" },
-      { count: 22, expected: "22 байты" },
-      { count: 25, expected: "25 байтаў" },
-      { count: 101, expected: "101 байт" },
-      { count: 110, expected: "110 байтаў" },
-    ],
-  },
-] as const;

package/node_modules/@relaycast/types/node_modules/zod/src/v4/core/tests/locales/en.test.ts

@@ -1,22 +0,0 @@
-import { expect, test } from "vitest";
-import { parsedType } from "../../util.js";
-
-test("parsedType", () => {
-  expect(parsedType("string")).toBe("string");
-  expect(parsedType(1)).toBe("number");
-  expect(parsedType(true)).toBe("boolean");
-  expect(parsedType(null)).toBe("null");
-  expect(parsedType(undefined)).toBe("undefined");
-  expect(parsedType([])).toBe("array");
-  expect(parsedType({})).toBe("object");
-  expect(parsedType(new Date())).toBe("Date");
-  expect(parsedType(new Map())).toBe("Map");
-  expect(parsedType(new Set())).toBe("Set");
-  expect(parsedType(new Error())).toBe("Error");
-
-  const nullPrototype = Object.create(null);
-  expect(parsedType(nullPrototype)).toBe("object");
-
-  const doubleNullPrototype = Object.create(Object.create(null));
-  expect(parsedType(doubleNullPrototype)).toBe("object");
-});

package/node_modules/@relaycast/types/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"');
-  }
-});