@langchain/core 0.3.43 → 0.3.44

package/dist/utils/json_schema.js

@@ -1 +1,80 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { dereference } from "@cfworker/json-schema";
+import { isZodSchema } from "./types/is_zod_schema.js";
 export { deepCompareStrict, Validator } from "@cfworker/json-schema";
+/**
+ * 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 (isZodSchema(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;
+}

package/dist/utils/types/is_zod_schema.cjs

@@ -1,16 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isZodSchema = void 0;
+const zod_1 = require("zod");
 /**
  * Given either a Zod schema, or plain object, determine if the input is a Zod schema.
  *
- * @param {z.ZodType<RunOutput> | Record<string, any>} input
+ * @param {z.ZodType<RunOutput> | Record<string, unknown>} input
  * @returns {boolean} Whether or not the provided input is a Zod schema.
  */
-function isZodSchema(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input) {
-    // Check for a characteristic method of Zod schemas
-    return typeof input?.parse === "function";
+function isZodSchema(input) {
+    if (!input) {
+        return false;
+    }
+    if (typeof input !== "object") {
+        return false;
+    }
+    if (Array.isArray(input)) {
+        return false;
+    }
+    const asZodSchema = input;
+    // relies on an internal property of Zod schemas, so this may break in the future, hence the
+    // additional fallback checks below
+    if (asZodSchema._def) {
+        return true;
+    }
+    const zodFirstPartyTypeKinds = Object.values(zod_1.z.ZodFirstPartyTypeKind);
+    if (zodFirstPartyTypeKinds.includes(asZodSchema.constructor?.name ?? "NOT_INCLUDED")) {
+        return true;
+    }
+    // if all else fails, assume based on the presence of parse, parseAsync, safeParse, and
+    // safeParseAsync, as these are characteristic of Zod schemas
+    return (typeof asZodSchema.parse === "function" &&
+        typeof asZodSchema.parseAsync === "function" &&
+        typeof asZodSchema.safeParse === "function" &&
+        typeof asZodSchema.safeParseAsync === "function");
 }
 exports.isZodSchema = isZodSchema;

package/dist/utils/types/is_zod_schema.d.ts

@@ -1,8 +1,8 @@
-import { type z } from "zod";
+import { z } from "zod";
 /**
  * Given either a Zod schema, or plain object, determine if the input is a Zod schema.
  *
- * @param {z.ZodType<RunOutput> | Record<string, any>} input
+ * @param {z.ZodType<RunOutput> | Record<string, unknown>} input
  * @returns {boolean} Whether or not the provided input is a Zod schema.
  */
-export declare function isZodSchema<RunOutput extends Record<string, any> = Record<string, any>>(input: z.ZodType<RunOutput> | Record<string, any>): input is z.ZodType<RunOutput>;
+export declare function isZodSchema<RunOutput extends Record<string, unknown> = Record<string, unknown>>(input: z.ZodType<RunOutput> | Record<string, unknown>): input is z.ZodType<RunOutput>;

package/dist/utils/types/is_zod_schema.js

@@ -1,12 +1,34 @@
+import { z } from "zod";
 /**
  * Given either a Zod schema, or plain object, determine if the input is a Zod schema.
  *
- * @param {z.ZodType<RunOutput> | Record<string, any>} input
+ * @param {z.ZodType<RunOutput> | Record<string, unknown>} input
  * @returns {boolean} Whether or not the provided input is a Zod schema.
  */
-export function isZodSchema(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input) {
-    // Check for a characteristic method of Zod schemas
-    return typeof input?.parse === "function";
+export function isZodSchema(input) {
+    if (!input) {
+        return false;
+    }
+    if (typeof input !== "object") {
+        return false;
+    }
+    if (Array.isArray(input)) {
+        return false;
+    }
+    const asZodSchema = input;
+    // relies on an internal property of Zod schemas, so this may break in the future, hence the
+    // additional fallback checks below
+    if (asZodSchema._def) {
+        return true;
+    }
+    const zodFirstPartyTypeKinds = Object.values(z.ZodFirstPartyTypeKind);
+    if (zodFirstPartyTypeKinds.includes(asZodSchema.constructor?.name ?? "NOT_INCLUDED")) {
+        return true;
+    }
+    // if all else fails, assume based on the presence of parse, parseAsync, safeParse, and
+    // safeParseAsync, as these are characteristic of Zod schemas
+    return (typeof asZodSchema.parse === "function" &&
+        typeof asZodSchema.parseAsync === "function" &&
+        typeof asZodSchema.safeParse === "function" &&
+        typeof asZodSchema.safeParseAsync === "function");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.43",
+  "version": "0.3.44",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {