@langchain/core 0.3.25 → 0.3.27

package/dist/runnables/base.cjs

@@ -1944,32 +1944,38 @@ class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const config = (0, config_js_1.ensureConfig)(options);
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
-        let firstError;
-        for (const runnable of this.runnables()) {
-            config?.signal?.throwIfAborted();
-            try {
-                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(otherConfigFields, { callbacks: runManager?.getChild() }));
-                await runManager?.handleChainEnd(_coerceToDict(output, "output"));
-                return output;
-            }
-            catch (e) {
-                if (firstError === undefined) {
-                    firstError = e;
+        const childConfig = (0, config_js_1.patchConfig)(otherConfigFields, {
+            callbacks: runManager?.getChild(),
+        });
+        const res = await index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+            let firstError;
+            for (const runnable of this.runnables()) {
+                config?.signal?.throwIfAborted();
+                try {
+                    const output = await runnable.invoke(input, childConfig);
+                    await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+                    return output;
+                }
+                catch (e) {
+                    if (firstError === undefined) {
+                        firstError = e;
+                    }
                 }
             }
-        }
-        if (firstError === undefined) {
-            throw new Error("No error stored at end of fallback.");
-        }
-        await runManager?.handleChainError(firstError);
-        throw firstError;
+            if (firstError === undefined) {
+                throw new Error("No error stored at end of fallback.");
+            }
+            await runManager?.handleChainError(firstError);
+            throw firstError;
+        });
+        return res;
     }
     async *_streamIterator(input, options) {
         const config = (0, config_js_1.ensureConfig)(options);
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
@@ -1980,7 +1986,8 @@ class RunnableWithFallbacks extends Runnable {
                 callbacks: runManager?.getChild(),
             });
             try {
-                stream = await runnable.stream(input, childConfig);
+                const originalStream = await runnable.stream(input, childConfig);
+                stream = (0, iter_js_1.consumeAsyncIterableInContext)(childConfig, originalStream);
                 break;
             }
             catch (e) {

package/dist/runnables/base.js

@@ -1928,32 +1928,38 @@ export class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const config = ensureConfig(options);
-        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
-        let firstError;
-        for (const runnable of this.runnables()) {
-            config?.signal?.throwIfAborted();
-            try {
-                const output = await runnable.invoke(input, patchConfig(otherConfigFields, { callbacks: runManager?.getChild() }));
-                await runManager?.handleChainEnd(_coerceToDict(output, "output"));
-                return output;
-            }
-            catch (e) {
-                if (firstError === undefined) {
-                    firstError = e;
+        const childConfig = patchConfig(otherConfigFields, {
+            callbacks: runManager?.getChild(),
+        });
+        const res = await AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+            let firstError;
+            for (const runnable of this.runnables()) {
+                config?.signal?.throwIfAborted();
+                try {
+                    const output = await runnable.invoke(input, childConfig);
+                    await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+                    return output;
+                }
+                catch (e) {
+                    if (firstError === undefined) {
+                        firstError = e;
+                    }
                 }
             }
-        }
-        if (firstError === undefined) {
-            throw new Error("No error stored at end of fallback.");
-        }
-        await runManager?.handleChainError(firstError);
-        throw firstError;
+            if (firstError === undefined) {
+                throw new Error("No error stored at end of fallback.");
+            }
+            await runManager?.handleChainError(firstError);
+            throw firstError;
+        });
+        return res;
     }
     async *_streamIterator(input, options) {
         const config = ensureConfig(options);
-        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
         const { runId, ...otherConfigFields } = config;
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
@@ -1964,7 +1970,8 @@ export class RunnableWithFallbacks extends Runnable {
                 callbacks: runManager?.getChild(),
             });
             try {
-                stream = await runnable.stream(input, childConfig);
+                const originalStream = await runnable.stream(input, childConfig);
+                stream = consumeAsyncIterableInContext(childConfig, originalStream);
                 break;
             }
             catch (e) {

package/dist/structured_query/base.cjs

@@ -51,7 +51,7 @@ class BasicTranslator extends BaseTranslator {
         if (func in ir_js_1.Comparators) {
             if (this.allowedComparators.length > 0 &&
                 this.allowedComparators.indexOf(func) === -1) {
-                throw new Error(`Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(", ")}`);
+                throw new Error(`Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(", ")}`);
             }
         }
         else if (func in ir_js_1.Operators) {

package/dist/structured_query/base.js

@@ -47,7 +47,7 @@ export class BasicTranslator extends BaseTranslator {
         if (func in Comparators) {
             if (this.allowedComparators.length > 0 &&
                 this.allowedComparators.indexOf(func) === -1) {
-                throw new Error(`Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(", ")}`);
+                throw new Error(`Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(", ")}`);
             }
         }
         else if (func in Operators) {

package/dist/structured_query/functional.cjs

@@ -41,6 +41,41 @@ class FunctionalTranslator extends base_js_1.BaseTranslator {
     formatFunction() {
         throw new Error("Not implemented");
     }
+    /**
+     * Returns the allowed comparators for a given data type.
+     * @param input The input value to get the allowed comparators for.
+     * @returns An array of allowed comparators for the input data type.
+     */
+    getAllowedComparatorsForType(inputType) {
+        switch (inputType) {
+            case "string": {
+                return [
+                    ir_js_1.Comparators.eq,
+                    ir_js_1.Comparators.ne,
+                    ir_js_1.Comparators.gt,
+                    ir_js_1.Comparators.gte,
+                    ir_js_1.Comparators.lt,
+                    ir_js_1.Comparators.lte,
+                ];
+            }
+            case "number": {
+                return [
+                    ir_js_1.Comparators.eq,
+                    ir_js_1.Comparators.ne,
+                    ir_js_1.Comparators.gt,
+                    ir_js_1.Comparators.gte,
+                    ir_js_1.Comparators.lt,
+                    ir_js_1.Comparators.lte,
+                ];
+            }
+            case "boolean": {
+                return [ir_js_1.Comparators.eq, ir_js_1.Comparators.ne];
+            }
+            default: {
+                throw new Error(`Unsupported data type: ${inputType}`);
+            }
+        }
+    }
     /**
      * Returns a function that performs a comparison based on the provided
      * comparator.
@@ -130,6 +165,9 @@ class FunctionalTranslator extends base_js_1.BaseTranslator {
         const { comparator, attribute, value } = comparison;
         const undefinedTrue = [ir_js_1.Comparators.ne];
         if (this.allowedComparators.includes(comparator)) {
+            if (!this.getAllowedComparatorsForType(typeof value).includes(comparator)) {
+                throw new Error(`'${comparator}' comparator not allowed to be used with ${typeof value}`);
+            }
             const comparatorFunction = this.getComparatorFunction(comparator);
             return (document) => {
                 const documentValue = document.metadata[attribute];

package/dist/structured_query/functional.d.ts

@@ -7,8 +7,8 @@ import { BaseTranslator } from "./base.js";
  * the result of a comparison operation.
  */
 type ValueType = {
-    eq: string | number;
-    ne: string | number;
+    eq: string | number | boolean;
+    ne: string | number | boolean;
     lt: string | number;
     lte: string | number;
     gt: string | number;
@@ -41,6 +41,12 @@ export declare class FunctionalTranslator extends BaseTranslator {
     allowedOperators: Operator[];
     allowedComparators: Comparator[];
     formatFunction(): string;
+    /**
+     * Returns the allowed comparators for a given data type.
+     * @param input The input value to get the allowed comparators for.
+     * @returns An array of allowed comparators for the input data type.
+     */
+    getAllowedComparatorsForType(inputType: string): Comparator[];
     /**
      * Returns a function that performs a comparison based on the provided
      * comparator.
@@ -68,7 +74,7 @@ export declare class FunctionalTranslator extends BaseTranslator {
      * @param comparison The comparison part of a structured query.
      * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.
      */
-    visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
+    visitComparison(comparison: Comparison<string | number | boolean>): this["VisitComparisonOutput"];
     /**
      * Visits a structured query and translates it into a functional filter.
      * @param query The structured query to translate.

package/dist/structured_query/functional.js

@@ -38,6 +38,41 @@ export class FunctionalTranslator extends BaseTranslator {
     formatFunction() {
         throw new Error("Not implemented");
     }
+    /**
+     * Returns the allowed comparators for a given data type.
+     * @param input The input value to get the allowed comparators for.
+     * @returns An array of allowed comparators for the input data type.
+     */
+    getAllowedComparatorsForType(inputType) {
+        switch (inputType) {
+            case "string": {
+                return [
+                    Comparators.eq,
+                    Comparators.ne,
+                    Comparators.gt,
+                    Comparators.gte,
+                    Comparators.lt,
+                    Comparators.lte,
+                ];
+            }
+            case "number": {
+                return [
+                    Comparators.eq,
+                    Comparators.ne,
+                    Comparators.gt,
+                    Comparators.gte,
+                    Comparators.lt,
+                    Comparators.lte,
+                ];
+            }
+            case "boolean": {
+                return [Comparators.eq, Comparators.ne];
+            }
+            default: {
+                throw new Error(`Unsupported data type: ${inputType}`);
+            }
+        }
+    }
     /**
      * Returns a function that performs a comparison based on the provided
      * comparator.
@@ -127,6 +162,9 @@ export class FunctionalTranslator extends BaseTranslator {
         const { comparator, attribute, value } = comparison;
         const undefinedTrue = [Comparators.ne];
         if (this.allowedComparators.includes(comparator)) {
+            if (!this.getAllowedComparatorsForType(typeof value).includes(comparator)) {
+                throw new Error(`'${comparator}' comparator not allowed to be used with ${typeof value}`);
+            }
             const comparatorFunction = this.getComparatorFunction(comparator);
             return (document) => {
                 const documentValue = document.metadata[attribute];

package/dist/structured_query/ir.d.ts

@@ -66,7 +66,7 @@ export type VisitorOperationResult = {
  */
 export type VisitorComparisonResult = {
     [attr: string]: {
-        [comparator: string]: string | number;
+        [comparator: string]: string | number | boolean;
     };
 };
 /**
@@ -109,12 +109,12 @@ export declare abstract class FilterDirective extends Expression {
  * Class representing a comparison filter directive. It extends the
  * FilterDirective class.
  */
-export declare class Comparison extends FilterDirective {
+export declare class Comparison<ValueTypes = string | number> extends FilterDirective {
     comparator: Comparator;
     attribute: string;
-    value: string | number;
+    value: ValueTypes;
     exprName: "Comparison";
-    constructor(comparator: Comparator, attribute: string, value: string | number);
+    constructor(comparator: Comparator, attribute: string, value: ValueTypes);
 }
 /**
  * Class representing an operation filter directive. It extends the

package/dist/structured_query/utils.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.castValue = exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
+exports.castValue = exports.isBoolean = exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
 /**
  * Checks if the provided argument is an object and not an array.
  */
@@ -69,6 +69,13 @@ function isString(value) {
         (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
 }
 exports.isString = isString;
+/**
+ * Checks if the provided value is a boolean.
+ */
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+exports.isBoolean = isBoolean;
 /**
  * Casts a value that might be string or number to actual string or number.
  * Since LLM might return back an integer/float as a string, we need to cast
@@ -86,6 +93,9 @@ function castValue(input) {
     else if (isFloat(input)) {
         value = parseFloat(input);
     }
+    else if (isBoolean(input)) {
+        value = Boolean(input);
+    }
     else {
         throw new Error("Unsupported value type");
     }

package/dist/structured_query/utils.d.ts

@@ -20,10 +20,14 @@ export declare function isFloat(value: unknown): boolean;
  * number.
  */
 export declare function isString(value: unknown): boolean;
+/**
+ * Checks if the provided value is a boolean.
+ */
+export declare function isBoolean(value: unknown): boolean;
 /**
  * Casts a value that might be string or number to actual string or number.
  * Since LLM might return back an integer/float as a string, we need to cast
  * it back to a number, as many vector databases can't handle number as string
  * values as a comparator.
  */
-export declare function castValue(input: unknown): string | number;
+export declare function castValue(input: unknown): string | number | boolean;

package/dist/structured_query/utils.js

@@ -61,6 +61,12 @@ export function isString(value) {
     return (typeof value === "string" &&
         (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
 }
+/**
+ * Checks if the provided value is a boolean.
+ */
+export function isBoolean(value) {
+    return typeof value === "boolean";
+}
 /**
  * Casts a value that might be string or number to actual string or number.
  * Since LLM might return back an integer/float as a string, we need to cast
@@ -78,6 +84,9 @@ export function castValue(input) {
     else if (isFloat(input)) {
         value = parseFloat(input);
     }
+    else if (isBoolean(input)) {
+        value = Boolean(input);
+    }
     else {
         throw new Error("Unsupported value type");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.25",
+  "version": "0.3.27",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {