@langchain/core 0.3.56 → 0.3.58-rc.0

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/prompts/structured.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StructuredPrompt = void 0;
+const base_js_1 = require("../runnables/base.cjs");
 const chat_js_1 = require("./chat.cjs");
 function isWithStructuredOutput(x
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -54,15 +55,12 @@ class StructuredPrompt extends chat_js_1.ChatPromptTemplate {
         }
         if (isRunnableBinding(coerceable) &&
             isWithStructuredOutput(coerceable.bound)) {
-            return super.pipe(this.method
-                ? coerceable.bound
-                    .withStructuredOutput(this.schema, { method: this.method })
-                    .bind(coerceable.kwargs ?? {})
-                    .withConfig(coerceable.config)
-                : coerceable.bound
-                    .withStructuredOutput(this.schema)
-                    .bind(coerceable.kwargs ?? {})
-                    .withConfig(coerceable.config));
+            return super.pipe(new base_js_1.RunnableBinding({
+                bound: coerceable.bound.withStructuredOutput(this.schema, ...(this.method ? [{ method: this.method }] : [])),
+                kwargs: coerceable.kwargs ?? {},
+                config: coerceable.config,
+                configFactories: coerceable.configFactories,
+            }));
         }
         throw new Error(`Structured prompts need to be piped to a language model that supports the "withStructuredOutput()" method.`);
     }

package/dist/prompts/structured.js

@@ -1,3 +1,4 @@
+import { RunnableBinding } from "../runnables/base.js";
 import { ChatPromptTemplate, } from "./chat.js";
 function isWithStructuredOutput(x
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -51,15 +52,12 @@ export class StructuredPrompt extends ChatPromptTemplate {
         }
         if (isRunnableBinding(coerceable) &&
             isWithStructuredOutput(coerceable.bound)) {
-            return super.pipe(this.method
-                ? coerceable.bound
-                    .withStructuredOutput(this.schema, { method: this.method })
-                    .bind(coerceable.kwargs ?? {})
-                    .withConfig(coerceable.config)
-                : coerceable.bound
-                    .withStructuredOutput(this.schema)
-                    .bind(coerceable.kwargs ?? {})
-                    .withConfig(coerceable.config));
+            return super.pipe(new RunnableBinding({
+                bound: coerceable.bound.withStructuredOutput(this.schema, ...(this.method ? [{ method: this.method }] : [])),
+                kwargs: coerceable.kwargs ?? {},
+                config: coerceable.config,
+                configFactories: coerceable.configFactories,
+            }));
         }
         throw new Error(`Structured prompts need to be piped to a language model that supports the "withStructuredOutput()" method.`);
     }