@langchain/core 0.2.30 → 0.3.0-rc.0

package/README.md

@@ -89,7 +89,7 @@ For more check out the [LCEL docs](https://js.langchain.com/v0.2/docs/concepts#l
 
 ## 📕 Releases & Versioning
 
-`@langchain/core` is currently on version `0.1.x`.
+`@langchain/core` is currently on version `0.3.x`.
 
 As `@langchain/core` contains the base abstractions and runtime for the whole LangChain ecosystem, we will communicate any breaking changes with advance notice and version bumps. The exception for this is anything in `@langchain/core/beta`. The reason for `@langchain/core/beta` is that given the rate of change of the field, being able to move quickly is still a priority, and this module is our attempt to do so.
 
@@ -109,7 +109,7 @@ Patch version increases will occur for:
 Other LangChain packages should add this package as a dependency and extend the classes within.
 For an example, see the [@langchain/anthropic](https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-anthropic) in this repo.
 
-Because all used packages must share the same version of core, we suggest using a tilde dependency to allow for different (backwards-compatible) patch versions:
+Because all used packages must share the same version of core, packages should never directly depend on `@langchain/core`. Instead they should have core as a peer dependency and a dev dependency. We suggest using a tilde dependency to allow for different (backwards-compatible) patch versions:
 
 ```json
 {
@@ -120,8 +120,13 @@ Because all used packages must share the same version of core, we suggest using
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.10.0",
-    "@langchain/core": "~0.1.5"
+    "@anthropic-ai/sdk": "^0.10.0"
+  },
+  "peerDependencies": {
+    "@langchain/core": "~0.3.0"
+  },
+  "devDependencies": {
+    "@langchain/core": "~0.3.0"
   }
 }
 ```

package/dist/callbacks/base.cjs

@@ -125,7 +125,7 @@ class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !== "true"
+            value: (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
         });
         this.lc_kwargs = input || {};
         if (input) {

package/dist/callbacks/base.js

@@ -99,7 +99,7 @@ export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !== "true"
+            value: getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
         });
         this.lc_kwargs = input || {};
         if (input) {

package/dist/callbacks/manager.cjs

@@ -10,16 +10,6 @@ const tracer_langchain_js_1 = require("../tracers/tracer_langchain.cjs");
 const promises_js_1 = require("./promises.cjs");
 const callbacks_js_1 = require("../utils/callbacks.cjs");
 const base_js_2 = require("../tracers/base.cjs");
-if (
-/* #__PURE__ */ (0, callbacks_js_1.isTracingEnabled)() &&
-    /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !==
-        "true") {
-    /* #__PURE__ */ console.warn([
-        "[WARN]: You have enabled LangSmith tracing without backgrounding callbacks.",
-        "[WARN]: If you are not using a serverless environment where you must wait for tracing calls to finish,",
-        `[WARN]: we suggest setting "process.env.LANGCHAIN_CALLBACKS_BACKGROUND=true" to avoid additional latency.`,
-    ].join("\n"));
-}
 function parseCallbackConfigArg(arg) {
     if (!arg) {
         return {};
@@ -729,7 +719,7 @@ class CallbackManager extends BaseCallbackManager {
         manager.addHandler(new Handler());
         return manager;
     }
-    static async configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
+    static configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
         return this._configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options);
     }
     // TODO: Deprecate async method in favor of this one.

package/dist/callbacks/manager.d.ts

@@ -152,7 +152,7 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     removeMetadata(metadata: Record<string, unknown>): void;
     copy(additionalHandlers?: BaseCallbackHandler[], inherit?: boolean): CallbackManager;
     static fromHandlers(handlers: CallbackHandlerMethods): CallbackManager;
-    static configure(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): Promise<CallbackManager | undefined>;
+    static configure(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): CallbackManager | undefined;
     static _configureSync(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): CallbackManager | undefined;
 }
 export declare function ensureHandler(handler: BaseCallbackHandler | CallbackHandlerMethods): BaseCallbackHandler;

package/dist/callbacks/manager.js

@@ -7,16 +7,6 @@ import { LangChainTracer, } from "../tracers/tracer_langchain.js";
 import { consumeCallback } from "./promises.js";
 import { isTracingEnabled } from "../utils/callbacks.js";
 import { isBaseTracer } from "../tracers/base.js";
-if (
-/* #__PURE__ */ isTracingEnabled() &&
-    /* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !==
-        "true") {
-    /* #__PURE__ */ console.warn([
-        "[WARN]: You have enabled LangSmith tracing without backgrounding callbacks.",
-        "[WARN]: If you are not using a serverless environment where you must wait for tracing calls to finish,",
-        `[WARN]: we suggest setting "process.env.LANGCHAIN_CALLBACKS_BACKGROUND=true" to avoid additional latency.`,
-    ].join("\n"));
-}
 export function parseCallbackConfigArg(arg) {
     if (!arg) {
         return {};
@@ -719,7 +709,7 @@ export class CallbackManager extends BaseCallbackManager {
         manager.addHandler(new Handler());
         return manager;
     }
-    static async configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
+    static configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
         return this._configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options);
     }
     // TODO: Deprecate async method in favor of this one.

package/dist/language_models/chat_models.cjs

@@ -90,6 +90,11 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             let generationChunk;
             try {
                 for await (const chunk of this._streamResponseChunks(messages, callOptions, runManagers?.[0])) {
+                    if (chunk.message.id == null) {
+                        const runId = runManagers?.at(0)?.runId;
+                        if (runId != null)
+                            chunk.message._updateId(`run-${runId}`);
+                    }
                     chunk.message.response_metadata = {
                         ...chunk.generationInfo,
                         ...chunk.message.response_metadata,
@@ -150,6 +155,11 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
                 const stream = await this._streamResponseChunks(baseMessages[0], parsedOptions, runManagers?.[0]);
                 let aggregated;
                 for await (const chunk of stream) {
+                    if (chunk.message.id == null) {
+                        const runId = runManagers?.at(0)?.runId;
+                        if (runId != null)
+                            chunk.message._updateId(`run-${runId}`);
+                    }
                     if (aggregated === undefined) {
                         aggregated = chunk;
                     }
@@ -179,6 +189,11 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
                 if (pResult.status === "fulfilled") {
                     const result = pResult.value;
                     for (const generation of result.generations) {
+                        if (generation.message.id == null) {
+                            const runId = runManagers?.at(0)?.runId;
+                            if (runId != null)
+                                generation.message._updateId(`run-${runId}`);
+                        }
                         generation.message.response_metadata = {
                             ...generation.generationInfo,
                             ...generation.message.response_metadata,

package/dist/language_models/chat_models.js

@@ -86,6 +86,11 @@ export class BaseChatModel extends BaseLanguageModel {
             let generationChunk;
             try {
                 for await (const chunk of this._streamResponseChunks(messages, callOptions, runManagers?.[0])) {
+                    if (chunk.message.id == null) {
+                        const runId = runManagers?.at(0)?.runId;
+                        if (runId != null)
+                            chunk.message._updateId(`run-${runId}`);
+                    }
                     chunk.message.response_metadata = {
                         ...chunk.generationInfo,
                         ...chunk.message.response_metadata,
@@ -146,6 +151,11 @@ export class BaseChatModel extends BaseLanguageModel {
                 const stream = await this._streamResponseChunks(baseMessages[0], parsedOptions, runManagers?.[0]);
                 let aggregated;
                 for await (const chunk of stream) {
+                    if (chunk.message.id == null) {
+                        const runId = runManagers?.at(0)?.runId;
+                        if (runId != null)
+                            chunk.message._updateId(`run-${runId}`);
+                    }
                     if (aggregated === undefined) {
                         aggregated = chunk;
                     }
@@ -175,6 +185,11 @@ export class BaseChatModel extends BaseLanguageModel {
                 if (pResult.status === "fulfilled") {
                     const result = pResult.value;
                     for (const generation of result.generations) {
+                        if (generation.message.id == null) {
+                            const runId = runManagers?.at(0)?.runId;
+                            if (runId != null)
+                                generation.message._updateId(`run-${runId}`);
+                        }
                         generation.message.response_metadata = {
                             ...generation.generationInfo,
                             ...generation.message.response_metadata,

package/dist/messages/base.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBaseMessageChunk = exports.isBaseMessage = exports.BaseMessageChunk = exports._mergeObj = exports._mergeLists = exports._mergeDicts = exports.isOpenAIToolCallArray = exports.BaseMessage = exports._mergeStatus = exports.mergeContent = void 0;
+exports.isBaseMessageChunk = exports.isBaseMessage = exports._isMessageFieldWithRole = exports.BaseMessageChunk = exports._mergeObj = exports._mergeLists = exports._mergeDicts = exports.isOpenAIToolCallArray = exports.BaseMessage = exports._mergeStatus = exports.mergeContent = void 0;
 const serializable_js_1 = require("../load/serializable.cjs");
 function mergeContent(firstContent, secondContent) {
     // If first content is a string
@@ -181,6 +181,14 @@ class BaseMessage extends serializable_js_1.Serializable {
             response_metadata: this.response_metadata,
         };
     }
+    // this private method is used to update the ID for the runtime
+    // value as well as in lc_kwargs for serialisation
+    _updateId(value) {
+        this.id = value;
+        // lc_attributes wouldn't work here, because jest compares the
+        // whole object
+        this.lc_kwargs.id = value;
+    }
     get [Symbol.toStringTag]() {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.constructor.lc_name();
@@ -317,6 +325,10 @@ exports._mergeObj = _mergeObj;
 class BaseMessageChunk extends BaseMessage {
 }
 exports.BaseMessageChunk = BaseMessageChunk;
+function _isMessageFieldWithRole(x) {
+    return typeof x.role === "string";
+}
+exports._isMessageFieldWithRole = _isMessageFieldWithRole;
 function isBaseMessage(messageLike) {
     return typeof messageLike?._getType === "function";
 }

package/dist/messages/base.d.ts

@@ -55,30 +55,12 @@ export interface FunctionCall {
      */
     name: string;
 }
-/**
- * @deprecated
- * Import as "OpenAIToolCall" instead
- */
-export interface ToolCall {
-    /**
-     * The ID of the tool call.
-     */
-    id: string;
-    /**
-     * The function that the model called.
-     */
-    function: FunctionCall;
-    /**
-     * The type of the tool. Currently, only `function` is supported.
-     */
-    type: "function";
-}
 export type BaseMessageFields = {
     content: MessageContent;
     name?: string;
     additional_kwargs?: {
         function_call?: FunctionCall;
-        tool_calls?: ToolCall[];
+        tool_calls?: OpenAIToolCall[];
         [key: string]: unknown;
     };
     /** Response metadata. For example: response headers, logprobs, token counts. */
@@ -134,10 +116,23 @@ export declare abstract class BaseMessage extends Serializable implements BaseMe
     toDict(): StoredMessage;
     static lc_name(): string;
     get _printableFields(): Record<string, unknown>;
+    _updateId(value: string | undefined): void;
     get [Symbol.toStringTag](): any;
 }
-export type OpenAIToolCall = ToolCall & {
-    index: number;
+export type OpenAIToolCall = {
+    /**
+     * The ID of the tool call.
+     */
+    id: string;
+    /**
+     * The function that the model called.
+     */
+    function: FunctionCall;
+    /**
+     * The type of the tool. Currently, only `function` is supported.
+     */
+    type: "function";
+    index?: number;
 };
 export declare function isOpenAIToolCallArray(value?: unknown): value is OpenAIToolCall[];
 export declare function _mergeDicts(left: Record<string, any>, right: Record<string, any>): Record<string, any>;
@@ -153,9 +148,15 @@ export declare function _mergeObj<T = any>(left: T | undefined, right: T | undef
 export declare abstract class BaseMessageChunk extends BaseMessage {
     abstract concat(chunk: BaseMessageChunk): BaseMessageChunk;
 }
+export type MessageFieldWithRole = {
+    role: StringWithAutocomplete<"user" | "assistant" | MessageType>;
+    content: MessageContent;
+    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>) | [
+} & BaseMessageFields & Record<string, unknown>) | MessageFieldWithRole | [
     StringWithAutocomplete<MessageType | "user" | "assistant" | "placeholder">,
     MessageContent
 ] | string;

package/dist/messages/base.js

@@ -176,6 +176,14 @@ export class BaseMessage extends Serializable {
             response_metadata: this.response_metadata,
         };
     }
+    // this private method is used to update the ID for the runtime
+    // value as well as in lc_kwargs for serialisation
+    _updateId(value) {
+        this.id = value;
+        // lc_attributes wouldn't work here, because jest compares the
+        // whole object
+        this.lc_kwargs.id = value;
+    }
     get [Symbol.toStringTag]() {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.constructor.lc_name();
@@ -306,6 +314,9 @@ export function _mergeObj(left, right) {
  */
 export class BaseMessageChunk extends BaseMessage {
 }
+export function _isMessageFieldWithRole(x) {
+    return typeof x.role === "string";
+}
 export function isBaseMessage(messageLike) {
     return typeof messageLike?._getType === "function";
 }

package/dist/messages/utils.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToChunk = exports.mapChatMessagesToStoredMessages = exports.mapStoredMessagesToChatMessages = exports.mapStoredMessageToChatMessage = exports.getBufferString = exports.coerceMessageLikeToMessage = void 0;
+const utils_js_1 = require("../tools/utils.cjs");
 const ai_js_1 = require("./ai.cjs");
 const base_js_1 = require("./base.cjs");
 const chat_js_1 = require("./chat.cjs");
@@ -8,13 +9,43 @@ const function_js_1 = require("./function.cjs");
 const human_js_1 = require("./human.cjs");
 const system_js_1 = require("./system.cjs");
 const tool_js_1 = require("./tool.cjs");
+function _coerceToolCall(toolCall) {
+    if ((0, utils_js_1._isToolCall)(toolCall)) {
+        return toolCall;
+    }
+    else if (typeof toolCall.id === "string" &&
+        toolCall.type === "function" &&
+        typeof toolCall.function === "object" &&
+        toolCall.function !== null &&
+        "arguments" in toolCall.function &&
+        typeof toolCall.function.arguments === "string" &&
+        "name" in toolCall.function &&
+        typeof toolCall.function.name === "string") {
+        // Handle OpenAI tool call format
+        return {
+            id: toolCall.id,
+            args: JSON.parse(toolCall.function.arguments),
+            name: toolCall.function.name,
+            type: "tool_call",
+        };
+    }
+    else {
+        // TODO: Throw an error?
+        return toolCall;
+    }
+}
 function _constructMessageFromParams(params) {
     const { type, ...rest } = params;
     if (type === "human" || type === "user") {
         return new human_js_1.HumanMessage(rest);
     }
     else if (type === "ai" || type === "assistant") {
-        return new ai_js_1.AIMessage(rest);
+        const { tool_calls: rawToolCalls, ...other } = rest;
+        if (!Array.isArray(rawToolCalls)) {
+            return new ai_js_1.AIMessage(rest);
+        }
+        const tool_calls = rawToolCalls.map(_coerceToolCall);
+        return new ai_js_1.AIMessage({ ...other, tool_calls });
     }
     else if (type === "system") {
         return new system_js_1.SystemMessage(rest);
@@ -42,6 +73,10 @@ function coerceMessageLikeToMessage(messageLike) {
         const [type, content] = messageLike;
         return _constructMessageFromParams({ type, content });
     }
+    else if ((0, base_js_1._isMessageFieldWithRole)(messageLike)) {
+        const { role: type, ...rest } = messageLike;
+        return _constructMessageFromParams({ ...rest, type });
+    }
     else {
         return _constructMessageFromParams(messageLike);
     }

package/dist/messages/utils.js

@@ -1,17 +1,48 @@
+import { _isToolCall } from "../tools/utils.js";
 import { AIMessage, AIMessageChunk } from "./ai.js";
-import { isBaseMessage, } from "./base.js";
+import { isBaseMessage, _isMessageFieldWithRole, } from "./base.js";
 import { ChatMessage, ChatMessageChunk, } from "./chat.js";
 import { FunctionMessage, FunctionMessageChunk, } from "./function.js";
 import { HumanMessage, HumanMessageChunk } from "./human.js";
 import { SystemMessage, SystemMessageChunk } from "./system.js";
-import { ToolMessage } from "./tool.js";
+import { ToolMessage, } from "./tool.js";
+function _coerceToolCall(toolCall) {
+    if (_isToolCall(toolCall)) {
+        return toolCall;
+    }
+    else if (typeof toolCall.id === "string" &&
+        toolCall.type === "function" &&
+        typeof toolCall.function === "object" &&
+        toolCall.function !== null &&
+        "arguments" in toolCall.function &&
+        typeof toolCall.function.arguments === "string" &&
+        "name" in toolCall.function &&
+        typeof toolCall.function.name === "string") {
+        // Handle OpenAI tool call format
+        return {
+            id: toolCall.id,
+            args: JSON.parse(toolCall.function.arguments),
+            name: toolCall.function.name,
+            type: "tool_call",
+        };
+    }
+    else {
+        // TODO: Throw an error?
+        return toolCall;
+    }
+}
 function _constructMessageFromParams(params) {
     const { type, ...rest } = params;
     if (type === "human" || type === "user") {
         return new HumanMessage(rest);
     }
     else if (type === "ai" || type === "assistant") {
-        return new AIMessage(rest);
+        const { tool_calls: rawToolCalls, ...other } = rest;
+        if (!Array.isArray(rawToolCalls)) {
+            return new AIMessage(rest);
+        }
+        const tool_calls = rawToolCalls.map(_coerceToolCall);
+        return new AIMessage({ ...other, tool_calls });
     }
     else if (type === "system") {
         return new SystemMessage(rest);
@@ -39,6 +70,10 @@ export function coerceMessageLikeToMessage(messageLike) {
         const [type, content] = messageLike;
         return _constructMessageFromParams({ type, content });
     }
+    else if (_isMessageFieldWithRole(messageLike)) {
+        const { role: type, ...rest } = messageLike;
+        return _constructMessageFromParams({ ...rest, type });
+    }
     else {
         return _constructMessageFromParams(messageLike);
     }

package/dist/runnables/base.cjs

@@ -942,7 +942,7 @@ class RunnableEach extends Runnable {
      * @returns A promise that resolves to the output of the runnable.
      */
     async invoke(inputs, config) {
-        return this._callWithConfig(this._invoke, inputs, config);
+        return this._callWithConfig(this._invoke.bind(this), inputs, config);
     }
     /**
      * A helper method that is used to invoke the runnable with the specified input and configuration.
@@ -1026,7 +1026,7 @@ class RunnableRetry extends RunnableBinding {
      * @returns A promise that resolves to the output of the runnable.
      */
     async invoke(input, config) {
-        return this._callWithConfig(this._invoke, input, config);
+        return this._callWithConfig(this._invoke.bind(this), input, config);
     }
     async _batch(inputs, configs, runManagers, batchOptions) {
         const resultsMap = {};
@@ -1590,7 +1590,7 @@ class RunnableLambda extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this._callWithConfig(this._invoke, input, options);
+        return this._callWithConfig(this._invoke.bind(this), input, options);
     }
     async *_transform(generator, runManager, config) {
         let finalChunk;

package/dist/runnables/base.d.ts

@@ -11,13 +11,7 @@ import { Run } from "../tracers/base.js";
 import { Graph } from "./graph.js";
 import { ToolCall } from "../messages/tool.js";
 export { type RunnableInterface, RunnableBatchOptions };
-export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options?: ({
-    /** @deprecated Use top-level config fields instead. */
-    config?: RunnableConfig;
-} & RunnableConfig) | Record<string, any> | (Record<string, any> & {
-    /** @deprecated Use top-level config fields instead. */
-    config: RunnableConfig;
-} & RunnableConfig)) => RunOutput | Promise<RunOutput>;
+export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options: RunnableConfig | Record<string, any> | (Record<string, any> & RunnableConfig)) => RunOutput | Promise<RunOutput>;
 export type RunnableMapLike<RunInput, RunOutput> = {
     [K in keyof RunOutput]: RunnableLike<RunInput, RunOutput[K]>;
 };
@@ -351,7 +345,7 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     _streamIterator(input: RunInput, options?: Partial<CallOptions> | undefined): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
     stream(input: RunInput, options?: Partial<CallOptions> | undefined): Promise<IterableReadableStream<RunOutput>>;
-    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    transform(generator: AsyncGenerator<RunInput>, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1" | "v2";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;

package/dist/runnables/base.js

@@ -933,7 +933,7 @@ export class RunnableEach extends Runnable {
      * @returns A promise that resolves to the output of the runnable.
      */
     async invoke(inputs, config) {
-        return this._callWithConfig(this._invoke, inputs, config);
+        return this._callWithConfig(this._invoke.bind(this), inputs, config);
     }
     /**
      * A helper method that is used to invoke the runnable with the specified input and configuration.
@@ -1016,7 +1016,7 @@ export class RunnableRetry extends RunnableBinding {
      * @returns A promise that resolves to the output of the runnable.
      */
     async invoke(input, config) {
-        return this._callWithConfig(this._invoke, input, config);
+        return this._callWithConfig(this._invoke.bind(this), input, config);
     }
     async _batch(inputs, configs, runManagers, batchOptions) {
         const resultsMap = {};
@@ -1576,7 +1576,7 @@ export class RunnableLambda extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this._callWithConfig(this._invoke, input, options);
+        return this._callWithConfig(this._invoke.bind(this), input, options);
     }
     async *_transform(generator, runManager, config) {
         let finalChunk;

package/dist/tracers/event_stream.cjs

@@ -279,7 +279,7 @@ class EventStreamCallbackHandler extends base_js_1.BaseTracer {
         if (runInfo.runType === "chat_model") {
             eventName = "on_chat_model_stream";
             if (kwargs?.chunk === undefined) {
-                chunk = new ai_js_1.AIMessageChunk({ content: token });
+                chunk = new ai_js_1.AIMessageChunk({ content: token, id: `run-${run.id}` });
             }
             else {
                 chunk = kwargs.chunk.message;

package/dist/tracers/event_stream.js

@@ -275,7 +275,7 @@ export class EventStreamCallbackHandler extends BaseTracer {
         if (runInfo.runType === "chat_model") {
             eventName = "on_chat_model_stream";
             if (kwargs?.chunk === undefined) {
-                chunk = new AIMessageChunk({ content: token });
+                chunk = new AIMessageChunk({ content: token, id: `run-${run.id}` });
             }
             else {
                 chunk = kwargs.chunk.message;

package/dist/tracers/log_stream.cjs

@@ -401,7 +401,10 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
                 streamedOutputValue = kwargs?.chunk;
             }
             else {
-                streamedOutputValue = new ai_js_1.AIMessageChunk(token);
+                streamedOutputValue = new ai_js_1.AIMessageChunk({
+                    id: `run-${run.id}`,
+                    content: token,
+                });
             }
         }
         else {

package/dist/tracers/log_stream.js

@@ -395,7 +395,10 @@ export class LogStreamCallbackHandler extends BaseTracer {
                 streamedOutputValue = kwargs?.chunk;
             }
             else {
-                streamedOutputValue = new AIMessageChunk(token);
+                streamedOutputValue = new AIMessageChunk({
+                    id: `run-${run.id}`,
+                    content: token,
+                });
             }
         }
         else {

package/dist/tracers/root_listener.cjs

@@ -61,12 +61,7 @@ class RootListenersTracer extends base_js_1.BaseTracer {
         }
         this.rootId = run.id;
         if (this.argOnStart) {
-            if (this.argOnStart.length === 1) {
-                await this.argOnStart(run);
-            }
-            else if (this.argOnStart.length === 2) {
-                await this.argOnStart(run, this.config);
-            }
+            await this.argOnStart(run, this.config);
         }
     }
     async onRunUpdate(run) {
@@ -75,21 +70,11 @@ class RootListenersTracer extends base_js_1.BaseTracer {
         }
         if (!run.error) {
             if (this.argOnEnd) {
-                if (this.argOnEnd.length === 1) {
-                    await this.argOnEnd(run);
-                }
-                else if (this.argOnEnd.length === 2) {
-                    await this.argOnEnd(run, this.config);
-                }
+                await this.argOnEnd(run, this.config);
             }
         }
         else if (this.argOnError) {
-            if (this.argOnError.length === 1) {
-                await this.argOnError(run);
-            }
-            else if (this.argOnError.length === 2) {
-                await this.argOnError(run, this.config);
-            }
+            await this.argOnError(run, this.config);
         }
     }
 }

package/dist/tracers/root_listener.d.ts

@@ -5,23 +5,14 @@ export declare class RootListenersTracer extends BaseTracer {
     /** The Run's ID. Type UUID */
     rootId?: string;
     config: RunnableConfig;
-    argOnStart?: {
-        (run: Run): void | Promise<void>;
-        (run: Run, config: RunnableConfig): void | Promise<void>;
-    };
-    argOnEnd?: {
-        (run: Run): void | Promise<void>;
-        (run: Run, config: RunnableConfig): void | Promise<void>;
-    };
-    argOnError?: {
-        (run: Run): void | Promise<void>;
-        (run: Run, config: RunnableConfig): void | Promise<void>;
-    };
+    argOnStart?: (run: Run, config: RunnableConfig) => void | Promise<void>;
+    argOnEnd?: (run: Run, config: RunnableConfig) => void | Promise<void>;
+    argOnError?: (run: Run, config: RunnableConfig) => void | Promise<void>;
     constructor({ config, onStart, onEnd, onError, }: {
         config: RunnableConfig;
-        onStart?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
-        onEnd?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
-        onError?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
+        onStart?: (run: Run, config: RunnableConfig) => void | Promise<void>;
+        onEnd?: (run: Run, config: RunnableConfig) => void | Promise<void>;
+        onError?: (run: Run, config: RunnableConfig) => void | Promise<void>;
     });
     /**
      * This is a legacy method only called once for an entire run tree

package/dist/tracers/root_listener.js

@@ -58,12 +58,7 @@ export class RootListenersTracer extends BaseTracer {
         }
         this.rootId = run.id;
         if (this.argOnStart) {
-            if (this.argOnStart.length === 1) {
-                await this.argOnStart(run);
-            }
-            else if (this.argOnStart.length === 2) {
-                await this.argOnStart(run, this.config);
-            }
+            await this.argOnStart(run, this.config);
         }
     }
     async onRunUpdate(run) {
@@ -72,21 +67,11 @@ export class RootListenersTracer extends BaseTracer {
         }
         if (!run.error) {
             if (this.argOnEnd) {
-                if (this.argOnEnd.length === 1) {
-                    await this.argOnEnd(run);
-                }
-                else if (this.argOnEnd.length === 2) {
-                    await this.argOnEnd(run, this.config);
-                }
+                await this.argOnEnd(run, this.config);
             }
         }
         else if (this.argOnError) {
-            if (this.argOnError.length === 1) {
-                await this.argOnError(run);
-            }
-            else if (this.argOnError.length === 2) {
-                await this.argOnError(run, this.config);
-            }
+            await this.argOnError(run, this.config);
         }
     }
 }

package/package.json

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