@langchain/core 0.3.59 → 0.3.60

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

@@ -22,6 +22,9 @@ export type InferInteropZodOutput<T> = T extends z3.ZodType<infer Output, z3.Zod
         output: infer Output;
     };
 } ? Output : never;
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
 export declare function isZodSchemaV4(schema: unknown): schema is z4.$ZodType<unknown, unknown>;
 export declare function isZodSchemaV3(schema: unknown): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown>;
 /** Backward compatible isZodSchema for Zod 3 */
@@ -122,6 +125,9 @@ export declare function isShapelessZodSchema(schema: unknown): boolean;
  * @returns {boolean} True if the schema is a basic ZodString, false otherwise.
  */
 export declare function isSimpleStringZodSchema(schema: unknown): schema is InteropZodType<string | undefined>;
+export declare function isZodObjectV3(obj: unknown): obj is ZodObjectV3;
+export declare function isZodObjectV4(obj: unknown): obj is z4.$ZodObject;
+export declare function isZodArrayV4(obj: unknown): obj is z4.$ZodArray;
 /**
  * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).
  *
@@ -158,7 +164,30 @@ export declare function extendInteropZodObject<T extends InteropZodObject>(schem
  * @throws {Error} If the schema is not a Zod v3 or v4 object.
  */
 export declare function interopZodObjectPartial<T extends InteropZodObject>(schema: T): InteropZodObject;
-export declare function interopZodObjectPassthrough<T extends InteropZodObject>(schema: T): InteropZodObject;
+/**
+ * Returns a strict version of a Zod object schema, disallowing unknown keys.
+ * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness
+ * recursively to all nested object schemas and arrays of object schemas.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.
+ * @returns {InteropZodObject} The strict Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+export declare function interopZodObjectStrict<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;
+/**
+ * Returns a passthrough version of a Zod object schema, allowing unknown keys.
+ * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough
+ * recursively to all nested object schemas and arrays of object schemas.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.
+ * @returns {InteropZodObject} The passthrough Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+export declare function interopZodObjectPassthrough<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;
 /**
  * Returns a getter function for the default value of a Zod schema, if one is defined.
  * Supports both Zod v3 and v4 schemas. If the schema has a default value,
@@ -170,4 +199,12 @@ export declare function interopZodObjectPassthrough<T extends InteropZodObject>(
  * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.
  */
 export declare function getInteropZodDefaultGetter<T extends InteropZodType>(schema: T): (() => InferInteropZodOutput<T>) | undefined;
+/**
+ * Returns the input type of a Zod transform schema, for both v3 and v4.
+ * If the schema is not a transform, returns undefined.
+ *
+ * @param schema - The Zod schema instance (v3 or v4)
+ * @returns The input Zod schema of the transform, or undefined if not a transform
+ */
+export declare function interopZodTransformInputSchema(schema: InteropZodType): InteropZodType | undefined;
 export {};

package/dist/utils/types/zod.js

@@ -1,4 +1,4 @@
-import { parse, parseAsync, globalRegistry, util, clone, _unknown, $ZodUnknown, $ZodOptional, } from "zod/v4/core";
+import { parse, parseAsync, globalRegistry, util, clone, _unknown, _never, $ZodUnknown, $ZodNever, $ZodOptional, } from "zod/v4/core";
 export function isZodSchemaV4(schema) {
     if (typeof schema !== "object" || schema === null) {
         return false;
@@ -264,6 +264,55 @@ export function isSimpleStringZodSchema(schema) {
     }
     return false;
 }
+export function isZodObjectV3(obj) {
+    // Zod v3 object schemas have _def.typeName === "ZodObject"
+    if (typeof obj === "object" &&
+        obj !== null &&
+        "_def" in obj &&
+        typeof obj._def === "object" &&
+        obj._def !== null &&
+        "typeName" in obj._def &&
+        obj._def.typeName === "ZodObject") {
+        return true;
+    }
+    return false;
+}
+export function isZodObjectV4(obj) {
+    if (!isZodSchemaV4(obj))
+        return false;
+    // Zod v4 object schemas have _zod.def.type === "object"
+    if (typeof obj === "object" &&
+        obj !== null &&
+        "_zod" in obj &&
+        typeof obj._zod === "object" &&
+        obj._zod !== null &&
+        "def" in obj._zod &&
+        typeof obj._zod.def === "object" &&
+        obj._zod.def !== null &&
+        "type" in obj._zod.def &&
+        obj._zod.def.type === "object") {
+        return true;
+    }
+    return false;
+}
+export function isZodArrayV4(obj) {
+    if (!isZodSchemaV4(obj))
+        return false;
+    // Zod v4 array schemas have _zod.def.type === "array"
+    if (typeof obj === "object" &&
+        obj !== null &&
+        "_zod" in obj &&
+        typeof obj._zod === "object" &&
+        obj._zod !== null &&
+        "def" in obj._zod &&
+        typeof obj._zod.def === "object" &&
+        obj._zod.def !== null &&
+        "type" in obj._zod.def &&
+        obj._zod.def.type === "array") {
+        return true;
+    }
+    return false;
+}
 /**
  * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).
  *
@@ -271,33 +320,10 @@ export function isSimpleStringZodSchema(schema) {
  * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.
  */
 export function isInteropZodObject(obj) {
-    if (isZodSchemaV3(obj)) {
-        // Zod v3 object schemas have _def.typeName === "ZodObject"
-        if (typeof obj === "object" &&
-            obj !== null &&
-            "_def" in obj &&
-            typeof obj._def === "object" &&
-            obj._def !== null &&
-            "typeName" in obj._def &&
-            obj._def.typeName === "ZodObject") {
-            return true;
-        }
-    }
-    if (isZodSchemaV4(obj)) {
-        // Zod v4 object schemas have _zod.def.type === "object"
-        if (typeof obj === "object" &&
-            obj !== null &&
-            "_zod" in obj &&
-            typeof obj._zod === "object" &&
-            obj._zod !== null &&
-            "def" in obj._zod &&
-            typeof obj._zod.def === "object" &&
-            obj._zod.def !== null &&
-            "type" in obj._zod.def &&
-            obj._zod.def.type === "object") {
-            return true;
-        }
-    }
+    if (isZodObjectV3(obj))
+        return true;
+    if (isZodObjectV4(obj))
+        return true;
     return false;
 }
 /**
@@ -355,19 +381,123 @@ export function interopZodObjectPartial(schema) {
     }
     throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
 }
-export function interopZodObjectPassthrough(schema) {
-    if (isInteropZodObject(schema)) {
-        if (isZodSchemaV3(schema)) {
-            return schema.passthrough();
+/**
+ * Returns a strict version of a Zod object schema, disallowing unknown keys.
+ * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness
+ * recursively to all nested object schemas and arrays of object schemas.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.
+ * @returns {InteropZodObject} The strict Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+export function interopZodObjectStrict(schema, recursive = false) {
+    if (isZodSchemaV3(schema)) {
+        // TODO: v3 schemas aren't recursively handled here
+        // (currently not necessary since zodToJsonSchema handles this)
+        return schema.strict();
+    }
+    if (isZodObjectV4(schema)) {
+        const outputShape = schema._zod.def.shape;
+        if (recursive) {
+            for (const [key, keySchema] of Object.entries(schema._zod.def.shape)) {
+                // If the shape key is a v4 object schema, we need to make it strict
+                if (isZodObjectV4(keySchema)) {
+                    const outputSchema = interopZodObjectStrict(keySchema, recursive);
+                    outputShape[key] = outputSchema;
+                }
+                // If the shape key is a v4 array schema, we need to make the element
+                // schema strict if it's an object schema
+                else if (isZodArrayV4(keySchema)) {
+                    let elementSchema = keySchema._zod.def.element;
+                    if (isZodObjectV4(elementSchema)) {
+                        elementSchema = interopZodObjectStrict(elementSchema, recursive);
+                    }
+                    outputShape[key] = clone(keySchema, {
+                        ...keySchema._zod.def,
+                        element: elementSchema,
+                    });
+                }
+                // Otherwise, just use the keySchema
+                else {
+                    outputShape[key] = keySchema;
+                }
+                // Assign meta fields to the keySchema
+                const meta = globalRegistry.get(keySchema);
+                if (meta)
+                    globalRegistry.add(outputShape[key], meta);
+            }
         }
-        if (isZodSchemaV4(schema)) {
-            // Type reassign since ZodObjectV4 assumes that generics should be washed
-            const objectSchema = schema;
-            return clone(objectSchema, {
-                ...objectSchema._zod.def,
-                catchall: _unknown($ZodUnknown),
-            });
+        const modifiedSchema = clone(schema, {
+            ...schema._zod.def,
+            shape: outputShape,
+            catchall: _never($ZodNever),
+        });
+        const meta = globalRegistry.get(schema);
+        if (meta)
+            globalRegistry.add(modifiedSchema, meta);
+        return modifiedSchema;
+    }
+    throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
+}
+/**
+ * Returns a passthrough version of a Zod object schema, allowing unknown keys.
+ * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough
+ * recursively to all nested object schemas and arrays of object schemas.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.
+ * @returns {InteropZodObject} The passthrough Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+export function interopZodObjectPassthrough(schema, recursive = false) {
+    if (isZodObjectV3(schema)) {
+        // TODO: v3 schemas aren't recursively handled here
+        // (currently not necessary since zodToJsonSchema handles this)
+        return schema.passthrough();
+    }
+    if (isZodObjectV4(schema)) {
+        const outputShape = schema._zod.def.shape;
+        if (recursive) {
+            for (const [key, keySchema] of Object.entries(schema._zod.def.shape)) {
+                // If the shape key is a v4 object schema, we need to make it passthrough
+                if (isZodObjectV4(keySchema)) {
+                    const outputSchema = interopZodObjectPassthrough(keySchema, recursive);
+                    outputShape[key] = outputSchema;
+                }
+                // If the shape key is a v4 array schema, we need to make the element
+                // schema passthrough if it's an object schema
+                else if (isZodArrayV4(keySchema)) {
+                    let elementSchema = keySchema._zod.def.element;
+                    if (isZodObjectV4(elementSchema)) {
+                        elementSchema = interopZodObjectPassthrough(elementSchema, recursive);
+                    }
+                    outputShape[key] = clone(keySchema, {
+                        ...keySchema._zod.def,
+                        element: elementSchema,
+                    });
+                }
+                // Otherwise, just use the keySchema
+                else {
+                    outputShape[key] = keySchema;
+                }
+                // Assign meta fields to the keySchema
+                const meta = globalRegistry.get(keySchema);
+                if (meta)
+                    globalRegistry.add(outputShape[key], meta);
+            }
         }
+        const modifiedSchema = clone(schema, {
+            ...schema._zod.def,
+            shape: outputShape,
+            catchall: _unknown($ZodUnknown),
+        });
+        const meta = globalRegistry.get(schema);
+        if (meta)
+            globalRegistry.add(modifiedSchema, meta);
+        return modifiedSchema;
     }
     throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
 }
@@ -402,3 +532,36 @@ export function getInteropZodDefaultGetter(schema) {
     }
     return undefined;
 }
+function isZodTransformV3(schema) {
+    return (isZodSchemaV3(schema) &&
+        "typeName" in schema._def &&
+        schema._def.typeName === "ZodEffects");
+}
+function isZodTransformV4(schema) {
+    return isZodSchemaV4(schema) && schema._zod.def.type === "pipe";
+}
+/**
+ * Returns the input type of a Zod transform schema, for both v3 and v4.
+ * If the schema is not a transform, returns undefined.
+ *
+ * @param schema - The Zod schema instance (v3 or v4)
+ * @returns The input Zod schema of the transform, or undefined if not a transform
+ */
+export function interopZodTransformInputSchema(schema) {
+    // Zod v3: ._def.schema is the input schema for ZodEffects (transform)
+    if (isZodSchemaV3(schema)) {
+        if (isZodTransformV3(schema)) {
+            return interopZodTransformInputSchema(schema._def.schema);
+        }
+        return schema;
+    }
+    // Zod v4: _def.type is the input schema for ZodEffects (transform)
+    if (isZodSchemaV4(schema)) {
+        if (isZodTransformV4(schema)) {
+            const inner = interopZodTransformInputSchema(schema._zod.def.in);
+            return inner ?? schema;
+        }
+        return schema;
+    }
+    throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.59",
+  "version": "0.3.60",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "build:internal": "yarn lc_build --create-entrypoints --pre --tree-shaking",
     "clean": "rm -rf .turbo dist/",
     "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
-    "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
+    "lint:dpdm": "dpdm --skip-dynamic-imports circular --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",
     "prepack": "yarn build",
@@ -53,7 +53,7 @@
     "@swc/jest": "^0.2.29",
     "@types/decamelize": "^1.2.0",
     "@types/mustache": "^4",
-    "dpdm": "^3.12.0",
+    "dpdm": "^3.14.0",
     "eslint": "^8.33.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.6.0",
@@ -68,7 +68,7 @@
     "release-it": "^18.1.2",
     "rimraf": "^5.0.1",
     "ts-jest": "^29.1.0",
-    "typescript": "~5.1.6",
+    "typescript": "~5.8.3",
     "web-streams-polyfill": "^4.0.0"
   },
   "publishConfig": {
@@ -557,6 +557,24 @@
       "import": "./utils/hash.js",
       "require": "./utils/hash.cjs"
     },
+    "./utils/hash/insecure": {
+      "types": {
+        "import": "./utils/hash/insecure.d.ts",
+        "require": "./utils/hash/insecure.d.cts",
+        "default": "./utils/hash/insecure.d.ts"
+      },
+      "import": "./utils/hash/insecure.js",
+      "require": "./utils/hash/insecure.cjs"
+    },
+    "./utils/hash/sha256": {
+      "types": {
+        "import": "./utils/hash/sha256.d.ts",
+        "require": "./utils/hash/sha256.d.cts",
+        "default": "./utils/hash/sha256.d.ts"
+      },
+      "import": "./utils/hash/sha256.js",
+      "require": "./utils/hash/sha256.cjs"
+    },
     "./utils/json_patch": {
       "types": {
         "import": "./utils/json_patch.d.ts",
@@ -841,6 +859,14 @@
     "utils/hash.js",
     "utils/hash.d.ts",
     "utils/hash.d.cts",
+    "utils/hash/insecure.cjs",
+    "utils/hash/insecure.js",
+    "utils/hash/insecure.d.ts",
+    "utils/hash/insecure.d.cts",
+    "utils/hash/sha256.cjs",
+    "utils/hash/sha256.js",
+    "utils/hash/sha256.d.ts",
+    "utils/hash/sha256.d.cts",
     "utils/json_patch.cjs",
     "utils/json_patch.js",
     "utils/json_patch.d.ts",

package/utils/hash/insecure.cjs

@@ -0,0 +1 @@
+module.exports = require('../../dist/utils/js-sha1/hash.cjs');

package/utils/hash/insecure.d.cts

@@ -0,0 +1 @@
+export * from '../../dist/utils/js-sha1/hash.js'

package/utils/hash/insecure.d.ts

@@ -0,0 +1 @@
+export * from '../../dist/utils/js-sha1/hash.js'

package/utils/hash/insecure.js

@@ -0,0 +1 @@
+export * from '../../dist/utils/js-sha1/hash.js'

package/utils/hash/sha256.cjs

@@ -0,0 +1 @@
+module.exports = require('../../dist/utils/js-sha256/hash.cjs');

package/utils/hash/sha256.d.cts

@@ -0,0 +1 @@
+export * from '../../dist/utils/js-sha256/hash.js'

package/utils/hash/sha256.d.ts

@@ -0,0 +1 @@
+export * from '../../dist/utils/js-sha256/hash.js'

package/utils/hash/sha256.js

@@ -0,0 +1 @@
+export * from '../../dist/utils/js-sha256/hash.js'