@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/utils/json_schema.cjs

@@ -1,98 +1,83 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = exports.deepCompareStrict = void 0;
-exports.toJsonSchema = toJsonSchema;
-exports.validatesOnlyStrings = validatesOnlyStrings;
-const core_1 = require("zod/v4/core");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const json_schema_1 = require("@cfworker/json-schema");
-const zod_js_1 = require("./types/zod.cjs");
-var json_schema_2 = require("@cfworker/json-schema");
-Object.defineProperty(exports, "deepCompareStrict", { enumerable: true, get: function () { return json_schema_2.deepCompareStrict; } });
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return json_schema_2.Validator; } });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_zod = require('./types/zod.cjs');
+const zod_v4_core = require_rolldown_runtime.__toESM(require("zod/v4/core"));
+const zod_to_json_schema = require_rolldown_runtime.__toESM(require("zod-to-json-schema"));
+const __cfworker_json_schema = require_rolldown_runtime.__toESM(require("@cfworker/json-schema"));
+
+//#region src/utils/json_schema.ts
+var json_schema_exports = {};
+require_rolldown_runtime.__export(json_schema_exports, {
+	Validator: () => __cfworker_json_schema.Validator,
+	deepCompareStrict: () => __cfworker_json_schema.deepCompareStrict,
+	toJsonSchema: () => toJsonSchema,
+	validatesOnlyStrings: () => validatesOnlyStrings
+});
 /**
- * Converts a Zod schema or JSON schema to a JSON schema.
- * @param schema - The schema to convert.
- * @returns The converted schema.
- */
+* Converts a Zod schema or JSON schema to a JSON schema.
+* @param schema - The schema to convert.
+* @returns The converted schema.
+*/
 function toJsonSchema(schema) {
-    if ((0, zod_js_1.isZodSchemaV4)(schema)) {
-        const inputSchema = (0, zod_js_1.interopZodTransformInputSchema)(schema, true);
-        if ((0, zod_js_1.isZodObjectV4)(inputSchema)) {
-            const strictSchema = (0, zod_js_1.interopZodObjectStrict)(inputSchema, true);
-            return (0, core_1.toJSONSchema)(strictSchema);
-        }
-        else {
-            return (0, core_1.toJSONSchema)(schema);
-        }
-    }
-    if ((0, zod_js_1.isZodSchemaV3)(schema)) {
-        return (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
-    }
-    return schema;
+	if (require_zod.isZodSchemaV4(schema)) {
+		const inputSchema = require_zod.interopZodTransformInputSchema(schema, true);
+		if (require_zod.isZodObjectV4(inputSchema)) {
+			const strictSchema = require_zod.interopZodObjectStrict(inputSchema, true);
+			return (0, zod_v4_core.toJSONSchema)(strictSchema);
+		} else return (0, zod_v4_core.toJSONSchema)(schema);
+	}
+	if (require_zod.isZodSchemaV3(schema)) return (0, zod_to_json_schema.zodToJsonSchema)(schema);
+	return schema;
 }
 /**
- * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
- * (like recursive or unresolvable refs).
- *
- * @param schema - The schema to validate.
- * @returns `true` if the schema validates only strings, `false` otherwise.
- */
+* Validates if a JSON schema validates only strings. May return false negatives in some edge cases
+* (like recursive or unresolvable refs).
+*
+* @param schema - The schema to validate.
+* @returns `true` if the schema validates only strings, `false` otherwise.
+*/
 function validatesOnlyStrings(schema) {
-    // Null, undefined, or empty schema
-    if (!schema ||
-        typeof schema !== "object" ||
-        Object.keys(schema).length === 0 ||
-        Array.isArray(schema)) {
-        return false; // Validates anything, not just strings
-    }
-    // Explicit type constraint
-    if ("type" in schema) {
-        if (typeof schema.type === "string") {
-            return schema.type === "string";
-        }
-        if (Array.isArray(schema.type)) {
-            // not sure why someone would do `"type": ["string"]` or especially `"type": ["string",
-            // "string", "string", ...]` but we're not here to judge
-            return schema.type.every((t) => t === "string");
-        }
-        return false; // Invalid or non-string type
-    }
-    // Enum with only string values
-    if ("enum" in schema) {
-        return (Array.isArray(schema.enum) &&
-            schema.enum.length > 0 &&
-            schema.enum.every((val) => typeof val === "string"));
-    }
-    // String constant
-    if ("const" in schema) {
-        return typeof schema.const === "string";
-    }
-    // Schema combinations
-    if ("allOf" in schema && Array.isArray(schema.allOf)) {
-        // If any subschema validates only strings, then the overall schema validates only strings
-        return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
-    }
-    if (("anyOf" in schema && Array.isArray(schema.anyOf)) ||
-        ("oneOf" in schema && Array.isArray(schema.oneOf))) {
-        const subschemas = ("anyOf" in schema ? schema.anyOf : schema.oneOf);
-        // All subschemas must validate only strings
-        return (subschemas.length > 0 &&
-            subschemas.every((subschema) => validatesOnlyStrings(subschema)));
-    }
-    // We're not going to try on this one, it's too complex - we just assume if it has a "not" key and hasn't matched one of the above checks, it's not a string schema.
-    if ("not" in schema) {
-        return false; // The not case can validate non-strings
-    }
-    if ("$ref" in schema && typeof schema.$ref === "string") {
-        const ref = schema.$ref;
-        const resolved = (0, json_schema_1.dereference)(schema);
-        if (resolved[ref]) {
-            return validatesOnlyStrings(resolved[ref]);
-        }
-        return false;
-    }
-    // ignore recursive refs and other cases where type is omitted for now
-    // ignore other cases for now where type is omitted
-    return false;
+	if (!schema || typeof schema !== "object" || Object.keys(schema).length === 0 || Array.isArray(schema)) return false;
+	if ("type" in schema) {
+		if (typeof schema.type === "string") return schema.type === "string";
+		if (Array.isArray(schema.type)) return schema.type.every((t) => t === "string");
+		return false;
+	}
+	if ("enum" in schema) return Array.isArray(schema.enum) && schema.enum.length > 0 && schema.enum.every((val) => typeof val === "string");
+	if ("const" in schema) return typeof schema.const === "string";
+	if ("allOf" in schema && Array.isArray(schema.allOf)) return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
+	if ("anyOf" in schema && Array.isArray(schema.anyOf) || "oneOf" in schema && Array.isArray(schema.oneOf)) {
+		const subschemas = "anyOf" in schema ? schema.anyOf : schema.oneOf;
+		return subschemas.length > 0 && subschemas.every((subschema) => validatesOnlyStrings(subschema));
+	}
+	if ("not" in schema) return false;
+	if ("$ref" in schema && typeof schema.$ref === "string") {
+		const ref = schema.$ref;
+		const resolved = (0, __cfworker_json_schema.dereference)(schema);
+		if (resolved[ref]) return validatesOnlyStrings(resolved[ref]);
+		return false;
+	}
+	return false;
 }
+
+//#endregion
+Object.defineProperty(exports, 'Validator', {
+  enumerable: true,
+  get: function () {
+    return __cfworker_json_schema.Validator;
+  }
+});
+Object.defineProperty(exports, 'deepCompareStrict', {
+  enumerable: true,
+  get: function () {
+    return __cfworker_json_schema.deepCompareStrict;
+  }
+});
+Object.defineProperty(exports, 'json_schema_exports', {
+  enumerable: true,
+  get: function () {
+    return json_schema_exports;
+  }
+});
+exports.toJsonSchema = toJsonSchema;
+exports.validatesOnlyStrings = validatesOnlyStrings;
+//# sourceMappingURL=json_schema.cjs.map

package/dist/utils/json_schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema.cjs","names":["schema: InteropZodType | JSONSchema","isZodSchemaV4","interopZodTransformInputSchema","isZodObjectV4","interopZodObjectStrict","isZodSchemaV3","schema: unknown"],"sources":["../../src/utils/json_schema.ts"],"sourcesContent":["import { toJSONSchema } from \"zod/v4/core\";\nimport {\n  type JsonSchema7Type as JSONSchema,\n  zodToJsonSchema,\n} from \"zod-to-json-schema\";\nimport { dereference, type Schema } from \"@cfworker/json-schema\";\nimport {\n  isZodSchemaV3,\n  isZodSchemaV4,\n  InteropZodType,\n  interopZodObjectStrict,\n  isZodObjectV4,\n  ZodObjectV4,\n  interopZodTransformInputSchema,\n} from \"./types/zod.js\";\n\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @returns The converted schema.\n */\nexport function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema {\n  if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(\n        inputSchema,\n        true\n      ) as ZodObjectV4;\n      return toJSONSchema(strictSchema);\n    } else {\n      return toJSONSchema(schema);\n    }\n  }\n  if (isZodSchemaV3(schema)) {\n    return zodToJsonSchema(schema);\n  }\n  return schema as JSONSchema;\n}\n\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport function validatesOnlyStrings(schema: unknown): boolean {\n  // Null, undefined, or empty schema\n  if (\n    !schema ||\n    typeof schema !== \"object\" ||\n    Object.keys(schema).length === 0 ||\n    Array.isArray(schema)\n  ) {\n    return false; // Validates anything, not just strings\n  }\n\n  // Explicit type constraint\n  if (\"type\" in schema) {\n    if (typeof schema.type === \"string\") {\n      return schema.type === \"string\";\n    }\n\n    if (Array.isArray(schema.type)) {\n      // not sure why someone would do `\"type\": [\"string\"]` or especially `\"type\": [\"string\",\n      // \"string\", \"string\", ...]` but we're not here to judge\n      return schema.type.every((t) => t === \"string\");\n    }\n    return false; // Invalid or non-string type\n  }\n\n  // Enum with only string values\n  if (\"enum\" in schema) {\n    return (\n      Array.isArray(schema.enum) &&\n      schema.enum.length > 0 &&\n      schema.enum.every((val) => typeof val === \"string\")\n    );\n  }\n\n  // String constant\n  if (\"const\" in schema) {\n    return typeof schema.const === \"string\";\n  }\n\n  // Schema combinations\n  if (\"allOf\" in schema && Array.isArray(schema.allOf)) {\n    // If any subschema validates only strings, then the overall schema validates only strings\n    return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));\n  }\n\n  if (\n    (\"anyOf\" in schema && Array.isArray(schema.anyOf)) ||\n    (\"oneOf\" in schema && Array.isArray(schema.oneOf))\n  ) {\n    const subschemas = (\n      \"anyOf\" in schema ? schema.anyOf : schema.oneOf\n    ) as unknown[];\n\n    // All subschemas must validate only strings\n    return (\n      subschemas.length > 0 &&\n      subschemas.every((subschema) => validatesOnlyStrings(subschema))\n    );\n  }\n\n  // We're not going to try on this one, it's too complex - we just assume if it has a \"not\" key and hasn't matched one of the above checks, it's not a string schema.\n  if (\"not\" in schema) {\n    return false; // The not case can validate non-strings\n  }\n\n  if (\"$ref\" in schema && typeof schema.$ref === \"string\") {\n    const ref = schema.$ref as string;\n    const resolved = dereference(schema as Schema);\n    if (resolved[ref]) {\n      return validatesOnlyStrings(resolved[ref]);\n    }\n    return false;\n  }\n\n  // ignore recursive refs and other cases where type is omitted for now\n  // ignore other cases for now where type is omitted\n\n  return false;\n}\n\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\n\nexport {\n  type JsonSchema7Type,\n  type JsonSchema7Type as JSONSchema,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"zod-to-json-schema\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,aAAaA,QAAiD;AAC5E,KAAIC,0BAAc,OAAO,EAAE;EACzB,MAAM,cAAcC,2CAA+B,QAAQ,KAAK;AAChE,MAAIC,0BAAc,YAAY,EAAE;GAC9B,MAAM,eAAeC,mCACnB,aACA,KACD;AACD,wCAAoB,aAAa;EAClC,MACC,sCAAoB,OAAO;CAE9B;AACD,KAAIC,0BAAc,OAAO,CACvB,gDAAuB,OAAO;AAEhC,QAAO;AACR;;;;;;;;AASD,SAAgB,qBAAqBC,QAA0B;AAE7D,KACE,CAAC,UACD,OAAO,WAAW,YAClB,OAAO,KAAK,OAAO,CAAC,WAAW,KAC/B,MAAM,QAAQ,OAAO,CAErB,QAAO;AAIT,KAAI,UAAU,QAAQ;AACpB,MAAI,OAAO,OAAO,SAAS,SACzB,QAAO,OAAO,SAAS;AAGzB,MAAI,MAAM,QAAQ,OAAO,KAAK,CAG5B,QAAO,OAAO,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS;AAEjD,SAAO;CACR;AAGD,KAAI,UAAU,OACZ,QACE,MAAM,QAAQ,OAAO,KAAK,IAC1B,OAAO,KAAK,SAAS,KACrB,OAAO,KAAK,MAAM,CAAC,QAAQ,OAAO,QAAQ,SAAS;AAKvD,KAAI,WAAW,OACb,QAAO,OAAO,OAAO,UAAU;AAIjC,KAAI,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,CAElD,QAAO,OAAO,MAAM,KAAK,CAAC,cAAc,qBAAqB,UAAU,CAAC;AAG1E,KACG,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,IAChD,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,EACjD;EACA,MAAM,aACJ,WAAW,SAAS,OAAO,QAAQ,OAAO;AAI5C,SACE,WAAW,SAAS,KACpB,WAAW,MAAM,CAAC,cAAc,qBAAqB,UAAU,CAAC;CAEnE;AAGD,KAAI,SAAS,OACX,QAAO;AAGT,KAAI,UAAU,UAAU,OAAO,OAAO,SAAS,UAAU;EACvD,MAAM,MAAM,OAAO;EACnB,MAAM,mDAAuB,OAAiB;AAC9C,MAAI,SAAS,KACX,QAAO,qBAAqB,SAAS,KAAK;AAE5C,SAAO;CACR;AAKD,QAAO;AACR"}

package/dist/utils/json_schema.d.cts

@@ -0,0 +1,28 @@
+import { InteropZodType } from "./types/zod.cjs";
+import { JsonSchema7ArrayType, JsonSchema7NullableType, JsonSchema7NumberType, JsonSchema7ObjectType, JsonSchema7StringType, JsonSchema7Type, JsonSchema7Type as JSONSchema, JsonSchema7Type as JsonSchema7Type$1 } from "zod-to-json-schema";
+import { Validator, deepCompareStrict } from "@cfworker/json-schema";
+
+//#region src/utils/json_schema.d.ts
+
+/**
+ * Converts a Zod schema or JSON schema to a JSON schema.
+ * @param schema - The schema to convert.
+ * @returns The converted schema.
+ */
+declare function toJsonSchema(schema: InteropZodType | JsonSchema7Type$1): JsonSchema7Type$1;
+/**
+ * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
+ * (like recursive or unresolvable refs).
+ *
+ * @param schema - The schema to validate.
+ * @returns `true` if the schema validates only strings, `false` otherwise.
+ */
+declare function validatesOnlyStrings(schema: unknown): boolean;
+// Re-export of the types used throughout langchain for json schema serialization.
+// The plan is to eventually nix zod-to-json-schema altogether in place for
+// zod v4 / a more standardized way of serializing validated inputs, so its re-exported
+// here to remove the dependency on zod-to-json-schema in downstream packages until
+// a determination is made.
+//#endregion
+export { type JSONSchema, type JsonSchema7ArrayType, type JsonSchema7NullableType, type JsonSchema7NumberType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7Type, Validator, deepCompareStrict, toJsonSchema, validatesOnlyStrings };
+//# sourceMappingURL=json_schema.d.cts.map

package/dist/utils/json_schema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema.d.cts","names":["JsonSchema7Type","JSONSchema","InteropZodType","deepCompareStrict","Validator","toJsonSchema","validatesOnlyStrings","JsonSchema7ArrayType","JsonSchema7ObjectType","JsonSchema7StringType","JsonSchema7NumberType","JsonSchema7NullableType"],"sources":["../../src/utils/json_schema.d.ts"],"sourcesContent":["import { type JsonSchema7Type as JSONSchema } from \"zod-to-json-schema\";\nimport { InteropZodType } from \"./types/zod.js\";\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @returns The converted schema.\n */\nexport declare function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema;\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport declare function validatesOnlyStrings(schema: unknown): boolean;\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\nexport { type JsonSchema7Type, type JsonSchema7Type as JSONSchema, type JsonSchema7ArrayType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7NumberType, type JsonSchema7NullableType, } from \"zod-to-json-schema\";\n"],"mappings":";;;;;;;;AAQA;;;AAA8DC,iBAAtCI,YAAAA,CAAsCJ,MAAAA,EAAjBC,cAAiBD,GAAAA,iBAAAA,CAAAA,EAAaA,iBAAbA;;AAAuB;AAQrF;;;;;iBAAwBK,oBAAAA"}

package/dist/utils/json_schema.d.ts

@@ -1,13 +1,15 @@
-import { type JsonSchema7Type } from "zod-to-json-schema";
 import { InteropZodType } from "./types/zod.js";
-export type JSONSchema = JsonSchema7Type;
-export { deepCompareStrict, Validator } from "@cfworker/json-schema";
+import { JsonSchema7ArrayType, JsonSchema7NullableType, JsonSchema7NumberType, JsonSchema7ObjectType, JsonSchema7StringType, JsonSchema7Type, JsonSchema7Type as JSONSchema, JsonSchema7Type as JsonSchema7Type$1 } from "zod-to-json-schema";
+import { Validator, deepCompareStrict } from "@cfworker/json-schema";
+
+//#region src/utils/json_schema.d.ts
+
 /**
  * Converts a Zod schema or JSON schema to a JSON schema.
  * @param schema - The schema to convert.
  * @returns The converted schema.
  */
-export declare function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema;
+declare function toJsonSchema(schema: InteropZodType | JsonSchema7Type$1): JsonSchema7Type$1;
 /**
  * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
  * (like recursive or unresolvable refs).
@@ -15,5 +17,12 @@ export declare function toJsonSchema(schema: InteropZodType | JSONSchema): JSONS
  * @param schema - The schema to validate.
  * @returns `true` if the schema validates only strings, `false` otherwise.
  */
-export declare function validatesOnlyStrings(schema: unknown): boolean;
-export { type JsonSchema7Type, type JsonSchema7ArrayType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7NumberType, type JsonSchema7NullableType, } from "zod-to-json-schema";
+declare function validatesOnlyStrings(schema: unknown): boolean;
+// Re-export of the types used throughout langchain for json schema serialization.
+// The plan is to eventually nix zod-to-json-schema altogether in place for
+// zod v4 / a more standardized way of serializing validated inputs, so its re-exported
+// here to remove the dependency on zod-to-json-schema in downstream packages until
+// a determination is made.
+//#endregion
+export { type JSONSchema, type JsonSchema7ArrayType, type JsonSchema7NullableType, type JsonSchema7NumberType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7Type, Validator, deepCompareStrict, toJsonSchema, validatesOnlyStrings };
+//# sourceMappingURL=json_schema.d.ts.map

package/dist/utils/json_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema.d.ts","names":["JsonSchema7Type","JSONSchema","InteropZodType","deepCompareStrict","Validator","toJsonSchema","validatesOnlyStrings","JsonSchema7ArrayType","JsonSchema7ObjectType","JsonSchema7StringType","JsonSchema7NumberType","JsonSchema7NullableType"],"sources":["../../src/utils/json_schema.d.ts"],"sourcesContent":["import { type JsonSchema7Type as JSONSchema } from \"zod-to-json-schema\";\nimport { InteropZodType } from \"./types/zod.js\";\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @returns The converted schema.\n */\nexport declare function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema;\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport declare function validatesOnlyStrings(schema: unknown): boolean;\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\nexport { type JsonSchema7Type, type JsonSchema7Type as JSONSchema, type JsonSchema7ArrayType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7NumberType, type JsonSchema7NullableType, } from \"zod-to-json-schema\";\n"],"mappings":";;;;;;;;AAQA;;;AAA8DC,iBAAtCI,YAAAA,CAAsCJ,MAAAA,EAAjBC,cAAiBD,GAAAA,iBAAAA,CAAAA,EAAaA,iBAAbA;;AAAuB;AAQrF;;;;;iBAAwBK,oBAAAA"}

package/dist/utils/json_schema.js

@@ -1,91 +1,64 @@
+import { __export } from "../_virtual/rolldown_runtime.js";
+import { interopZodObjectStrict, interopZodTransformInputSchema, isZodObjectV4, isZodSchemaV3, isZodSchemaV4 } from "./types/zod.js";
 import { toJSONSchema } from "zod/v4/core";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { dereference } from "@cfworker/json-schema";
-import { isZodSchemaV3, isZodSchemaV4, interopZodObjectStrict, isZodObjectV4, interopZodTransformInputSchema, } from "./types/zod.js";
-export { deepCompareStrict, Validator } from "@cfworker/json-schema";
+import { Validator, deepCompareStrict, dereference } from "@cfworker/json-schema";
+
+//#region src/utils/json_schema.ts
+var json_schema_exports = {};
+__export(json_schema_exports, {
+	Validator: () => Validator,
+	deepCompareStrict: () => deepCompareStrict,
+	toJsonSchema: () => toJsonSchema,
+	validatesOnlyStrings: () => validatesOnlyStrings
+});
 /**
- * Converts a Zod schema or JSON schema to a JSON schema.
- * @param schema - The schema to convert.
- * @returns The converted schema.
- */
-export function toJsonSchema(schema) {
-    if (isZodSchemaV4(schema)) {
-        const inputSchema = interopZodTransformInputSchema(schema, true);
-        if (isZodObjectV4(inputSchema)) {
-            const strictSchema = interopZodObjectStrict(inputSchema, true);
-            return toJSONSchema(strictSchema);
-        }
-        else {
-            return toJSONSchema(schema);
-        }
-    }
-    if (isZodSchemaV3(schema)) {
-        return zodToJsonSchema(schema);
-    }
-    return schema;
+* Converts a Zod schema or JSON schema to a JSON schema.
+* @param schema - The schema to convert.
+* @returns The converted schema.
+*/
+function toJsonSchema(schema) {
+	if (isZodSchemaV4(schema)) {
+		const inputSchema = interopZodTransformInputSchema(schema, true);
+		if (isZodObjectV4(inputSchema)) {
+			const strictSchema = interopZodObjectStrict(inputSchema, true);
+			return toJSONSchema(strictSchema);
+		} else return toJSONSchema(schema);
+	}
+	if (isZodSchemaV3(schema)) return zodToJsonSchema(schema);
+	return schema;
 }
 /**
- * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
- * (like recursive or unresolvable refs).
- *
- * @param schema - The schema to validate.
- * @returns `true` if the schema validates only strings, `false` otherwise.
- */
-export function validatesOnlyStrings(schema) {
-    // Null, undefined, or empty schema
-    if (!schema ||
-        typeof schema !== "object" ||
-        Object.keys(schema).length === 0 ||
-        Array.isArray(schema)) {
-        return false; // Validates anything, not just strings
-    }
-    // Explicit type constraint
-    if ("type" in schema) {
-        if (typeof schema.type === "string") {
-            return schema.type === "string";
-        }
-        if (Array.isArray(schema.type)) {
-            // not sure why someone would do `"type": ["string"]` or especially `"type": ["string",
-            // "string", "string", ...]` but we're not here to judge
-            return schema.type.every((t) => t === "string");
-        }
-        return false; // Invalid or non-string type
-    }
-    // Enum with only string values
-    if ("enum" in schema) {
-        return (Array.isArray(schema.enum) &&
-            schema.enum.length > 0 &&
-            schema.enum.every((val) => typeof val === "string"));
-    }
-    // String constant
-    if ("const" in schema) {
-        return typeof schema.const === "string";
-    }
-    // Schema combinations
-    if ("allOf" in schema && Array.isArray(schema.allOf)) {
-        // If any subschema validates only strings, then the overall schema validates only strings
-        return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
-    }
-    if (("anyOf" in schema && Array.isArray(schema.anyOf)) ||
-        ("oneOf" in schema && Array.isArray(schema.oneOf))) {
-        const subschemas = ("anyOf" in schema ? schema.anyOf : schema.oneOf);
-        // All subschemas must validate only strings
-        return (subschemas.length > 0 &&
-            subschemas.every((subschema) => validatesOnlyStrings(subschema)));
-    }
-    // We're not going to try on this one, it's too complex - we just assume if it has a "not" key and hasn't matched one of the above checks, it's not a string schema.
-    if ("not" in schema) {
-        return false; // The not case can validate non-strings
-    }
-    if ("$ref" in schema && typeof schema.$ref === "string") {
-        const ref = schema.$ref;
-        const resolved = dereference(schema);
-        if (resolved[ref]) {
-            return validatesOnlyStrings(resolved[ref]);
-        }
-        return false;
-    }
-    // ignore recursive refs and other cases where type is omitted for now
-    // ignore other cases for now where type is omitted
-    return false;
+* Validates if a JSON schema validates only strings. May return false negatives in some edge cases
+* (like recursive or unresolvable refs).
+*
+* @param schema - The schema to validate.
+* @returns `true` if the schema validates only strings, `false` otherwise.
+*/
+function validatesOnlyStrings(schema) {
+	if (!schema || typeof schema !== "object" || Object.keys(schema).length === 0 || Array.isArray(schema)) return false;
+	if ("type" in schema) {
+		if (typeof schema.type === "string") return schema.type === "string";
+		if (Array.isArray(schema.type)) return schema.type.every((t) => t === "string");
+		return false;
+	}
+	if ("enum" in schema) return Array.isArray(schema.enum) && schema.enum.length > 0 && schema.enum.every((val) => typeof val === "string");
+	if ("const" in schema) return typeof schema.const === "string";
+	if ("allOf" in schema && Array.isArray(schema.allOf)) return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
+	if ("anyOf" in schema && Array.isArray(schema.anyOf) || "oneOf" in schema && Array.isArray(schema.oneOf)) {
+		const subschemas = "anyOf" in schema ? schema.anyOf : schema.oneOf;
+		return subschemas.length > 0 && subschemas.every((subschema) => validatesOnlyStrings(subschema));
+	}
+	if ("not" in schema) return false;
+	if ("$ref" in schema && typeof schema.$ref === "string") {
+		const ref = schema.$ref;
+		const resolved = dereference(schema);
+		if (resolved[ref]) return validatesOnlyStrings(resolved[ref]);
+		return false;
+	}
+	return false;
 }
+
+//#endregion
+export { Validator, deepCompareStrict, json_schema_exports, toJsonSchema, validatesOnlyStrings };
+//# sourceMappingURL=json_schema.js.map

package/dist/utils/json_schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema.js","names":["schema: InteropZodType | JSONSchema","schema: unknown"],"sources":["../../src/utils/json_schema.ts"],"sourcesContent":["import { toJSONSchema } from \"zod/v4/core\";\nimport {\n  type JsonSchema7Type as JSONSchema,\n  zodToJsonSchema,\n} from \"zod-to-json-schema\";\nimport { dereference, type Schema } from \"@cfworker/json-schema\";\nimport {\n  isZodSchemaV3,\n  isZodSchemaV4,\n  InteropZodType,\n  interopZodObjectStrict,\n  isZodObjectV4,\n  ZodObjectV4,\n  interopZodTransformInputSchema,\n} from \"./types/zod.js\";\n\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @returns The converted schema.\n */\nexport function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema {\n  if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(\n        inputSchema,\n        true\n      ) as ZodObjectV4;\n      return toJSONSchema(strictSchema);\n    } else {\n      return toJSONSchema(schema);\n    }\n  }\n  if (isZodSchemaV3(schema)) {\n    return zodToJsonSchema(schema);\n  }\n  return schema as JSONSchema;\n}\n\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport function validatesOnlyStrings(schema: unknown): boolean {\n  // Null, undefined, or empty schema\n  if (\n    !schema ||\n    typeof schema !== \"object\" ||\n    Object.keys(schema).length === 0 ||\n    Array.isArray(schema)\n  ) {\n    return false; // Validates anything, not just strings\n  }\n\n  // Explicit type constraint\n  if (\"type\" in schema) {\n    if (typeof schema.type === \"string\") {\n      return schema.type === \"string\";\n    }\n\n    if (Array.isArray(schema.type)) {\n      // not sure why someone would do `\"type\": [\"string\"]` or especially `\"type\": [\"string\",\n      // \"string\", \"string\", ...]` but we're not here to judge\n      return schema.type.every((t) => t === \"string\");\n    }\n    return false; // Invalid or non-string type\n  }\n\n  // Enum with only string values\n  if (\"enum\" in schema) {\n    return (\n      Array.isArray(schema.enum) &&\n      schema.enum.length > 0 &&\n      schema.enum.every((val) => typeof val === \"string\")\n    );\n  }\n\n  // String constant\n  if (\"const\" in schema) {\n    return typeof schema.const === \"string\";\n  }\n\n  // Schema combinations\n  if (\"allOf\" in schema && Array.isArray(schema.allOf)) {\n    // If any subschema validates only strings, then the overall schema validates only strings\n    return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));\n  }\n\n  if (\n    (\"anyOf\" in schema && Array.isArray(schema.anyOf)) ||\n    (\"oneOf\" in schema && Array.isArray(schema.oneOf))\n  ) {\n    const subschemas = (\n      \"anyOf\" in schema ? schema.anyOf : schema.oneOf\n    ) as unknown[];\n\n    // All subschemas must validate only strings\n    return (\n      subschemas.length > 0 &&\n      subschemas.every((subschema) => validatesOnlyStrings(subschema))\n    );\n  }\n\n  // We're not going to try on this one, it's too complex - we just assume if it has a \"not\" key and hasn't matched one of the above checks, it's not a string schema.\n  if (\"not\" in schema) {\n    return false; // The not case can validate non-strings\n  }\n\n  if (\"$ref\" in schema && typeof schema.$ref === \"string\") {\n    const ref = schema.$ref as string;\n    const resolved = dereference(schema as Schema);\n    if (resolved[ref]) {\n      return validatesOnlyStrings(resolved[ref]);\n    }\n    return false;\n  }\n\n  // ignore recursive refs and other cases where type is omitted for now\n  // ignore other cases for now where type is omitted\n\n  return false;\n}\n\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\n\nexport {\n  type JsonSchema7Type,\n  type JsonSchema7Type as JSONSchema,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"zod-to-json-schema\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,aAAaA,QAAiD;AAC5E,KAAI,cAAc,OAAO,EAAE;EACzB,MAAM,cAAc,+BAA+B,QAAQ,KAAK;AAChE,MAAI,cAAc,YAAY,EAAE;GAC9B,MAAM,eAAe,uBACnB,aACA,KACD;AACD,UAAO,aAAa,aAAa;EAClC,MACC,QAAO,aAAa,OAAO;CAE9B;AACD,KAAI,cAAc,OAAO,CACvB,QAAO,gBAAgB,OAAO;AAEhC,QAAO;AACR;;;;;;;;AASD,SAAgB,qBAAqBC,QAA0B;AAE7D,KACE,CAAC,UACD,OAAO,WAAW,YAClB,OAAO,KAAK,OAAO,CAAC,WAAW,KAC/B,MAAM,QAAQ,OAAO,CAErB,QAAO;AAIT,KAAI,UAAU,QAAQ;AACpB,MAAI,OAAO,OAAO,SAAS,SACzB,QAAO,OAAO,SAAS;AAGzB,MAAI,MAAM,QAAQ,OAAO,KAAK,CAG5B,QAAO,OAAO,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS;AAEjD,SAAO;CACR;AAGD,KAAI,UAAU,OACZ,QACE,MAAM,QAAQ,OAAO,KAAK,IAC1B,OAAO,KAAK,SAAS,KACrB,OAAO,KAAK,MAAM,CAAC,QAAQ,OAAO,QAAQ,SAAS;AAKvD,KAAI,WAAW,OACb,QAAO,OAAO,OAAO,UAAU;AAIjC,KAAI,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,CAElD,QAAO,OAAO,MAAM,KAAK,CAAC,cAAc,qBAAqB,UAAU,CAAC;AAG1E,KACG,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,IAChD,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,EACjD;EACA,MAAM,aACJ,WAAW,SAAS,OAAO,QAAQ,OAAO;AAI5C,SACE,WAAW,SAAS,KACpB,WAAW,MAAM,CAAC,cAAc,qBAAqB,UAAU,CAAC;CAEnE;AAGD,KAAI,SAAS,OACX,QAAO;AAGT,KAAI,UAAU,UAAU,OAAO,OAAO,SAAS,UAAU;EACvD,MAAM,MAAM,OAAO;EACnB,MAAM,WAAW,YAAY,OAAiB;AAC9C,MAAI,SAAS,KACX,QAAO,qBAAqB,SAAS,KAAK;AAE5C,SAAO;CACR;AAKD,QAAO;AACR"}