@langchain/core 0.3.17 → 0.3.19-rc.0

package/dist/callbacks/manager.cjs

@@ -789,36 +789,8 @@ function ensureHandler(handler) {
 }
 exports.ensureHandler = ensureHandler;
 /**
- * @example
- * ```typescript
- * const prompt = PromptTemplate.fromTemplate(`What is the answer to {question}?`);
- *
- * // Example of using LLMChain to process a series of questions
- * const chain = new LLMChain({
- *   llm: new ChatOpenAI({ temperature: 0.9 }),
- *   prompt,
- * });
- *
- * // Process questions using the chain
- * const processQuestions = async (questions) => {
- *   for (const question of questions) {
- *     const result = await chain.call({ question });
- *     console.log(result);
- *   }
- * };
- *
- * // Example questions
- * const questions = [
- *   "What is your name?",
- *   "What is your quest?",
- *   "What is your favorite color?",
- * ];
- *
- * // Run the example
-const logFunction = handler.raiseError ? console.error : console.warn;
-* processQuestions(questions).catch(consolelogFunction;
- *
- * ```
+ * @deprecated Use [`traceable`](https://docs.smith.langchain.com/observability/how_to_guides/tracing/annotate_code)
+ * from "langsmith" instead.
  */
 class TraceGroup {
     constructor(groupName, options) {

package/dist/callbacks/manager.d.ts

@@ -157,36 +157,8 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
 }
 export declare function ensureHandler(handler: BaseCallbackHandler | CallbackHandlerMethods): BaseCallbackHandler;
 /**
- * @example
- * ```typescript
- * const prompt = PromptTemplate.fromTemplate(`What is the answer to {question}?`);
- *
- * // Example of using LLMChain to process a series of questions
- * const chain = new LLMChain({
- *   llm: new ChatOpenAI({ temperature: 0.9 }),
- *   prompt,
- * });
- *
- * // Process questions using the chain
- * const processQuestions = async (questions) => {
- *   for (const question of questions) {
- *     const result = await chain.call({ question });
- *     console.log(result);
- *   }
- * };
- *
- * // Example questions
- * const questions = [
- *   "What is your name?",
- *   "What is your quest?",
- *   "What is your favorite color?",
- * ];
- *
- * // Run the example
-const logFunction = handler.raiseError ? console.error : console.warn;
-* processQuestions(questions).catch(consolelogFunction;
- *
- * ```
+ * @deprecated Use [`traceable`](https://docs.smith.langchain.com/observability/how_to_guides/tracing/annotate_code)
+ * from "langsmith" instead.
  */
 export declare class TraceGroup {
     private groupName;

package/dist/callbacks/manager.js

@@ -777,36 +777,8 @@ export function ensureHandler(handler) {
     return BaseCallbackHandler.fromMethods(handler);
 }
 /**
- * @example
- * ```typescript
- * const prompt = PromptTemplate.fromTemplate(`What is the answer to {question}?`);
- *
- * // Example of using LLMChain to process a series of questions
- * const chain = new LLMChain({
- *   llm: new ChatOpenAI({ temperature: 0.9 }),
- *   prompt,
- * });
- *
- * // Process questions using the chain
- * const processQuestions = async (questions) => {
- *   for (const question of questions) {
- *     const result = await chain.call({ question });
- *     console.log(result);
- *   }
- * };
- *
- * // Example questions
- * const questions = [
- *   "What is your name?",
- *   "What is your quest?",
- *   "What is your favorite color?",
- * ];
- *
- * // Run the example
-const logFunction = handler.raiseError ? console.error : console.warn;
-* processQuestions(questions).catch(consolelogFunction;
- *
- * ```
+ * @deprecated Use [`traceable`](https://docs.smith.langchain.com/observability/how_to_guides/tracing/annotate_code)
+ * from "langsmith" instead.
  */
 export class TraceGroup {
     constructor(groupName, options) {

package/dist/callbacks/promises.cjs

@@ -1,45 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitAllCallbacks = exports.consumeCallback = void 0;
-const p_queue_1 = __importDefault(require("p-queue"));
-let queue;
-/**
- * Creates a queue using the p-queue library. The queue is configured to
- * auto-start and has a concurrency of 1, meaning it will process tasks
- * one at a time.
- */
-function createQueue() {
-    const PQueue = "default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default;
-    return new PQueue({
-        autoStart: true,
-        concurrency: 1,
-    });
-}
-/**
- * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promiseFn Promise to consume
- * @param wait Whether to wait for the promise to resolve or resolve immediately
- */
-async function consumeCallback(promiseFn, wait) {
-    if (wait === true) {
-        await promiseFn();
-    }
-    else {
-        if (typeof queue === "undefined") {
-            queue = createQueue();
-        }
-        void queue.add(promiseFn);
-    }
-}
-exports.consumeCallback = consumeCallback;
-/**
- * Waits for all promises in the queue to resolve. If the queue is
- * undefined, it immediately resolves a promise.
- */
-function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
-}
-exports.awaitAllCallbacks = awaitAllCallbacks;
+exports.consumeCallback = exports.awaitAllCallbacks = void 0;
+const callbacks_js_1 = require("../singletons/callbacks.cjs");
+Object.defineProperty(exports, "awaitAllCallbacks", { enumerable: true, get: function () { return callbacks_js_1.awaitAllCallbacks; } });
+Object.defineProperty(exports, "consumeCallback", { enumerable: true, get: function () { return callbacks_js_1.consumeCallback; } });

package/dist/callbacks/promises.d.ts

@@ -1,11 +1,2 @@
-/**
- * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promiseFn Promise to consume
- * @param wait Whether to wait for the promise to resolve or resolve immediately
- */
-export declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;
-/**
- * Waits for all promises in the queue to resolve. If the queue is
- * undefined, it immediately resolves a promise.
- */
-export declare function awaitAllCallbacks(): Promise<void>;
+import { awaitAllCallbacks, consumeCallback } from "../singletons/callbacks.js";
+export { awaitAllCallbacks, consumeCallback };

package/dist/callbacks/promises.js

@@ -1,37 +1,2 @@
-import PQueueMod from "p-queue";
-let queue;
-/**
- * Creates a queue using the p-queue library. The queue is configured to
- * auto-start and has a concurrency of 1, meaning it will process tasks
- * one at a time.
- */
-function createQueue() {
-    const PQueue = "default" in PQueueMod ? PQueueMod.default : PQueueMod;
-    return new PQueue({
-        autoStart: true,
-        concurrency: 1,
-    });
-}
-/**
- * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promiseFn Promise to consume
- * @param wait Whether to wait for the promise to resolve or resolve immediately
- */
-export async function consumeCallback(promiseFn, wait) {
-    if (wait === true) {
-        await promiseFn();
-    }
-    else {
-        if (typeof queue === "undefined") {
-            queue = createQueue();
-        }
-        void queue.add(promiseFn);
-    }
-}
-/**
- * Waits for all promises in the queue to resolve. If the queue is
- * undefined, it immediately resolves a promise.
- */
-export function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
-}
+import { awaitAllCallbacks, consumeCallback } from "../singletons/callbacks.js";
+export { awaitAllCallbacks, consumeCallback };

package/dist/language_models/base.d.ts

@@ -107,6 +107,8 @@ export type StructuredOutputMethodOptions<IncludeRaw extends boolean = false> =
     name?: string;
     method?: "functionCalling" | "jsonMode" | "jsonSchema" | string;
     includeRaw?: IncludeRaw;
+    /** Whether to use strict mode. Currently only supported by OpenAI models. */
+    strict?: boolean;
 };
 /** @deprecated Use StructuredOutputMethodOptions instead */
 export type StructuredOutputMethodParams<RunOutput, IncludeRaw extends boolean = false> = {

package/dist/language_models/chat_models.cjs

@@ -466,6 +466,9 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         if (typeof this.bindTools !== "function") {
             throw new Error(`Chat model must implement ".bindTools()" to use withStructuredOutput.`);
         }
+        if (config?.strict) {
+            throw new Error(`"strict" mode is not supported for this model by default.`);
+        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const schema = outputSchema;
         const name = config?.name;

package/dist/language_models/chat_models.js

@@ -462,6 +462,9 @@ export class BaseChatModel extends BaseLanguageModel {
         if (typeof this.bindTools !== "function") {
             throw new Error(`Chat model must implement ".bindTools()" to use withStructuredOutput.`);
         }
+        if (config?.strict) {
+            throw new Error(`"strict" mode is not supported for this model by default.`);
+        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const schema = outputSchema;
         const name = config?.name;

package/dist/retrievers/index.cjs

@@ -5,31 +5,57 @@ const manager_js_1 = require("../callbacks/manager.cjs");
 const base_js_1 = require("../runnables/base.cjs");
 const config_js_1 = require("../runnables/config.cjs");
 /**
- * Abstract base class for a Document retrieval system. A retrieval system
- * is defined as something that can take string queries and return the
- * most 'relevant' Documents from some source.
+ * Abstract base class for a document retrieval system, designed to
+ * process string queries and return the most relevant documents from a source.
+ *
+ * `BaseRetriever` provides common properties and methods for derived retrievers,
+ * such as callbacks, tagging, and verbose logging. Custom retrieval systems
+ * should extend this class and implement `_getRelevantDocuments` to define
+ * the specific retrieval logic.
+ *
+ * @template Metadata - The type of metadata associated with each document,
+ *                      defaulting to `Record<string, any>`.
  */
 class BaseRetriever extends base_js_1.Runnable {
+    /**
+     * Constructs a new `BaseRetriever` instance with optional configuration fields.
+     *
+     * @param fields - Optional input configuration that can include `callbacks`,
+     *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.
+     */
     constructor(fields) {
         super(fields);
+        /**
+         * Optional callbacks to handle various events in the retrieval process.
+         */
         Object.defineProperty(this, "callbacks", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Tags to label or categorize the retrieval operation.
+         */
         Object.defineProperty(this, "tags", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Metadata to provide additional context or information about the retrieval
+         * operation.
+         */
         Object.defineProperty(this, "metadata", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * If set to `true`, enables verbose logging for the retrieval process.
+         */
         Object.defineProperty(this, "verbose", {
             enumerable: true,
             configurable: true,
@@ -46,9 +72,32 @@ class BaseRetriever extends base_js_1.Runnable {
      * changes to people currently using subclassed custom retrievers.
      * Change it on next major release.
      */
+    /**
+     * Placeholder method for retrieving relevant documents based on a query.
+     *
+     * This method is intended to be implemented by subclasses and will be
+     * converted to an abstract method in the next major release. Currently, it
+     * throws an error if not implemented, ensuring that custom retrievers define
+     * the specific retrieval logic.
+     *
+     * @param _query - The query string used to search for relevant documents.
+     * @param _callbacks - (optional) Callback manager for managing callbacks
+     *                     during retrieval.
+     * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.
+     * @throws {Error} Throws an error indicating the method is not implemented.
+     */
     _getRelevantDocuments(_query, _callbacks) {
         throw new Error("Not implemented!");
     }
+    /**
+     * Executes a retrieval operation.
+     *
+     * @param input - The query string used to search for relevant documents.
+     * @param options - (optional) Configuration options for the retrieval run,
+     *                  which may include callbacks, tags, and metadata.
+     * @returns A promise that resolves to an array of `DocumentInterface` instances
+     *          representing the most relevant documents to the query.
+     */
     async invoke(input, options) {
         return this.getRelevantDocuments(input, (0, config_js_1.ensureConfig)(options));
     }

package/dist/retrievers/index.d.ts

@@ -3,7 +3,24 @@ import type { DocumentInterface } from "../documents/document.js";
 import { Runnable, type RunnableInterface } from "../runnables/base.js";
 import { RunnableConfig } from "../runnables/config.js";
 /**
- * Base Retriever class. All indexes should extend this class.
+ * Input configuration options for initializing a retriever that extends
+ * the `BaseRetriever` class. This interface provides base properties
+ * common to all retrievers, allowing customization of callback functions,
+ * tagging, metadata, and logging verbosity.
+ *
+ * Fields:
+ * - `callbacks` (optional): An array of callback functions that handle various
+ *   events during retrieval, such as logging, error handling, or progress updates.
+ *
+ * - `tags` (optional): An array of strings used to add contextual tags to
+ *   retrieval operations, allowing for easier categorization and tracking.
+ *
+ * - `metadata` (optional): A record of key-value pairs to store additional
+ *   contextual information for retrieval operations, which can be useful
+ *   for logging or auditing purposes.
+ *
+ * - `verbose` (optional): A boolean flag that, if set to `true`, enables
+ *   detailed logging and output during the retrieval process. Defaults to `false`.
  */
 export interface BaseRetrieverInput {
     callbacks?: Callbacks;
@@ -11,26 +28,95 @@ export interface BaseRetrieverInput {
     metadata?: Record<string, unknown>;
     verbose?: boolean;
 }
+/**
+ * Interface for a base retriever that defines core functionality for
+ * retrieving relevant documents from a source based on a query.
+ *
+ * The `BaseRetrieverInterface` standardizes the `getRelevantDocuments` method,
+ * enabling retrieval of documents that match the query criteria.
+ *
+ * @template Metadata - The type of metadata associated with each document,
+ *                      defaulting to `Record<string, any>`.
+ */
 export interface BaseRetrieverInterface<Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {
+    /**
+     * Retrieves documents relevant to a given query, allowing optional
+     * configurations for customization.
+     *
+     * @param query - A string representing the query to search for relevant documents.
+     * @param config - (optional) Configuration options for the retrieval process,
+     *                 which may include callbacks and additional context settings.
+     * @returns A promise that resolves to an array of `DocumentInterface` instances,
+     *          each containing metadata specified by the `Metadata` type parameter.
+     */
     getRelevantDocuments(query: string, config?: Callbacks | BaseCallbackConfig): Promise<DocumentInterface<Metadata>[]>;
 }
 /**
- * Abstract base class for a Document retrieval system. A retrieval system
- * is defined as something that can take string queries and return the
- * most 'relevant' Documents from some source.
+ * Abstract base class for a document retrieval system, designed to
+ * process string queries and return the most relevant documents from a source.
+ *
+ * `BaseRetriever` provides common properties and methods for derived retrievers,
+ * such as callbacks, tagging, and verbose logging. Custom retrieval systems
+ * should extend this class and implement `_getRelevantDocuments` to define
+ * the specific retrieval logic.
+ *
+ * @template Metadata - The type of metadata associated with each document,
+ *                      defaulting to `Record<string, any>`.
  */
 export declare abstract class BaseRetriever<Metadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {
+    /**
+     * Optional callbacks to handle various events in the retrieval process.
+     */
     callbacks?: Callbacks;
+    /**
+     * Tags to label or categorize the retrieval operation.
+     */
     tags?: string[];
+    /**
+     * Metadata to provide additional context or information about the retrieval
+     * operation.
+     */
     metadata?: Record<string, unknown>;
+    /**
+     * If set to `true`, enables verbose logging for the retrieval process.
+     */
     verbose?: boolean;
+    /**
+     * Constructs a new `BaseRetriever` instance with optional configuration fields.
+     *
+     * @param fields - Optional input configuration that can include `callbacks`,
+     *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.
+     */
     constructor(fields?: BaseRetrieverInput);
     /**
      * TODO: This should be an abstract method, but we'd like to avoid breaking
      * changes to people currently using subclassed custom retrievers.
      * Change it on next major release.
      */
+    /**
+     * Placeholder method for retrieving relevant documents based on a query.
+     *
+     * This method is intended to be implemented by subclasses and will be
+     * converted to an abstract method in the next major release. Currently, it
+     * throws an error if not implemented, ensuring that custom retrievers define
+     * the specific retrieval logic.
+     *
+     * @param _query - The query string used to search for relevant documents.
+     * @param _callbacks - (optional) Callback manager for managing callbacks
+     *                     during retrieval.
+     * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.
+     * @throws {Error} Throws an error indicating the method is not implemented.
+     */
     _getRelevantDocuments(_query: string, _callbacks?: CallbackManagerForRetrieverRun): Promise<DocumentInterface<Metadata>[]>;
+    /**
+     * Executes a retrieval operation.
+     *
+     * @param input - The query string used to search for relevant documents.
+     * @param options - (optional) Configuration options for the retrieval run,
+     *                  which may include callbacks, tags, and metadata.
+     * @returns A promise that resolves to an array of `DocumentInterface` instances
+     *          representing the most relevant documents to the query.
+     */
     invoke(input: string, options?: RunnableConfig): Promise<DocumentInterface<Metadata>[]>;
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.

package/dist/retrievers/index.js

@@ -2,31 +2,57 @@ import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.j
 import { Runnable } from "../runnables/base.js";
 import { ensureConfig } from "../runnables/config.js";
 /**
- * Abstract base class for a Document retrieval system. A retrieval system
- * is defined as something that can take string queries and return the
- * most 'relevant' Documents from some source.
+ * Abstract base class for a document retrieval system, designed to
+ * process string queries and return the most relevant documents from a source.
+ *
+ * `BaseRetriever` provides common properties and methods for derived retrievers,
+ * such as callbacks, tagging, and verbose logging. Custom retrieval systems
+ * should extend this class and implement `_getRelevantDocuments` to define
+ * the specific retrieval logic.
+ *
+ * @template Metadata - The type of metadata associated with each document,
+ *                      defaulting to `Record<string, any>`.
  */
 export class BaseRetriever extends Runnable {
+    /**
+     * Constructs a new `BaseRetriever` instance with optional configuration fields.
+     *
+     * @param fields - Optional input configuration that can include `callbacks`,
+     *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.
+     */
     constructor(fields) {
         super(fields);
+        /**
+         * Optional callbacks to handle various events in the retrieval process.
+         */
         Object.defineProperty(this, "callbacks", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Tags to label or categorize the retrieval operation.
+         */
         Object.defineProperty(this, "tags", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Metadata to provide additional context or information about the retrieval
+         * operation.
+         */
         Object.defineProperty(this, "metadata", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * If set to `true`, enables verbose logging for the retrieval process.
+         */
         Object.defineProperty(this, "verbose", {
             enumerable: true,
             configurable: true,
@@ -43,9 +69,32 @@ export class BaseRetriever extends Runnable {
      * changes to people currently using subclassed custom retrievers.
      * Change it on next major release.
      */
+    /**
+     * Placeholder method for retrieving relevant documents based on a query.
+     *
+     * This method is intended to be implemented by subclasses and will be
+     * converted to an abstract method in the next major release. Currently, it
+     * throws an error if not implemented, ensuring that custom retrievers define
+     * the specific retrieval logic.
+     *
+     * @param _query - The query string used to search for relevant documents.
+     * @param _callbacks - (optional) Callback manager for managing callbacks
+     *                     during retrieval.
+     * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.
+     * @throws {Error} Throws an error indicating the method is not implemented.
+     */
     _getRelevantDocuments(_query, _callbacks) {
         throw new Error("Not implemented!");
     }
+    /**
+     * Executes a retrieval operation.
+     *
+     * @param input - The query string used to search for relevant documents.
+     * @param options - (optional) Configuration options for the retrieval run,
+     *                  which may include callbacks, tags, and metadata.
+     * @returns A promise that resolves to an array of `DocumentInterface` instances
+     *          representing the most relevant documents to the query.
+     */
     async invoke(input, options) {
         return this.getRelevantDocuments(input, ensureConfig(options));
     }

package/dist/singletons/async_local_storage/globals.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalAsyncLocalStorageInstance = exports.setGlobalAsyncLocalStorageInstance = exports.TRACING_ALS_KEY = void 0;
+exports.TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+const setGlobalAsyncLocalStorageInstance = (instance) => {
+    globalThis[exports.TRACING_ALS_KEY] = instance;
+};
+exports.setGlobalAsyncLocalStorageInstance = setGlobalAsyncLocalStorageInstance;
+const getGlobalAsyncLocalStorageInstance = () => {
+    return globalThis[exports.TRACING_ALS_KEY];
+};
+exports.getGlobalAsyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance;

package/dist/singletons/async_local_storage/globals.d.ts

@@ -0,0 +1,8 @@
+export interface AsyncLocalStorageInterface {
+    getStore: () => any | undefined;
+    run: <T>(store: any, callback: () => T) => T;
+    enterWith: (store: any) => void;
+}
+export declare const TRACING_ALS_KEY: unique symbol;
+export declare const setGlobalAsyncLocalStorageInstance: (instance: AsyncLocalStorageInterface) => void;
+export declare const getGlobalAsyncLocalStorageInstance: () => any;

package/dist/singletons/async_local_storage/globals.js

@@ -0,0 +1,7 @@
+export const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+export const setGlobalAsyncLocalStorageInstance = (instance) => {
+    globalThis[TRACING_ALS_KEY] = instance;
+};
+export const getGlobalAsyncLocalStorageInstance = () => {
+    return globalThis[TRACING_ALS_KEY];
+};

package/dist/singletons/async_local_storage/index.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLocalStorageProviderSingleton = exports._CONTEXT_VARIABLES_KEY = exports.MockAsyncLocalStorage = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const langsmith_1 = require("langsmith");
+const globals_js_1 = require("./globals.cjs");
+const manager_js_1 = require("../../callbacks/manager.cjs");
+class MockAsyncLocalStorage {
+    getStore() {
+        return undefined;
+    }
+    run(_store, callback) {
+        return callback();
+    }
+    enterWith(_store) {
+        return undefined;
+    }
+}
+exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
+const mockAsyncLocalStorage = new MockAsyncLocalStorage();
+const LC_CHILD_KEY = Symbol.for("lc:child_config");
+exports._CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
+class AsyncLocalStorageProvider {
+    getInstance() {
+        return (0, globals_js_1.getGlobalAsyncLocalStorageInstance)() ?? mockAsyncLocalStorage;
+    }
+    getRunnableConfig() {
+        const storage = this.getInstance();
+        // this has the runnable config
+        // which means that we should also have an instance of a LangChainTracer
+        // with the run map prepopulated
+        return storage.getStore()?.extra?.[LC_CHILD_KEY];
+    }
+    runWithConfig(config, callback, avoidCreatingRootRunTree) {
+        const callbackManager = manager_js_1.CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
+        const storage = this.getInstance();
+        const previousValue = storage.getStore();
+        const parentRunId = callbackManager?.getParentRunId();
+        const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
+        let runTree;
+        if (langChainTracer && parentRunId) {
+            runTree = langChainTracer.convertToRunTree(parentRunId);
+        }
+        else if (!avoidCreatingRootRunTree) {
+            runTree = new langsmith_1.RunTree({
+                name: "<runnable_lambda>",
+                tracingEnabled: false,
+            });
+        }
+        if (runTree) {
+            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
+        }
+        if (previousValue !== undefined &&
+            previousValue[exports._CONTEXT_VARIABLES_KEY] !== undefined) {
+            runTree[exports._CONTEXT_VARIABLES_KEY] =
+                previousValue[exports._CONTEXT_VARIABLES_KEY];
+        }
+        return storage.run(runTree, callback);
+    }
+    initializeGlobalInstance(instance) {
+        if ((0, globals_js_1.getGlobalAsyncLocalStorageInstance)() === undefined) {
+            (0, globals_js_1.setGlobalAsyncLocalStorageInstance)(instance);
+        }
+    }
+}
+const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
+exports.AsyncLocalStorageProviderSingleton = AsyncLocalStorageProviderSingleton;