@nocobase/plugin-ai 1.6.0-beta.17

package/dist/node_modules/@langchain/core/dist/callbacks/base.d.ts

@@ -0,0 +1,291 @@
+import type { ChainValues } from "../utils/types/index.js";
+import type { BaseMessage } from "../messages/base.js";
+import type { AgentAction, AgentFinish } from "../agents.js";
+import type { ChatGenerationChunk, GenerationChunk, LLMResult } from "../outputs.js";
+import { Serializable, Serialized, SerializedNotImplemented } from "../load/serializable.js";
+import type { SerializedFields } from "../load/map_keys.js";
+import type { DocumentInterface } from "../documents/document.js";
+type Error = any;
+/**
+ * Interface for the input parameters of the BaseCallbackHandler class. It
+ * allows to specify which types of events should be ignored by the
+ * callback handler.
+ */
+export interface BaseCallbackHandlerInput {
+    ignoreLLM?: boolean;
+    ignoreChain?: boolean;
+    ignoreAgent?: boolean;
+    ignoreRetriever?: boolean;
+    ignoreCustomEvent?: boolean;
+    _awaitHandler?: boolean;
+    raiseError?: boolean;
+}
+/**
+ * Interface for the indices of a new token produced by an LLM or Chat
+ * Model in streaming mode.
+ */
+export interface NewTokenIndices {
+    prompt: number;
+    completion: number;
+}
+export type HandleLLMNewTokenCallbackFields = {
+    chunk?: GenerationChunk | ChatGenerationChunk;
+};
+/**
+ * Abstract class that provides a set of optional methods that can be
+ * overridden in derived classes to handle various events during the
+ * execution of a LangChain application.
+ */
+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>, 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
+     */
+    handleLLMNewToken?(token: string, 
+    /**
+     * idx.prompt is the index of the prompt that produced the token
+     *   (if there are multiple prompts)
+     * idx.completion is the index of the completion that produced the token
+     *   (if multiple completions per prompt are requested)
+     */
+    idx: NewTokenIndices, runId: string, parentRunId?: string, tags?: string[], fields?: HandleLLMNewTokenCallbackFields): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called if an LLM/ChatModel run encounters an error
+     */
+    handleLLMError?(err: Error, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the end of an LLM/ChatModel run, with the output and the run ID.
+     */
+    handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * 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>, 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, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called if a Chain run encounters an error
+     */
+    handleChainError?(err: Error, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the end of a Chain run, with the outputs and the run ID.
+     */
+    handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * 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>, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called if a Tool run encounters an error
+     */
+    handleToolError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the end of a Tool run, with the tool output and the run ID.
+     */
+    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;
+    /**
+     * Called when an agent is about to execute an action,
+     * with the action and the run ID.
+     */
+    handleAgentAction?(action: AgentAction, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    /**
+     * Called when an agent finishes execution, before it exits.
+     * with the final output and the run ID.
+     */
+    handleAgentEnd?(action: AgentFinish, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, name?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    handleRetrieverEnd?(documents: DocumentInterface[], runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    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
+ * implemented, it will be ignored. If a method is implemented, it will be
+ * called at the appropriate time. All methods are called with the run ID of
+ * the LLM/ChatModel/Chain that is running, which is generated by the
+ * CallbackManager.
+ *
+ * @interface
+ */
+export type CallbackHandlerMethods = BaseCallbackHandlerMethodsClass;
+/**
+ * Interface for handlers that can indicate a preference for streaming responses.
+ * When implemented, this allows the handler to signal whether it prefers to receive
+ * streaming responses from language models rather than complete responses.
+ */
+export interface CallbackHandlerPrefersStreaming {
+    readonly lc_prefer_streaming: boolean;
+}
+export declare function callbackHandlerPrefersStreaming(x: BaseCallbackHandler): unknown;
+/**
+ * Abstract base class for creating callback handlers in the LangChain
+ * framework. It provides a set of optional methods that can be overridden
+ * in derived classes to handle various events during the execution of a
+ * LangChain application.
+ */
+export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass implements BaseCallbackHandlerInput, Serializable {
+    lc_serializable: boolean;
+    get lc_namespace(): ["langchain_core", "callbacks", string];
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    get lc_attributes(): {
+        [key: string]: string;
+    } | undefined;
+    get lc_aliases(): {
+        [key: string]: string;
+    } | undefined;
+    get lc_serializable_keys(): string[] | undefined;
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name(): string;
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id(): string[];
+    lc_kwargs: SerializedFields;
+    abstract name: string;
+    ignoreLLM: boolean;
+    ignoreChain: boolean;
+    ignoreAgent: boolean;
+    ignoreRetriever: boolean;
+    ignoreCustomEvent: boolean;
+    raiseError: boolean;
+    awaitHandlers: boolean;
+    constructor(input?: BaseCallbackHandlerInput);
+    copy(): BaseCallbackHandler;
+    toJSON(): Serialized;
+    toJSONNotImplemented(): SerializedNotImplemented;
+    static fromMethods(methods: CallbackHandlerMethods): {
+        name: string;
+        lc_serializable: boolean;
+        readonly lc_namespace: ["langchain_core", "callbacks", string];
+        readonly lc_secrets: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_attributes: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_aliases: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_serializable_keys: string[] | undefined;
+        /**
+         * The final serialized identifier for the module.
+         */
+        readonly lc_id: string[];
+        lc_kwargs: SerializedFields;
+        ignoreLLM: boolean;
+        ignoreChain: boolean;
+        ignoreAgent: boolean;
+        ignoreRetriever: boolean;
+        ignoreCustomEvent: boolean;
+        raiseError: boolean;
+        awaitHandlers: boolean;
+        copy(): BaseCallbackHandler;
+        toJSON(): Serialized;
+        toJSONNotImplemented(): SerializedNotImplemented;
+        /**
+         * 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, runName?: string | undefined): any;
+        /**
+         * Called when an LLM/ChatModel in `streaming` mode produces a new token
+         */
+        handleLLMNewToken?(token: string, idx: NewTokenIndices, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, fields?: HandleLLMNewTokenCallbackFields | undefined): any;
+        /**
+         * Called if an LLM/ChatModel run encounters an error
+         */
+        handleLLMError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, extraParams?: Record<string, unknown> | undefined): any;
+        /**
+         * Called at the end of an LLM/ChatModel run, with the output and the run ID.
+         */
+        handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, extraParams?: Record<string, unknown> | undefined): any;
+        /**
+         * 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, 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, runName?: string | undefined): any;
+        /**
+         * Called if a Chain run encounters an error
+         */
+        handleChainError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
+            inputs?: Record<string, unknown> | undefined;
+        } | undefined): any;
+        /**
+         * Called at the end of a Chain run, with the outputs and the run ID.
+         */
+        handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
+            inputs?: Record<string, unknown> | undefined;
+        } | undefined): any;
+        /**
+         * 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, runName?: string | undefined): any;
+        /**
+         * Called if a Tool run encounters an error
+         */
+        handleToolError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        /**
+         * Called at the end of a Tool run, with the tool output and the run ID.
+         */
+        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,
+         * with the action and the run ID.
+         */
+        handleAgentAction?(action: AgentAction, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        /**
+         * Called when an agent finishes execution, before it exits.
+         * with the final output and the run ID.
+         */
+        handleAgentEnd?(action: AgentFinish, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        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 declare const isBaseCallbackHandler: (x: unknown) => boolean;
+export {};

package/dist/node_modules/@langchain/core/dist/callbacks/base.js

@@ -0,0 +1,154 @@
+import * as uuid from "uuid";
+import { Serializable, get_lc_unique_name, } from "../load/serializable.js";
+import { getEnvironmentVariable } from "../utils/env.js";
+/**
+ * Abstract class that provides a set of optional methods that can be
+ * overridden in derived classes to handle various events during the
+ * execution of a LangChain application.
+ */
+class BaseCallbackHandlerMethodsClass {
+}
+export function callbackHandlerPrefersStreaming(x) {
+    return "lc_prefer_streaming" in x && x.lc_prefer_streaming;
+}
+/**
+ * Abstract base class for creating callback handlers in the LangChain
+ * framework. It provides a set of optional methods that can be overridden
+ * in derived classes to handle various events during the execution of a
+ * LangChain application.
+ */
+export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
+    get lc_namespace() {
+        return ["langchain_core", "callbacks", this.name];
+    }
+    get lc_secrets() {
+        return undefined;
+    }
+    get lc_attributes() {
+        return undefined;
+    }
+    get lc_aliases() {
+        return undefined;
+    }
+    get lc_serializable_keys() {
+        return undefined;
+    }
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name() {
+        return this.name;
+    }
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id() {
+        return [
+            ...this.lc_namespace,
+            get_lc_unique_name(this.constructor),
+        ];
+    }
+    constructor(input) {
+        super();
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_kwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ignoreLLM", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "ignoreChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "ignoreAgent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "ignoreRetriever", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "ignoreCustomEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "raiseError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "awaitHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
+        });
+        this.lc_kwargs = input || {};
+        if (input) {
+            this.ignoreLLM = input.ignoreLLM ?? this.ignoreLLM;
+            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);
+        }
+    }
+    copy() {
+        return new this.constructor(this);
+    }
+    toJSON() {
+        return Serializable.prototype.toJSON.call(this);
+    }
+    toJSONNotImplemented() {
+        return Serializable.prototype.toJSONNotImplemented.call(this);
+    }
+    static fromMethods(methods) {
+        class Handler extends BaseCallbackHandler {
+            constructor() {
+                super();
+                Object.defineProperty(this, "name", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: uuid.v4()
+                });
+                Object.assign(this, methods);
+            }
+        }
+        return new Handler();
+    }
+}
+export const isBaseCallbackHandler = (x) => {
+    const callbackHandler = x;
+    return (callbackHandler !== undefined &&
+        typeof callbackHandler.copy === "function" &&
+        typeof callbackHandler.name === "string" &&
+        typeof callbackHandler.awaitHandlers === "boolean");
+};

package/dist/node_modules/@langchain/core/dist/callbacks/dispatch/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
+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");
+index_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(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/node_modules/@langchain/core/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/node_modules/@langchain/core/dist/callbacks/dispatch/index.js

@@ -0,0 +1,45 @@
+/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
+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";
+AsyncLocalStorageProviderSingleton.initializeGlobalInstance(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/node_modules/@langchain/core/dist/callbacks/dispatch/web.cjs

@@ -0,0 +1,59 @@
+"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) {
+    if (config === undefined) {
+        throw new Error([
+            "Unable to dispatch a custom event without a parent run id.",
+            `"dispatchCustomEvent" 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/docs/how_to/custom_tools#tool-function",
+            "\n",
+        ].join(" "));
+    }
+    const callbackManager = await (0, config_js_1.getCallbackManagerForConfig)(config);
+    const parentRunId = callbackManager?.getParentRunId();
+    // We pass parent id as the current run id here intentionally since events dispatch
+    // from within things like RunnableLambda
+    if (callbackManager !== undefined && parentRunId !== undefined) {
+        await callbackManager.handleCustomEvent?.(name, payload, parentRunId);
+    }
+}
+exports.dispatchCustomEvent = dispatchCustomEvent;

package/dist/node_modules/@langchain/core/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>;