@langchain/core 0.3.57 → 0.3.58

package/dist/language_models/base.d.ts

@@ -1,5 +1,6 @@
 import type { TiktokenModel } from "js-tiktoken/lite";
-import { z } from "zod";
+import type { ZodType as ZodTypeV3 } from "zod/v3";
+import type { $ZodType as ZodTypeV4 } from "zod/v4/core";
 import { type BaseCache } from "../caches/base.js";
 import { type BasePromptValueInterface } from "../prompt_values.js";
 import { type BaseMessage, type BaseMessageLike, type MessageContent } from "../messages/base.js";
@@ -9,6 +10,7 @@ import { AsyncCaller, AsyncCallerParams } from "../utils/async_caller.js";
 import { Runnable, type RunnableInterface } from "../runnables/base.js";
 import { RunnableConfig } from "../runnables/config.js";
 import { JSONSchema } from "../utils/json_schema.js";
+import { InferInteropZodOutput, InteropZodObject, InteropZodType } from "../utils/types/zod.js";
 export declare const getModelNameForTiktoken: (modelName: string) => TiktokenModel;
 export declare const getEmbeddingContextSize: (modelName?: string) => number;
 export declare const getModelContextSize: (modelName: string) => number;
@@ -103,7 +105,7 @@ export interface BaseFunctionCallOptions extends BaseLanguageModelCallOptions {
     functions?: FunctionDefinition[];
 }
 export type BaseLanguageModelInput = BasePromptValueInterface | string | BaseMessageLike[];
-export type StructuredOutputType = z.infer<z.ZodObject<any, any, any, any>>;
+export type StructuredOutputType = InferInteropZodOutput<InteropZodObject>;
 export type StructuredOutputMethodOptions<IncludeRaw extends boolean = false> = {
     name?: string;
     method?: "functionCalling" | "jsonMode" | "jsonSchema" | string;
@@ -114,7 +116,7 @@ export type StructuredOutputMethodOptions<IncludeRaw extends boolean = false> =
 /** @deprecated Use StructuredOutputMethodOptions instead */
 export type StructuredOutputMethodParams<RunOutput, IncludeRaw extends boolean = false> = {
     /** @deprecated Pass schema in as the first argument */
-    schema: z.ZodType<RunOutput> | Record<string, any>;
+    schema: InteropZodType<RunOutput> | Record<string, any>;
     name?: string;
     method?: "functionCalling" | "jsonMode";
     includeRaw?: IncludeRaw;
@@ -192,8 +194,13 @@ export declare abstract class BaseLanguageModel<RunOutput = any, CallOptions ext
      * Load an LLM from a json-like object describing it.
      */
     static deserialize(_data: SerializedLLM): Promise<BaseLanguageModel>;
-    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
+    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;
@@ -203,14 +210,14 @@ export declare abstract class BaseLanguageModel<RunOutput = any, CallOptions ext
      * @template {BaseLanguageModelInput} RunInput The input type for the Runnable, expected to be the same input for the LLM.
      * @template {Record<string, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.
      *
-     * @param {z.ZodEffects<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.
+     * @param {InteropZodType<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.
      *   If a Zod schema is passed, the returned attributes will be validated, whereas with JSON schema they will not be.
      * @param {string} name The name of the function to call.
      * @param {"functionCalling" | "jsonMode"} [method=functionCalling] The method to use for getting the structured output. Defaults to "functionCalling".
      * @param {boolean | undefined} [includeRaw=false] Whether to include the raw output in the result. Defaults to false.
      * @returns {Runnable<RunInput, RunOutput> | Runnable<RunInput, { raw: BaseMessage; parsed: RunOutput }>} A new runnable that calls the LLM with structured output.
      */
-    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/language_models/chat_models.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleChatModel = exports.BaseChatModel = exports.createChatMessageChunkEncoderStream = void 0;
-const zod_to_json_schema_1 = require("zod-to-json-schema");
 const index_js_1 = require("../messages/index.cjs");
 const outputs_js_1 = require("../outputs.cjs");
 const base_js_1 = require("./base.cjs");
@@ -9,8 +8,9 @@ const manager_js_1 = require("../callbacks/manager.cjs");
 const base_js_2 = require("../runnables/base.cjs");
 const stream_js_1 = require("../utils/stream.cjs");
 const passthrough_js_1 = require("../runnables/passthrough.cjs");
-const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.cjs");
+const zod_js_1 = require("../utils/types/zod.cjs");
 const base_js_3 = require("../callbacks/base.cjs");
+const json_schema_js_1 = require("../utils/json_schema.cjs");
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead
@@ -534,7 +534,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const schema = outputSchema;
         const name = config?.name;
-        const description = schema.description ?? "A function available to call.";
+        const description = (0, zod_js_1.getSchemaDescription)(schema) ?? "A function available to call.";
         const method = config?.method;
         const includeRaw = config?.includeRaw;
         if (method === "jsonMode") {
@@ -542,14 +542,14 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         }
         let functionName = name ?? "extract";
         let tools;
-        if ((0, is_zod_schema_js_1.isZodSchema)(schema)) {
+        if ((0, zod_js_1.isInteropZodSchema)(schema)) {
             tools = [
                 {
                     type: "function",
                     function: {
                         name: functionName,
                         description,
-                        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(schema),
+                        parameters: (0, json_schema_js_1.toJsonSchema)(schema),
                     },
                 },
             ];

package/dist/language_models/chat_models.d.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import type { ZodType as ZodTypeV3 } from "zod/v3";
+import type { $ZodType as ZodTypeV4 } from "zod/v4/core";
 import { type BaseMessage, BaseMessageChunk, type BaseMessageLike, AIMessageChunk } from "../messages/index.js";
 import type { BasePromptValueInterface } from "../prompt_values.js";
 import { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from "../outputs.js";
@@ -183,8 +184,13 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
      * @returns A Promise that resolves to a string.
      */
     predict(text: string, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<string>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/language_models/chat_models.js

@@ -1,4 +1,3 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
 import { AIMessage, HumanMessage, coerceMessageLikeToMessage, isAIMessageChunk, isBaseMessage, isAIMessage, convertToOpenAIImageBlock, isURLContentBlock, isBase64ContentBlock, } from "../messages/index.js";
 import { RUN_KEY, } from "../outputs.js";
 import { BaseLanguageModel, } from "./base.js";
@@ -6,8 +5,9 @@ import { CallbackManager, } from "../callbacks/manager.js";
 import { RunnableLambda, RunnableSequence, } from "../runnables/base.js";
 import { concat } from "../utils/stream.js";
 import { RunnablePassthrough } from "../runnables/passthrough.js";
-import { isZodSchema } from "../utils/types/is_zod_schema.js";
+import { getSchemaDescription, isInteropZodSchema, } from "../utils/types/zod.js";
 import { callbackHandlerPrefersStreaming } from "../callbacks/base.js";
+import { toJsonSchema } from "../utils/json_schema.js";
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead
@@ -530,7 +530,7 @@ export class BaseChatModel extends BaseLanguageModel {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const schema = outputSchema;
         const name = config?.name;
-        const description = schema.description ?? "A function available to call.";
+        const description = getSchemaDescription(schema) ?? "A function available to call.";
         const method = config?.method;
         const includeRaw = config?.includeRaw;
         if (method === "jsonMode") {
@@ -538,14 +538,14 @@ export class BaseChatModel extends BaseLanguageModel {
         }
         let functionName = name ?? "extract";
         let tools;
-        if (isZodSchema(schema)) {
+        if (isInteropZodSchema(schema)) {
             tools = [
                 {
                     type: "function",
                     function: {
                         name: functionName,
                         description,
-                        parameters: zodToJsonSchema(schema),
+                        parameters: toJsonSchema(schema),
                     },
                 },
             ];

package/dist/output_parsers/openai_functions/json_output_functions_parsers.d.ts

@@ -1,8 +1,8 @@
-import { JsonSchema7ObjectType } from "zod-to-json-schema";
 import { Optional } from "../../types/type-utils.js";
 import { Generation, ChatGeneration } from "../../outputs.js";
 import { BaseLLMOutputParser } from "../base.js";
 import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from "../transform.js";
+import { JsonSchema7ObjectType } from "../../utils/json_schema.js";
 import { type Operation as JSONPatchOperation } from "../../utils/json_patch.js";
 /**
  * Represents optional parameters for a function in a JSON Schema.

package/dist/output_parsers/openai_tools/json_output_tools_parsers.cjs

@@ -5,6 +5,7 @@ const base_js_1 = require("../base.cjs");
 const json_js_1 = require("../json.cjs");
 const transform_js_1 = require("../transform.cjs");
 const ai_js_1 = require("../../messages/ai.cjs");
+const zod_js_1 = require("../../utils/types/zod.cjs");
 function parseToolCall(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 rawToolCall, options) {
@@ -215,12 +216,12 @@ class JsonOutputKeyToolsParser extends JsonOutputToolsParser {
         if (this.zodSchema === undefined) {
             return result;
         }
-        const zodParsedResult = await this.zodSchema.safeParseAsync(result);
+        const zodParsedResult = await (0, zod_js_1.interopSafeParseAsync)(this.zodSchema, result);
         if (zodParsedResult.success) {
             return zodParsedResult.data;
         }
         else {
-            throw new base_js_1.OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
+            throw new base_js_1.OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error?.issues)}`, JSON.stringify(result, null, 2));
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/output_parsers/openai_tools/json_output_tools_parsers.d.ts

@@ -1,7 +1,9 @@
-import { z } from "zod";
+import type * as z3 from "zod/v3";
+import type * as z4 from "zod/v4/core";
 import { ChatGeneration, ChatGenerationChunk } from "../../outputs.js";
 import { InvalidToolCall, ToolCall } from "../../messages/tool.js";
 import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from "../transform.js";
+import { type InteropZodType } from "../../utils/types/zod.js";
 export type ParsedToolCall = {
     id?: string;
     type: string;
@@ -52,11 +54,20 @@ export declare class JsonOutputToolsParser<T> extends BaseCumulativeTransformOut
      */
     parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean): Promise<any>;
 }
-export type JsonOutputKeyToolsParserParams<T extends Record<string, any> = Record<string, any>> = {
+type JsonOutputKeyToolsParserParamsBase = {
     keyName: string;
     returnSingle?: boolean;
-    zodSchema?: z.ZodType<T>;
 } & JsonOutputToolsParserParams;
+type JsonOutputKeyToolsParserParamsV3<T extends Record<string, any> = Record<string, any>> = {
+    zodSchema?: z3.ZodType<T>;
+} & JsonOutputKeyToolsParserParamsBase;
+type JsonOutputKeyToolsParserParamsV4<T extends Record<string, any> = Record<string, any>> = {
+    zodSchema?: z4.$ZodType<T, T>;
+} & JsonOutputKeyToolsParserParamsBase;
+export type JsonOutputKeyToolsParserParamsInterop<T extends Record<string, any> = Record<string, any>> = {
+    zodSchema?: InteropZodType<T>;
+} & JsonOutputKeyToolsParserParamsBase;
+export type JsonOutputKeyToolsParserParams<T extends Record<string, any> = Record<string, any>> = JsonOutputKeyToolsParserParamsV3<T>;
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object if you are
  * expecting only a single tool to be called.
@@ -70,9 +81,12 @@ export declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Re
     keyName: string;
     /** Whether to return only the first tool call. */
     returnSingle: boolean;
-    zodSchema?: z.ZodType<T>;
-    constructor(params: JsonOutputKeyToolsParserParams<T>);
+    zodSchema?: InteropZodType<T>;
+    constructor(params: JsonOutputKeyToolsParserParamsV3<T>);
+    constructor(params: JsonOutputKeyToolsParserParamsV4<T>);
+    constructor(params: JsonOutputKeyToolsParserParamsInterop<T>);
     protected _validateResult(result: unknown): Promise<T>;
     parsePartialResult(generations: ChatGeneration[]): Promise<any>;
     parseResult(generations: ChatGeneration[]): Promise<any>;
 }
+export {};

package/dist/output_parsers/openai_tools/json_output_tools_parsers.js

@@ -2,6 +2,7 @@ import { OutputParserException } from "../base.js";
 import { parsePartialJson } from "../json.js";
 import { BaseCumulativeTransformOutputParser, } from "../transform.js";
 import { isAIMessage } from "../../messages/ai.js";
+import { interopSafeParseAsync, } from "../../utils/types/zod.js";
 export function parseToolCall(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 rawToolCall, options) {
@@ -208,12 +209,12 @@ export class JsonOutputKeyToolsParser extends JsonOutputToolsParser {
         if (this.zodSchema === undefined) {
             return result;
         }
-        const zodParsedResult = await this.zodSchema.safeParseAsync(result);
+        const zodParsedResult = await interopSafeParseAsync(this.zodSchema, result);
         if (zodParsedResult.success) {
             return zodParsedResult.data;
         }
         else {
-            throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
+            throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error?.issues)}`, JSON.stringify(result, null, 2));
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/output_parsers/structured.cjs

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsymmetricStructuredOutputParser = exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = void 0;
-const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const v3_1 = require("zod/v3");
 const base_js_1 = require("./base.cjs");
+const zod_js_1 = require("../utils/types/zod.cjs");
+const json_schema_js_1 = require("../utils/json_schema.cjs");
 class StructuredOutputParser extends base_js_1.BaseOutputParser {
     static lc_name() {
         return "StructuredOutputParser";
@@ -41,7 +42,7 @@ class StructuredOutputParser extends base_js_1.BaseOutputParser {
      * @returns A new instance of StructuredOutputParser.
      */
     static fromNamesAndDescriptions(schemas) {
-        const zodSchema = zod_1.z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, zod_1.z.string().describe(description)])));
+        const zodSchema = v3_1.z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, v3_1.z.string().describe(description)])));
         return new this(zodSchema);
     }
     /**
@@ -63,7 +64,7 @@ Your output will be parsed and type-checked according to the provided schema ins
 
 Here is the JSON Schema instance your output must adhere to. Include the enclosing markdown codeblock:
 \`\`\`json
-${JSON.stringify((0, zod_to_json_schema_1.zodToJsonSchema)(this.schema))}
+${JSON.stringify((0, json_schema_js_1.toJsonSchema)(this.schema))}
 \`\`\`
 `;
     }
@@ -83,7 +84,7 @@ ${JSON.stringify((0, zod_to_json_schema_1.zodToJsonSchema)(this.schema))}
                 return `"${escapedInsideQuotes}"`;
             })
                 .replace(/\n/g, "");
-            return await this.schema.parseAsync(JSON.parse(escapedJson));
+            return await (0, zod_js_1.interopParseAsync)(this.schema, JSON.parse(escapedJson));
         }
         catch (e) {
             throw new base_js_1.OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
@@ -104,7 +105,7 @@ class JsonMarkdownStructuredOutputParser extends StructuredOutputParser {
         if (interpolationDepth < 1) {
             throw new Error("f string interpolation depth must be at least 1");
         }
-        return `Return a markdown code snippet with a JSON object formatted to look like:\n\`\`\`json\n${this._schemaToInstruction((0, zod_to_json_schema_1.zodToJsonSchema)(this.schema))
+        return `Return a markdown code snippet with a JSON object formatted to look like:\n\`\`\`json\n${this._schemaToInstruction((0, json_schema_js_1.toJsonSchema)(this.schema))
             .replaceAll("{", "{".repeat(interpolationDepth))
             .replaceAll("}", "}".repeat(interpolationDepth))}\n\`\`\``;
     }
@@ -159,7 +160,7 @@ class JsonMarkdownStructuredOutputParser extends StructuredOutputParser {
         return new this(schema);
     }
     static fromNamesAndDescriptions(schemas) {
-        const zodSchema = zod_1.z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, zod_1.z.string().describe(description)])));
+        const zodSchema = v3_1.z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, v3_1.z.string().describe(description)])));
         return new this(zodSchema);
     }
 }

package/dist/output_parsers/structured.d.ts

@@ -1,12 +1,13 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 import { BaseOutputParser, FormatInstructionsOptions } from "./base.js";
+import { type InteropZodType, type InferInteropZodOutput } from "../utils/types/zod.js";
 export type JsonMarkdownStructuredOutputParserInput = {
     interpolationDepth?: number;
 };
 export interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {
     interpolationDepth?: number;
 }
-export declare class StructuredOutputParser<T extends z.ZodTypeAny> extends BaseOutputParser<z.infer<T>> {
+export declare class StructuredOutputParser<T extends InteropZodType> extends BaseOutputParser<InferInteropZodOutput<T>> {
     schema: T;
     static lc_name(): string;
     lc_namespace: string[];
@@ -17,7 +18,7 @@ export declare class StructuredOutputParser<T extends z.ZodTypeAny> extends Base
      * @param schema The Zod schema which the output should match
      * @returns A new instance of StructuredOutputParser.
      */
-    static fromZodSchema<T extends z.ZodTypeAny>(schema: T): StructuredOutputParser<T>;
+    static fromZodSchema<T extends InteropZodType>(schema: T): StructuredOutputParser<T>;
     /**
      * Creates a new StructuredOutputParser from a set of names and
      * descriptions.
@@ -45,17 +46,17 @@ export declare class StructuredOutputParser<T extends z.ZodTypeAny> extends Base
      * @param text The text to parse
      * @returns The parsed output.
      */
-    parse(text: string): Promise<z.infer<T>>;
+    parse(text: string): Promise<InferInteropZodOutput<T>>;
 }
 /**
  * A specific type of `StructuredOutputParser` that parses JSON data
  * formatted as a markdown code snippet.
  */
-export declare class JsonMarkdownStructuredOutputParser<T extends z.ZodTypeAny> extends StructuredOutputParser<T> {
+export declare class JsonMarkdownStructuredOutputParser<T extends InteropZodType> extends StructuredOutputParser<T> {
     static lc_name(): string;
     getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;
     private _schemaToInstruction;
-    static fromZodSchema<T extends z.ZodTypeAny>(schema: T): JsonMarkdownStructuredOutputParser<T>;
+    static fromZodSchema<T extends InteropZodType>(schema: T): JsonMarkdownStructuredOutputParser<T>;
     static fromNamesAndDescriptions<S extends {
         [key: string]: string;
     }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{
@@ -66,14 +67,14 @@ export declare class JsonMarkdownStructuredOutputParser<T extends z.ZodTypeAny>
         [x: string]: string;
     }>>;
 }
-export interface AsymmetricStructuredOutputParserFields<T extends z.ZodTypeAny> {
+export interface AsymmetricStructuredOutputParserFields<T extends InteropZodType> {
     inputSchema: T;
 }
 /**
  * A type of `StructuredOutputParser` that handles asymmetric input and
  * output schemas.
  */
-export declare abstract class AsymmetricStructuredOutputParser<T extends z.ZodTypeAny, Y = unknown> extends BaseOutputParser<Y> {
+export declare abstract class AsymmetricStructuredOutputParser<T extends InteropZodType, Y = unknown> extends BaseOutputParser<Y> {
     private structuredInputParser;
     constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>);
     /**
@@ -82,7 +83,7 @@ export declare abstract class AsymmetricStructuredOutputParser<T extends z.ZodTy
      * @param input The parsed input
      * @returns The processed output.
      */
-    abstract outputProcessor(input: z.infer<T>): Promise<Y>;
+    abstract outputProcessor(input: InferInteropZodOutput<T>): Promise<Y>;
     parse(text: string): Promise<Y>;
     getFormatInstructions(): string;
 }

package/dist/output_parsers/structured.js

@@ -1,6 +1,7 @@
-import { z } from "zod";
-import { zodToJsonSchema, } from "zod-to-json-schema";
+import { z } from "zod/v3";
 import { BaseOutputParser, OutputParserException, } from "./base.js";
+import { interopParseAsync, } from "../utils/types/zod.js";
+import { toJsonSchema, } from "../utils/json_schema.js";
 export class StructuredOutputParser extends BaseOutputParser {
     static lc_name() {
         return "StructuredOutputParser";
@@ -60,7 +61,7 @@ Your output will be parsed and type-checked according to the provided schema ins
 
 Here is the JSON Schema instance your output must adhere to. Include the enclosing markdown codeblock:
 \`\`\`json
-${JSON.stringify(zodToJsonSchema(this.schema))}
+${JSON.stringify(toJsonSchema(this.schema))}
 \`\`\`
 `;
     }
@@ -80,7 +81,7 @@ ${JSON.stringify(zodToJsonSchema(this.schema))}
                 return `"${escapedInsideQuotes}"`;
             })
                 .replace(/\n/g, "");
-            return await this.schema.parseAsync(JSON.parse(escapedJson));
+            return await interopParseAsync(this.schema, JSON.parse(escapedJson));
         }
         catch (e) {
             throw new OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
@@ -100,7 +101,7 @@ export class JsonMarkdownStructuredOutputParser extends StructuredOutputParser {
         if (interpolationDepth < 1) {
             throw new Error("f string interpolation depth must be at least 1");
         }
-        return `Return a markdown code snippet with a JSON object formatted to look like:\n\`\`\`json\n${this._schemaToInstruction(zodToJsonSchema(this.schema))
+        return `Return a markdown code snippet with a JSON object formatted to look like:\n\`\`\`json\n${this._schemaToInstruction(toJsonSchema(this.schema))
             .replaceAll("{", "{".repeat(interpolationDepth))
             .replaceAll("}", "}".repeat(interpolationDepth))}\n\`\`\``;
     }

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 &&
@@ -342,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);
@@ -2334,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));
@@ -2388,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> = {
@@ -310,8 +310,8 @@ 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>;
@@ -910,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;
@@ -933,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 &&
@@ -2314,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));
@@ -2367,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,
         });