@digipair/skill-llm 0.7.3 → 0.8.0

package/sequential_chain.esm.js

@@ -0,0 +1,1089 @@
+import { f as BaseChain } from './index.esm2.js';
+
+/**
+ * Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#implementing_basic_set_operations
+ */ /**
+ * returns intersection of two sets
+ */ function intersection(setA, setB) {
+    var _intersection = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = setB[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var elem = _step.value;
+            if (setA.has(elem)) {
+                _intersection.add(elem);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return _intersection;
+}
+/**
+ * returns union of two sets
+ */ function union(setA, setB) {
+    var _union = new Set(setA);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = setB[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var elem = _step.value;
+            _union.add(elem);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return _union;
+}
+/**
+ * returns difference of two sets
+ */ function difference(setA, setB) {
+    var _difference = new Set(setA);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = setB[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var elem = _step.value;
+            _difference.delete(elem);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return _difference;
+}
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function formatSet(input) {
+    return Array.from(input).map(function(i) {
+        return '"'.concat(i, '"');
+    }).join(", ");
+}
+/**
+ * Chain where the outputs of one chain feed directly into next.
+ * @example
+ * ```typescript
+ * const promptTemplate = new PromptTemplate({
+ *   template: `You are a playwright. Given the title of play and the era it is set in, it is your job to write a synopsis for that title.
+ * Title: {title}
+ * Era: {era}
+ * Playwright: This is a synopsis for the above play:`,
+ *   inputVariables: ["title", "era"],
+ * });
+
+ * const reviewPromptTemplate = new PromptTemplate({
+ *   template: `You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.
+ *
+ *     Play Synopsis:
+ *     {synopsis}
+ *     Review from a New York Times play critic of the above play:`,
+ *   inputVariables: ["synopsis"],
+ * });
+
+ * const overallChain = new SequentialChain({
+ *   chains: [
+ *     new LLMChain({
+ *       llm: new ChatOpenAI({ temperature: 0 }),
+ *       prompt: promptTemplate,
+ *       outputKey: "synopsis",
+ *     }),
+ *     new LLMChain({
+ *       llm: new OpenAI({ temperature: 0 }),
+ *       prompt: reviewPromptTemplate,
+ *       outputKey: "review",
+ *     }),
+ *   ],
+ *   inputVariables: ["era", "title"],
+ *   outputVariables: ["synopsis", "review"],
+ *   verbose: true,
+ * });
+
+ * const chainExecutionResult = await overallChain.call({
+ *   title: "Tragedy at sunset on the beach",
+ *   era: "Victorian England",
+ * });
+ * console.log(chainExecutionResult);
+ * ```
+ *
+ * @deprecated
+ * Switch to {@link https://js.langchain.com/docs/expression_language/ | expression language}.
+ * Will be removed in 0.2.0
+ */ var SequentialChain = /*#__PURE__*/ function(BaseChain1) {
+    _inherits(SequentialChain, BaseChain1);
+    var _super = _create_super(SequentialChain);
+    function SequentialChain(fields) {
+        _class_call_check(this, SequentialChain);
+        var _this;
+        _this = _super.call(this, fields);
+        Object.defineProperty(_assert_this_initialized(_this), "chains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "inputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "outputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "returnAll", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _this.chains = fields.chains;
+        _this.inputVariables = fields.inputVariables;
+        var _fields_outputVariables;
+        _this.outputVariables = (_fields_outputVariables = fields.outputVariables) !== null && _fields_outputVariables !== void 0 ? _fields_outputVariables : [];
+        if (_this.outputVariables.length > 0 && fields.returnAll) {
+            throw new Error("Either specify variables to return using `outputVariables` or use `returnAll` param. Cannot apply both conditions at the same time.");
+        }
+        var _fields_returnAll;
+        _this.returnAll = (_fields_returnAll = fields.returnAll) !== null && _fields_returnAll !== void 0 ? _fields_returnAll : false;
+        _this._validateChains();
+        return _this;
+    }
+    _create_class(SequentialChain, [
+        {
+            key: "inputKeys",
+            get: function get() {
+                return this.inputVariables;
+            }
+        },
+        {
+            key: "outputKeys",
+            get: function get() {
+                return this.outputVariables;
+            }
+        },
+        {
+            /** @ignore */ key: "_validateChains",
+            value: function _validateChains() {
+                var _this_memory;
+                if (this.chains.length === 0) {
+                    throw new Error("Sequential chain must have at least one chain.");
+                }
+                var _this_memory_memoryKeys;
+                var memoryKeys = (_this_memory_memoryKeys = (_this_memory = this.memory) === null || _this_memory === void 0 ? void 0 : _this_memory.memoryKeys) !== null && _this_memory_memoryKeys !== void 0 ? _this_memory_memoryKeys : [];
+                var inputKeysSet = new Set(this.inputKeys);
+                var memoryKeysSet = new Set(memoryKeys);
+                var keysIntersection = intersection(inputKeysSet, memoryKeysSet);
+                if (keysIntersection.size > 0) {
+                    throw new Error("The following keys: ".concat(formatSet(keysIntersection), " are overlapping between memory and input keys of the chain variables. This can lead to unexpected behaviour. Please use input and memory keys that don't overlap."));
+                }
+                var availableKeys = union(inputKeysSet, memoryKeysSet);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this.chains[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var chain = _step.value;
+                        var missingKeys = difference(new Set(chain.inputKeys), availableKeys);
+                        if (chain.memory) {
+                            missingKeys = difference(missingKeys, new Set(chain.memory.memoryKeys));
+                        }
+                        if (missingKeys.size > 0) {
+                            throw new Error('Missing variables for chain "'.concat(chain._chainType(), '": ').concat(formatSet(missingKeys), ". Only got the following variables: ").concat(formatSet(availableKeys), "."));
+                        }
+                        var outputKeysSet = new Set(chain.outputKeys);
+                        var overlappingOutputKeys = intersection(availableKeys, outputKeysSet);
+                        if (overlappingOutputKeys.size > 0) {
+                            throw new Error('The following output variables for chain "'.concat(chain._chainType(), '" are overlapping: ').concat(formatSet(overlappingOutputKeys), ". This can lead to unexpected behaviour."));
+                        }
+                        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                        try {
+                            for(var _iterator1 = outputKeysSet[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                var outputKey = _step1.value;
+                                availableKeys.add(outputKey);
+                            }
+                        } catch (err) {
+                            _didIteratorError1 = true;
+                            _iteratorError1 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                    _iterator1.return();
+                                }
+                            } finally{
+                                if (_didIteratorError1) {
+                                    throw _iteratorError1;
+                                }
+                            }
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                if (this.outputVariables.length === 0) {
+                    if (this.returnAll) {
+                        var outputKeys = difference(availableKeys, inputKeysSet);
+                        this.outputVariables = Array.from(outputKeys);
+                    } else {
+                        this.outputVariables = this.chains[this.chains.length - 1].outputKeys;
+                    }
+                } else {
+                    var missingKeys1 = difference(new Set(this.outputVariables), new Set(availableKeys));
+                    if (missingKeys1.size > 0) {
+                        throw new Error("The following output variables were expected to be in the final chain output but were not found: ".concat(formatSet(missingKeys1), "."));
+                    }
+                }
+            }
+        },
+        {
+            key: "_call",
+            value: /** @ignore */ function _call(values, runManager) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var input, allChainValues, i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, chain, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, key, err, output, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, key1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                input = {};
+                                allChainValues = values;
+                                i = 0;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _iterator = _this.chains[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                chain = _step.value;
+                                i += 1;
+                                return [
+                                    4,
+                                    chain.call(allChainValues, runManager === null || runManager === void 0 ? void 0 : runManager.getChild("step_".concat(i)))
+                                ];
+                            case 3:
+                                input = _state.sent();
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                try {
+                                    for(_iterator1 = Object.keys(input)[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                        key = _step1.value;
+                                        allChainValues[key] = input[key];
+                                    }
+                                } catch (err) {
+                                    _didIteratorError1 = true;
+                                    _iteratorError1 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                            _iterator1.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError1) {
+                                            throw _iteratorError1;
+                                        }
+                                    }
+                                }
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                output = {};
+                                _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                try {
+                                    for(_iterator2 = _this.outputVariables[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                                        key1 = _step2.value;
+                                        output[key1] = allChainValues[key1];
+                                    }
+                                } catch (err) {
+                                    _didIteratorError2 = true;
+                                    _iteratorError2 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                            _iterator2.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError2) {
+                                            throw _iteratorError2;
+                                        }
+                                    }
+                                }
+                                return [
+                                    2,
+                                    output
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "_chainType",
+            value: function _chainType() {
+                return "sequential_chain";
+            }
+        },
+        {
+            key: "serialize",
+            value: function serialize() {
+                var chains = [];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this.chains[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var chain = _step.value;
+                        chains.push(chain.serialize());
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return {
+                    _type: this._chainType(),
+                    input_variables: this.inputVariables,
+                    output_variables: this.outputVariables,
+                    chains: chains
+                };
+            }
+        }
+    ], [
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "SequentialChain";
+            }
+        },
+        {
+            key: "deserialize",
+            value: function deserialize(data) {
+                return _async_to_generator(function() {
+                    var chains, inputVariables, outputVariables, serializedChains, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, serializedChain, deserializedChain, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                chains = [];
+                                inputVariables = data.input_variables;
+                                outputVariables = data.output_variables;
+                                serializedChains = data.chains;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _iterator = serializedChains[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                serializedChain = _step.value;
+                                return [
+                                    4,
+                                    BaseChain.deserialize(serializedChain)
+                                ];
+                            case 3:
+                                deserializedChain = _state.sent();
+                                chains.push(deserializedChain);
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                return [
+                                    2,
+                                    new SequentialChain({
+                                        chains: chains,
+                                        inputVariables: inputVariables,
+                                        outputVariables: outputVariables
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return SequentialChain;
+}(BaseChain);
+/**
+ * @deprecated Switch to expression language: https://js.langchain.com/docs/expression_language/
+ * Simple chain where a single string output of one chain is fed directly into the next.
+ * @augments BaseChain
+ * @augments SimpleSequentialChainInput
+ *
+ * @example
+ * ```ts
+ * import { SimpleSequentialChain, LLMChain } from "langchain/chains";
+ * import { OpenAI } from "langchain/llms/openai";
+ * import { PromptTemplate } from "langchain/prompts";
+ *
+ * // This is an LLMChain to write a synopsis given a title of a play.
+ * const llm = new OpenAI({ temperature: 0 });
+ * const template = `You are a playwright. Given the title of play, it is your job to write a synopsis for that title.
+ *
+ * Title: {title}
+ * Playwright: This is a synopsis for the above play:`
+ * const promptTemplate = new PromptTemplate({ template, inputVariables: ["title"] });
+ * const synopsisChain = new LLMChain({ llm, prompt: promptTemplate });
+ *
+ *
+ * // This is an LLMChain to write a review of a play given a synopsis.
+ * const reviewLLM = new OpenAI({ temperature: 0 })
+ * const reviewTemplate = `You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.
+ *
+ * Play Synopsis:
+ * {synopsis}
+ * Review from a New York Times play critic of the above play:`
+ * const reviewPromptTemplate = new PromptTemplate({ template: reviewTemplate, inputVariables: ["synopsis"] });
+ * const reviewChain = new LLMChain({ llm: reviewLLM, prompt: reviewPromptTemplate });
+ *
+ * const overallChain = new SimpleSequentialChain({chains: [synopsisChain, reviewChain], verbose:true})
+ * const review = await overallChain.run("Tragedy at sunset on the beach")
+ * // the variable review contains resulting play review.
+ * ```
+ */ var SimpleSequentialChain = /*#__PURE__*/ function(BaseChain1) {
+    _inherits(SimpleSequentialChain, BaseChain1);
+    var _super = _create_super(SimpleSequentialChain);
+    function SimpleSequentialChain(fields) {
+        _class_call_check(this, SimpleSequentialChain);
+        var _this;
+        _this = _super.call(this, fields);
+        Object.defineProperty(_assert_this_initialized(_this), "chains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "inputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "input"
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "output"
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "trimOutputs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _this.chains = fields.chains;
+        var _fields_trimOutputs;
+        _this.trimOutputs = (_fields_trimOutputs = fields.trimOutputs) !== null && _fields_trimOutputs !== void 0 ? _fields_trimOutputs : false;
+        _this._validateChains();
+        return _this;
+    }
+    _create_class(SimpleSequentialChain, [
+        {
+            key: "inputKeys",
+            get: function get() {
+                return [
+                    this.inputKey
+                ];
+            }
+        },
+        {
+            key: "outputKeys",
+            get: function get() {
+                return [
+                    this.outputKey
+                ];
+            }
+        },
+        {
+            /** @ignore */ key: "_validateChains",
+            value: function _validateChains() {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    var _loop = function() {
+                        var chain = _step.value;
+                        if (chain.inputKeys.filter(function(k) {
+                            var _chain_memory;
+                            var _ref;
+                            return (_ref = !((_chain_memory = chain.memory) === null || _chain_memory === void 0 ? void 0 : _chain_memory.memoryKeys.includes(k))) !== null && _ref !== void 0 ? _ref : true;
+                        }).length !== 1) {
+                            throw new Error("Chains used in SimpleSequentialChain should all have one input, got ".concat(chain.inputKeys.length, " for ").concat(chain._chainType(), "."));
+                        }
+                        if (chain.outputKeys.length !== 1) {
+                            throw new Error("Chains used in SimpleSequentialChain should all have one output, got ".concat(chain.outputKeys.length, " for ").concat(chain._chainType(), "."));
+                        }
+                    };
+                    for(var _iterator = this.chains[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_call",
+            value: /** @ignore */ function _call(values, runManager) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var input, i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, chain, _obj, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                input = values[_this.inputKey];
+                                i = 0;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    7,
+                                    8,
+                                    9
+                                ]);
+                                _iterator = _this.chains[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    6
+                                ];
+                                chain = _step.value;
+                                i += 1;
+                                return [
+                                    4,
+                                    chain.call((_obj = {}, _define_property(_obj, chain.inputKeys[0], input), _define_property(_obj, "signal", values.signal), _obj), runManager === null || runManager === void 0 ? void 0 : runManager.getChild("step_".concat(i)))
+                                ];
+                            case 3:
+                                input = _state.sent()[chain.outputKeys[0]];
+                                if (_this.trimOutputs) {
+                                    input = input.trim();
+                                }
+                                return [
+                                    4,
+                                    runManager === null || runManager === void 0 ? void 0 : runManager.handleText(input)
+                                ];
+                            case 4:
+                                _state.sent();
+                                _state.label = 5;
+                            case 5:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 6:
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 7:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 8:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 9:
+                                return [
+                                    2,
+                                    _define_property({}, _this.outputKey, input)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "_chainType",
+            value: function _chainType() {
+                return "simple_sequential_chain";
+            }
+        },
+        {
+            key: "serialize",
+            value: function serialize() {
+                var chains = [];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this.chains[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var chain = _step.value;
+                        chains.push(chain.serialize());
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return {
+                    _type: this._chainType(),
+                    chains: chains
+                };
+            }
+        }
+    ], [
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "SimpleSequentialChain";
+            }
+        },
+        {
+            key: "deserialize",
+            value: function deserialize(data) {
+                return _async_to_generator(function() {
+                    var chains, serializedChains, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, serializedChain, deserializedChain, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                chains = [];
+                                serializedChains = data.chains;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _iterator = serializedChains[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                serializedChain = _step.value;
+                                return [
+                                    4,
+                                    BaseChain.deserialize(serializedChain)
+                                ];
+                            case 3:
+                                deserializedChain = _state.sent();
+                                chains.push(deserializedChain);
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                return [
+                                    2,
+                                    new SimpleSequentialChain({
+                                        chains: chains
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return SimpleSequentialChain;
+}(BaseChain);
+
+export { SequentialChain, SimpleSequentialChain };