@tambo-ai/react 0.66.1 → 0.67.0

package/esm/schema/zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/schema/zod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,QAAQ,EACR,aAAa,EACb,OAAO,EACP,UAAU,EACX,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,YAAY,EACZ,QAAQ,EAET,MAAM,aAAa,CAAC;AAGrB;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,EAAE,UAAU,CAAC,CAMjE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,YAAY,CAoB5E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,iKAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,yEAWjD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,OAWpD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,OAkBpD;AAaD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,OAAO,CAE/D;AAUD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,QAAQ,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,OAAO,GACd,UAAU,CAAC,OAAO,YAAY,CAAC,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAEnE"}
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/schema/zod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,QAAQ,EACR,aAAa,EACb,OAAO,EACP,UAAU,EACX,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,YAAY,EACZ,QAAQ,EAET,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,EAAE,UAAU,CAAC,CAQjE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,YAAY,CAoB5E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,iKAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,yEAWjD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,OAWpD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,OAmBpD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,OAAO,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,QAAQ,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,OAAO,GAAG,QAAQ,CAczE"}

package/esm/schema/zod.js

@@ -1,13 +1,13 @@
 import { toJSONSchema as zod4ToJSONSchema, } from "zod/v4/core";
-import { z } from "zodInternalAlias";
 /**
  * @returns True if the schema is a Zod 3 function schema
  */
 export function isZod3FunctionSchema(schema) {
-    if (!isZod3Schema(schema)) {
+    if (!isZodSchema(schema))
         return false;
-    }
-    return "typeName" in schema._def && schema._def.typeName === "ZodFunction";
+    return ("_def" in schema &&
+        "typeName" in schema._def &&
+        schema._def.typeName === "ZodFunction");
 }
 /**
  * @returns True if the schema is a Zod 4 function schema
@@ -78,12 +78,12 @@ export function getZodFunctionReturns(schema) {
 export function handleZodSchemaToJson(schema) {
     // If Zod4 schema detected, use the toJSONSchema function from "zod/v4/core"
     if (isZod4Schema(schema))
-        return zod4ToJSONSchema(schema);
+        return zod4ToJSONSchema(schema, { reused: "inline" });
     try {
         // Dynamic require for optional peer dependency
         // eslint-disable-next-line @typescript-eslint/no-require-imports -- need require because zod-to-json-schema may be missing
         const { zodToJsonSchema } = require("zod-to-json-schema");
-        return zodToJsonSchema(schema);
+        return zodToJsonSchema(schema, { $refStrategy: "none" });
     }
     catch (error) {
         throw new Error("Zod 3 requires 'zod-to-json-schema' package for JSON Schema conversion. " +
@@ -92,38 +92,21 @@ export function handleZodSchemaToJson(schema) {
         });
     }
 }
-// Zod 3 schemas have _def with typeName and ~standard with vendor "zod"
-// Use looseObject to allow any _def shape (different for each type)
-const zod3SchemaType = z.object({
-    _def: z.looseObject({
-        typeName: z.string().optional(),
-    }),
-    "~standard": z.looseObject({
-        vendor: z.literal("zod"),
-    }),
-});
 /**
  * Checks if a schema is probably a Zod 3 schema.
  * @param schema - The schema to check
  * @returns True if the schema looks like a Zod 3 schema
  */
 export function isZod3Schema(schema) {
-    return zod3SchemaType.safeParse(schema).success;
+    return isZodSchema(schema) && "_def" in schema && !("def" in schema);
 }
-const zod4SchemaType = z.object({
-    def: z.object(),
-    _zod: z.looseObject({
-        def: z.looseObject({}),
-    }),
-    "~standard": z.looseObject({}),
-});
 /**
  * Detects if a schema is Zod 4 by checking for def.type property.
  * Zod 4 uses `def.type` with lowercase type names like "object", "string".
  * @returns True if the schema appears to be Zod 4 style
  */
 export function isZod4Schema(schema) {
-    return zod4SchemaType.safeParse(schema).success;
+    return isZodSchema(schema) && "_zod" in schema;
 }
 /**
  * Checks if a schema is a Zod schema
@@ -131,6 +114,24 @@ export function isZod4Schema(schema) {
  * @returns True if the schema is a Zod schema
  */
 export function isZodSchema(schema) {
-    return isZod3Schema(schema) || isZod4Schema(schema);
+    // schema must be { ~standard: { vendor: "zod" } }
+    if (typeof schema !== "object")
+        return false;
+    if (!schema)
+        return false;
+    if (!("~standard" in schema))
+        return false;
+    if (!schema["~standard"])
+        return false;
+    if (typeof schema["~standard"] !== "object")
+        return false;
+    if (!("vendor" in schema["~standard"]))
+        return false;
+    if (schema["~standard"].vendor !== "zod")
+        return false;
+    // Require at least one internal marker to reduce false positives
+    const looksLikeV3 = "_def" in schema;
+    const looksLikeV4 = "_zod" in schema || "def" in schema;
+    return looksLikeV3 || looksLikeV4;
 }
 //# sourceMappingURL=zod.js.map

package/esm/schema/zod.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.js","sourceRoot":"","sources":["../../src/schema/zod.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,YAAY,IAAI,gBAAgB,GACjC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,CAAC,EAAE,MAAM,kBAAkB,CAAC;AAErC;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAe;IAEf,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,UAAU,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,KAAK,aAAa,CAAC;AAC7E,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAe;IAClD,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,2EAA2E;IAC3E,6EAA6E;IAC7E,4EAA4E;IAC5E,8CAA8C;IAC9C,gIAAgI;IAChI,IAAI,KAAK,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;QACpE,IAAK,MAAM,CAAC,GAAwB,EAAE,IAAI,KAAK,UAAU,EAAE,CAAC;YAC1D,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,8EAA8E;IAC9E,6EAA6E;IAC7E,mDAAmD;IACnD,OAAQ,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,IAAe,KAAK,UAAU,CAAC;AAC3D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAe;IACjD,OAAO,oBAAoB,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,MAAM,CAAC,CAAC;AACtE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAe;IAChD,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QACjC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QACjC,wDAAwD;QACxD,OAAO,MAAM,EAAE,GAAG,EAAE,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC;IACvD,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;AAC7E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAe;IACnD,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QACjC,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;IAC7B,CAAC;IAED,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QACjC,sDAAsD;QACtD,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;IAChC,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAe;IACnD,4EAA4E;IAC5E,IAAI,YAAY,CAAC,MAAM,CAAC;QAAE,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAE1D,IAAI,CAAC;QACH,+CAA+C;QAC/C,2HAA2H;QAC3H,MAAM,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;QAC1D,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,0EAA0E;YACxE,iDAAiD,EACnD;YACE,KAAK,EAAE,KAAK;SACb,CACF,CAAC;IACJ,CAAC;AACH,CAAC;AAED,wEAAwE;AACxE,oEAAoE;AACpE,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9B,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC;QAClB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAChC,CAAC;IACF,WAAW,EAAE,CAAC,CAAC,WAAW,CAAC;QACzB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;KACzB,CAAC;CACH,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,MAAe;IAC1C,OAAO,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;AAClD,CAAC;AAED,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9B,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC;QAClB,GAAG,EAAE,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC;KACvB,CAAC;IACF,WAAW,EAAE,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC;CAC/B,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,MAAe;IAC1C,OAAO,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;AAClD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CACzB,MAAe;IAEf,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC;AACtD,CAAC","sourcesContent":["import {\n  ZodFunction,\n  ZodTuple,\n  ZodTupleItems,\n  ZodType,\n  ZodTypeAny,\n} from \"zod/v3\";\nimport {\n  $ZodFunction,\n  $ZodType,\n  toJSONSchema as zod4ToJSONSchema,\n} from \"zod/v4/core\";\nimport { z } from \"zodInternalAlias\";\n\n/**\n * @returns True if the schema is a Zod 3 function schema\n */\nexport function isZod3FunctionSchema(\n  schema: unknown,\n): schema is ZodFunction<ZodTuple<ZodTupleItems, any>, ZodTypeAny> {\n  if (!isZod3Schema(schema)) {\n    return false;\n  }\n\n  return \"typeName\" in schema._def && schema._def.typeName === \"ZodFunction\";\n}\n\n/**\n * @returns True if the schema is a Zod 4 function schema\n */\nexport function isZod4FunctionSchema(schema: unknown): schema is $ZodFunction {\n  if (!isZod4Schema(schema)) {\n    return false;\n  }\n\n  // $ZodFunctions in zod 4.0 most certainly do have .def.type === \"function\"\n  // but the type definitions do not reflect this because $ZodFunction does not\n  // extend $ZodType. This is corrected in zod 4.1, but zod 3 does not include\n  // the types for 4.1 yet (and might not ever).\n  // See: https://github.com/colinhacks/zod/blob/463f03eb8183dcdcdf735b180f2bf40883e66220/packages/zod/src/v4/core/function.ts#L48\n  if (\"def\" in schema && typeof schema.def !== \"object\" && schema.def) {\n    if ((schema.def as { type: string })?.type === \"function\") {\n      return true;\n    }\n  }\n\n  // We're casting as string here because zod 4.0 types don't include \"function\"\n  // literal in the union for `_zod.def.type`. The optional chaining is because\n  // _zod does not exist on zod 4 objects from zod 3.\n  return (schema._zod?.def?.type as string) === \"function\";\n}\n\n/**\n * Checks if a schema is a Zod function schema (Zod 3 or Zod 4).\n * @param schema - The schema to check\n * @returns True if the schema is a Zod function schema\n */\nexport function isZodFunctionSchema(schema: unknown) {\n  return isZod3FunctionSchema(schema) || isZod4FunctionSchema(schema);\n}\n\n/**\n * Extracts the args schema from a Zod function schema.\n * @param schema - The Zod function schema\n * @returns The args schema, or undefined if not a Zod function schema\n */\nexport function getZodFunctionArgs(schema: unknown) {\n  if (isZod3FunctionSchema(schema)) {\n    return schema._def.args;\n  }\n\n  if (isZod4FunctionSchema(schema)) {\n    // @ts-expect-error -- Error in Zod types for v3 vs v4.0\n    return schema?.def?.input ?? schema._zod?.def?.input;\n  }\n\n  throw new Error(\"Unable to determine parameters from zod function schema\");\n}\n\n/**\n * Extracts the return schema from a Zod 3 or Zod 4 function schema.\n * @param schema - The Zod function schema\n * @returns The return schema, or undefined if not a Zod function schema\n */\nexport function getZodFunctionReturns(schema: unknown) {\n  if (isZod3FunctionSchema(schema)) {\n    return schema._def.returns;\n  }\n\n  if (isZod4FunctionSchema(schema)) {\n    // @ts-expect-error -- Error in Zod types for v3 vs v4\n    return schema._zod.def.output;\n  }\n\n  throw new Error(\"Unable to determine return type from zod function schema\");\n}\n\n/**\n * Handles conversion of Zod schemas to JSON Schema.\n * Supports both Zod 3 (via zod-to-json-schema) and Zod 4 (native).\n * @param schema - The Zod schema to convert\n * @returns The JSON Schema representation\n */\nexport function handleZodSchemaToJson(schema: unknown) {\n  // If Zod4 schema detected, use the toJSONSchema function from \"zod/v4/core\"\n  if (isZod4Schema(schema)) return zod4ToJSONSchema(schema);\n\n  try {\n    // Dynamic require for optional peer dependency\n    // eslint-disable-next-line @typescript-eslint/no-require-imports -- need require because zod-to-json-schema may be missing\n    const { zodToJsonSchema } = require(\"zod-to-json-schema\");\n    return zodToJsonSchema(schema);\n  } catch (error) {\n    throw new Error(\n      \"Zod 3 requires 'zod-to-json-schema' package for JSON Schema conversion. \" +\n        \"Install it with: npm install zod-to-json-schema\",\n      {\n        cause: error,\n      },\n    );\n  }\n}\n\n// Zod 3 schemas have _def with typeName and ~standard with vendor \"zod\"\n// Use looseObject to allow any _def shape (different for each type)\nconst zod3SchemaType = z.object({\n  _def: z.looseObject({\n    typeName: z.string().optional(),\n  }),\n  \"~standard\": z.looseObject({\n    vendor: z.literal(\"zod\"),\n  }),\n});\n\n/**\n * Checks if a schema is probably a Zod 3 schema.\n * @param schema - The schema to check\n * @returns True if the schema looks like a Zod 3 schema\n */\nexport function isZod3Schema(schema: unknown): schema is ZodType {\n  return zod3SchemaType.safeParse(schema).success;\n}\n\nconst zod4SchemaType = z.object({\n  def: z.object(),\n  _zod: z.looseObject({\n    def: z.looseObject({}),\n  }),\n  \"~standard\": z.looseObject({}),\n});\n\n/**\n * Detects if a schema is Zod 4 by checking for def.type property.\n * Zod 4 uses `def.type` with lowercase type names like \"object\", \"string\".\n * @returns True if the schema appears to be Zod 4 style\n */\nexport function isZod4Schema(schema: unknown): schema is $ZodType {\n  return zod4SchemaType.safeParse(schema).success;\n}\n\n/**\n * Checks if a schema is a Zod schema\n * @param schema - The schema to check\n * @returns True if the schema is a Zod schema\n */\nexport function isZodSchema(\n  schema: unknown,\n): ReturnType<typeof isZod3Schema> | ReturnType<typeof isZod4Schema> {\n  return isZod3Schema(schema) || isZod4Schema(schema);\n}\n"]}
+{"version":3,"file":"zod.js","sourceRoot":"","sources":["../../src/schema/zod.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ZodFunction,\n  ZodTuple,\n  ZodTupleItems,\n  ZodType,\n  ZodTypeAny,\n} from \"zod/v3\";\nimport {\n  $ZodFunction,\n  $ZodType,\n  toJSONSchema as zod4ToJSONSchema,\n} from \"zod/v4/core\";\n\n/**\n * @returns True if the schema is a Zod 3 function schema\n */\nexport function isZod3FunctionSchema(\n  schema: unknown,\n): schema is ZodFunction<ZodTuple<ZodTupleItems, any>, ZodTypeAny> {\n  if (!isZodSchema(schema)) return false;\n\n  return (\n    \"_def\" in schema &&\n    \"typeName\" in schema._def &&\n    schema._def.typeName === \"ZodFunction\"\n  );\n}\n\n/**\n * @returns True if the schema is a Zod 4 function schema\n */\nexport function isZod4FunctionSchema(schema: unknown): schema is $ZodFunction {\n  if (!isZod4Schema(schema)) {\n    return false;\n  }\n\n  // $ZodFunctions in zod 4.0 most certainly do have .def.type === \"function\"\n  // but the type definitions do not reflect this because $ZodFunction does not\n  // extend $ZodType. This is corrected in zod 4.1, but zod 3 does not include\n  // the types for 4.1 yet (and might not ever).\n  // See: https://github.com/colinhacks/zod/blob/463f03eb8183dcdcdf735b180f2bf40883e66220/packages/zod/src/v4/core/function.ts#L48\n  if (\"def\" in schema && typeof schema.def !== \"object\" && schema.def) {\n    if ((schema.def as { type: string })?.type === \"function\") {\n      return true;\n    }\n  }\n\n  // We're casting as string here because zod 4.0 types don't include \"function\"\n  // literal in the union for `_zod.def.type`. The optional chaining is because\n  // _zod does not exist on zod 4 objects from zod 3.\n  return (schema._zod?.def?.type as string) === \"function\";\n}\n\n/**\n * Checks if a schema is a Zod function schema (Zod 3 or Zod 4).\n * @param schema - The schema to check\n * @returns True if the schema is a Zod function schema\n */\nexport function isZodFunctionSchema(schema: unknown) {\n  return isZod3FunctionSchema(schema) || isZod4FunctionSchema(schema);\n}\n\n/**\n * Extracts the args schema from a Zod function schema.\n * @param schema - The Zod function schema\n * @returns The args schema, or undefined if not a Zod function schema\n */\nexport function getZodFunctionArgs(schema: unknown) {\n  if (isZod3FunctionSchema(schema)) {\n    return schema._def.args;\n  }\n\n  if (isZod4FunctionSchema(schema)) {\n    // @ts-expect-error -- Error in Zod types for v3 vs v4.0\n    return schema?.def?.input ?? schema._zod?.def?.input;\n  }\n\n  throw new Error(\"Unable to determine parameters from zod function schema\");\n}\n\n/**\n * Extracts the return schema from a Zod 3 or Zod 4 function schema.\n * @param schema - The Zod function schema\n * @returns The return schema, or undefined if not a Zod function schema\n */\nexport function getZodFunctionReturns(schema: unknown) {\n  if (isZod3FunctionSchema(schema)) {\n    return schema._def.returns;\n  }\n\n  if (isZod4FunctionSchema(schema)) {\n    // @ts-expect-error -- Error in Zod types for v3 vs v4\n    return schema._zod.def.output;\n  }\n\n  throw new Error(\"Unable to determine return type from zod function schema\");\n}\n\n/**\n * Handles conversion of Zod schemas to JSON Schema.\n * Supports both Zod 3 (via zod-to-json-schema) and Zod 4 (native).\n * @param schema - The Zod schema to convert\n * @returns The JSON Schema representation\n */\nexport function handleZodSchemaToJson(schema: unknown) {\n  // If Zod4 schema detected, use the toJSONSchema function from \"zod/v4/core\"\n  if (isZod4Schema(schema))\n    return zod4ToJSONSchema(schema, { reused: \"inline\" });\n\n  try {\n    // Dynamic require for optional peer dependency\n    // eslint-disable-next-line @typescript-eslint/no-require-imports -- need require because zod-to-json-schema may be missing\n    const { zodToJsonSchema } = require(\"zod-to-json-schema\");\n    return zodToJsonSchema(schema, { $refStrategy: \"none\" });\n  } catch (error) {\n    throw new Error(\n      \"Zod 3 requires 'zod-to-json-schema' package for JSON Schema conversion. \" +\n        \"Install it with: npm install zod-to-json-schema\",\n      {\n        cause: error,\n      },\n    );\n  }\n}\n\n/**\n * Checks if a schema is probably a Zod 3 schema.\n * @param schema - The schema to check\n * @returns True if the schema looks like a Zod 3 schema\n */\nexport function isZod3Schema(schema: unknown): schema is ZodType {\n  return isZodSchema(schema) && \"_def\" in schema && !(\"def\" in schema);\n}\n\n/**\n * Detects if a schema is Zod 4 by checking for def.type property.\n * Zod 4 uses `def.type` with lowercase type names like \"object\", \"string\".\n * @returns True if the schema appears to be Zod 4 style\n */\nexport function isZod4Schema(schema: unknown): schema is $ZodType {\n  return isZodSchema(schema) && \"_zod\" in schema;\n}\n\n/**\n * Checks if a schema is a Zod schema\n * @param schema - The schema to check\n * @returns True if the schema is a Zod schema\n */\nexport function isZodSchema(schema: unknown): schema is ZodType | $ZodType {\n  // schema must be { ~standard: { vendor: \"zod\" } }\n  if (typeof schema !== \"object\") return false;\n  if (!schema) return false;\n  if (!(\"~standard\" in schema)) return false;\n  if (!schema[\"~standard\"]) return false;\n  if (typeof schema[\"~standard\"] !== \"object\") return false;\n  if (!(\"vendor\" in schema[\"~standard\"])) return false;\n  if (schema[\"~standard\"].vendor !== \"zod\") return false;\n\n  // Require at least one internal marker to reduce false positives\n  const looksLikeV3 = \"_def\" in schema;\n  const looksLikeV4 = \"_zod\" in schema || \"def\" in schema;\n  return looksLikeV3 || looksLikeV4;\n}\n"]}

package/esm/schema/zod.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=zod.test.d.ts.map

package/esm/schema/zod.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.test.d.ts","sourceRoot":"","sources":["../../src/schema/zod.test.ts"],"names":[],"mappings":""}

package/esm/schema/zod.test.js

@@ -0,0 +1,516 @@
+import * as z3 from "zod/v3";
+import * as z4 from "zod/v4";
+import { handleZodSchemaToJson, isZod3Schema, isZod4Schema } from "./zod";
+// Test helper: assumes `value` is JSON-serializable (plain objects/arrays/primitives).
+// Conservative helper: returns true if any object in the tree has an own `key`
+// property at any depth. This lets us assert against JSON Schema `$ref` keys
+// structurally (not via incidental substrings in string values).
+function hasKeyDeep(value, key) {
+    const seen = new Set();
+    function isPlainObject(v) {
+        if (!v || typeof v !== "object" || Array.isArray(v))
+            return false;
+        const proto = Object.getPrototypeOf(v);
+        return proto === Object.prototype || proto === null;
+    }
+    function visit(node) {
+        if (!node || typeof node !== "object")
+            return false;
+        if (seen.has(node))
+            return false;
+        seen.add(node);
+        if (Array.isArray(node)) {
+            return node.some(visit);
+        }
+        if (!isPlainObject(node))
+            return false;
+        if (Object.prototype.hasOwnProperty.call(node, key))
+            return true;
+        return Object.values(node).some(visit);
+    }
+    return visit(value);
+}
+function resolveJsonPointer(doc, pointer) {
+    if (!pointer.startsWith("#"))
+        return undefined;
+    if (pointer === "#")
+        return doc;
+    if (!pointer.startsWith("#/"))
+        return undefined;
+    return pointer
+        .slice(2)
+        .split("/")
+        .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
+        .reduce((current, segment) => {
+        if (!current || typeof current !== "object")
+            return undefined;
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index))
+                return undefined;
+            return current[index];
+        }
+        return current[segment];
+    }, doc);
+}
+function createRecursiveZod4NodeSchema() {
+    // Placeholder schema so we can self-reference via `z4.lazy` without
+    // fighting ESLint `prefer-const`.
+    let nodeSchema = z4.any();
+    nodeSchema = z4.object({ next: z4.lazy(() => nodeSchema).optional() });
+    return nodeSchema;
+}
+describe("zod schema utilities", () => {
+    describe("isZod3Schema", () => {
+        it("returns true for Zod 3 schemas", () => {
+            const schema = z3.object({ name: z3.string() });
+            expect(isZod3Schema(schema)).toBe(true);
+            expect(isZod4Schema(schema)).toBe(false);
+        });
+        it("returns true for Zod 4 schemas (they also have _def)", () => {
+            // Note: Zod 4 schemas have both _def and _zod, so isZod3Schema returns true.
+            // This is fine because handleZodSchemaToJson checks isZod4Schema first.
+            const schema = z4.object({ name: z4.string() });
+            expect(isZod4Schema(schema)).toBe(true);
+            expect(isZod3Schema(schema)).toBe(false);
+        });
+        it("returns false for non-Zod values", () => {
+            expect(isZod3Schema({})).toBe(false);
+            expect(isZod3Schema(null)).toBe(false);
+            expect(isZod3Schema("string")).toBe(false);
+        });
+    });
+    describe("isZod4Schema", () => {
+        it("returns true for Zod 4 schemas", () => {
+            const schema = z4.object({ name: z4.string() });
+            expect(isZod4Schema(schema)).toBe(true);
+        });
+        it("returns false for Zod 3 schemas", () => {
+            const schema = z3.object({ name: z3.string() });
+            expect(isZod4Schema(schema)).toBe(false);
+        });
+        it("returns false for non-Zod values", () => {
+            expect(isZod4Schema({})).toBe(false);
+            expect(isZod4Schema(null)).toBe(false);
+            expect(isZod4Schema("string")).toBe(false);
+        });
+    });
+    describe("handleZodSchemaToJson", () => {
+        describe("basic conversion", () => {
+            it("converts Zod 3 schema to JSON Schema", () => {
+                const schema = z3.object({
+                    name: z3.string(),
+                    age: z3.number(),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        age: { type: "number" },
+                    },
+                });
+            });
+            it("converts Zod 4 schema to JSON Schema", () => {
+                const schema = z4.object({
+                    name: z4.string(),
+                    age: z4.number(),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        age: { type: "number" },
+                    },
+                });
+            });
+        });
+        describe("reused schemas - no $ref references", () => {
+            it("inlines reused Zod 3 schemas without any $ref in output", () => {
+                // Define a shared schema that will be reused
+                const dataSchema = z3.object({
+                    name: z3.string(),
+                    value: z3.number(),
+                });
+                // Use the same schema in multiple places
+                const props = z3.object({
+                    data: z3.array(dataSchema),
+                    historicalData: z3.array(dataSchema),
+                });
+                const result = handleZodSchemaToJson(props);
+                // Ensure there are no JSON Schema `$ref` keys anywhere in the produced schema.
+                expect(hasKeyDeep(result, "$ref")).toBe(false);
+                // Both arrays should have the full schema inline
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        data: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    value: { type: "number" },
+                                },
+                            },
+                        },
+                        historicalData: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    value: { type: "number" },
+                                },
+                            },
+                        },
+                    },
+                });
+            });
+            it("inlines reused Zod 4 schemas without any $ref in output", () => {
+                // Define a shared schema that will be reused
+                const dataSchema = z4.object({
+                    name: z4.string(),
+                    value: z4.number(),
+                });
+                // Use the same schema in multiple places
+                const props = z4.object({
+                    data: z4.array(dataSchema),
+                    historicalData: z4.array(dataSchema),
+                });
+                const result = handleZodSchemaToJson(props);
+                expect(hasKeyDeep(result, "$ref")).toBe(false);
+                // Both arrays should have the full schema inline
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        data: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    value: { type: "number" },
+                                },
+                            },
+                        },
+                        historicalData: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    value: { type: "number" },
+                                },
+                            },
+                        },
+                    },
+                });
+            });
+            it("handles deeply nested reused Zod 3 schemas without any $ref", () => {
+                const addressSchema = z3.object({
+                    street: z3.string(),
+                    city: z3.string(),
+                });
+                const personSchema = z3.object({
+                    name: z3.string(),
+                    homeAddress: addressSchema,
+                    workAddress: addressSchema,
+                });
+                const result = handleZodSchemaToJson(personSchema);
+                expect(hasKeyDeep(result, "$ref")).toBe(false);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        homeAddress: {
+                            type: "object",
+                            properties: {
+                                street: { type: "string" },
+                                city: { type: "string" },
+                            },
+                        },
+                        workAddress: {
+                            type: "object",
+                            properties: {
+                                street: { type: "string" },
+                                city: { type: "string" },
+                            },
+                        },
+                    },
+                });
+            });
+            it("handles deeply nested reused Zod 4 schemas without any $ref", () => {
+                const addressSchema = z4.object({
+                    street: z4.string(),
+                    city: z4.string(),
+                });
+                const personSchema = z4.object({
+                    name: z4.string(),
+                    homeAddress: addressSchema,
+                    workAddress: addressSchema,
+                });
+                const result = handleZodSchemaToJson(personSchema);
+                expect(hasKeyDeep(result, "$ref")).toBe(false);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        homeAddress: {
+                            type: "object",
+                            properties: {
+                                street: { type: "string" },
+                                city: { type: "string" },
+                            },
+                        },
+                        workAddress: {
+                            type: "object",
+                            properties: {
+                                street: { type: "string" },
+                                city: { type: "string" },
+                            },
+                        },
+                    },
+                });
+            });
+            it("handles triple-nested reused Zod 4 schemas without any $ref", () => {
+                const pointSchema = z4.object({
+                    x: z4.number(),
+                    y: z4.number(),
+                });
+                const lineSchema = z4.object({
+                    start: pointSchema,
+                    end: pointSchema,
+                });
+                const shapeSchema = z4.object({
+                    outline: z4.array(lineSchema),
+                    boundingBox: z4.object({
+                        topLeft: pointSchema,
+                        bottomRight: pointSchema,
+                    }),
+                });
+                const result = handleZodSchemaToJson(shapeSchema);
+                expect(result).toMatchInlineSnapshot(`
+          {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "additionalProperties": false,
+            "properties": {
+              "boundingBox": {
+                "additionalProperties": false,
+                "properties": {
+                  "bottomRight": {
+                    "additionalProperties": false,
+                    "properties": {
+                      "x": {
+                        "type": "number",
+                      },
+                      "y": {
+                        "type": "number",
+                      },
+                    },
+                    "required": [
+                      "x",
+                      "y",
+                    ],
+                    "type": "object",
+                  },
+                  "topLeft": {
+                    "additionalProperties": false,
+                    "properties": {
+                      "x": {
+                        "type": "number",
+                      },
+                      "y": {
+                        "type": "number",
+                      },
+                    },
+                    "required": [
+                      "x",
+                      "y",
+                    ],
+                    "type": "object",
+                  },
+                },
+                "required": [
+                  "topLeft",
+                  "bottomRight",
+                ],
+                "type": "object",
+              },
+              "outline": {
+                "items": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "end": {
+                      "additionalProperties": false,
+                      "properties": {
+                        "x": {
+                          "type": "number",
+                        },
+                        "y": {
+                          "type": "number",
+                        },
+                      },
+                      "required": [
+                        "x",
+                        "y",
+                      ],
+                      "type": "object",
+                    },
+                    "start": {
+                      "additionalProperties": false,
+                      "properties": {
+                        "x": {
+                          "type": "number",
+                        },
+                        "y": {
+                          "type": "number",
+                        },
+                      },
+                      "required": [
+                        "x",
+                        "y",
+                      ],
+                      "type": "object",
+                    },
+                  },
+                  "required": [
+                    "start",
+                    "end",
+                  ],
+                  "type": "object",
+                },
+                "type": "array",
+              },
+            },
+            "required": [
+              "outline",
+              "boundingBox",
+            ],
+            "type": "object",
+          }
+        `);
+                expect(hasKeyDeep(result, "$ref")).toBe(false);
+            });
+        });
+        describe("recursive schemas", () => {
+            it("represents Zod 4 recursive schemas using $ref", () => {
+                const nodeSchema = createRecursiveZod4NodeSchema();
+                const result = handleZodSchemaToJson(nodeSchema);
+                const schema = result;
+                const properties = schema.properties;
+                const next = properties?.next;
+                const ref = next?.$ref;
+                expect(hasKeyDeep(result, "$ref")).toBe(true);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        next: {
+                            $ref: expect.stringMatching(/^#(\/.*)?$/),
+                        },
+                    },
+                });
+                expect(ref).toEqual(expect.stringMatching(/^#(\/.*)?$/));
+                const resolved = typeof ref === "string" ? resolveJsonPointer(result, ref) : undefined;
+                expect(resolved).toBe(result);
+                expect(resolved).toMatchObject({
+                    type: "object",
+                });
+            });
+        });
+        describe("complex schemas", () => {
+            it("handles optional fields in Zod 3", () => {
+                const schema = z3.object({
+                    required: z3.string(),
+                    optional: z3.string().optional(),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        required: { type: "string" },
+                        optional: { type: "string" },
+                    },
+                    required: ["required"],
+                });
+            });
+            it("handles optional fields in Zod 4", () => {
+                const schema = z4.object({
+                    required: z4.string(),
+                    optional: z4.string().optional(),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        required: { type: "string" },
+                        optional: { type: "string" },
+                    },
+                    required: ["required"],
+                });
+            });
+            it("handles enums in Zod 3", () => {
+                const schema = z3.object({
+                    status: z3.enum(["active", "inactive", "pending"]),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        status: {
+                            type: "string",
+                            enum: ["active", "inactive", "pending"],
+                        },
+                    },
+                });
+            });
+            it("handles enums in Zod 4", () => {
+                const schema = z4.object({
+                    status: z4.enum(["active", "inactive", "pending"]),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        status: {
+                            type: "string",
+                            enum: ["active", "inactive", "pending"],
+                        },
+                    },
+                });
+            });
+            it("handles descriptions in Zod 3", () => {
+                const schema = z3.object({
+                    name: z3.string().describe("The user name"),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "The user name",
+                        },
+                    },
+                });
+            });
+            it("handles descriptions in Zod 4", () => {
+                const schema = z4.object({
+                    name: z4.string().describe("The user name"),
+                });
+                const result = handleZodSchemaToJson(schema);
+                expect(result).toMatchObject({
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "The user name",
+                        },
+                    },
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=zod.test.js.map