@langchain/core 0.2.15 → 0.2.17

package/caches.cjs

@@ -1 +1 @@
-module.exports = require('./dist/caches.cjs');
+module.exports = require('./dist/caches/base.cjs');

package/caches.d.cts

@@ -1 +1 @@
-export * from './dist/caches.js'
+export * from './dist/caches/base.js'

package/caches.d.ts

@@ -1 +1 @@
-export * from './dist/caches.js'
+export * from './dist/caches/base.js'

package/caches.js

@@ -1 +1 @@
-export * from './dist/caches.js'
+export * from './dist/caches/base.js'

package/callbacks/dispatch/web.cjs

@@ -0,0 +1 @@
+module.exports = require('../../dist/callbacks/dispatch/web.cjs');

package/callbacks/dispatch/web.d.cts

@@ -0,0 +1 @@
+export * from '../../dist/callbacks/dispatch/web.js'

package/callbacks/dispatch/web.d.ts

@@ -0,0 +1 @@
+export * from '../../dist/callbacks/dispatch/web.js'

package/callbacks/dispatch/web.js

@@ -0,0 +1 @@
+export * from '../../dist/callbacks/dispatch/web.js'

package/callbacks/dispatch.cjs

@@ -0,0 +1 @@
+module.exports = require('../dist/callbacks/dispatch/index.cjs');

package/callbacks/dispatch.d.cts

@@ -0,0 +1 @@
+export * from '../dist/callbacks/dispatch/index.js'

package/callbacks/dispatch.d.ts

@@ -0,0 +1 @@
+export * from '../dist/callbacks/dispatch/index.js'

package/callbacks/dispatch.js

@@ -0,0 +1 @@
+export * from '../dist/callbacks/dispatch/index.js'

package/dist/{caches.cjs → caches/base.cjs}

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryCache = exports.BaseCache = exports.serializeGeneration = exports.deserializeStoredGeneration = exports.getCacheKey = void 0;
-const hash_js_1 = require("./utils/hash.cjs");
-const utils_js_1 = require("./messages/utils.cjs");
+const hash_js_1 = require("../utils/hash.cjs");
+const utils_js_1 = require("../messages/utils.cjs");
 /**
- * This cache key should be consistent across all versions of langchain.
- * It is currently NOT consistent across versions of langchain.
+ * This cache key should be consistent across all versions of LangChain.
+ * It is currently NOT consistent across versions of LangChain.
  *
  * A huge benefit of having a remote cache (like redis) is that you can
  * access the cache from different processes/machines. The allows you to
- * seperate concerns and scale horizontally.
+ * separate concerns and scale horizontally.
  *
- * TODO: Make cache key consistent across versions of langchain.
+ * TODO: Make cache key consistent across versions of LangChain.
  */
 const getCacheKey = (...strings) => (0, hash_js_1.insecureHash)(strings.join("_"));
 exports.getCacheKey = getCacheKey;

package/dist/{caches.d.ts → caches/base.d.ts}

@@ -1,19 +1,19 @@
-import type { Generation } from "./outputs.js";
-import { type StoredGeneration } from "./messages/base.js";
+import type { Generation } from "../outputs.js";
+import { type StoredGeneration } from "../messages/base.js";
 /**
- * This cache key should be consistent across all versions of langchain.
- * It is currently NOT consistent across versions of langchain.
+ * This cache key should be consistent across all versions of LangChain.
+ * It is currently NOT consistent across versions of LangChain.
  *
  * A huge benefit of having a remote cache (like redis) is that you can
  * access the cache from different processes/machines. The allows you to
- * seperate concerns and scale horizontally.
+ * separate concerns and scale horizontally.
  *
- * TODO: Make cache key consistent across versions of langchain.
+ * TODO: Make cache key consistent across versions of LangChain.
  */
 export declare const getCacheKey: (...strings: string[]) => string;
 export declare function deserializeStoredGeneration(storedGeneration: StoredGeneration): {
     text: string;
-    message: import("./messages/tool.js").ToolMessage | import("./messages/ai.js").AIMessage | import("./messages/chat.js").ChatMessage | import("./messages/function.js").FunctionMessage | import("./messages/human.js").HumanMessage | import("./messages/system.js").SystemMessage;
+    message: import("../messages/tool.js").ToolMessage | import("../messages/ai.js").AIMessage | import("../messages/chat.js").ChatMessage | import("../messages/function.js").FunctionMessage | import("../messages/human.js").HumanMessage | import("../messages/system.js").SystemMessage;
 } | {
     text: string;
     message?: undefined;

package/dist/{caches.js → caches/base.js}

@@ -1,14 +1,14 @@
-import { insecureHash } from "./utils/hash.js";
-import { mapStoredMessageToChatMessage } from "./messages/utils.js";
+import { insecureHash } from "../utils/hash.js";
+import { mapStoredMessageToChatMessage } from "../messages/utils.js";
 /**
- * This cache key should be consistent across all versions of langchain.
- * It is currently NOT consistent across versions of langchain.
+ * This cache key should be consistent across all versions of LangChain.
+ * It is currently NOT consistent across versions of LangChain.
  *
  * A huge benefit of having a remote cache (like redis) is that you can
  * access the cache from different processes/machines. The allows you to
- * seperate concerns and scale horizontally.
+ * separate concerns and scale horizontally.
  *
- * TODO: Make cache key consistent across versions of langchain.
+ * TODO: Make cache key consistent across versions of LangChain.
  */
 export const getCacheKey = (...strings) => insecureHash(strings.join("_"));
 export function deserializeStoredGeneration(storedGeneration) {

package/dist/caches/tests/in_memory_cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/caches/tests/in_memory_cache.test.js

@@ -0,0 +1,33 @@
+import { InMemoryCache } from "../base.js";
+test("InMemoryCache works", async () => {
+    const cache = new InMemoryCache();
+    await cache.update("prompt", "key1", [
+        {
+            text: "text1",
+        },
+    ]);
+    const result = await cache.lookup("prompt", "key1");
+    expect(result).toBeDefined();
+    if (!result) {
+        return;
+    }
+    expect(result[0].text).toBe("text1");
+});
+test("InMemoryCache works with complex message types", async () => {
+    const cache = new InMemoryCache();
+    await cache.update("prompt", "key1", [
+        {
+            type: "text",
+            text: "text1",
+        },
+    ]);
+    const result = await cache.lookup("prompt", "key1");
+    expect(result).toBeDefined();
+    if (!result) {
+        return;
+    }
+    expect(result[0]).toEqual({
+        type: "text",
+        text: "text1",
+    });
+});

package/dist/callbacks/base.cjs

@@ -109,6 +109,12 @@ class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "ignoreCustomEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "raiseError", {
             enumerable: true,
             configurable: true,
@@ -127,6 +133,8 @@ class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
             this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
             this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
+            this.ignoreCustomEvent =
+                input.ignoreCustomEvent ?? this.ignoreCustomEvent;
             this.raiseError = input.raiseError ?? this.raiseError;
             this.awaitHandlers =
                 this.raiseError || (input._awaitHandler ?? this.awaitHandlers);

package/dist/callbacks/base.d.ts

@@ -16,6 +16,7 @@ export interface BaseCallbackHandlerInput {
     ignoreChain?: boolean;
     ignoreAgent?: boolean;
     ignoreRetriever?: boolean;
+    ignoreCustomEvent?: boolean;
     _awaitHandler?: boolean;
     raiseError?: boolean;
 }
@@ -40,7 +41,7 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      * Called at the start of an LLM or Chat Model run, with the prompt(s)
      * and the run ID.
      */
-    handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, name?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
     /**
      * Called when an LLM/ChatModel in `streaming` mode produces a new token
@@ -68,13 +69,13 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      * Called at the start of a Chat Model run, with the prompt(s)
      * and the run ID.
      */
-    handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, name?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
     /**
      * Called at the start of a Chain run, with the chain name and inputs
      * and the run ID.
      */
-    handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string, name?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
     /**
      * Called if a Chain run encounters an error
@@ -94,7 +95,7 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      * Called at the start of a Tool run, with the tool name and input
      * and the run ID.
      */
-    handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, name?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
     /**
      * Called if a Tool run encounters an error
@@ -104,7 +105,7 @@ declare abstract class BaseCallbackHandlerMethodsClass {
     /**
      * Called at the end of a Tool run, with the tool output and the run ID.
      */
-    handleToolEnd?(output: string, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleToolEnd?(output: any, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
     handleText?(text: string, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
     /**
@@ -123,6 +124,8 @@ declare abstract class BaseCallbackHandlerMethodsClass {
     Promise<any> | any;
     handleRetrieverError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
+    handleCustomEvent?(eventName: string, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
 }
 /**
  * Base interface for callbacks. All methods are optional. If a method is not
@@ -169,6 +172,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
     ignoreChain: boolean;
     ignoreAgent: boolean;
     ignoreRetriever: boolean;
+    ignoreCustomEvent: boolean;
     raiseError: boolean;
     awaitHandlers: boolean;
     constructor(input?: BaseCallbackHandlerInput);
@@ -197,6 +201,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
         ignoreChain: boolean;
         ignoreAgent: boolean;
         ignoreRetriever: boolean;
+        ignoreCustomEvent: boolean;
         raiseError: boolean;
         awaitHandlers: boolean;
         copy(): BaseCallbackHandler;
@@ -206,7 +211,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          * Called at the start of an LLM or Chat Model run, with the prompt(s)
          * and the run ID.
          */
-        handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, name?: string | undefined): any;
+        handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runName?: string | undefined): any;
         /**
          * Called when an LLM/ChatModel in `streaming` mode produces a new token
          */
@@ -223,12 +228,12 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          * Called at the start of a Chat Model run, with the prompt(s)
          * and the run ID.
          */
-        handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, name?: string | undefined): any;
+        handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runName?: string | undefined): any;
         /**
          * Called at the start of a Chain run, with the chain name and inputs
          * and the run ID.
          */
-        handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runType?: string | undefined, name?: string | undefined): any;
+        handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runType?: string | undefined, runName?: string | undefined): any;
         /**
          * Called if a Chain run encounters an error
          */
@@ -245,7 +250,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          * Called at the start of a Tool run, with the tool name and input
          * and the run ID.
          */
-        handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, name?: string | undefined): any;
+        handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runName?: string | undefined): any;
         /**
          * Called if a Tool run encounters an error
          */
@@ -253,7 +258,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
         /**
          * Called at the end of a Tool run, with the tool output and the run ID.
          */
-        handleToolEnd?(output: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleToolEnd?(output: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
         handleText?(text: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
         /**
          * Called when an agent is about to execute an action,
@@ -268,6 +273,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
         handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, name?: string | undefined): any;
         handleRetrieverEnd?(documents: DocumentInterface<Record<string, any>>[], runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
         handleRetrieverError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleCustomEvent?(eventName: string, data: any, runId: string, tags?: string[] | undefined, metadata?: Record<string, any> | undefined): any;
     };
 }
 export {};

package/dist/callbacks/base.js

@@ -83,6 +83,12 @@ export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "ignoreCustomEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "raiseError", {
             enumerable: true,
             configurable: true,
@@ -101,6 +107,8 @@ export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
             this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
             this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
+            this.ignoreCustomEvent =
+                input.ignoreCustomEvent ?? this.ignoreCustomEvent;
             this.raiseError = input.raiseError ?? this.raiseError;
             this.awaitHandlers =
                 this.raiseError || (input._awaitHandler ?? this.awaitHandlers);

package/dist/callbacks/dispatch/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchCustomEvent = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const web_js_1 = require("./web.cjs");
+const config_js_1 = require("../../runnables/config.cjs");
+const index_js_1 = require("../../singletons/index.cjs");
+/* #__PURE__ */ index_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(
+/* #__PURE__ */ new node_async_hooks_1.AsyncLocalStorage());
+/**
+ * Dispatch a custom event.
+ *
+ * Note: this method is only supported in non-web environments
+ * due to usage of async_hooks to infer config.
+ *
+ * If you are using this method in the browser, please import and use
+ * from "@langchain/core/callbacks/dispatch/web".
+ *
+ * @param name The name of the custom event.
+ * @param payload The data for the custom event.
+ *   Ideally should be JSON serializable to avoid serialization issues downstream, but not enforced.
+ * @param config Optional config object.
+ *
+ * @example
+ * ```typescript
+ * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+ *
+ * const foo = RunnableLambda.from(async (input: string) => {
+ *   await dispatchCustomEvent("my_custom_event", { arbitraryField: "someval" });
+ *   return input;
+ * });
+ *
+ * const callbacks = [{
+ *   handleCustomEvent: (eventName: string, payload: any) => {
+ *     // Logs "my_custom_event" and { arbitraryField: "someval" }
+ *     console.log(eventName, payload);
+ *   }
+ * }];
+ *
+ * await foo.invoke("hi", { callbacks })
+ * ```
+ */
+async function dispatchCustomEvent(eventName, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+payload, config) {
+    const ensuredConfig = (0, config_js_1.ensureConfig)(config);
+    await (0, web_js_1.dispatchCustomEvent)(eventName, payload, ensuredConfig);
+}
+exports.dispatchCustomEvent = dispatchCustomEvent;

package/dist/callbacks/dispatch/index.d.ts

@@ -0,0 +1,35 @@
+import { type RunnableConfig } from "../../runnables/config.js";
+/**
+ * Dispatch a custom event.
+ *
+ * Note: this method is only supported in non-web environments
+ * due to usage of async_hooks to infer config.
+ *
+ * If you are using this method in the browser, please import and use
+ * from "@langchain/core/callbacks/dispatch/web".
+ *
+ * @param name The name of the custom event.
+ * @param payload The data for the custom event.
+ *   Ideally should be JSON serializable to avoid serialization issues downstream, but not enforced.
+ * @param config Optional config object.
+ *
+ * @example
+ * ```typescript
+ * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+ *
+ * const foo = RunnableLambda.from(async (input: string) => {
+ *   await dispatchCustomEvent("my_custom_event", { arbitraryField: "someval" });
+ *   return input;
+ * });
+ *
+ * const callbacks = [{
+ *   handleCustomEvent: (eventName: string, payload: any) => {
+ *     // Logs "my_custom_event" and { arbitraryField: "someval" }
+ *     console.log(eventName, payload);
+ *   }
+ * }];
+ *
+ * await foo.invoke("hi", { callbacks })
+ * ```
+ */
+export declare function dispatchCustomEvent(eventName: string, payload: any, config?: RunnableConfig): Promise<void>;

package/dist/callbacks/dispatch/index.js

@@ -0,0 +1,45 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { dispatchCustomEvent as dispatchCustomEventWeb } from "./web.js";
+import { ensureConfig } from "../../runnables/config.js";
+import { AsyncLocalStorageProviderSingleton } from "../../singletons/index.js";
+/* #__PURE__ */ AsyncLocalStorageProviderSingleton.initializeGlobalInstance(
+/* #__PURE__ */ new AsyncLocalStorage());
+/**
+ * Dispatch a custom event.
+ *
+ * Note: this method is only supported in non-web environments
+ * due to usage of async_hooks to infer config.
+ *
+ * If you are using this method in the browser, please import and use
+ * from "@langchain/core/callbacks/dispatch/web".
+ *
+ * @param name The name of the custom event.
+ * @param payload The data for the custom event.
+ *   Ideally should be JSON serializable to avoid serialization issues downstream, but not enforced.
+ * @param config Optional config object.
+ *
+ * @example
+ * ```typescript
+ * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+ *
+ * const foo = RunnableLambda.from(async (input: string) => {
+ *   await dispatchCustomEvent("my_custom_event", { arbitraryField: "someval" });
+ *   return input;
+ * });
+ *
+ * const callbacks = [{
+ *   handleCustomEvent: (eventName: string, payload: any) => {
+ *     // Logs "my_custom_event" and { arbitraryField: "someval" }
+ *     console.log(eventName, payload);
+ *   }
+ * }];
+ *
+ * await foo.invoke("hi", { callbacks })
+ * ```
+ */
+export async function dispatchCustomEvent(eventName, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+payload, config) {
+    const ensuredConfig = ensureConfig(config);
+    await dispatchCustomEventWeb(eventName, payload, ensuredConfig);
+}

package/dist/callbacks/dispatch/web.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchCustomEvent = void 0;
+const config_js_1 = require("../../runnables/config.cjs");
+/**
+ * Dispatch a custom event. Requires an explicit config object.
+ * @param name The name of the custom event.
+ * @param payload The data for the custom event.
+ *   Ideally should be JSON serializable to avoid serialization issues downstream, but not enforced.
+ * @param config Config object.
+ *
+ * @example
+ * ```typescript
+ * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+ *
+ * const foo = RunnableLambda.from(async (input: string, config?: RunnableConfig) => {
+ *   await dispatchCustomEvent(
+ *     "my_custom_event",
+ *     { arbitraryField: "someval" },
+ *     config
+ *   );
+ *   return input;
+ * });
+ *
+ * const callbacks = [{
+ *   handleCustomEvent: (eventName: string, payload: any) => {
+ *     // Logs "my_custom_event" and { arbitraryField: "someval" }
+ *     console.log(eventName, payload);
+ *   }
+ * }];
+ *
+ * await foo.invoke("hi", { callbacks })
+ * ```
+ */
+async function dispatchCustomEvent(name, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+payload, config) {
+    const callbackManager = await (0, config_js_1.getCallbackManagerForConfig)(config);
+    const parentRunId = callbackManager?.getParentRunId();
+    // We want to get the callback manager for the parent run.
+    // This is a work-around for now to be able to dispatch adhoc events from
+    // within a tool or a lambda and have the metadata events associated
+    // with the parent run rather than have a new run id generated for each.
+    if (callbackManager === undefined || parentRunId === undefined) {
+        throw new Error([
+            "Unable to dispatch a custom event without a parent run id.",
+            "This function can only be called from within an existing run (e.g.,",
+            "inside a tool or a RunnableLambda).",
+            `\n\nIf you continue to see this error, please import from "@langchain/core/callbacks/dispatch/web"`,
+            "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",
+        ].join(" "));
+    }
+    // We pass parent id as the current run id here intentionally since events dispatch
+    // from within things like RunnableLambda
+    await callbackManager.handleCustomEvent?.(name, payload, parentRunId);
+}
+exports.dispatchCustomEvent = dispatchCustomEvent;

package/dist/callbacks/dispatch/web.d.ts

@@ -0,0 +1,32 @@
+import { type RunnableConfig } from "../../runnables/config.js";
+/**
+ * Dispatch a custom event. Requires an explicit config object.
+ * @param name The name of the custom event.
+ * @param payload The data for the custom event.
+ *   Ideally should be JSON serializable to avoid serialization issues downstream, but not enforced.
+ * @param config Config object.
+ *
+ * @example
+ * ```typescript
+ * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+ *
+ * const foo = RunnableLambda.from(async (input: string, config?: RunnableConfig) => {
+ *   await dispatchCustomEvent(
+ *     "my_custom_event",
+ *     { arbitraryField: "someval" },
+ *     config
+ *   );
+ *   return input;
+ * });
+ *
+ * const callbacks = [{
+ *   handleCustomEvent: (eventName: string, payload: any) => {
+ *     // Logs "my_custom_event" and { arbitraryField: "someval" }
+ *     console.log(eventName, payload);
+ *   }
+ * }];
+ *
+ * await foo.invoke("hi", { callbacks })
+ * ```
+ */
+export declare function dispatchCustomEvent(name: string, payload: any, config?: RunnableConfig): Promise<void>;

package/dist/callbacks/dispatch/web.js

@@ -0,0 +1,57 @@
+import { getCallbackManagerForConfig, } from "../../runnables/config.js";
+/**
+ * Dispatch a custom event. Requires an explicit config object.
+ * @param name The name of the custom event.
+ * @param payload The data for the custom event.
+ *   Ideally should be JSON serializable to avoid serialization issues downstream, but not enforced.
+ * @param config Config object.
+ *
+ * @example
+ * ```typescript
+ * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+ *
+ * const foo = RunnableLambda.from(async (input: string, config?: RunnableConfig) => {
+ *   await dispatchCustomEvent(
+ *     "my_custom_event",
+ *     { arbitraryField: "someval" },
+ *     config
+ *   );
+ *   return input;
+ * });
+ *
+ * const callbacks = [{
+ *   handleCustomEvent: (eventName: string, payload: any) => {
+ *     // Logs "my_custom_event" and { arbitraryField: "someval" }
+ *     console.log(eventName, payload);
+ *   }
+ * }];
+ *
+ * await foo.invoke("hi", { callbacks })
+ * ```
+ */
+export async function dispatchCustomEvent(name, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+payload, config) {
+    const callbackManager = await getCallbackManagerForConfig(config);
+    const parentRunId = callbackManager?.getParentRunId();
+    // We want to get the callback manager for the parent run.
+    // This is a work-around for now to be able to dispatch adhoc events from
+    // within a tool or a lambda and have the metadata events associated
+    // with the parent run rather than have a new run id generated for each.
+    if (callbackManager === undefined || parentRunId === undefined) {
+        throw new Error([
+            "Unable to dispatch a custom event without a parent run id.",
+            "This function can only be called from within an existing run (e.g.,",
+            "inside a tool or a RunnableLambda).",
+            `\n\nIf you continue to see this error, please import from "@langchain/core/callbacks/dispatch/web"`,
+            "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",
+        ].join(" "));
+    }
+    // We pass parent id as the current run id here intentionally since events dispatch
+    // from within things like RunnableLambda
+    await callbackManager.handleCustomEvent?.(name, payload, parentRunId);
+}

package/dist/callbacks/manager.cjs

@@ -308,6 +308,7 @@ class CallbackManagerForToolRun extends BaseRunManager {
             }
         }, handler.awaitHandlers)));
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleToolEnd(output) {
         await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
             if (!handler.ignoreAgent) {
@@ -506,6 +507,25 @@ class CallbackManager extends BaseCallbackManager {
         }, handler.awaitHandlers)));
         return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
+    async handleCustomEvent(eventName, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data, runId, _tags, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _metadata) {
+        await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
+            if (!handler.ignoreCustomEvent) {
+                try {
+                    await handler.handleCustomEvent?.(eventName, data, runId, this.tags, this.metadata);
+                }
+                catch (err) {
+                    console.error(`Error in handler ${handler.constructor.name}, handleCustomEvent: ${err}`);
+                    if (handler.raiseError) {
+                        throw err;
+                    }
+                }
+            }
+        }, handler.awaitHandlers)));
+    }
     addHandler(handler, inherit = true) {
         this.handlers.push(handler);
         if (inherit) {