@langchain/core 0.3.57 → 0.3.58

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/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 ??

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>;

package/dist/tools/index.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 import { validate, } from "@cfworker/json-schema";
 import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
 import { BaseLangChain } from "../language_models/base.js";
@@ -6,7 +6,7 @@ import { ensureConfig, patchConfig, pickRunnableConfigKeys, } from "../runnables
 import { isDirectToolOutput, ToolMessage } from "../messages/tool.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { _configHasToolCallId, _isToolCall, ToolInputParsingException, } from "./utils.js";
-import { isZodSchema } from "../utils/types/is_zod_schema.js";
+import { interopParseAsync, isSimpleStringZodSchema, isInteropZodSchema, } from "../utils/types/zod.js";
 import { validatesOnlyStrings } from "../utils/json_schema.js";
 export { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, } from "./types.js";
 export { ToolInputParsingException };
@@ -95,10 +95,10 @@ export class StructuredTool extends BaseLangChain {
         // If arg is a ToolCall, use its args; otherwise, use arg directly.
         const inputForValidation = _isToolCall(arg) ? arg.args : arg;
         let parsed; // This will hold the successfully parsed input of the expected output type.
-        if (isZodSchema(this.schema)) {
+        if (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 interopParseAsync(this.schema, inputForValidation);
             }
             catch (e) {
                 let message = `Received tool input did not match expected schema`;
@@ -330,12 +330,10 @@ export class BaseToolkit {
     }
 }
 export function tool(func, fields) {
-    const isShapelessZodSchema = fields.schema &&
-        isZodSchema(fields.schema) &&
-        (!("shape" in fields.schema) || !fields.schema.shape);
+    const isSimpleStringSchema = isSimpleStringZodSchema(fields.schema);
     const isStringJSONSchema = 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 ??

package/dist/tools/types.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isLangChainTool = exports.isStructuredToolParams = exports.isRunnableToolLike = exports.isStructuredTool = void 0;
 const base_js_1 = require("../runnables/base.cjs");
-const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.cjs");
+const zod_js_1 = require("../utils/types/zod.cjs");
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
  *
@@ -40,7 +40,7 @@ function isStructuredToolParams(tool) {
         "name" in tool &&
         "schema" in tool &&
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ((0, is_zod_schema_js_1.isZodSchema)(tool.schema) ||
+        ((0, zod_js_1.isInteropZodSchema)(tool.schema) ||
             (tool.schema != null &&
                 typeof tool.schema === "object" &&
                 "type" in tool.schema &&

package/dist/tools/types.d.ts

@@ -1,15 +1,15 @@
-import { z } from "zod";
+import type { z as z3 } from "zod/v3";
 import { CallbackManagerForToolRun } from "../callbacks/manager.js";
 import type { BaseLangChainParams, ToolDefinition } from "../language_models/base.js";
 import type { RunnableConfig } from "../runnables/config.js";
 import { RunnableToolLike, type RunnableInterface } from "../runnables/base.js";
 import { type DirectToolOutput, type ToolCall, type ToolMessage } from "../messages/tool.js";
 import type { MessageContent } from "../messages/base.js";
+import { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType } from "../utils/types/zod.js";
 import { JSONSchema } from "../utils/json_schema.js";
 export type ResponseFormat = "content" | "content_and_artifact" | string;
 export type ToolOutputType = any;
 export type ContentAndArtifact = [MessageContent, any];
-export type ZodObjectAny = z.ZodObject<any, any, any, any>;
 /**
  * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.
  * - If the input is a ToolCall, it returns a ToolMessage
@@ -33,7 +33,7 @@ export type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToo
  * Base type that establishes the types of input schemas that can be used for LangChain tool
  * definitions.
  */
-export type ToolInputSchemaBase = z.ZodAny | JSONSchema;
+export type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;
 /**
  * Parameters for the Tool classes.
  */
@@ -80,7 +80,7 @@ export interface StructuredToolParams extends Pick<StructuredToolInterface, "nam
  * applying any transforms defined in your schema. If there are no transforms, the input and output
  * types will be the same.
  */
-export type ToolInputSchemaOutputType<T extends ToolInputSchemaBase> = T extends z.ZodSchema ? z.output<T> : T extends JSONSchema ? unknown : never;
+export type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;
 /**
  * Utility type that resolves the input type of a tool input schema.
  *
@@ -92,14 +92,14 @@ export type ToolInputSchemaOutputType<T extends ToolInputSchemaBase> = T extends
  * applying any transforms defined in your schema. If there are no transforms, the input and output
  * types will be the same.
  */
-export type ToolInputSchemaInputType<T extends ToolInputSchemaBase> = T extends z.ZodSchema ? z.input<T> : T extends JSONSchema ? unknown : never;
+export type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;
 /**
  * Defines the type that will be passed into a tool handler function as a result of a tool call.
  *
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.
  */
-export type StructuredToolCallInput<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;
+export type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;
 /**
  * An input schema type for tools that accept a single string input.
  *
@@ -109,9 +109,7 @@ export type StructuredToolCallInput<SchemaT extends ToolInputSchemaBase = ToolIn
  * This is primarily used for creating simple string-based tools where the LLM
  * only needs to provide a single text value as input to the tool.
  */
-export type StringInputToolSchema = z.ZodEffects<z.ZodObject<{
-    input: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, any, any>, any, any>;
+export type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef, any>;
 /**
  * Defines the type for input to a tool's call method.
  *
@@ -124,7 +122,7 @@ export type StringInputToolSchema = z.ZodEffects<z.ZodObject<{
  *
  * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema
  */
-export type ToolCallInput<SchemaT extends ToolInputSchemaBase = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;
+export type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;
 /**
  * Interface that defines the shape of a LangChain structured tool.
  *
@@ -134,7 +132,7 @@ export type ToolCallInput<SchemaT extends ToolInputSchemaBase = StringInputToolS
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.
  */
-export interface StructuredToolInterface<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {
+export interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {
     lc_namespace: string[];
     /**
      * A Zod schema representing the parameters of the tool.
@@ -183,7 +181,7 @@ export interface StructuredToolInterface<SchemaT extends ToolInputSchemaBase = T
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.
  */
-export interface ToolInterface<SchemaT extends StringInputToolSchema = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
+export interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      *
@@ -222,7 +220,7 @@ export interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDyna
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.
  */
-export interface DynamicStructuredToolInput<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
+export interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
     /**
      * Tool handler function - the function that will be called when the tool is invoked.
      *

package/dist/tools/types.js

@@ -1,5 +1,5 @@
 import { Runnable, } from "../runnables/base.js";
-import { isZodSchema } from "../utils/types/is_zod_schema.js";
+import { isInteropZodSchema, } from "../utils/types/zod.js";
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
  *
@@ -35,7 +35,7 @@ export function isStructuredToolParams(tool) {
         "name" in tool &&
         "schema" in tool &&
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (isZodSchema(tool.schema) ||
+        (isInteropZodSchema(tool.schema) ||
             (tool.schema != null &&
                 typeof tool.schema === "object" &&
                 "type" in tool.schema &&

package/dist/utils/env.cjs

@@ -8,9 +8,7 @@ const isWebWorker = () => typeof globalThis === "object" &&
     globalThis.constructor.name === "DedicatedWorkerGlobalScope";
 exports.isWebWorker = isWebWorker;
 const isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") ||
-    (typeof navigator !== "undefined" &&
-        (navigator.userAgent.includes("Node.js") ||
-            navigator.userAgent.includes("jsdom")));
+    (typeof navigator !== "undefined" && navigator.userAgent.includes("jsdom"));
 exports.isJsDom = isJsDom;
 // Supabase Edge Function provides a `Deno` global object
 // without `version` property

package/dist/utils/env.js

@@ -3,9 +3,7 @@ export const isWebWorker = () => typeof globalThis === "object" &&
     globalThis.constructor &&
     globalThis.constructor.name === "DedicatedWorkerGlobalScope";
 export const isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") ||
-    (typeof navigator !== "undefined" &&
-        (navigator.userAgent.includes("Node.js") ||
-            navigator.userAgent.includes("jsdom")));
+    (typeof navigator !== "undefined" && navigator.userAgent.includes("jsdom"));
 // Supabase Edge Function provides a `Deno` global object
 // without `version` property
 export const isDeno = () => typeof Deno !== "undefined";

package/dist/utils/function_calling.cjs

@@ -13,9 +13,8 @@ Object.defineProperty(exports, "isLangChainTool", { enumerable: true, get: funct
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
  * that is compatible with OpenAI function calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
- * into a JSON schema, which is then used as the parameters for the OpenAI function.
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
@@ -35,9 +34,8 @@ exports.convertToOpenAIFunction = convertToOpenAIFunction;
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
  * format that is compatible with OpenAI tool calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
- * into a JSON schema, which is then used as the parameters for the OpenAI tool.
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.

package/dist/utils/function_calling.d.ts

@@ -5,9 +5,8 @@ export { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangCha
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
  * that is compatible with OpenAI function calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
- * into a JSON schema, which is then used as the parameters for the OpenAI function.
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
@@ -22,9 +21,8 @@ export declare function convertToOpenAIFunction(tool: StructuredToolInterface |
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
  * format that is compatible with OpenAI tool calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
- * into a JSON schema, which is then used as the parameters for the OpenAI tool.
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.

package/dist/utils/function_calling.js

@@ -6,9 +6,8 @@ export { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangCha
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
  * that is compatible with OpenAI function calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
- * into a JSON schema, which is then used as the parameters for the OpenAI function.
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
@@ -27,9 +26,8 @@ export function convertToOpenAIFunction(tool, fields) {
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
  * format that is compatible with OpenAI tool calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
- * into a JSON schema, which is then used as the parameters for the OpenAI tool.
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.

package/dist/utils/json_schema.cjs

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatesOnlyStrings = exports.toJsonSchema = exports.Validator = exports.deepCompareStrict = void 0;
+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 is_zod_schema_js_1 = require("./types/is_zod_schema.cjs");
+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; } });
@@ -13,7 +14,10 @@ Object.defineProperty(exports, "Validator", { enumerable: true, get: function ()
  * @returns The converted schema.
  */
 function toJsonSchema(schema) {
-    if ((0, is_zod_schema_js_1.isZodSchema)(schema)) {
+    if ((0, zod_js_1.isZodSchemaV4)(schema)) {
+        return (0, core_1.toJSONSchema)(schema);
+    }
+    if ((0, zod_js_1.isZodSchemaV3)(schema)) {
         return (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
     }
     return schema;

package/dist/utils/json_schema.d.ts

@@ -1,5 +1,5 @@
-import type { z } from "zod";
 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";
 /**
@@ -7,7 +7,7 @@ export { deepCompareStrict, Validator } from "@cfworker/json-schema";
  * @param schema - The schema to convert.
  * @returns The converted schema.
  */
-export declare function toJsonSchema(schema: z.ZodType | JSONSchema): JSONSchema;
+export declare function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema;
 /**
  * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
  * (like recursive or unresolvable refs).
@@ -16,3 +16,4 @@ export declare function toJsonSchema(schema: z.ZodType | JSONSchema): JSONSchema
  * @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";

package/dist/utils/json_schema.js

@@ -1,6 +1,7 @@
+import { toJSONSchema } from "zod/v4/core";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { dereference } from "@cfworker/json-schema";
-import { isZodSchema } from "./types/is_zod_schema.js";
+import { isZodSchemaV3, isZodSchemaV4 } from "./types/zod.js";
 export { deepCompareStrict, Validator } from "@cfworker/json-schema";
 /**
  * Converts a Zod schema or JSON schema to a JSON schema.
@@ -8,7 +9,10 @@ export { deepCompareStrict, Validator } from "@cfworker/json-schema";
  * @returns The converted schema.
  */
 export function toJsonSchema(schema) {
-    if (isZodSchema(schema)) {
+    if (isZodSchemaV4(schema)) {
+        return toJSONSchema(schema);
+    }
+    if (isZodSchemaV3(schema)) {
         return zodToJsonSchema(schema);
     }
     return schema;

package/dist/utils/testing/index.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { BaseCallbackConfig, CallbackManagerForLLMRun, CallbackManagerForToolRun } from "../../callbacks/manager.js";
 import { BaseChatMessageHistory, BaseListChatMessageHistory } from "../../chat_history.js";
 import { Document } from "../../documents/document.js";
@@ -10,11 +9,13 @@ import { GenerationChunk, type ChatResult, ChatGenerationChunk } from "../../out
 import { BaseRetriever } from "../../retrievers/index.js";
 import { Runnable } from "../../runnables/base.js";
 import { StructuredTool, ToolParams } from "../../tools/index.js";
+import { ToolInputSchemaOutputType } from "../../tools/types.js";
 import { BaseTracer, Run } from "../../tracers/base.js";
 import { Embeddings, EmbeddingsInterface, EmbeddingsParams } from "../../embeddings.js";
 import { StructuredOutputMethodParams, BaseLanguageModelInput, StructuredOutputMethodOptions } from "../../language_models/base.js";
 import { VectorStore } from "../../vectorstores.js";
 import { cosine } from "../ml-distance/similarities.js";
+import { InteropZodObject, InteropZodType } from "../types/zod.js";
 /**
  * Parser for comma-separated values. It splits the input text by commas
  * and trims the resulting values.
@@ -85,7 +86,7 @@ export declare class FakeRetriever extends BaseRetriever {
 export interface ToolSpec {
     name: string;
     description?: string;
-    schema: z.ZodTypeAny | Record<string, unknown>;
+    schema: InteropZodType | Record<string, unknown>;
 }
 /**
  * Interface specific to the Fake Streaming Chat model.
@@ -161,8 +162,8 @@ export declare class FakeListChatModel extends BaseChatModel<FakeListChatModelCa
     _createResponseChunk(text: string): ChatGenerationChunk;
     _currentResponse(): string;
     _incrementResponse(): void;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, false> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, true> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, false> | InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, true> | InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;
@@ -190,17 +191,17 @@ export declare class FakeTracer extends BaseTracer {
     constructor();
     protected persistRun(run: Run): Promise<void>;
 }
-export interface FakeToolParams<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends ToolParams {
+export interface FakeToolParams<T extends InteropZodObject = InteropZodObject> extends ToolParams {
     name: string;
     description: string;
     schema: T;
 }
-export declare class FakeTool<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends StructuredTool<T> {
+export declare class FakeTool<T extends InteropZodObject = InteropZodObject> extends StructuredTool<T> {
     name: string;
     description: string;
     schema: T;
     constructor(fields: FakeToolParams<T>);
-    protected _call(arg: z.output<T>, _runManager?: CallbackManagerForToolRun): Promise<string>;
+    protected _call(arg: ToolInputSchemaOutputType<T>, _runManager?: CallbackManagerForToolRun): Promise<string>;
 }
 /**
  * A class that provides fake embeddings by overriding the embedDocuments

package/dist/utils/types/index.cjs

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./is_zod_schema.cjs"), exports);
+__exportStar(require("./zod.cjs"), exports);

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

@@ -1,4 +1,4 @@
-export * from "./is_zod_schema.js";
+export * from "./zod.js";
 /**
  * Represents a string value with autocompleted, but not required, suggestions.
  */

package/dist/utils/types/index.js

@@ -1 +1 @@
-export * from "./is_zod_schema.js";
+export * from "./zod.js";