@langchain/core 0.3.0-rc.0 → 0.3.0

package/README.md

@@ -83,7 +83,7 @@ Streaming (and streaming of intermediate steps) is needed to show the user that
 Async interfaces are nice when moving into production.
 Rather than having to write multiple implementations for all of those, LCEL allows you to write a runnable once and invoke it in many different ways.
 
-For more check out the [LCEL docs](https://js.langchain.com/v0.2/docs/concepts#langchain-expression-language).
+For more check out the [LCEL docs](https://js.langchain.com/docs/concepts#langchain-expression-language).
 
 ![LangChain Stack](../docs/core_docs/static/svg/langchain_stack_062024.svg)
 

package/dist/callbacks/dispatch/web.cjs

@@ -50,7 +50,7 @@ payload, config) {
             "and explicitly pass in a config parameter.",
             `\n\nOr, if you are calling this from a custom tool, ensure you're using the "tool" helper constructor as documented here:`,
             "\n  |",
-            "\n  └-> https://js.langchain.com/v0.2/docs/how_to/custom_tools#tool-function",
+            "\n  └-> https://js.langchain.com/docs/how_to/custom_tools#tool-function",
             "\n",
         ].join(" "));
     }

package/dist/callbacks/dispatch/web.js

@@ -47,7 +47,7 @@ payload, config) {
             "and explicitly pass in a config parameter.",
             `\n\nOr, if you are calling this from a custom tool, ensure you're using the "tool" helper constructor as documented here:`,
             "\n  |",
-            "\n  └-> https://js.langchain.com/v0.2/docs/how_to/custom_tools#tool-function",
+            "\n  └-> https://js.langchain.com/docs/how_to/custom_tools#tool-function",
             "\n",
         ].join(" "));
     }

package/dist/language_models/base.d.ts

@@ -89,14 +89,6 @@ export interface FunctionDefinition {
      * how to call the function.
      */
     description?: string;
-    /**
-     * Whether to enable strict schema adherence when generating the function call. If
-     * set to true, the model will follow the exact schema defined in the `parameters`
-     * field. Only a subset of JSON Schema is supported when `strict` is `true`. Learn
-     * more about Structured Outputs in the
-     * [function calling guide](https://platform.openai.com/docs/guides/function-calling).
-     */
-    strict?: boolean;
 }
 export interface ToolDefinition {
     type: "function";

package/dist/language_models/chat_models.d.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { type BaseMessage, BaseMessageChunk, type BaseMessageLike } from "../messages/index.js";
 import type { BasePromptValueInterface } from "../prompt_values.js";
 import { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from "../outputs.js";
-import { BaseLanguageModel, StructuredOutputMethodOptions, ToolDefinition, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from "./base.js";
+import { BaseLanguageModel, type StructuredOutputMethodOptions, type ToolDefinition, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from "./base.js";
 import { type CallbackManagerForLLMRun, type Callbacks } from "../callbacks/manager.js";
 import type { RunnableConfig } from "../runnables/config.js";
 import type { BaseCache } from "../caches/base.js";

package/dist/messages/ai.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIMessageChunk = exports.isAIMessage = exports.AIMessage = void 0;
+exports.AIMessageChunk = exports.isAIMessageChunk = exports.isAIMessage = exports.AIMessage = void 0;
 const json_js_1 = require("../utils/json.cjs");
 const base_js_1 = require("./base.cjs");
 const tool_js_1 = require("./tool.cjs");
@@ -112,6 +112,10 @@ function isAIMessage(x) {
     return x._getType() === "ai";
 }
 exports.isAIMessage = isAIMessage;
+function isAIMessageChunk(x) {
+    return x._getType() === "ai";
+}
+exports.isAIMessageChunk = isAIMessageChunk;
 /**
  * Represents a chunk of an AI message, which can be concatenated with
  * other AI message chunks.

package/dist/messages/ai.d.ts

@@ -41,6 +41,7 @@ export declare class AIMessage extends BaseMessage {
     get _printableFields(): Record<string, unknown>;
 }
 export declare function isAIMessage(x: BaseMessage): x is AIMessage;
+export declare function isAIMessageChunk(x: BaseMessageChunk): x is AIMessageChunk;
 export type AIMessageChunkFields = AIMessageFields & {
     tool_call_chunks?: ToolCallChunk[];
 };

package/dist/messages/ai.js

@@ -107,6 +107,9 @@ export class AIMessage extends BaseMessage {
 export function isAIMessage(x) {
     return x._getType() === "ai";
 }
+export function isAIMessageChunk(x) {
+    return x._getType() === "ai";
+}
 /**
  * Represents a chunk of an AI message, which can be concatenated with
  * other AI message chunks.

package/dist/messages/base.d.ts

@@ -59,7 +59,13 @@ export type BaseMessageFields = {
     content: MessageContent;
     name?: string;
     additional_kwargs?: {
+        /**
+         * @deprecated Use "tool_calls" field on AIMessages instead
+         */
         function_call?: FunctionCall;
+        /**
+         * @deprecated Use "tool_calls" field on AIMessages instead
+         */
         tool_calls?: OpenAIToolCall[];
         [key: string]: unknown;
     };
@@ -119,6 +125,9 @@ export declare abstract class BaseMessage extends Serializable implements BaseMe
     _updateId(value: string | undefined): void;
     get [Symbol.toStringTag](): any;
 }
+/**
+ * @deprecated Use "tool_calls" field on AIMessages instead
+ */
 export type OpenAIToolCall = {
     /**
      * The ID of the tool call.
@@ -154,11 +163,15 @@ export type MessageFieldWithRole = {
     name?: string;
 } & Record<string, unknown>;
 export declare function _isMessageFieldWithRole(x: BaseMessageLike): x is MessageFieldWithRole;
-export type BaseMessageLike = BaseMessage | ({
-    type: MessageType | "user" | "assistant" | "placeholder";
-} & BaseMessageFields & Record<string, unknown>) | MessageFieldWithRole | [
+export type BaseMessageLike = BaseMessage | MessageFieldWithRole | [
     StringWithAutocomplete<MessageType | "user" | "assistant" | "placeholder">,
     MessageContent
-] | string;
+] | string
+/**
+ * @deprecated Specifying "type" is deprecated and will be removed in 0.4.0.
+ */
+ | ({
+    type: MessageType | "user" | "assistant" | "placeholder";
+} & BaseMessageFields & Record<string, unknown>);
 export declare function isBaseMessage(messageLike?: unknown): messageLike is BaseMessage;
 export declare function isBaseMessageChunk(messageLike?: unknown): messageLike is BaseMessageChunk;

package/dist/output_parsers/openai_tools/json_output_tools_parsers.cjs

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonOutputKeyToolsParser = exports.JsonOutputToolsParser = exports.makeInvalidToolCall = exports.convertLangChainToolCallToOpenAI = exports.parseToolCall = void 0;
 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");
 function parseToolCall(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 rawToolCall, options) {
@@ -74,7 +76,7 @@ exports.makeInvalidToolCall = makeInvalidToolCall;
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
-class JsonOutputToolsParser extends base_js_1.BaseLLMOutputParser {
+class JsonOutputToolsParser extends transform_js_1.BaseCumulativeTransformOutputParser {
     static lc_name() {
         return "JsonOutputToolsParser";
     }
@@ -100,40 +102,56 @@ class JsonOutputToolsParser extends base_js_1.BaseLLMOutputParser {
         });
         this.returnId = fields?.returnId ?? this.returnId;
     }
+    _diff() {
+        throw new Error("Not supported.");
+    }
+    async parse() {
+        throw new Error("Not implemented.");
+    }
+    async parseResult(generations) {
+        const result = await this.parsePartialResult(generations, false);
+        return result;
+    }
     /**
      * Parses the output and returns a JSON object. If `argsOnly` is true,
      * only the arguments of the function call are returned.
      * @param generations The output of the LLM to parse.
      * @returns A JSON object representation of the function call or its arguments.
      */
-    async parseResult(generations) {
-        const toolCalls = generations[0].message.additional_kwargs.tool_calls;
+    async parsePartialResult(generations, partial = true
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        const message = generations[0].message;
+        let toolCalls;
+        if ((0, ai_js_1.isAIMessage)(message) && message.tool_calls?.length) {
+            toolCalls = message.tool_calls.map((toolCall) => {
+                const { id, ...rest } = toolCall;
+                if (!this.returnId) {
+                    return rest;
+                }
+                return {
+                    id,
+                    ...rest,
+                };
+            });
+        }
+        else if (message.additional_kwargs.tool_calls !== undefined) {
+            const rawToolCalls = JSON.parse(JSON.stringify(message.additional_kwargs.tool_calls));
+            toolCalls = rawToolCalls.map((rawToolCall) => {
+                return parseToolCall(rawToolCall, { returnId: this.returnId, partial });
+            });
+        }
         if (!toolCalls) {
-            throw new Error(`No tools_call in message ${JSON.stringify(generations)}`);
+            return [];
         }
-        const clonedToolCalls = JSON.parse(JSON.stringify(toolCalls));
         const parsedToolCalls = [];
-        for (const toolCall of clonedToolCalls) {
-            const parsedToolCall = parseToolCall(toolCall, { partial: true });
-            if (parsedToolCall !== undefined) {
-                // backward-compatibility with previous
-                // versions of Langchain JS, which uses `name` and `arguments`
-                // @ts-expect-error name and arguemnts are defined by Object.defineProperty
+        for (const toolCall of toolCalls) {
+            if (toolCall !== undefined) {
                 const backwardsCompatibleToolCall = {
-                    type: parsedToolCall.name,
-                    args: parsedToolCall.args,
-                    id: parsedToolCall.id,
+                    type: toolCall.name,
+                    args: toolCall.args,
+                    id: toolCall.id,
                 };
-                Object.defineProperty(backwardsCompatibleToolCall, "name", {
-                    get() {
-                        return this.type;
-                    },
-                });
-                Object.defineProperty(backwardsCompatibleToolCall, "arguments", {
-                    get() {
-                        return this.args;
-                    },
-                });
                 parsedToolCalls.push(backwardsCompatibleToolCall);
             }
         }
@@ -145,7 +163,7 @@ exports.JsonOutputToolsParser = JsonOutputToolsParser;
  * 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.
  */
-class JsonOutputKeyToolsParser extends base_js_1.BaseLLMOutputParser {
+class JsonOutputKeyToolsParser extends JsonOutputToolsParser {
     static lc_name() {
         return "JsonOutputKeyToolsParser";
     }
@@ -183,12 +201,6 @@ class JsonOutputKeyToolsParser extends base_js_1.BaseLLMOutputParser {
             writable: true,
             value: false
         });
-        Object.defineProperty(this, "initialParser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "zodSchema", {
             enumerable: true,
             configurable: true,
@@ -197,7 +209,6 @@ class JsonOutputKeyToolsParser extends base_js_1.BaseLLMOutputParser {
         });
         this.keyName = params.keyName;
         this.returnSingle = params.returnSingle ?? this.returnSingle;
-        this.initialParser = new JsonOutputToolsParser(params);
         this.zodSchema = params.zodSchema;
     }
     async _validateResult(result) {
@@ -213,11 +224,31 @@ class JsonOutputKeyToolsParser extends base_js_1.BaseLLMOutputParser {
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parsePartialResult(generations) {
+        const results = await super.parsePartialResult(generations);
+        const matchingResults = results.filter((result) => result.type === this.keyName);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let returnedValues = matchingResults;
+        if (!matchingResults.length) {
+            return undefined;
+        }
+        if (!this.returnId) {
+            returnedValues = matchingResults.map((result) => result.args);
+        }
+        if (this.returnSingle) {
+            return returnedValues[0];
+        }
+        return returnedValues;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async parseResult(generations) {
-        const results = await this.initialParser.parseResult(generations);
+        const results = await super.parsePartialResult(generations, false);
         const matchingResults = results.filter((result) => result.type === this.keyName);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnedValues = matchingResults;
+        if (!matchingResults.length) {
+            return undefined;
+        }
         if (!this.returnId) {
             returnedValues = matchingResults.map((result) => result.args);
         }

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

@@ -1,20 +1,16 @@
 import { z } from "zod";
-import { ChatGeneration } from "../../outputs.js";
-import { BaseLLMOutputParser } from "../base.js";
+import { ChatGeneration, ChatGenerationChunk } from "../../outputs.js";
 import { InvalidToolCall, ToolCall } from "../../messages/tool.js";
+import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from "../transform.js";
 export type ParsedToolCall = {
     id?: string;
     type: string;
     args: Record<string, any>;
-    /** @deprecated Use `type` instead. Will be removed in 0.2.0. */
-    name: string;
-    /** @deprecated Use `args` instead. Will be removed in 0.2.0. */
-    arguments: Record<string, any>;
 };
 export type JsonOutputToolsParserParams = {
     /** Whether to return the tool call id. */
     returnId?: boolean;
-};
+} & BaseCumulativeTransformOutputParserInput;
 export declare function parseToolCall(rawToolCall: Record<string, any>, options: {
     returnId?: boolean;
     partial: true;
@@ -23,6 +19,10 @@ export declare function parseToolCall(rawToolCall: Record<string, any>, options?
     returnId?: boolean;
     partial?: false;
 }): ToolCall;
+export declare function parseToolCall(rawToolCall: Record<string, any>, options?: {
+    returnId?: boolean;
+    partial?: boolean;
+}): ToolCall | undefined;
 export declare function convertLangChainToolCallToOpenAI(toolCall: ToolCall): {
     id: string;
     type: string;
@@ -35,32 +35,33 @@ export declare function makeInvalidToolCall(rawToolCall: Record<string, any>, er
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
-export declare class JsonOutputToolsParser extends BaseLLMOutputParser<ParsedToolCall[]> {
+export declare class JsonOutputToolsParser<T> extends BaseCumulativeTransformOutputParser<T> {
     static lc_name(): string;
     returnId: boolean;
     lc_namespace: string[];
     lc_serializable: boolean;
     constructor(fields?: JsonOutputToolsParserParams);
+    protected _diff(): void;
+    parse(): Promise<T>;
+    parseResult(generations: ChatGeneration[]): Promise<T>;
     /**
      * Parses the output and returns a JSON object. If `argsOnly` is true,
      * only the arguments of the function call are returned.
      * @param generations The output of the LLM to parse.
      * @returns A JSON object representation of the function call or its arguments.
      */
-    parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]>;
+    parsePartialResult(generations: ChatGenerationChunk[] | ChatGeneration[], partial?: boolean): Promise<any>;
 }
 export type JsonOutputKeyToolsParserParams<T extends Record<string, any> = Record<string, any>> = {
     keyName: string;
     returnSingle?: boolean;
-    /** Whether to return the tool call id. */
-    returnId?: boolean;
     zodSchema?: z.ZodType<T>;
-};
+} & JsonOutputToolsParserParams;
 /**
  * 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.
  */
-export declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+export declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Record<string, any>> extends JsonOutputToolsParser<T> {
     static lc_name(): string;
     lc_namespace: string[];
     lc_serializable: boolean;
@@ -69,9 +70,9 @@ export declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Re
     keyName: string;
     /** Whether to return only the first tool call. */
     returnSingle: boolean;
-    initialParser: JsonOutputToolsParser;
     zodSchema?: z.ZodType<T>;
     constructor(params: JsonOutputKeyToolsParserParams<T>);
     protected _validateResult(result: unknown): Promise<T>;
+    parsePartialResult(generations: ChatGeneration[]): Promise<any>;
     parseResult(generations: ChatGeneration[]): Promise<any>;
 }

package/dist/output_parsers/openai_tools/json_output_tools_parsers.js

@@ -1,5 +1,7 @@
-import { BaseLLMOutputParser, OutputParserException } from "../base.js";
+import { OutputParserException } from "../base.js";
 import { parsePartialJson } from "../json.js";
+import { BaseCumulativeTransformOutputParser, } from "../transform.js";
+import { isAIMessage } from "../../messages/ai.js";
 export function parseToolCall(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 rawToolCall, options) {
@@ -68,7 +70,7 @@ rawToolCall, errorMsg) {
 /**
  * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
-export class JsonOutputToolsParser extends BaseLLMOutputParser {
+export class JsonOutputToolsParser extends BaseCumulativeTransformOutputParser {
     static lc_name() {
         return "JsonOutputToolsParser";
     }
@@ -94,40 +96,56 @@ export class JsonOutputToolsParser extends BaseLLMOutputParser {
         });
         this.returnId = fields?.returnId ?? this.returnId;
     }
+    _diff() {
+        throw new Error("Not supported.");
+    }
+    async parse() {
+        throw new Error("Not implemented.");
+    }
+    async parseResult(generations) {
+        const result = await this.parsePartialResult(generations, false);
+        return result;
+    }
     /**
      * Parses the output and returns a JSON object. If `argsOnly` is true,
      * only the arguments of the function call are returned.
      * @param generations The output of the LLM to parse.
      * @returns A JSON object representation of the function call or its arguments.
      */
-    async parseResult(generations) {
-        const toolCalls = generations[0].message.additional_kwargs.tool_calls;
+    async parsePartialResult(generations, partial = true
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        const message = generations[0].message;
+        let toolCalls;
+        if (isAIMessage(message) && message.tool_calls?.length) {
+            toolCalls = message.tool_calls.map((toolCall) => {
+                const { id, ...rest } = toolCall;
+                if (!this.returnId) {
+                    return rest;
+                }
+                return {
+                    id,
+                    ...rest,
+                };
+            });
+        }
+        else if (message.additional_kwargs.tool_calls !== undefined) {
+            const rawToolCalls = JSON.parse(JSON.stringify(message.additional_kwargs.tool_calls));
+            toolCalls = rawToolCalls.map((rawToolCall) => {
+                return parseToolCall(rawToolCall, { returnId: this.returnId, partial });
+            });
+        }
         if (!toolCalls) {
-            throw new Error(`No tools_call in message ${JSON.stringify(generations)}`);
+            return [];
         }
-        const clonedToolCalls = JSON.parse(JSON.stringify(toolCalls));
         const parsedToolCalls = [];
-        for (const toolCall of clonedToolCalls) {
-            const parsedToolCall = parseToolCall(toolCall, { partial: true });
-            if (parsedToolCall !== undefined) {
-                // backward-compatibility with previous
-                // versions of Langchain JS, which uses `name` and `arguments`
-                // @ts-expect-error name and arguemnts are defined by Object.defineProperty
+        for (const toolCall of toolCalls) {
+            if (toolCall !== undefined) {
                 const backwardsCompatibleToolCall = {
-                    type: parsedToolCall.name,
-                    args: parsedToolCall.args,
-                    id: parsedToolCall.id,
+                    type: toolCall.name,
+                    args: toolCall.args,
+                    id: toolCall.id,
                 };
-                Object.defineProperty(backwardsCompatibleToolCall, "name", {
-                    get() {
-                        return this.type;
-                    },
-                });
-                Object.defineProperty(backwardsCompatibleToolCall, "arguments", {
-                    get() {
-                        return this.args;
-                    },
-                });
                 parsedToolCalls.push(backwardsCompatibleToolCall);
             }
         }
@@ -138,7 +156,7 @@ export class JsonOutputToolsParser extends BaseLLMOutputParser {
  * 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.
  */
-export class JsonOutputKeyToolsParser extends BaseLLMOutputParser {
+export class JsonOutputKeyToolsParser extends JsonOutputToolsParser {
     static lc_name() {
         return "JsonOutputKeyToolsParser";
     }
@@ -176,12 +194,6 @@ export class JsonOutputKeyToolsParser extends BaseLLMOutputParser {
             writable: true,
             value: false
         });
-        Object.defineProperty(this, "initialParser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "zodSchema", {
             enumerable: true,
             configurable: true,
@@ -190,7 +202,6 @@ export class JsonOutputKeyToolsParser extends BaseLLMOutputParser {
         });
         this.keyName = params.keyName;
         this.returnSingle = params.returnSingle ?? this.returnSingle;
-        this.initialParser = new JsonOutputToolsParser(params);
         this.zodSchema = params.zodSchema;
     }
     async _validateResult(result) {
@@ -206,11 +217,31 @@ export class JsonOutputKeyToolsParser extends BaseLLMOutputParser {
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parsePartialResult(generations) {
+        const results = await super.parsePartialResult(generations);
+        const matchingResults = results.filter((result) => result.type === this.keyName);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let returnedValues = matchingResults;
+        if (!matchingResults.length) {
+            return undefined;
+        }
+        if (!this.returnId) {
+            returnedValues = matchingResults.map((result) => result.args);
+        }
+        if (this.returnSingle) {
+            return returnedValues[0];
+        }
+        return returnedValues;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async parseResult(generations) {
-        const results = await this.initialParser.parseResult(generations);
+        const results = await super.parsePartialResult(generations, false);
         const matchingResults = results.filter((result) => result.type === this.keyName);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnedValues = matchingResults;
+        if (!matchingResults.length) {
+            return undefined;
+        }
         if (!this.returnId) {
             returnedValues = matchingResults.map((result) => result.args);
         }

package/dist/output_parsers/transform.cjs

@@ -105,5 +105,8 @@ class BaseCumulativeTransformOutputParser extends BaseTransformOutputParser {
             }
         }
     }
+    getFormatInstructions() {
+        return "";
+    }
 }
 exports.BaseCumulativeTransformOutputParser = BaseCumulativeTransformOutputParser;

package/dist/output_parsers/transform.d.ts

@@ -30,4 +30,5 @@ export declare abstract class BaseCumulativeTransformOutputParser<T = unknown> e
     protected abstract _diff(prev: any | undefined, next: any): any;
     abstract parsePartialResult(generations: Generation[] | ChatGeneration[]): Promise<T | undefined>;
     _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;
+    getFormatInstructions(): string;
 }

package/dist/output_parsers/transform.js

@@ -101,4 +101,7 @@ export class BaseCumulativeTransformOutputParser extends BaseTransformOutputPars
             }
         }
     }
+    getFormatInstructions() {
+        return "";
+    }
 }

package/dist/runnables/base.d.ts

@@ -182,39 +182,39 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * **ATTENTION** This reference table is for the V2 version of the schema.
      *
      * ```md
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | event                | name             | chunk                           | input                                         | output                                          |
-     * +======================+==================+=================================+===============================================+=================================================+
-     * | on_chat_model_start  | [model name]     |                                 | {"messages": [[SystemMessage, HumanMessage]]} |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chat_model_stream | [model name]     | AIMessageChunk(content="hello") |                                               |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chat_model_end    | [model name]     |                                 | {"messages": [[SystemMessage, HumanMessage]]} | AIMessageChunk(content="hello world")           |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_llm_start         | [model name]     |                                 | {'input': 'hello'}                            |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_llm_stream        | [model name]     | 'Hello'                         |                                               |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_llm_end           | [model name]     |                                 | 'Hello human!'                                |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chain_start       | some_runnable    |                                 |                                               |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chain_stream      | some_runnable    | "hello world!, goodbye world!"  |                                               |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chain_end         | some_runnable    |                                 | [Document(...)]                               | "hello world!, goodbye world!"                  |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_tool_start        | some_tool        |                                 | {"x": 1, "y": "2"}                            |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_tool_end          | some_tool        |                                 |                                               | {"x": 1, "y": "2"}                              |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_retriever_start   | [retriever name] |                                 | {"query": "hello"}                            |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_retriever_end     | [retriever name] |                                 | {"query": "hello"}                            | [Document(...), ..]                             |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_prompt_start      | [template_name]  |                                 | {"question": "hello"}                         |                                                 |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_prompt_end        | [template_name]  |                                 | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
-     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | event                | input                       | output/chunk                             |
+     * +======================+=============================+==========================================+
+     * | on_chat_model_start  | {"messages": BaseMessage[]} |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chat_model_stream |                             | AIMessageChunk("hello")                  |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chat_model_end    | {"messages": BaseMessage[]} | AIMessageChunk("hello world")            |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_llm_start         | {'input': 'hello'}          |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_llm_stream        |                             | 'Hello'                                  |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_llm_end           | 'Hello human!'              |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chain_start       |                             |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chain_stream      |                             | "hello world!"                           |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chain_end         | [Document(...)]             | "hello world!, goodbye world!"           |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_tool_start        | {"x": 1, "y": "2"}          |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_tool_end          |                             | {"x": 1, "y": "2"}                       |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_retriever_start   | {"query": "hello"}          |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_retriever_end     | {"query": "hello"}          | [Document(...), ..]                      |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_prompt_start      | {"question": "hello"}       |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_prompt_end        | {"question": "hello"}       | ChatPromptValue(messages: BaseMessage[]) |
+     * +----------------------+-----------------------------+------------------------------------------+
      * ```
      *
      * The "on_chain_*" events are the default for Runnables that don't fit one of the above categories.
@@ -226,13 +226,13 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * A custom event has following format:
      *
      * ```md
-     * +-----------+------+-----------------------------------------------------------------------------------------------------------+
-     * | Attribute | Type | Description                                                                                               |
-     * +===========+======+===========================================================================================================+
-     * | name      | str  | A user defined name for the event.                                                                        |
-     * +-----------+------+-----------------------------------------------------------------------------------------------------------+
-     * | data      | Any  | The data associated with the event. This can be anything, though we suggest making it JSON serializable.  |
-     * +-----------+------+-----------------------------------------------------------------------------------------------------------+
+     * +-----------+------+------------------------------------------------------------+
+     * | Attribute | Type | Description                                                |
+     * +===========+======+============================================================+
+     * | name      | str  | A user defined name for the event.                         |
+     * +-----------+------+------------------------------------------------------------+
+     * | data      | Any  | The data associated with the event. This can be anything.  |
+     * +-----------+------+------------------------------------------------------------+
      * ```
      *
      * Here's an example:

package/dist/utils/function_calling.cjs

@@ -51,6 +51,7 @@ tool, fields) {
         toolDef = tool;
     }
     if (fieldsCopy?.strict !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         toolDef.function.strict = fieldsCopy.strict;
     }
     return toolDef;

package/dist/utils/function_calling.js

@@ -47,6 +47,7 @@ tool, fields) {
         toolDef = tool;
     }
     if (fieldsCopy?.strict !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         toolDef.function.strict = fieldsCopy.strict;
     }
     return toolDef;

package/dist/utils/stream.cjs

@@ -68,6 +68,11 @@ class IterableReadableStream extends ReadableStream {
     [Symbol.asyncIterator]() {
         return this;
     }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Not present in Node 18 types, required in latest Node 22
+    async [Symbol.asyncDispose]() {
+        await this.return();
+    }
     static fromReadableStream(stream) {
         // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream
         const reader = stream.getReader();
@@ -249,6 +254,11 @@ class AsyncGeneratorWithSetup {
     [Symbol.asyncIterator]() {
         return this;
     }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Not present in Node 18 types, required in latest Node 22
+    async [Symbol.asyncDispose]() {
+        await this.return();
+    }
 }
 exports.AsyncGeneratorWithSetup = AsyncGeneratorWithSetup;
 async function pipeGeneratorWithSetup(to, generator, startSetup, signal, ...args) {

package/dist/utils/stream.d.ts

@@ -6,6 +6,7 @@ export declare class IterableReadableStream<T> extends ReadableStream<T> impleme
     return(): Promise<IteratorResult<T>>;
     throw(e: any): Promise<IteratorResult<T>>;
     [Symbol.asyncIterator](): this;
+    [Symbol.asyncDispose](): Promise<void>;
     static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
     static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;
 }
@@ -25,9 +26,10 @@ export declare class AsyncGeneratorWithSetup<S = unknown, T = unknown, TReturn =
         signal?: AbortSignal;
     });
     next(...args: [] | [TNext]): Promise<IteratorResult<T>>;
-    return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;
+    return(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;
     throw(e: Error): Promise<IteratorResult<T>>;
     [Symbol.asyncIterator](): this;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export declare function pipeGeneratorWithSetup<S, A extends unknown[], T, TReturn, TNext, U, UReturn, UNext>(to: (g: AsyncGenerator<T, TReturn, TNext>, s: S, ...args: A) => AsyncGenerator<U, UReturn, UNext>, generator: AsyncGenerator<T, TReturn, TNext>, startSetup: () => Promise<S>, signal: AbortSignal | undefined, ...args: A): Promise<{
     output: AsyncGenerator<U, UReturn, UNext>;

package/dist/utils/stream.js

@@ -65,6 +65,11 @@ export class IterableReadableStream extends ReadableStream {
     [Symbol.asyncIterator]() {
         return this;
     }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Not present in Node 18 types, required in latest Node 22
+    async [Symbol.asyncDispose]() {
+        await this.return();
+    }
     static fromReadableStream(stream) {
         // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream
         const reader = stream.getReader();
@@ -243,6 +248,11 @@ export class AsyncGeneratorWithSetup {
     [Symbol.asyncIterator]() {
         return this;
     }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Not present in Node 18 types, required in latest Node 22
+    async [Symbol.asyncDispose]() {
+        await this.return();
+    }
 }
 export async function pipeGeneratorWithSetup(to, generator, startSetup, signal, ...args) {
     const gen = new AsyncGeneratorWithSetup({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.0-rc.0",
+  "version": "0.3.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {