@langchain/core 0.1.32 → 0.1.33-rc.1

package/dist/runnables/base.cjs

@@ -13,6 +13,7 @@ const config_js_1 = require("./config.cjs");
 const async_caller_js_1 = require("../utils/async_caller.cjs");
 const root_listener_js_1 = require("../tracers/root_listener.cjs");
 const utils_js_1 = require("./utils.cjs");
+const index_js_1 = require("../singletons/index.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value &&
@@ -1279,20 +1280,29 @@ class RunnableLambda extends Runnable {
         });
     }
     async _invoke(input, config, runManager) {
-        let output = await this.func(input, { ...config, config });
-        if (output && Runnable.isRunnable(output)) {
-            if (config?.recursionLimit === 0) {
-                throw new Error("Recursion limit reached.");
-            }
-            output = await output.invoke(input, (0, config_js_1.patchConfig)(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
-            }));
-        }
-        return output;
+        return new Promise((resolve, reject) => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+                try {
+                    let output = await this.func(input, { ...config, config });
+                    if (output && Runnable.isRunnable(output)) {
+                        if (config?.recursionLimit === 0) {
+                            throw new Error("Recursion limit reached.");
+                        }
+                        output = await output.invoke(input, (0, config_js_1.patchConfig)(config, {
+                            callbacks: runManager?.getChild(),
+                            recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+                        }));
+                    }
+                    resolve(output);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
     }
     async invoke(input, options) {
-        return this._callWithConfig(this._invoke, input, options);
+        return this._callWithConfig(this._invoke, input, options ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore());
     }
     async *_transform(generator, runManager, config) {
         let finalChunk;
@@ -1311,25 +1321,36 @@ class RunnableLambda extends Runnable {
                 }
             }
         }
-        const output = await this.func(finalChunk, { ...config, config });
-        if (output && Runnable.isRunnable(output)) {
-            if (config?.recursionLimit === 0) {
-                throw new Error("Recursion limit reached.");
+        // eslint-disable-next-line prefer-destructuring
+        const func = this.func;
+        async function* generatorWrapper() {
+            const output = await func(finalChunk, { ...config, config });
+            if (output && Runnable.isRunnable(output)) {
+                if (config?.recursionLimit === 0) {
+                    throw new Error("Recursion limit reached.");
+                }
+                const stream = await output.stream(finalChunk, (0, config_js_1.patchConfig)(config, {
+                    callbacks: runManager?.getChild(),
+                    recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+                }));
+                for await (const chunk of stream) {
+                    yield chunk;
+                }
             }
-            const stream = await output.stream(finalChunk, (0, config_js_1.patchConfig)(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
-            }));
-            for await (const chunk of stream) {
-                yield chunk;
+            else {
+                yield output;
             }
         }
-        else {
-            yield output;
-        }
+        const finalGenerator = await new Promise((resolve) => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+                const wrappedGenerator = generatorWrapper();
+                resolve(wrappedGenerator);
+            });
+        });
+        yield* finalGenerator;
     }
     transform(generator, options) {
-        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore());
     }
     async stream(input, options) {
         async function* generator() {

package/dist/runnables/base.js

@@ -7,6 +7,7 @@ import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mer
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";
 import { _RootEventFilter } from "./utils.js";
+import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -1266,20 +1267,29 @@ export class RunnableLambda extends Runnable {
         });
     }
     async _invoke(input, config, runManager) {
-        let output = await this.func(input, { ...config, config });
-        if (output && Runnable.isRunnable(output)) {
-            if (config?.recursionLimit === 0) {
-                throw new Error("Recursion limit reached.");
-            }
-            output = await output.invoke(input, patchConfig(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
-            }));
-        }
-        return output;
+        return new Promise((resolve, reject) => {
+            void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+                try {
+                    let output = await this.func(input, { ...config, config });
+                    if (output && Runnable.isRunnable(output)) {
+                        if (config?.recursionLimit === 0) {
+                            throw new Error("Recursion limit reached.");
+                        }
+                        output = await output.invoke(input, patchConfig(config, {
+                            callbacks: runManager?.getChild(),
+                            recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+                        }));
+                    }
+                    resolve(output);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
     }
     async invoke(input, options) {
-        return this._callWithConfig(this._invoke, input, options);
+        return this._callWithConfig(this._invoke, input, options ?? AsyncLocalStorageProviderSingleton.getInstance().getStore());
     }
     async *_transform(generator, runManager, config) {
         let finalChunk;
@@ -1298,25 +1308,36 @@ export class RunnableLambda extends Runnable {
                 }
             }
         }
-        const output = await this.func(finalChunk, { ...config, config });
-        if (output && Runnable.isRunnable(output)) {
-            if (config?.recursionLimit === 0) {
-                throw new Error("Recursion limit reached.");
+        // eslint-disable-next-line prefer-destructuring
+        const func = this.func;
+        async function* generatorWrapper() {
+            const output = await func(finalChunk, { ...config, config });
+            if (output && Runnable.isRunnable(output)) {
+                if (config?.recursionLimit === 0) {
+                    throw new Error("Recursion limit reached.");
+                }
+                const stream = await output.stream(finalChunk, patchConfig(config, {
+                    callbacks: runManager?.getChild(),
+                    recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+                }));
+                for await (const chunk of stream) {
+                    yield chunk;
+                }
             }
-            const stream = await output.stream(finalChunk, patchConfig(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
-            }));
-            for await (const chunk of stream) {
-                yield chunk;
+            else {
+                yield output;
             }
         }
-        else {
-            yield output;
-        }
+        const finalGenerator = await new Promise((resolve) => {
+            void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+                const wrappedGenerator = generatorWrapper();
+                resolve(wrappedGenerator);
+            });
+        });
+        yield* finalGenerator;
     }
     transform(generator, options) {
-        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options ?? AsyncLocalStorageProviderSingleton.getInstance().getStore());
     }
     async stream(input, options) {
         async function* generator() {

package/dist/singletons/index.cjs

@@ -0,0 +1,40 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLocalStorageProviderSingleton = exports.MockAsyncLocalStorage = void 0;
+class MockAsyncLocalStorage {
+    getStore() {
+        return undefined;
+    }
+    run(_store, callback) {
+        callback();
+    }
+}
+exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
+class AsyncLocalStorageProvider {
+    constructor() {
+        Object.defineProperty(this, "asyncLocalStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new MockAsyncLocalStorage()
+        });
+        Object.defineProperty(this, "hasBeenInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    getInstance() {
+        return this.asyncLocalStorage;
+    }
+    initializeGlobalInstance(instance) {
+        if (!this.hasBeenInitialized) {
+            this.hasBeenInitialized = true;
+            this.asyncLocalStorage = instance;
+        }
+    }
+}
+const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
+exports.AsyncLocalStorageProviderSingleton = AsyncLocalStorageProviderSingleton;

package/dist/singletons/index.d.ts

@@ -0,0 +1,16 @@
+export interface AsyncLocalStorageInterface {
+    getStore: () => any | undefined;
+    run: (store: any, callback: () => any) => any;
+}
+export declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {
+    getStore(): any;
+    run(_store: any, callback: () => any): any;
+}
+declare class AsyncLocalStorageProvider {
+    private asyncLocalStorage;
+    private hasBeenInitialized;
+    getInstance(): AsyncLocalStorageInterface;
+    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
+}
+declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;
+export { AsyncLocalStorageProviderSingleton };

package/dist/singletons/index.js

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class MockAsyncLocalStorage {
+    getStore() {
+        return undefined;
+    }
+    run(_store, callback) {
+        callback();
+    }
+}
+class AsyncLocalStorageProvider {
+    constructor() {
+        Object.defineProperty(this, "asyncLocalStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new MockAsyncLocalStorage()
+        });
+        Object.defineProperty(this, "hasBeenInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    getInstance() {
+        return this.asyncLocalStorage;
+    }
+    initializeGlobalInstance(instance) {
+        if (!this.hasBeenInitialized) {
+            this.hasBeenInitialized = true;
+            this.asyncLocalStorage = instance;
+        }
+    }
+}
+const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
+export { AsyncLocalStorageProviderSingleton };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.32",
+  "version": "0.1.33-rc.1",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -298,6 +298,15 @@
       "import": "./retrievers.js",
       "require": "./retrievers.cjs"
     },
+    "./singletons": {
+      "types": {
+        "import": "./singletons.d.ts",
+        "require": "./singletons.d.cts",
+        "default": "./singletons.d.ts"
+      },
+      "import": "./singletons.js",
+      "require": "./singletons.cjs"
+    },
     "./stores": {
       "types": {
         "import": "./stores.d.ts",
@@ -601,6 +610,10 @@
     "retrievers.js",
     "retrievers.d.ts",
     "retrievers.d.cts",
+    "singletons.cjs",
+    "singletons.js",
+    "singletons.d.ts",
+    "singletons.d.cts",
     "stores.cjs",
     "stores.js",
     "stores.d.ts",

package/singletons.cjs

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

package/singletons.d.cts

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

package/singletons.d.ts

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

package/singletons.js

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