fix(langchain): Fix toJsonSchema mutating underlying zod schema

Author: ro0sterjam

libs/langchain-core/src/utils/json_schema.ts

@@ -16,12 +16,20 @@ import {
 
 export { deepCompareStrict, Validator } from "@cfworker/json-schema";
 
+export type ToJSONSchemaParams = NonNullable<
+  Parameters<typeof toJSONSchema>[1]
+>;
+
 /**
  * Converts a Zod schema or JSON schema to a JSON schema.
  * @param schema - The schema to convert.
+ * @param _params - The parameters to pass to the toJSONSchema function.
  * @returns The converted schema.
  */
-export function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema {
+export function toJsonSchema(
+  schema: InteropZodType | JSONSchema,
+  _params?: ToJSONSchemaParams
+): JSONSchema {
   if (isZodSchemaV4(schema)) {
     const inputSchema = interopZodTransformInputSchema(schema, true);
     if (isZodObjectV4(inputSchema)) {

libs/langchain-core/src/utils/types/tests/zod.test.ts

@@ -1525,6 +1525,47 @@ describe("Zod utility functions", () => {
         expect(elementShape.name).toBeInstanceOf(z4.ZodString);
         expect(elementShape.age).toBeInstanceOf(z4.ZodNumber);
       });
+
+      it("should not mutate the original schema when removing transforms", () => {
+        const inputSchema = z4.object({
+          name: z4.string().transform((s) => s.toUpperCase()),
+          email: z4
+            .string()
+            .email()
+            .transform((s) => s.toLowerCase()),
+          age: z4.number(),
+          metadata: z4.object({
+            key: z4.string(),
+            value: z4.string().transform((s) => s.trim()),
+          }),
+        });
+
+        // Capture the original schema structure before processing
+        const originalSchemaJson = JSON.stringify(inputSchema);
+
+        // Process the schema
+        const result = interopZodTransformInputSchema(inputSchema, true);
+
+        // Verify the original schema is unchanged
+        const schemaJsonAfter = JSON.stringify(inputSchema);
+        expect(schemaJsonAfter).toBe(originalSchemaJson);
+
+        // Verify that the result is different from the original
+        const resultJson = JSON.stringify(result);
+        expect(resultJson).not.toBe(originalSchemaJson);
+
+        // Verify the result actually has transforms removed
+        expect(result).toBeInstanceOf(z4.ZodObject);
+        const resultShape = getInteropZodObjectShape(result as any);
+        expect(resultShape.name).toBeInstanceOf(z4.ZodString);
+        expect(resultShape.email).toBeInstanceOf(z4.ZodString);
+        expect(resultShape.age).toBeInstanceOf(z4.ZodNumber);
+
+        const metadataShape = getInteropZodObjectShape(
+          resultShape.metadata as any
+        );
+        expect(metadataShape.value).toBeInstanceOf(z4.ZodString);
+      });
     });
 
     it("should throw error for non-schema values", () => {

libs/langchain-core/src/utils/types/zod.ts

@@ -814,7 +814,7 @@ export function interopZodTransformInputSchema(
     if (recursive) {
       // Handle nested object schemas
       if (isZodObjectV4(outputSchema)) {
-        const outputShape: Mutable<z4.$ZodShape> = outputSchema._zod.def.shape;
+        const outputShape: Mutable<z4.$ZodShape> = {};
         for (const [key, keySchema] of Object.entries(
           outputSchema._zod.def.shape
         )) {