@langchain/core 0.3.16 → 0.3.18

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;

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

@@ -0,0 +1,15 @@
+import { AsyncLocalStorageInterface } from "./globals.js";
+export declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {
+    getStore(): any;
+    run<T>(_store: any, callback: () => T): T;
+    enterWith(_store: any): undefined;
+}
+export declare const _CONTEXT_VARIABLES_KEY: unique symbol;
+declare class AsyncLocalStorageProvider {
+    getInstance(): AsyncLocalStorageInterface;
+    getRunnableConfig(): any;
+    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;
+    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
+}
+declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;
+export { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };

package/dist/singletons/async_local_storage/index.js

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { RunTree } from "langsmith";
+import { getGlobalAsyncLocalStorageInstance, setGlobalAsyncLocalStorageInstance, } from "./globals.js";
+import { CallbackManager } from "../../callbacks/manager.js";
+export class MockAsyncLocalStorage {
+    getStore() {
+        return undefined;
+    }
+    run(_store, callback) {
+        return callback();
+    }
+    enterWith(_store) {
+        return undefined;
+    }
+}
+const mockAsyncLocalStorage = new MockAsyncLocalStorage();
+const LC_CHILD_KEY = Symbol.for("lc:child_config");
+export const _CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
+class AsyncLocalStorageProvider {
+    getInstance() {
+        return 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 = 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 RunTree({
+                name: "<runnable_lambda>",
+                tracingEnabled: false,
+            });
+        }
+        if (runTree) {
+            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
+        }
+        if (previousValue !== undefined &&
+            previousValue[_CONTEXT_VARIABLES_KEY] !== undefined) {
+            runTree[_CONTEXT_VARIABLES_KEY] =
+                previousValue[_CONTEXT_VARIABLES_KEY];
+        }
+        return storage.run(runTree, callback);
+    }
+    initializeGlobalInstance(instance) {
+        if (getGlobalAsyncLocalStorageInstance() === undefined) {
+            setGlobalAsyncLocalStorageInstance(instance);
+        }
+    }
+}
+const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
+export { AsyncLocalStorageProviderSingleton };

package/dist/singletons/callbacks.cjs

@@ -0,0 +1,66 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awaitAllCallbacks = exports.consumeCallback = exports.getQueue = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+const globals_js_1 = require("./async_local_storage/globals.cjs");
+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,
+    });
+}
+function getQueue() {
+    if (typeof queue === "undefined") {
+        queue = createQueue();
+    }
+    return queue;
+}
+exports.getQueue = getQueue;
+/**
+ * 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) {
+        // Clear config since callbacks are not part of the root run
+        // Avoid using global singleton due to circuluar dependency issues
+        if ((0, globals_js_1.getGlobalAsyncLocalStorageInstance)() !== undefined) {
+            await (0, globals_js_1.getGlobalAsyncLocalStorageInstance)().run(undefined, async () => promiseFn());
+        }
+        else {
+            await promiseFn();
+        }
+    }
+    else {
+        queue = getQueue();
+        void queue.add(async () => {
+            if ((0, globals_js_1.getGlobalAsyncLocalStorageInstance)() !== undefined) {
+                await (0, globals_js_1.getGlobalAsyncLocalStorageInstance)().run(undefined, async () => promiseFn());
+            }
+            else {
+                await 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;

package/dist/singletons/callbacks.d.ts

@@ -0,0 +1,13 @@
+import PQueueMod from "p-queue";
+export declare function getQueue(): PQueueMod.default<any, any>;
+/**
+ * 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>;

package/dist/singletons/callbacks.js

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import PQueueMod from "p-queue";
+import { getGlobalAsyncLocalStorageInstance } from "./async_local_storage/globals.js";
+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,
+    });
+}
+export function getQueue() {
+    if (typeof queue === "undefined") {
+        queue = createQueue();
+    }
+    return queue;
+}
+/**
+ * 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) {
+        // Clear config since callbacks are not part of the root run
+        // Avoid using global singleton due to circuluar dependency issues
+        if (getGlobalAsyncLocalStorageInstance() !== undefined) {
+            await getGlobalAsyncLocalStorageInstance().run(undefined, async () => promiseFn());
+        }
+        else {
+            await promiseFn();
+        }
+    }
+    else {
+        queue = getQueue();
+        void queue.add(async () => {
+            if (getGlobalAsyncLocalStorageInstance() !== undefined) {
+                await getGlobalAsyncLocalStorageInstance().run(undefined, async () => promiseFn());
+            }
+            else {
+                await 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();
+}

package/dist/singletons/index.cjs

@@ -1,67 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLocalStorageProviderSingleton = exports._CONTEXT_VARIABLES_KEY = exports.MockAsyncLocalStorage = void 0;
+exports.MockAsyncLocalStorage = exports._CONTEXT_VARIABLES_KEY = exports.AsyncLocalStorageProviderSingleton = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
-const langsmith_1 = require("langsmith");
-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 TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
-const LC_CHILD_KEY = Symbol.for("lc:child_config");
-exports._CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
-class AsyncLocalStorageProvider {
-    getInstance() {
-        return globalThis[TRACING_ALS_KEY] ?? 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 (globalThis[TRACING_ALS_KEY] === undefined) {
-            globalThis[TRACING_ALS_KEY] = instance;
-        }
-    }
-}
-const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
-exports.AsyncLocalStorageProviderSingleton = AsyncLocalStorageProviderSingleton;
+const index_js_1 = require("./async_local_storage/index.cjs");
+Object.defineProperty(exports, "AsyncLocalStorageProviderSingleton", { enumerable: true, get: function () { return index_js_1.AsyncLocalStorageProviderSingleton; } });
+Object.defineProperty(exports, "_CONTEXT_VARIABLES_KEY", { enumerable: true, get: function () { return index_js_1._CONTEXT_VARIABLES_KEY; } });
+Object.defineProperty(exports, "MockAsyncLocalStorage", { enumerable: true, get: function () { return index_js_1.MockAsyncLocalStorage; } });

package/dist/singletons/index.d.ts

@@ -1,19 +1,2 @@
-export interface AsyncLocalStorageInterface {
-    getStore: () => any | undefined;
-    run: <T>(store: any, callback: () => T) => T;
-    enterWith: (store: any) => void;
-}
-export declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {
-    getStore(): any;
-    run<T>(_store: any, callback: () => T): T;
-    enterWith(_store: any): undefined;
-}
-export declare const _CONTEXT_VARIABLES_KEY: unique symbol;
-declare class AsyncLocalStorageProvider {
-    getInstance(): AsyncLocalStorageInterface;
-    getRunnableConfig(): any;
-    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;
-    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
-}
-declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;
-export { AsyncLocalStorageProviderSingleton };
+import { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage } from "./async_local_storage/index.js";
+export { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage, };

package/dist/singletons/index.js

@@ -1,63 +1,3 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { RunTree } from "langsmith";
-import { CallbackManager } from "../callbacks/manager.js";
-export class MockAsyncLocalStorage {
-    getStore() {
-        return undefined;
-    }
-    run(_store, callback) {
-        return callback();
-    }
-    enterWith(_store) {
-        return undefined;
-    }
-}
-const mockAsyncLocalStorage = new MockAsyncLocalStorage();
-const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
-const LC_CHILD_KEY = Symbol.for("lc:child_config");
-export const _CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
-class AsyncLocalStorageProvider {
-    getInstance() {
-        return globalThis[TRACING_ALS_KEY] ?? 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 = 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 RunTree({
-                name: "<runnable_lambda>",
-                tracingEnabled: false,
-            });
-        }
-        if (runTree) {
-            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
-        }
-        if (previousValue !== undefined &&
-            previousValue[_CONTEXT_VARIABLES_KEY] !== undefined) {
-            runTree[_CONTEXT_VARIABLES_KEY] =
-                previousValue[_CONTEXT_VARIABLES_KEY];
-        }
-        return storage.run(runTree, callback);
-    }
-    initializeGlobalInstance(instance) {
-        if (globalThis[TRACING_ALS_KEY] === undefined) {
-            globalThis[TRACING_ALS_KEY] = instance;
-        }
-    }
-}
-const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
-export { AsyncLocalStorageProviderSingleton };
+import { AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage, } from "./async_local_storage/index.js";
+export { AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage, };

package/dist/singletons/tracer.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultLangChainClientSingleton = void 0;
+const langsmith_1 = require("langsmith");
+const env_js_1 = require("../utils/env.cjs");
+let client;
+const getDefaultLangChainClientSingleton = () => {
+    if (client === undefined) {
+        const clientParams = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
+            ? {
+                // LangSmith has its own backgrounding system
+                blockOnRootRunFinalization: true,
+            }
+            : {};
+        client = new langsmith_1.Client(clientParams);
+    }
+    return client;
+};
+exports.getDefaultLangChainClientSingleton = getDefaultLangChainClientSingleton;

package/dist/singletons/tracer.d.ts

@@ -0,0 +1,2 @@
+import { Client } from "langsmith";
+export declare const getDefaultLangChainClientSingleton: () => Client;

package/dist/singletons/tracer.js

@@ -0,0 +1,15 @@
+import { Client } from "langsmith";
+import { getEnvironmentVariable } from "../utils/env.js";
+let client;
+export const getDefaultLangChainClientSingleton = () => {
+    if (client === undefined) {
+        const clientParams = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
+            ? {
+                // LangSmith has its own backgrounding system
+                blockOnRootRunFinalization: true,
+            }
+            : {};
+        client = new Client(clientParams);
+    }
+    return client;
+};

package/dist/tracers/tracer_langchain.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangChainTracer = void 0;
-const langsmith_1 = require("langsmith");
 const run_trees_1 = require("langsmith/run_trees");
 const traceable_1 = require("langsmith/singletons/traceable");
 const env_js_1 = require("../utils/env.cjs");
 const base_js_1 = require("./base.cjs");
+const tracer_js_1 = require("../singletons/tracer.cjs");
 class LangChainTracer extends base_js_1.BaseTracer {
     constructor(fields = {}) {
         super(fields);
@@ -39,13 +39,7 @@ class LangChainTracer extends base_js_1.BaseTracer {
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_PROJECT") ??
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
-        const clientParams = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
-            ? {
-                // LangSmith has its own backgrounding system
-                blockOnRootRunFinalization: true,
-            }
-            : {};
-        this.client = client ?? new langsmith_1.Client(clientParams);
+        this.client = client ?? (0, tracer_js_1.getDefaultLangChainClientSingleton)();
         const traceableTree = LangChainTracer.getTraceableRunTree();
         if (traceableTree) {
             this.updateFromRunTree(traceableTree);

package/dist/tracers/tracer_langchain.js

@@ -1,8 +1,8 @@
-import { Client } from "langsmith";
 import { RunTree } from "langsmith/run_trees";
 import { getCurrentRunTree } from "langsmith/singletons/traceable";
 import { getEnvironmentVariable, getRuntimeEnvironment } from "../utils/env.js";
 import { BaseTracer } from "./base.js";
+import { getDefaultLangChainClientSingleton } from "../singletons/tracer.js";
 export class LangChainTracer extends BaseTracer {
     constructor(fields = {}) {
         super(fields);
@@ -36,13 +36,7 @@ export class LangChainTracer extends BaseTracer {
                 getEnvironmentVariable("LANGCHAIN_PROJECT") ??
                 getEnvironmentVariable("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
-        const clientParams = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
-            ? {
-                // LangSmith has its own backgrounding system
-                blockOnRootRunFinalization: true,
-            }
-            : {};
-        this.client = client ?? new Client(clientParams);
+        this.client = client ?? getDefaultLangChainClientSingleton();
         const traceableTree = LangChainTracer.getTraceableRunTree();
         if (traceableTree) {
             this.updateFromRunTree(traceableTree);