@digipair/skill-llm 0.7.3 → 0.8.1

package/api_chain.esm.js

@@ -0,0 +1,478 @@
+import { P as PromptTemplate, L as LLMChain, f as BaseChain } from './index.esm2.js';
+
+var API_URL_RAW_PROMPT_TEMPLATE = "You are given the below API Documentation:\n{api_docs}\nUsing this documentation, generate the full API url to call for answering the user question.\nYou should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.\n\nQuestion:{question}\nAPI url:";
+var API_URL_PROMPT_TEMPLATE = /* #__PURE__ */ new PromptTemplate({
+    inputVariables: [
+        "api_docs",
+        "question"
+    ],
+    template: API_URL_RAW_PROMPT_TEMPLATE
+});
+var API_RESPONSE_RAW_PROMPT_TEMPLATE = "".concat(API_URL_RAW_PROMPT_TEMPLATE, " {api_url}\n\nHere is the response from the API:\n\n{api_response}\n\nSummarize this response to answer the original question.\n\nSummary:");
+var API_RESPONSE_PROMPT_TEMPLATE = /* #__PURE__ */ new PromptTemplate({
+    inputVariables: [
+        "api_docs",
+        "question",
+        "api_url",
+        "api_response"
+    ],
+    template: API_RESPONSE_RAW_PROMPT_TEMPLATE
+});
+
+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 _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+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
+        };
+    }
+}
+/**
+ * Class that extends BaseChain and represents a chain specifically
+ * designed for making API requests and processing API responses.
+ */ var APIChain = /*#__PURE__*/ function(BaseChain) {
+    _inherits(APIChain, BaseChain);
+    var _super = _create_super(APIChain);
+    function APIChain(fields) {
+        _class_call_check(this, APIChain);
+        var _this;
+        _this = _super.call(this, fields);
+        Object.defineProperty(_assert_this_initialized(_this), "apiAnswerChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "apiRequestChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "apiDocs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "inputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "question"
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "output"
+        });
+        _this.apiRequestChain = fields.apiRequestChain;
+        _this.apiAnswerChain = fields.apiAnswerChain;
+        _this.apiDocs = fields.apiDocs;
+        var _fields_inputKey;
+        _this.inputKey = (_fields_inputKey = fields.inputKey) !== null && _fields_inputKey !== void 0 ? _fields_inputKey : _this.inputKey;
+        var _fields_outputKey;
+        _this.outputKey = (_fields_outputKey = fields.outputKey) !== null && _fields_outputKey !== void 0 ? _fields_outputKey : _this.outputKey;
+        var _fields_headers;
+        _this.headers = (_fields_headers = fields.headers) !== null && _fields_headers !== void 0 ? _fields_headers : _this.headers;
+        return _this;
+    }
+    _create_class(APIChain, [
+        {
+            key: "inputKeys",
+            get: function get() {
+                return [
+                    this.inputKey
+                ];
+            }
+        },
+        {
+            key: "outputKeys",
+            get: function get() {
+                return [
+                    this.outputKey
+                ];
+            }
+        },
+        {
+            key: "_call",
+            value: /** @ignore */ function _call(values, runManager) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var question, api_url, res, api_response, answer;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                question = values[_this.inputKey];
+                                return [
+                                    4,
+                                    _this.apiRequestChain.predict({
+                                        question: question,
+                                        api_docs: _this.apiDocs
+                                    }, runManager === null || runManager === void 0 ? void 0 : runManager.getChild("request"))
+                                ];
+                            case 1:
+                                api_url = _state.sent();
+                                return [
+                                    4,
+                                    fetch(api_url, {
+                                        headers: _this.headers
+                                    })
+                                ];
+                            case 2:
+                                res = _state.sent();
+                                return [
+                                    4,
+                                    res.text()
+                                ];
+                            case 3:
+                                api_response = _state.sent();
+                                return [
+                                    4,
+                                    _this.apiAnswerChain.predict({
+                                        question: question,
+                                        api_docs: _this.apiDocs,
+                                        api_url: api_url,
+                                        api_response: api_response
+                                    }, runManager === null || runManager === void 0 ? void 0 : runManager.getChild("response"))
+                                ];
+                            case 4:
+                                answer = _state.sent();
+                                return [
+                                    2,
+                                    _define_property({}, _this.outputKey, answer)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "_chainType",
+            value: function _chainType() {
+                return "api_chain";
+            }
+        },
+        {
+            key: "serialize",
+            value: function serialize() {
+                return {
+                    _type: this._chainType(),
+                    api_answer_chain: this.apiAnswerChain.serialize(),
+                    api_request_chain: this.apiRequestChain.serialize(),
+                    api_docs: this.apiDocs
+                };
+            }
+        }
+    ], [
+        {
+            key: "deserialize",
+            value: function deserialize(data) {
+                return _async_to_generator(function() {
+                    var api_request_chain, api_answer_chain, api_docs, _, _tmp;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                api_request_chain = data.api_request_chain, api_answer_chain = data.api_answer_chain, api_docs = data.api_docs;
+                                if (!api_request_chain) {
+                                    throw new Error("LLMChain must have api_request_chain");
+                                }
+                                if (!api_answer_chain) {
+                                    throw new Error("LLMChain must have api_answer_chain");
+                                }
+                                if (!api_docs) {
+                                    throw new Error("LLMChain must have api_docs");
+                                }
+                                _ = APIChain.bind;
+                                _tmp = {};
+                                return [
+                                    4,
+                                    LLMChain.deserialize(api_answer_chain)
+                                ];
+                            case 1:
+                                _tmp.apiAnswerChain = _state.sent();
+                                return [
+                                    4,
+                                    LLMChain.deserialize(api_request_chain)
+                                ];
+                            case 2:
+                                return [
+                                    2,
+                                    new (_.apply(APIChain, [
+                                        void 0,
+                                        (_tmp.apiRequestChain = _state.sent(), _tmp.apiDocs = api_docs, _tmp)
+                                    ]))
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "fromLLMAndAPIDocs",
+            value: /**
+     * Static method to create a new APIChain from a BaseLanguageModel and API
+     * documentation.
+     * @param llm BaseLanguageModel instance.
+     * @param apiDocs API documentation.
+     * @param options Optional configuration options for the APIChain.
+     * @returns New APIChain instance.
+     */ function fromLLMAndAPIDocs(llm, apiDocs) {
+                var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+                var _options_apiUrlPrompt = options.apiUrlPrompt, apiUrlPrompt = _options_apiUrlPrompt === void 0 ? API_URL_PROMPT_TEMPLATE : _options_apiUrlPrompt, _options_apiResponsePrompt = options.apiResponsePrompt, apiResponsePrompt = _options_apiResponsePrompt === void 0 ? API_RESPONSE_PROMPT_TEMPLATE : _options_apiResponsePrompt;
+                var apiRequestChain = new LLMChain({
+                    prompt: apiUrlPrompt,
+                    llm: llm
+                });
+                var apiAnswerChain = new LLMChain({
+                    prompt: apiResponsePrompt,
+                    llm: llm
+                });
+                return new this(_object_spread({
+                    apiAnswerChain: apiAnswerChain,
+                    apiRequestChain: apiRequestChain,
+                    apiDocs: apiDocs
+                }, options));
+            }
+        }
+    ]);
+    return APIChain;
+}(BaseChain);
+
+export { APIChain };