@langchain/core 0.3.56 → 0.3.58-rc.0

package/dist/runnables/base.cjs

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertRunnableToTool = exports.RunnableToolLike = exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableTraceable = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = exports._coerceToDict = void 0;
-const zod_1 = require("zod");
+const v3_1 = require("zod/v3");
 const p_retry_1 = __importDefault(require("p-retry"));
 const uuid_1 = require("uuid");
 const traceable_1 = require("langsmith/singletons/traceable");
@@ -22,6 +22,7 @@ const graph_js_1 = require("./graph.cjs");
 const wrappers_js_1 = require("./wrappers.cjs");
 const iter_js_1 = require("./iter.cjs");
 const utils_js_2 = require("../tools/utils.cjs");
+const zod_js_1 = require("../utils/types/zod.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value &&
@@ -63,6 +64,8 @@ class Runnable extends serializable_js_1.Serializable {
      * Bind arguments to a Runnable, returning a new Runnable.
      * @param kwargs
      * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -71,6 +74,8 @@ class Runnable extends serializable_js_1.Serializable {
     /**
      * Return a new Runnable that maps a list of inputs to a list of outputs,
      * by calling invoke() with each input.
+     *
+     * @deprecated This will be removed in the next breaking release.
      */
     map() {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -78,7 +83,8 @@ class Runnable extends serializable_js_1.Serializable {
     }
     /**
      * Add retry logic to an existing runnable.
-     * @param kwargs
+     * @param fields.stopAfterAttempt The number of attempts to retry.
+     * @param fields.onFailedAttempt A function that is called when a retry fails.
      * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
      */
     withRetry(fields) {
@@ -337,13 +343,13 @@ class Runnable extends serializable_js_1.Serializable {
         // TODO: Add input schema for runnables
         const inputNode = graph.addNode({
             name: `${this.getName()}Input`,
-            schema: zod_1.z.any(),
+            schema: v3_1.z.any(),
         });
         const runnableNode = graph.addNode(this);
         // TODO: Add output schemas for runnables
         const outputNode = graph.addNode({
             name: `${this.getName()}Output`,
-            schema: zod_1.z.any(),
+            schema: v3_1.z.any(),
         });
         graph.addEdge(inputNode, runnableNode);
         graph.addEdge(runnableNode, outputNode);
@@ -774,7 +780,8 @@ class Runnable extends serializable_js_1.Serializable {
 }
 exports.Runnable = Runnable;
 /**
- * A runnable that delegates calls to another runnable with a set of kwargs.
+ * Wraps a runnable and applies partial config upon invocation.
+ *
  * @example
  * ```typescript
  * import {
@@ -869,8 +876,14 @@ class RunnableBinding extends Runnable {
             ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config)))
             : []));
     }
+    /**
+     * Binds the runnable with the specified arguments.
+     * @param kwargs The arguments to bind the runnable with.
+     * @returns A new instance of the `RunnableBinding` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
+     */
     bind(kwargs) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new this.constructor({
             bound: this.bound,
             kwargs: { ...this.kwargs, ...kwargs },
@@ -878,7 +891,6 @@ class RunnableBinding extends Runnable {
         });
     }
     withConfig(config) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new this.constructor({
             bound: this.bound,
             kwargs: this.kwargs,
@@ -886,11 +898,13 @@ class RunnableBinding extends Runnable {
         });
     }
     withRetry(fields) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return new this.constructor({
-            bound: this.bound.withRetry(fields),
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunnableRetry({
+            bound: this.bound,
             kwargs: this.kwargs,
             config: this.config,
+            maxAttemptNumber: fields?.stopAfterAttempt,
+            ...fields,
         });
     }
     async invoke(input, options) {
@@ -982,6 +996,8 @@ exports.RunnableBinding = RunnableBinding;
  *
  * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
  * ```
+ *
+ * @deprecated This will be removed in the next breaking release.
  */
 class RunnableEach extends Runnable {
     static lc_name() {
@@ -1013,6 +1029,8 @@ class RunnableEach extends Runnable {
      * Binds the runnable with the specified arguments.
      * @param kwargs The arguments to bind the runnable with.
      * @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs) {
         return new RunnableEach({
@@ -2317,7 +2335,7 @@ class RunnableToolLike extends RunnableBinding {
                 let toolInput;
                 if ((0, utils_js_2._isToolCall)(input)) {
                     try {
-                        toolInput = await this.schema.parseAsync(input.args);
+                        toolInput = await (0, zod_js_1.interopParseAsync)(this.schema, input.args);
                     }
                     catch (e) {
                         throw new utils_js_2.ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(input.args));
@@ -2371,20 +2389,18 @@ exports.RunnableToolLike = RunnableToolLike;
  * @param fields
  * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
  * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
- * @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
- * @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+ * @param {InteropZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+ * @returns {RunnableToolLike<InteropZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
  */
 function convertRunnableToTool(runnable, fields) {
     const name = fields.name ?? runnable.getName();
-    const description = fields.description ?? fields.schema?.description;
-    if (fields.schema.constructor === zod_1.z.ZodString) {
+    const description = fields.description ?? (0, zod_js_1.getSchemaDescription)(fields.schema);
+    if ((0, zod_js_1.isSimpleStringZodSchema)(fields.schema)) {
         return new RunnableToolLike({
             name,
             description,
-            schema: zod_1.z
-                .object({
-                input: zod_1.z.string(),
-            })
+            schema: v3_1.z
+                .object({ input: v3_1.z.string() })
                 .transform((input) => input.input),
             bound: runnable,
         });

package/dist/runnables/base.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { type TraceableFunction } from "langsmith/singletons/traceable";
 import type { RunnableInterface, RunnableBatchOptions, RunnableConfig } from "./types.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
@@ -9,6 +8,7 @@ import { IterableReadableStream } from "../utils/stream.js";
 import { Run } from "../tracers/base.js";
 import { Graph } from "./graph.js";
 import { ToolCall } from "../messages/tool.js";
+import { InferInteropZodOutput, InteropZodType } from "../utils/types/zod.js";
 export { type RunnableInterface, RunnableBatchOptions };
 export type RunnableFunc<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = (input: RunInput, options: CallOptions | Record<string, any> | (Record<string, any> & CallOptions)) => RunOutput | Promise<RunOutput>;
 export type RunnableMapLike<RunInput, RunOutput> = {
@@ -30,16 +30,21 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * Bind arguments to a Runnable, returning a new Runnable.
      * @param kwargs
      * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs: Partial<CallOptions>): Runnable<RunInput, RunOutput, CallOptions>;
     /**
      * Return a new Runnable that maps a list of inputs to a list of outputs,
      * by calling invoke() with each input.
+     *
+     * @deprecated This will be removed in the next breaking release.
      */
     map(): Runnable<RunInput[], RunOutput[], CallOptions>;
     /**
      * Add retry logic to an existing runnable.
-     * @param kwargs
+     * @param fields.stopAfterAttempt The number of attempts to retry.
+     * @param fields.onFailedAttempt A function that is called when a retry fails.
      * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
      */
     withRetry(fields?: {
@@ -305,17 +310,21 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
     asTool<T extends RunInput = RunInput>(fields: {
         name?: string;
         description?: string;
-        schema: z.ZodType<T>;
-    }): RunnableToolLike<z.ZodType<T | ToolCall>, RunOutput>;
+        schema: InteropZodType<T>;
+    }): RunnableToolLike<InteropZodType<T | ToolCall>, RunOutput>;
 }
 export type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = {
     bound: Runnable<RunInput, RunOutput, CallOptions>;
+    /**
+     * @deprecated use {@link config} instead
+     */
     kwargs?: Partial<CallOptions>;
     config: RunnableConfig;
-    configFactories?: Array<(config: RunnableConfig) => RunnableConfig>;
+    configFactories?: Array<(config: RunnableConfig) => RunnableConfig | Promise<RunnableConfig>>;
 };
 /**
- * A runnable that delegates calls to another runnable with a set of kwargs.
+ * Wraps a runnable and applies partial config upon invocation.
+ *
  * @example
  * ```typescript
  * import {
@@ -365,8 +374,15 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions>);
     getName(suffix?: string | undefined): string;
     _mergeConfig(...options: (Partial<CallOptions> | RunnableConfig | undefined)[]): Promise<Partial<CallOptions>>;
+    /**
+     * Binds the runnable with the specified arguments.
+     * @param kwargs The arguments to bind the runnable with.
+     * @returns A new instance of the `RunnableBinding` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
+     */
     bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
-    withConfig(config: RunnableConfig): Runnable<RunInput, RunOutput, CallOptions>;
+    withConfig(config: Partial<CallOptions>): Runnable<RunInput, RunOutput, CallOptions>;
     withRetry(fields?: {
         stopAfterAttempt?: number;
         onFailedAttempt?: RunnableRetryFailedAttemptHandler;
@@ -428,6 +444,8 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
  *
  * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
  * ```
+ *
+ * @deprecated This will be removed in the next breaking release.
  */
 export declare class RunnableEach<RunInputItem, RunOutputItem, CallOptions extends RunnableConfig> extends Runnable<RunInputItem[], RunOutputItem[], CallOptions> {
     static lc_name(): string;
@@ -441,6 +459,8 @@ export declare class RunnableEach<RunInputItem, RunOutputItem, CallOptions exten
      * Binds the runnable with the specified arguments.
      * @param kwargs The arguments to bind the runnable with.
      * @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs: Partial<CallOptions>): RunnableEach<RunInputItem, RunOutputItem, CallOptions>;
     /**
@@ -890,13 +910,13 @@ export declare class RunnablePick<RunInput extends Record<string, any> = Record<
     transform(generator: AsyncGenerator<RunInput>, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
     stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;
 }
-export interface RunnableToolLikeArgs<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends Omit<RunnableBindingArgs<z.infer<RunInput>, RunOutput>, "config"> {
+export interface RunnableToolLikeArgs<RunInput extends InteropZodType = InteropZodType, RunOutput = unknown> extends Omit<RunnableBindingArgs<InferInteropZodOutput<RunInput>, RunOutput>, "config"> {
     name: string;
     description?: string;
     schema: RunInput;
     config?: RunnableConfig;
 }
-export declare class RunnableToolLike<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends RunnableBinding<z.infer<RunInput>, RunOutput> {
+export declare class RunnableToolLike<RunInput extends InteropZodType = InteropZodType, RunOutput = unknown> extends RunnableBinding<InferInteropZodOutput<RunInput>, RunOutput> {
     name: string;
     description?: string;
     schema: RunInput;
@@ -913,11 +933,11 @@ export declare class RunnableToolLike<RunInput extends z.ZodType = z.ZodType, Ru
  * @param fields
  * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
  * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
- * @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
- * @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+ * @param {InteropZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+ * @returns {RunnableToolLike<InteropZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
  */
 export declare function convertRunnableToTool<RunInput, RunOutput>(runnable: Runnable<RunInput, RunOutput>, fields: {
     name?: string;
     description?: string;
-    schema: z.ZodType<RunInput>;
-}): RunnableToolLike<z.ZodType<RunInput | ToolCall>, RunOutput>;
+    schema: InteropZodType<RunInput>;
+}): RunnableToolLike<InteropZodType<RunInput | ToolCall>, RunOutput>;

package/dist/runnables/base.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 import pRetry from "p-retry";
 import { v4 as uuidv4 } from "uuid";
 import { isTraceableFunction, } from "langsmith/singletons/traceable";
@@ -16,6 +16,7 @@ import { Graph } from "./graph.js";
 import { convertToHttpEventStream } from "./wrappers.js";
 import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterableIterator, isIterator, } from "./iter.js";
 import { _isToolCall, ToolInputParsingException } from "../tools/utils.js";
+import { getSchemaDescription, interopParseAsync, isSimpleStringZodSchema, } from "../utils/types/zod.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -56,6 +57,8 @@ export class Runnable extends Serializable {
      * Bind arguments to a Runnable, returning a new Runnable.
      * @param kwargs
      * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -64,6 +67,8 @@ export class Runnable extends Serializable {
     /**
      * Return a new Runnable that maps a list of inputs to a list of outputs,
      * by calling invoke() with each input.
+     *
+     * @deprecated This will be removed in the next breaking release.
      */
     map() {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -71,7 +76,8 @@ export class Runnable extends Serializable {
     }
     /**
      * Add retry logic to an existing runnable.
-     * @param kwargs
+     * @param fields.stopAfterAttempt The number of attempts to retry.
+     * @param fields.onFailedAttempt A function that is called when a retry fails.
      * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
      */
     withRetry(fields) {
@@ -766,7 +772,8 @@ export class Runnable extends Serializable {
     }
 }
 /**
- * A runnable that delegates calls to another runnable with a set of kwargs.
+ * Wraps a runnable and applies partial config upon invocation.
+ *
  * @example
  * ```typescript
  * import {
@@ -861,8 +868,14 @@ export class RunnableBinding extends Runnable {
             ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config)))
             : []));
     }
+    /**
+     * Binds the runnable with the specified arguments.
+     * @param kwargs The arguments to bind the runnable with.
+     * @returns A new instance of the `RunnableBinding` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
+     */
     bind(kwargs) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new this.constructor({
             bound: this.bound,
             kwargs: { ...this.kwargs, ...kwargs },
@@ -870,7 +883,6 @@ export class RunnableBinding extends Runnable {
         });
     }
     withConfig(config) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new this.constructor({
             bound: this.bound,
             kwargs: this.kwargs,
@@ -878,11 +890,13 @@ export class RunnableBinding extends Runnable {
         });
     }
     withRetry(fields) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return new this.constructor({
-            bound: this.bound.withRetry(fields),
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunnableRetry({
+            bound: this.bound,
             kwargs: this.kwargs,
             config: this.config,
+            maxAttemptNumber: fields?.stopAfterAttempt,
+            ...fields,
         });
     }
     async invoke(input, options) {
@@ -973,6 +987,8 @@ export class RunnableBinding extends Runnable {
  *
  * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
  * ```
+ *
+ * @deprecated This will be removed in the next breaking release.
  */
 export class RunnableEach extends Runnable {
     static lc_name() {
@@ -1004,6 +1020,8 @@ export class RunnableEach extends Runnable {
      * Binds the runnable with the specified arguments.
      * @param kwargs The arguments to bind the runnable with.
      * @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs) {
         return new RunnableEach({
@@ -2297,7 +2315,7 @@ export class RunnableToolLike extends RunnableBinding {
                 let toolInput;
                 if (_isToolCall(input)) {
                     try {
-                        toolInput = await this.schema.parseAsync(input.args);
+                        toolInput = await interopParseAsync(this.schema, input.args);
                     }
                     catch (e) {
                         throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(input.args));
@@ -2350,20 +2368,18 @@ export class RunnableToolLike extends RunnableBinding {
  * @param fields
  * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
  * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
- * @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
- * @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+ * @param {InteropZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+ * @returns {RunnableToolLike<InteropZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
  */
 export function convertRunnableToTool(runnable, fields) {
     const name = fields.name ?? runnable.getName();
-    const description = fields.description ?? fields.schema?.description;
-    if (fields.schema.constructor === z.ZodString) {
+    const description = fields.description ?? getSchemaDescription(fields.schema);
+    if (isSimpleStringZodSchema(fields.schema)) {
         return new RunnableToolLike({
             name,
             description,
             schema: z
-                .object({
-                input: z.string(),
-            })
+                .object({ input: z.string() })
                 .transform((input) => input.input),
             bound: runnable,
         });

package/dist/runnables/graph.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Graph = void 0;
-const zod_to_json_schema_1 = require("zod-to-json-schema");
 const uuid_1 = require("uuid");
 const utils_js_1 = require("./utils.cjs");
 const graph_mermaid_js_1 = require("./graph_mermaid.cjs");
+const json_schema_js_1 = require("../utils/json_schema.cjs");
 function nodeDataStr(id, data) {
     if (id !== undefined && !(0, uuid_1.validate)(id)) {
         return id;
@@ -39,7 +39,7 @@ function nodeDataJson(node) {
     else {
         return {
             type: "schema",
-            data: { ...(0, zod_to_json_schema_1.zodToJsonSchema)(node.data.schema), title: node.data.name },
+            data: { ...(0, json_schema_js_1.toJsonSchema)(node.data.schema), title: node.data.name },
         };
     }
 }

package/dist/runnables/graph.js

@@ -1,7 +1,7 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
 import { v4 as uuidv4, validate as isUuid } from "uuid";
 import { isRunnableInterface } from "./utils.js";
 import { drawMermaid, drawMermaidPng } from "./graph_mermaid.js";
+import { toJsonSchema } from "../utils/json_schema.js";
 function nodeDataStr(id, data) {
     if (id !== undefined && !isUuid(id)) {
         return id;
@@ -36,7 +36,7 @@ function nodeDataJson(node) {
     else {
         return {
             type: "schema",
-            data: { ...zodToJsonSchema(node.data.schema), title: node.data.name },
+            data: { ...toJsonSchema(node.data.schema), title: node.data.name },
         };
     }
 }

package/dist/runnables/passthrough.cjs

@@ -112,7 +112,7 @@ class RunnablePassthrough extends base_js_1.Runnable {
      *     schema: async () => db.getTableInfo(),
      *   }),
      *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new ChatOpenAI({}).withConfig({ stop: ["\nSQLResult:"] }),
      *   new StringOutputParser(),
      * ]);
      * const result = await sqlQueryGeneratorChain.invoke({

package/dist/runnables/passthrough.d.ts

@@ -57,7 +57,7 @@ export declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInp
      *     schema: async () => db.getTableInfo(),
      *   }),
      *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new ChatOpenAI({}).withConfig({ stop: ["\nSQLResult:"] }),
      *   new StringOutputParser(),
      * ]);
      * const result = await sqlQueryGeneratorChain.invoke({

package/dist/runnables/passthrough.js

@@ -109,7 +109,7 @@ export class RunnablePassthrough extends Runnable {
      *     schema: async () => db.getTableInfo(),
      *   }),
      *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new ChatOpenAI({}).withConfig({ stop: ["\nSQLResult:"] }),
      *   new StringOutputParser(),
      * ]);
      * const result = await sqlQueryGeneratorChain.invoke({

package/dist/runnables/types.d.ts

@@ -1,7 +1,7 @@
-import type { z } from "zod";
 import type { SerializableInterface } from "../load/serializable.js";
 import type { BaseCallbackConfig } from "../callbacks/manager.js";
 import type { IterableReadableStreamInterface } from "../types/_internal.js";
+import { InteropZodType } from "../utils/types/zod.js";
 export type RunnableBatchOptions = {
     /** @deprecated Pass in via the standard runnable config object instead */
     maxConcurrency?: number;
@@ -9,7 +9,7 @@ export type RunnableBatchOptions = {
 };
 export type RunnableIOSchema = {
     name?: string;
-    schema: z.ZodType;
+    schema: InteropZodType;
 };
 /**
  * Base interface implemented by all runnables.

package/dist/tools/index.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tool = exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = exports.isStructuredToolParams = exports.isStructuredTool = exports.isRunnableToolLike = exports.isLangChainTool = void 0;
-const zod_1 = require("zod");
+const v3_1 = require("zod/v3");
 const json_schema_1 = require("@cfworker/json-schema");
 const manager_js_1 = require("../callbacks/manager.cjs");
 const base_js_1 = require("../language_models/base.cjs");
@@ -10,7 +10,7 @@ const tool_js_1 = require("../messages/tool.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 const utils_js_1 = require("./utils.cjs");
 Object.defineProperty(exports, "ToolInputParsingException", { enumerable: true, get: function () { return utils_js_1.ToolInputParsingException; } });
-const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.cjs");
+const zod_js_1 = require("../utils/types/zod.cjs");
 const json_schema_js_1 = require("../utils/json_schema.cjs");
 var types_js_1 = require("./types.cjs");
 Object.defineProperty(exports, "isLangChainTool", { enumerable: true, get: function () { return types_js_1.isLangChainTool; } });
@@ -102,10 +102,10 @@ class StructuredTool extends base_js_1.BaseLangChain {
         // If arg is a ToolCall, use its args; otherwise, use arg directly.
         const inputForValidation = (0, utils_js_1._isToolCall)(arg) ? arg.args : arg;
         let parsed; // This will hold the successfully parsed input of the expected output type.
-        if ((0, is_zod_schema_js_1.isZodSchema)(this.schema)) {
+        if ((0, zod_js_1.isInteropZodSchema)(this.schema)) {
             try {
                 // Validate the inputForValidation - TS needs help here as it can't exclude ToolCall based on the check
-                parsed = await this.schema.parseAsync(inputForValidation);
+                parsed = await (0, zod_js_1.interopParseAsync)(this.schema, inputForValidation);
             }
             catch (e) {
                 let message = `Received tool input did not match expected schema`;
@@ -190,8 +190,8 @@ class Tool extends StructuredTool {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: zod_1.z
-                .object({ input: zod_1.z.string().optional() })
+            value: v3_1.z
+                .object({ input: v3_1.z.string().optional() })
                 .transform((obj) => obj.input)
         });
     }
@@ -342,12 +342,10 @@ class BaseToolkit {
 }
 exports.BaseToolkit = BaseToolkit;
 function tool(func, fields) {
-    const isShapelessZodSchema = fields.schema &&
-        (0, is_zod_schema_js_1.isZodSchema)(fields.schema) &&
-        (!("shape" in fields.schema) || !fields.schema.shape);
+    const isSimpleStringSchema = (0, zod_js_1.isSimpleStringZodSchema)(fields.schema);
     const isStringJSONSchema = (0, json_schema_js_1.validatesOnlyStrings)(fields.schema);
-    // If the schema is not provided, or it's a shapeless schema (e.g. a ZodString), create a DynamicTool
-    if (!fields.schema || isShapelessZodSchema || isStringJSONSchema) {
+    // If the schema is not provided, or it's a simple string schema, create a DynamicTool
+    if (!fields.schema || isSimpleStringSchema || isStringJSONSchema) {
         return new DynamicTool({
             ...fields,
             description: fields.description ??
@@ -426,7 +424,7 @@ function _formatToolOutput(params) {
 }
 function _stringify(content) {
     try {
-        return JSON.stringify(content, null, 2);
+        return JSON.stringify(content, null, 2) ?? "";
     }
     catch (_noOp) {
         return `${content}`;

package/dist/tools/index.d.ts

@@ -1,11 +1,12 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 import { CallbackManagerForToolRun } from "../callbacks/manager.js";
 import { BaseLangChain } from "../language_models/base.js";
 import { type RunnableConfig } from "../runnables/config.js";
 import type { RunnableFunc } from "../runnables/base.js";
 import { ToolCall, ToolMessage } from "../messages/tool.js";
 import { ToolInputParsingException } from "./utils.js";
-import type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, ZodObjectAny, StringInputToolSchema, ToolInterface, ToolOutputType } from "./types.js";
+import { type InferInteropZodInput, type InferInteropZodOutput, type ZodStringV3, type ZodStringV4, type ZodObjectV3, type ZodObjectV4 } from "../utils/types/zod.js";
+import type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, StringInputToolSchema, ToolInterface, ToolOutputType } from "./types.js";
 import { type JSONSchema } from "../utils/json_schema.js";
 export type { BaseDynamicToolInput, ContentAndArtifact, DynamicToolInput, DynamicStructuredToolInput, ResponseFormat, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInterface, ToolParams, ToolReturnType, ToolRunnableConfig, ToolInputSchemaBase as ToolSchemaBase, } from "./types.js";
 export { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, } from "./types.js";
@@ -13,7 +14,7 @@ export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
-export declare abstract class StructuredTool<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
+export declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
     abstract name: string;
     abstract description: string;
     abstract schema: SchemaT;
@@ -111,7 +112,7 @@ export declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<Tool
  * Schema can be passed as Zod or JSON schema. The tool will not validate
  * input if JSON schema is passed.
  */
-export declare class DynamicStructuredTool<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {
+export declare class DynamicStructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {
     static lc_name(): string;
     name: string;
     description: string;
@@ -141,7 +142,7 @@ export declare abstract class BaseToolkit {
  * Both schema types will be validated.
  * @template {ToolInputSchemaBase} RunInput The input schema for the tool.
  */
-interface ToolWrapperParams<RunInput extends ToolInputSchemaBase | undefined = ToolInputSchemaBase | undefined> extends ToolParams {
+interface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined> extends ToolParams {
     /**
      * The name of the tool. If using with an LLM, this
      * will be passed as the tool name.
@@ -189,10 +190,12 @@ interface ToolWrapperParams<RunInput extends ToolInputSchemaBase | undefined = T
  * @param {ToolWrapperParams<SchemaT>} fields - An object containing the following properties:
  * @param {string} fields.name The name of the tool.
  * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.
- * @param {ZodObjectAny | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.
+ * @param {z.AnyZodObject | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.
  *
  * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.
  */
-export declare function tool<SchemaT extends z.ZodString, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaT extends z.ZodString ? z.output<SchemaT> : string, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
-export declare function tool<SchemaT extends ZodObjectAny, SchemaOutputT = z.output<SchemaT>, SchemaInputT = z.input<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
+export declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
+export declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
+export declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
+export declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
 export declare function tool<SchemaT extends JSONSchema, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>["func"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;