langchain 0.0.128 → 0.0.129

package/dist/schema/runnable.js

@@ -7,6 +7,10 @@ function _coerceToDict(value, defaultKey) {
         ? value
         : { [defaultKey]: value };
 }
+/**
+ * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
+ * transformed.
+ */
 export class Runnable extends Serializable {
     constructor() {
         super(...arguments);
@@ -17,10 +21,28 @@ export class Runnable extends Serializable {
             value: true
         });
     }
+    /**
+     * Bind arguments to a Runnable, returning a new Runnable.
+     * @param kwargs
+     * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     */
     bind(kwargs) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return new RunnableBinding({ bound: this, kwargs });
     }
+    /**
+     * Create a new runnable from the current one that will try invoking
+     * other passed fallback runnables if the initial invocation fails.
+     * @param fields.fallbacks Other runnables to call if the runnable errors.
+     * @returns A new RunnableWithFallbacks.
+     */
+    withFallbacks(fields) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunnableWithFallbacks({
+            runnable: this,
+            fallbacks: fields.fallbacks,
+        });
+    }
     _getOptionsList(options, length = 0) {
         if (Array.isArray(options)) {
             if (options.length !== length) {
@@ -30,6 +52,14 @@ export class Runnable extends Serializable {
         }
         return Array.from({ length }, () => options);
     }
+    /**
+     * Default implementation of batch, which calls invoke N times.
+     * Subclasses should override this method if they can batch more efficiently.
+     * @param inputs Array of inputs to each batch call.
+     * @param options Either a single call options object to apply to each batch call or an array for each call.
+     * @param batchOptions.maxConcurrency Maximum number of calls to run at once.
+     * @returns An array of RunOutputs
+     */
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
@@ -39,15 +69,27 @@ export class Runnable extends Serializable {
         for (let i = 0; i < inputs.length; i += batchSize) {
             const batchPromises = inputs
                 .slice(i, i + batchSize)
-                .map((input, i) => this.invoke(input, configList[i]));
+                .map((input, j) => this.invoke(input, configList[j]));
             const batchResult = await Promise.all(batchPromises);
             batchResults.push(batchResult);
         }
         return batchResults.flat();
     }
+    /**
+     * Default streaming implementation.
+     * Subclasses should override this method if they support streaming output.
+     * @param input
+     * @param options
+     */
     async *_streamIterator(input, options) {
         yield this.invoke(input, options);
     }
+    /**
+     * Stream output in chunks.
+     * @param input
+     * @param options
+     * @returns A readable stream that is also an iterable.
+     */
     async stream(input, options) {
         return IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
     }
@@ -112,6 +154,12 @@ export class Runnable extends Serializable {
     _patchConfig(config = {}, callbackManager = undefined) {
         return { ...config, callbacks: callbackManager };
     }
+    /**
+     * Create a new runnable sequence that runs each individual runnable in series,
+     * piping the output of one runnable into another runnable or runnable-like.
+     * @param coerceable A runnable, function, or object whose values are functions or runnables.
+     * @returns A new runnable sequence.
+     */
     pipe(coerceable) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return new RunnableSequence({
@@ -124,6 +172,9 @@ export class Runnable extends Serializable {
         return thing.lc_runnable;
     }
 }
+/**
+ * A sequence of runnables, where the output of each is the input of the next.
+ */
 export class RunnableSequence extends Runnable {
     constructor(fields) {
         super(fields);
@@ -194,9 +245,9 @@ export class RunnableSequence extends Runnable {
         try {
             for (let i = 0; i < [this.first, ...this.middle].length; i += 1) {
                 const step = this.steps[i];
-                nextStepInputs = await step.batch(nextStepInputs, runManagers.map((runManager) => this._patchConfig(configList[i], runManager?.getChild()), batchOptions));
+                nextStepInputs = await step.batch(nextStepInputs, runManagers.map((runManager, j) => this._patchConfig(configList[j], runManager?.getChild())), batchOptions);
             }
-            finalOutputs = await this.last.batch(nextStepInputs, runManagers.map((runManager) => this._patchConfig(configList[this.steps.length - 1], runManager?.getChild()), batchOptions));
+            finalOutputs = await this.last.batch(nextStepInputs, runManagers.map((runManager) => this._patchConfig(configList[this.steps.length - 1], runManager?.getChild())), batchOptions);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
@@ -291,6 +342,10 @@ export class RunnableSequence extends Runnable {
         });
     }
 }
+/**
+ * A runnable that runs a mapping of runnables in parallel,
+ * and returns a mapping of their outputs.
+ */
 export class RunnableMap extends Runnable {
     constructor(fields) {
         super(fields);
@@ -340,6 +395,9 @@ export class RunnableMap extends Runnable {
         return output;
     }
 }
+/**
+ * A runnable that runs a callable.
+ */
 export class RunnableLambda extends Runnable {
     constructor(fields) {
         super(fields);
@@ -361,6 +419,9 @@ export class RunnableLambda extends Runnable {
         return this._callWithConfig(async (input) => this.func(input), input, options);
     }
 }
+/**
+ * A runnable that passes through the input.
+ */
 export class RunnablePassthrough extends Runnable {
     constructor() {
         super(...arguments);
@@ -381,24 +442,9 @@ export class RunnablePassthrough extends Runnable {
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
 }
-function _coerceToRunnable(coerceable) {
-    if (typeof coerceable === "function") {
-        return new RunnableLambda({ func: coerceable });
-    }
-    else if (Runnable.isRunnable(coerceable)) {
-        return coerceable;
-    }
-    else if (!Array.isArray(coerceable) && typeof coerceable === "object") {
-        const runnables = {};
-        for (const [key, value] of Object.entries(coerceable)) {
-            runnables[key] = _coerceToRunnable(value);
-        }
-        return new RunnableMap({ steps: runnables });
-    }
-    else {
-        throw new Error(`Expected a Runnable, function or object.\nInstead got an unsupported type.`);
-    }
-}
+/**
+ * A runnable that delegates calls to another runnable with a set of kwargs.
+ */
 export class RunnableBinding extends Runnable {
     constructor(fields) {
         super(fields);
@@ -451,6 +497,10 @@ export class RunnableBinding extends Runnable {
         return this.bound.stream(input, { ...options, ...this.kwargs });
     }
 }
+/**
+ * A runnable that routes to a set of runnables based on Input['key'].
+ * Returns the output of the selected runnable.
+ */
 export class RouterRunnable extends Runnable {
     constructor(fields) {
         super(fields);
@@ -513,3 +563,107 @@ export class RouterRunnable extends Runnable {
         return runnable.stream(actualInput, options);
     }
 }
+/**
+ * A Runnable that can fallback to other Runnables if it fails.
+ */
+export class RunnableWithFallbacks extends Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["schema", "langchain"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "runnable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fallbacks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.runnable = fields.runnable;
+        this.fallbacks = fields.fallbacks;
+    }
+    *runnables() {
+        yield this.runnable;
+        for (const fallback of this.fallbacks) {
+            yield fallback;
+        }
+    }
+    async invoke(input, options) {
+        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
+        let firstError;
+        for (const runnable of this.runnables()) {
+            try {
+                const output = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild()));
+                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;
+    }
+    async batch(inputs, options, batchOptions) {
+        const configList = this._getOptionsList(options ?? {}, inputs.length);
+        const callbackManagers = await Promise.all(configList.map((config) => CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let firstError;
+        for (const runnable of this.runnables()) {
+            try {
+                const outputs = await runnable.batch(inputs, runManagers.map((runManager, j) => this._patchConfig(configList[j], runManager?.getChild())), batchOptions);
+                await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(_coerceToDict(outputs[i], "output"))));
+                return outputs;
+            }
+            catch (e) {
+                if (firstError === undefined) {
+                    firstError = e;
+                }
+            }
+        }
+        if (!firstError) {
+            throw new Error("No error stored at end of fallbacks.");
+        }
+        await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(firstError)));
+        throw firstError;
+    }
+}
+function _coerceToRunnable(coerceable) {
+    if (typeof coerceable === "function") {
+        return new RunnableLambda({ func: coerceable });
+    }
+    else if (Runnable.isRunnable(coerceable)) {
+        return coerceable;
+    }
+    else if (!Array.isArray(coerceable) && typeof coerceable === "object") {
+        const runnables = {};
+        for (const [key, value] of Object.entries(coerceable)) {
+            runnables[key] = _coerceToRunnable(value);
+        }
+        return new RunnableMap({ steps: runnables });
+    }
+    else {
+        throw new Error(`Expected a Runnable, function or object.\nInstead got an unsupported type.`);
+    }
+}

package/dist/schema/storage.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStore = void 0;
+const serializable_js_1 = require("../load/serializable.cjs");
+/**
+ * Abstract interface for a key-value store.
+ */
+class BaseStore extends serializable_js_1.Serializable {
+}
+exports.BaseStore = BaseStore;

package/dist/schema/storage.d.ts

@@ -0,0 +1,10 @@
+import { Serializable } from "../load/serializable.js";
+/**
+ * Abstract interface for a key-value store.
+ */
+export declare abstract class BaseStore<K, V> extends Serializable {
+    abstract mget(keys: K[]): Promise<(V | undefined)[]>;
+    abstract mset(keyValuePairs: [K, V][]): Promise<void>;
+    abstract mdelete(keys: K[]): Promise<void>;
+    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;
+}

package/dist/schema/storage.js

@@ -0,0 +1,6 @@
+import { Serializable } from "../load/serializable.js";
+/**
+ * Abstract interface for a key-value store.
+ */
+export class BaseStore extends Serializable {
+}

package/dist/storage/encoder_backed.cjs

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncoderBackedStore = void 0;
+const storage_js_1 = require("../schema/storage.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class EncoderBackedStore extends storage_js_1.BaseStore {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage", "encoder_backed"]
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyEncoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueSerializer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueDeserializer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.store = fields.store;
+        this.keyEncoder = fields.keyEncoder;
+        this.valueSerializer = fields.valueSerializer;
+        this.valueDeserializer = fields.valueDeserializer;
+    }
+    async mget(keys) {
+        const encodedKeys = keys.map(this.keyEncoder);
+        const values = await this.store.mget(encodedKeys);
+        return values.map((value) => {
+            if (value === undefined) {
+                return undefined;
+            }
+            return this.valueDeserializer(value);
+        });
+    }
+    async mset(keyValuePairs) {
+        const encodedPairs = keyValuePairs.map(([key, value]) => [this.keyEncoder(key), this.valueSerializer(value)]);
+        return this.store.mset(encodedPairs);
+    }
+    async mdelete(keys) {
+        const encodedKeys = keys.map(this.keyEncoder);
+        return this.store.mdelete(encodedKeys);
+    }
+    async *yieldKeys(prefix) {
+        yield* this.store.yieldKeys(prefix);
+    }
+}
+exports.EncoderBackedStore = EncoderBackedStore;

package/dist/storage/encoder_backed.d.ts

@@ -0,0 +1,18 @@
+import { BaseStore } from "../schema/storage.js";
+export declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {
+    lc_namespace: string[];
+    store: BaseStore<string, SerializedType>;
+    keyEncoder: (key: K) => string;
+    valueSerializer: (value: V) => SerializedType;
+    valueDeserializer: (value: SerializedType) => V;
+    constructor(fields: {
+        store: BaseStore<string, SerializedType>;
+        keyEncoder: (key: K) => string;
+        valueSerializer: (value: V) => SerializedType;
+        valueDeserializer: (value: SerializedType) => V;
+    });
+    mget(keys: K[]): Promise<(V | undefined)[]>;
+    mset(keyValuePairs: [K, V][]): Promise<void>;
+    mdelete(keys: K[]): Promise<void>;
+    yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K>;
+}

package/dist/storage/encoder_backed.js

@@ -0,0 +1,62 @@
+import { BaseStore } from "../schema/storage.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class EncoderBackedStore extends BaseStore {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage", "encoder_backed"]
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyEncoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueSerializer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueDeserializer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.store = fields.store;
+        this.keyEncoder = fields.keyEncoder;
+        this.valueSerializer = fields.valueSerializer;
+        this.valueDeserializer = fields.valueDeserializer;
+    }
+    async mget(keys) {
+        const encodedKeys = keys.map(this.keyEncoder);
+        const values = await this.store.mget(encodedKeys);
+        return values.map((value) => {
+            if (value === undefined) {
+                return undefined;
+            }
+            return this.valueDeserializer(value);
+        });
+    }
+    async mset(keyValuePairs) {
+        const encodedPairs = keyValuePairs.map(([key, value]) => [this.keyEncoder(key), this.valueSerializer(value)]);
+        return this.store.mset(encodedPairs);
+    }
+    async mdelete(keys) {
+        const encodedKeys = keys.map(this.keyEncoder);
+        return this.store.mdelete(encodedKeys);
+    }
+    async *yieldKeys(prefix) {
+        yield* this.store.yieldKeys(prefix);
+    }
+}

package/dist/storage/in_memory.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStore = void 0;
+const storage_js_1 = require("../schema/storage.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class InMemoryStore extends storage_js_1.BaseStore {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage", "in_memory"]
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    async mget(keys) {
+        return keys.map((key) => this.store[key]);
+    }
+    async mset(keyValuePairs) {
+        for (const [key, value] of keyValuePairs) {
+            this.store[key] = value;
+        }
+    }
+    async mdelete(keys) {
+        for (const key of keys) {
+            delete this.store[key];
+        }
+    }
+    async *yieldKeys(prefix) {
+        const keys = Object.keys(this.store);
+        for (const key of keys) {
+            if (prefix === undefined || key.startsWith(prefix)) {
+                yield key;
+            }
+        }
+    }
+}
+exports.InMemoryStore = InMemoryStore;

package/dist/storage/in_memory.d.ts

@@ -0,0 +1,9 @@
+import { BaseStore } from "../schema/storage.js";
+export declare class InMemoryStore<T = any> extends BaseStore<string, T> {
+    lc_namespace: string[];
+    protected store: Record<string, T>;
+    mget(keys: string[]): Promise<T[]>;
+    mset(keyValuePairs: [string, T][]): Promise<void>;
+    mdelete(keys: string[]): Promise<void>;
+    yieldKeys(prefix?: string | undefined): AsyncGenerator<string>;
+}

package/dist/storage/in_memory.js

@@ -0,0 +1,40 @@
+import { BaseStore } from "../schema/storage.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class InMemoryStore extends BaseStore {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage", "in_memory"]
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    async mget(keys) {
+        return keys.map((key) => this.store[key]);
+    }
+    async mset(keyValuePairs) {
+        for (const [key, value] of keyValuePairs) {
+            this.store[key] = value;
+        }
+    }
+    async mdelete(keys) {
+        for (const key of keys) {
+            delete this.store[key];
+        }
+    }
+    async *yieldKeys(prefix) {
+        const keys = Object.keys(this.store);
+        for (const key of keys) {
+            if (prefix === undefined || key.startsWith(prefix)) {
+                yield key;
+            }
+        }
+    }
+}

package/dist/storage/ioredis.cjs

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisByteStore = void 0;
+const storage_js_1 = require("../schema/storage.cjs");
+class RedisByteStore extends storage_js_1.BaseStore {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage", "ioredis"]
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ttl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "yieldKeysScanBatchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000
+        });
+        this.client = fields.client;
+        this.ttl = fields.ttl;
+        this.namespace = fields.namespace;
+        this.yieldKeysScanBatchSize =
+            fields.yieldKeysScanBatchSize ?? this.yieldKeysScanBatchSize;
+    }
+    _getPrefixedKey(key) {
+        if (this.namespace) {
+            const delimiter = "/";
+            return `${this.namespace}${delimiter}${key}`;
+        }
+        return key;
+    }
+    _getDeprefixedKey(key) {
+        if (this.namespace) {
+            const delimiter = "/";
+            return key.slice(this.namespace.length + delimiter.length);
+        }
+        return key;
+    }
+    async mget(keys) {
+        const prefixedKeys = keys.map(this._getPrefixedKey.bind(this));
+        const retrievedValues = await this.client.mgetBuffer(prefixedKeys);
+        return retrievedValues.map((key) => {
+            if (!key) {
+                return undefined;
+            }
+            else {
+                return key;
+            }
+        });
+    }
+    async mset(keyValuePairs) {
+        const decoder = new TextDecoder();
+        const encodedKeyValuePairs = keyValuePairs.map(([key, value]) => [
+            this._getPrefixedKey(key),
+            decoder.decode(value),
+        ]);
+        const pipeline = this.client.pipeline();
+        for (const [key, value] of encodedKeyValuePairs) {
+            if (this.ttl) {
+                pipeline.set(key, value, "EX", this.ttl);
+            }
+            else {
+                pipeline.set(key, value);
+            }
+        }
+        await pipeline.exec();
+    }
+    async mdelete(keys) {
+        await this.client.del(...keys.map(this._getPrefixedKey.bind(this)));
+    }
+    async *yieldKeys(prefix) {
+        let pattern;
+        if (prefix) {
+            pattern = this._getPrefixedKey(prefix);
+        }
+        else {
+            pattern = this._getPrefixedKey("*");
+        }
+        let [cursor, batch] = await this.client.scan(0, "MATCH", pattern, "COUNT", this.yieldKeysScanBatchSize);
+        for (const key of batch) {
+            yield this._getDeprefixedKey(key);
+        }
+        while (cursor !== "0") {
+            [cursor, batch] = await this.client.scan(cursor, "MATCH", pattern, "COUNT", this.yieldKeysScanBatchSize);
+            for (const key of batch) {
+                yield this._getDeprefixedKey(key);
+            }
+        }
+    }
+}
+exports.RedisByteStore = RedisByteStore;