@langchain/core 0.3.9 → 0.3.10

package/context.cjs

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

package/context.d.cts

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

package/context.d.ts

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

package/context.js

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

package/dist/callbacks/dispatch/index.cjs

@@ -1,12 +1,12 @@
 "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");
-/* #__PURE__ */ index_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(
-/* #__PURE__ */ new node_async_hooks_1.AsyncLocalStorage());
+index_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
 /**
  * Dispatch a custom event.
  *

package/dist/callbacks/dispatch/index.js

@@ -1,9 +1,9 @@
+/* __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";
-/* #__PURE__ */ AsyncLocalStorageProviderSingleton.initializeGlobalInstance(
-/* #__PURE__ */ new AsyncLocalStorage());
+AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
 /**
  * Dispatch a custom event.
  *

package/dist/context.cjs

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextVariable = exports.setContextVariable = void 0;
+/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
+const node_async_hooks_1 = require("node:async_hooks");
+const langsmith_1 = require("langsmith");
+const run_trees_1 = require("langsmith/run_trees");
+const index_js_1 = require("./singletons/index.cjs");
+index_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
+/**
+ * Set a context variable. Context variables are scoped to any
+ * child runnables called by the current runnable, or globally if set outside
+ * of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ * @param value The value to set.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function setContextVariable(name, value) {
+    const runTree = index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const contextVars = { ...runTree?.[index_js_1._CONTEXT_VARIABLES_KEY] };
+    contextVars[name] = value;
+    let newValue = {};
+    if ((0, run_trees_1.isRunTree)(runTree)) {
+        newValue = new langsmith_1.RunTree(runTree);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    newValue[index_js_1._CONTEXT_VARIABLES_KEY] = contextVars;
+    index_js_1.AsyncLocalStorageProviderSingleton.getInstance().enterWith(newValue);
+}
+exports.setContextVariable = setContextVariable;
+/**
+ * Get the value of a previously set context variable. Context variables
+ * are scoped to any child runnables called by the current runnable,
+ * or globally if set outside of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getContextVariable(name) {
+    const runTree = index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    return runTree?.[index_js_1._CONTEXT_VARIABLES_KEY]?.[name];
+}
+exports.getContextVariable = getContextVariable;

package/dist/context.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Set a context variable. Context variables are scoped to any
+ * child runnables called by the current runnable, or globally if set outside
+ * of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ * @param value The value to set.
+ */
+export declare function setContextVariable(name: PropertyKey, value: any): void;
+/**
+ * Get the value of a previously set context variable. Context variables
+ * are scoped to any child runnables called by the current runnable,
+ * or globally if set outside of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ */
+export declare function getContextVariable(name: PropertyKey): any;

package/dist/context.js

@@ -0,0 +1,123 @@
+/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { RunTree } from "langsmith";
+import { isRunTree } from "langsmith/run_trees";
+import { _CONTEXT_VARIABLES_KEY, AsyncLocalStorageProviderSingleton, } from "./singletons/index.js";
+AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
+/**
+ * Set a context variable. Context variables are scoped to any
+ * child runnables called by the current runnable, or globally if set outside
+ * of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ * @param value The value to set.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function setContextVariable(name, value) {
+    const runTree = AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };
+    contextVars[name] = value;
+    let newValue = {};
+    if (isRunTree(runTree)) {
+        newValue = new RunTree(runTree);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    newValue[_CONTEXT_VARIABLES_KEY] = contextVars;
+    AsyncLocalStorageProviderSingleton.getInstance().enterWith(newValue);
+}
+/**
+ * Get the value of a previously set context variable. Context variables
+ * are scoped to any child runnables called by the current runnable,
+ * or globally if set outside of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getContextVariable(name) {
+    const runTree = AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];
+}

package/dist/messages/utils.cjs

@@ -91,7 +91,7 @@ function _constructMessageFromParams(params) {
         });
     }
     else {
-        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.\n\nReceived:${params}`);
+        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.\n\nReceived: ${JSON.stringify(params, null, 2)}`);
     }
 }
 function coerceMessageLikeToMessage(messageLike) {

package/dist/messages/utils.js

@@ -88,7 +88,7 @@ function _constructMessageFromParams(params) {
         });
     }
     else {
-        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.\n\nReceived:${params}`);
+        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.\n\nReceived: ${JSON.stringify(params, null, 2)}`);
     }
 }
 export function coerceMessageLikeToMessage(messageLike) {

package/dist/singletons/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLocalStorageProviderSingleton = exports.MockAsyncLocalStorage = void 0;
+exports.AsyncLocalStorageProviderSingleton = exports._CONTEXT_VARIABLES_KEY = exports.MockAsyncLocalStorage = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const langsmith_1 = require("langsmith");
 const manager_js_1 = require("../callbacks/manager.cjs");
@@ -11,11 +11,15 @@ class MockAsyncLocalStorage {
     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;
@@ -30,6 +34,7 @@ class AsyncLocalStorageProvider {
     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;
@@ -45,6 +50,11 @@ class AsyncLocalStorageProvider {
         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) {

package/dist/singletons/index.d.ts

@@ -1,11 +1,14 @@
 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;

package/dist/singletons/index.js

@@ -8,10 +8,14 @@ export class MockAsyncLocalStorage {
     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;
@@ -26,6 +30,7 @@ class AsyncLocalStorageProvider {
     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;
@@ -41,6 +46,11 @@ class AsyncLocalStorageProvider {
         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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -37,7 +37,7 @@
     "camelcase": "6",
     "decamelize": "1.2.0",
     "js-tiktoken": "^1.0.12",
-    "langsmith": "^0.1.56",
+    "langsmith": "^0.1.65",
     "mustache": "^4.2.0",
     "p-queue": "^6.6.2",
     "p-retry": "4",
@@ -160,6 +160,15 @@
       "import": "./chat_history.js",
       "require": "./chat_history.cjs"
     },
+    "./context": {
+      "types": {
+        "import": "./context.d.ts",
+        "require": "./context.d.cts",
+        "default": "./context.d.ts"
+      },
+      "import": "./context.js",
+      "require": "./context.cjs"
+    },
     "./documents": {
       "types": {
         "import": "./documents.d.ts",
@@ -646,6 +655,10 @@
     "chat_history.js",
     "chat_history.d.ts",
     "chat_history.d.cts",
+    "context.cjs",
+    "context.js",
+    "context.d.ts",
+    "context.d.cts",
     "documents.cjs",
     "documents.js",
     "documents.d.ts",