@digipair/skill-llm 0.7.3 → 0.8.1

package/chat.esm.js

@@ -0,0 +1,2010 @@
+import { c as checkValidTemplate, a as BasePromptTemplate, I as ImagePromptValue, b as BaseMessage, P as PromptTemplate, H as HumanMessage, S as SystemMessage, i as isBaseMessage, d as coerceMessageLikeToMessage, C as ChatMessage, e as ChatPromptValue, p as parseFString, B as BaseStringPromptTemplate, A as AIMessage, R as Runnable } from './index.esm2.js';
+
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$1(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$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(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$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$1(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$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(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$1(subClass, superClass);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$1(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$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest();
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function _is_native_reflect_construct$1() {
+    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$1(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct$1();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of$1(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of$1(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return$1(this, result);
+    };
+}
+function _ts_generator$1(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
+        };
+    }
+}
+/**
+ * An image prompt template for a multimodal model.
+ */ var ImagePromptTemplate = /*#__PURE__*/ function(BasePromptTemplate) {
+    _inherits$1(ImagePromptTemplate, BasePromptTemplate);
+    var _super = _create_super$1(ImagePromptTemplate);
+    function ImagePromptTemplate(input) {
+        _class_call_check$1(this, ImagePromptTemplate);
+        var _this;
+        _this = _super.call(this, input);
+        Object.defineProperty(_assert_this_initialized$1(_this), "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                "langchain_core",
+                "prompts",
+                "image"
+            ]
+        });
+        Object.defineProperty(_assert_this_initialized$1(_this), "template", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized$1(_this), "templateFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "f-string"
+        });
+        Object.defineProperty(_assert_this_initialized$1(_this), "validateTemplate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        _this.template = input.template;
+        var _input_templateFormat;
+        _this.templateFormat = (_input_templateFormat = input.templateFormat) !== null && _input_templateFormat !== void 0 ? _input_templateFormat : _this.templateFormat;
+        var _input_validateTemplate;
+        _this.validateTemplate = (_input_validateTemplate = input.validateTemplate) !== null && _input_validateTemplate !== void 0 ? _input_validateTemplate : _this.validateTemplate;
+        if (_this.validateTemplate) {
+            var totalInputVariables = _this.inputVariables;
+            if (_this.partialVariables) {
+                totalInputVariables = totalInputVariables.concat(Object.keys(_this.partialVariables));
+            }
+            checkValidTemplate([
+                {
+                    type: "image_url",
+                    image_url: _this.template
+                }
+            ], _this.templateFormat, totalInputVariables);
+        }
+        return _this;
+    }
+    _create_class$1(ImagePromptTemplate, [
+        {
+            key: "_getPromptType",
+            value: function _getPromptType() {
+                return "prompt";
+            }
+        },
+        {
+            key: "partial",
+            value: /**
+     * Partially applies values to the prompt template.
+     * @param values The values to be partially applied to the prompt template.
+     * @returns A new instance of ImagePromptTemplate with the partially applied values.
+     */ function partial(values) {
+                var _this = this;
+                return _async_to_generator$1(function() {
+                    var newInputVariables, _this_partialVariables, newPartialVariables, promptDict;
+                    return _ts_generator$1(this, function(_state) {
+                        newInputVariables = _this.inputVariables.filter(function(iv) {
+                            return !(iv in values);
+                        });
+                        newPartialVariables = _object_spread$1({}, (_this_partialVariables = _this.partialVariables) !== null && _this_partialVariables !== void 0 ? _this_partialVariables : {}, values);
+                        promptDict = _object_spread_props$1(_object_spread$1({}, _this), {
+                            inputVariables: newInputVariables,
+                            partialVariables: newPartialVariables
+                        });
+                        return [
+                            2,
+                            new ImagePromptTemplate(promptDict)
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "format",
+            value: /**
+     * Formats the prompt template with the provided values.
+     * @param values The values to be used to format the prompt template.
+     * @returns A promise that resolves to a string which is the formatted prompt.
+     */ function format(values) {
+                var _this = this;
+                return _async_to_generator$1(function() {
+                    var formatted, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, url, detail, output;
+                    return _ts_generator$1(this, function(_state) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        formatted = {};
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = Object.entries(_this.template)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+                                if (typeof value === "string") {
+                                    formatted[key] = value.replace(/{([^{}]*)}/g, function(match, group) {
+                                        var replacement = values[group];
+                                        return typeof replacement === "string" || typeof replacement === "number" ? String(replacement) : match;
+                                    });
+                                } else {
+                                    formatted[key] = value;
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        url = values.url || formatted.url;
+                        detail = values.detail || formatted.detail;
+                        if (!url) {
+                            throw new Error("Must provide either an image URL.");
+                        }
+                        if (typeof url !== "string") {
+                            throw new Error("url must be a string.");
+                        }
+                        output = {
+                            url: url
+                        };
+                        if (detail) {
+                            output.detail = detail;
+                        }
+                        return [
+                            2,
+                            output
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "formatPromptValue",
+            value: /**
+     * Formats the prompt given the input values and returns a formatted
+     * prompt value.
+     * @param values The input values to format the prompt.
+     * @returns A Promise that resolves to a formatted prompt value.
+     */ function formatPromptValue(values) {
+                var _this = this;
+                return _async_to_generator$1(function() {
+                    var formattedPrompt;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.format(values)
+                                ];
+                            case 1:
+                                formattedPrompt = _state.sent();
+                                return [
+                                    2,
+                                    new ImagePromptValue(formattedPrompt)
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ], [
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "ImagePromptTemplate";
+            }
+        }
+    ]);
+    return ImagePromptTemplate;
+}(BasePromptTemplate);
+
+// Default generic "any" values are for backwards compatibility.
+// Replace with "string" when we are comfortable with a breaking change.
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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 _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+/**
+ * Abstract class that serves as a base for creating message prompt
+ * templates. It defines how to format messages for different roles in a
+ * conversation.
+ */ var BaseMessagePromptTemplate = /*#__PURE__*/ function(Runnable) {
+    _inherits(BaseMessagePromptTemplate, Runnable);
+    var _super = _create_super(BaseMessagePromptTemplate);
+    function BaseMessagePromptTemplate() {
+        _class_call_check(this, BaseMessagePromptTemplate);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments)));
+        Object.defineProperty(_assert_this_initialized(_this), "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                "langchain_core",
+                "prompts",
+                "chat"
+            ]
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        return _this;
+    }
+    _create_class(BaseMessagePromptTemplate, [
+        {
+            key: "invoke",
+            value: /**
+     * Calls the formatMessages method with the provided input and options.
+     * @param input Input for the formatMessages method
+     * @param options Optional BaseCallbackConfig
+     * @returns Formatted output messages
+     */ function invoke(input, options) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this._callWithConfig(function(input) {
+                                return _this.formatMessages(input);
+                            }, input, _object_spread_props(_object_spread({}, options), {
+                                runType: "prompt"
+                            }))
+                        ];
+                    });
+                })();
+            }
+        }
+    ]);
+    return BaseMessagePromptTemplate;
+}(Runnable);
+/**
+ * Abstract class that serves as a base for creating message string prompt
+ * templates. It extends the BaseMessagePromptTemplate.
+ */ var BaseMessageStringPromptTemplate = /*#__PURE__*/ function(BaseMessagePromptTemplate) {
+    _inherits(BaseMessageStringPromptTemplate, BaseMessagePromptTemplate);
+    var _super = _create_super(BaseMessageStringPromptTemplate);
+    function BaseMessageStringPromptTemplate(fields) {
+        _class_call_check(this, BaseMessageStringPromptTemplate);
+        var _this;
+        if (!("prompt" in fields)) {
+            // eslint-disable-next-line no-param-reassign
+            fields = {
+                prompt: fields
+            };
+        }
+        _this = _super.call(this, fields);
+        Object.defineProperty(_assert_this_initialized(_this), "prompt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _this.prompt = fields.prompt;
+        return _this;
+    }
+    _create_class(BaseMessageStringPromptTemplate, [
+        {
+            key: "inputVariables",
+            get: function get() {
+                return this.prompt.inputVariables;
+            }
+        },
+        {
+            key: "formatMessages",
+            value: function formatMessages(values) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.format(values)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    [
+                                        _state.sent()
+                                    ]
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return BaseMessageStringPromptTemplate;
+}(BaseMessagePromptTemplate);
+/**
+ * Abstract class that serves as a base for creating chat prompt
+ * templates. It extends the BasePromptTemplate.
+ */ var BaseChatPromptTemplate = /*#__PURE__*/ function(BasePromptTemplate) {
+    _inherits(BaseChatPromptTemplate, BasePromptTemplate);
+    var _super = _create_super(BaseChatPromptTemplate);
+    function BaseChatPromptTemplate(input) {
+        _class_call_check(this, BaseChatPromptTemplate);
+        return _super.call(this, input);
+    }
+    _create_class(BaseChatPromptTemplate, [
+        {
+            key: "format",
+            value: function format(values) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.formatPromptValue(values)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent().toString()
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "formatPromptValue",
+            value: function formatPromptValue(values) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var resultMessages;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.formatMessages(values)
+                                ];
+                            case 1:
+                                resultMessages = _state.sent();
+                                return [
+                                    2,
+                                    new ChatPromptValue(resultMessages)
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return BaseChatPromptTemplate;
+}(BasePromptTemplate);
+/**
+ * Class that represents a chat message prompt template. It extends the
+ * BaseMessageStringPromptTemplate.
+ */ var ChatMessagePromptTemplate = /*#__PURE__*/ function(BaseMessageStringPromptTemplate) {
+    _inherits(ChatMessagePromptTemplate, BaseMessageStringPromptTemplate);
+    var _super = _create_super(ChatMessagePromptTemplate);
+    function ChatMessagePromptTemplate(fields, role) {
+        _class_call_check(this, ChatMessagePromptTemplate);
+        var _this;
+        if (!("prompt" in fields)) {
+            // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion
+            fields = {
+                prompt: fields,
+                role: role
+            };
+        }
+        _this = _super.call(this, fields);
+        Object.defineProperty(_assert_this_initialized(_this), "role", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _this.role = fields.role;
+        return _this;
+    }
+    _create_class(ChatMessagePromptTemplate, [
+        {
+            key: "format",
+            value: function format(values) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _ = ChatMessage.bind;
+                                return [
+                                    4,
+                                    _this.prompt.format(values)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    new (_.apply(ChatMessage, [
+                                        void 0,
+                                        _state.sent(),
+                                        _this.role
+                                    ]))
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ], [
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "ChatMessagePromptTemplate";
+            }
+        },
+        {
+            key: "fromTemplate",
+            value: function fromTemplate(template, role) {
+                return new this(PromptTemplate.fromTemplate(template), role);
+            }
+        }
+    ]);
+    return ChatMessagePromptTemplate;
+}(BaseMessageStringPromptTemplate);
+var _StringImageMessagePromptTemplate = /*#__PURE__*/ function(BaseMessagePromptTemplate) {
+    _inherits(_StringImageMessagePromptTemplate, BaseMessagePromptTemplate);
+    var _super = _create_super(_StringImageMessagePromptTemplate);
+    function _StringImageMessagePromptTemplate(/** @TODO When we come up with a better way to type prompt templates, fix this */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fields, additionalOptions) {
+        _class_call_check(this, _StringImageMessagePromptTemplate);
+        var _this;
+        if (!("prompt" in fields)) {
+            // eslint-disable-next-line no-param-reassign
+            fields = {
+                prompt: fields
+            };
+        }
+        _this = _super.call(this, fields);
+        Object.defineProperty(_assert_this_initialized(_this), "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                "langchain_core",
+                "prompts",
+                "chat"
+            ]
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "inputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "additionalOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "prompt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "messageClass", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // ChatMessage contains role field, others don't.
+        // Because of this, we have a separate class property for ChatMessage.
+        Object.defineProperty(_assert_this_initialized(_this), "chatMessageClass", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _this.prompt = fields.prompt;
+        if (Array.isArray(_this.prompt)) {
+            var inputVariables = [];
+            _this.prompt.forEach(function(prompt) {
+                if ("inputVariables" in prompt) {
+                    inputVariables = inputVariables.concat(prompt.inputVariables);
+                }
+            });
+            _this.inputVariables = inputVariables;
+        } else {
+            _this.inputVariables = _this.prompt.inputVariables;
+        }
+        _this.additionalOptions = additionalOptions !== null && additionalOptions !== void 0 ? additionalOptions : _this.additionalOptions;
+        return _this;
+    }
+    _create_class(_StringImageMessagePromptTemplate, [
+        {
+            key: "createMessage",
+            value: function createMessage(content) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                var constructor = this.constructor;
+                if (constructor._messageClass()) {
+                    var MsgClass = constructor._messageClass();
+                    return new MsgClass({
+                        content: content
+                    });
+                } else if (constructor.chatMessageClass) {
+                    var MsgClass1 = constructor.chatMessageClass();
+                    // Assuming ChatMessage constructor also takes a content argument
+                    return new MsgClass1({
+                        content: content,
+                        role: this.getRoleFromMessageClass(MsgClass1.lc_name())
+                    });
+                } else {
+                    throw new Error("No message class defined");
+                }
+            }
+        },
+        {
+            key: "getRoleFromMessageClass",
+            value: function getRoleFromMessageClass(name) {
+                switch(name){
+                    case "HumanMessage":
+                        return "human";
+                    case "AIMessage":
+                        return "ai";
+                    case "SystemMessage":
+                        return "system";
+                    case "ChatMessage":
+                        return "chat";
+                    default:
+                        throw new Error("Invalid message class name");
+                }
+            }
+        },
+        {
+            key: "format",
+            value: function format(input) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var text, content, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, prompt, inputs, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, item, formatted, formatted1, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!_instanceof(_this.prompt, BaseStringPromptTemplate)) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    _this.prompt.format(input)
+                                ];
+                            case 1:
+                                text = _state.sent();
+                                return [
+                                    2,
+                                    _this.createMessage(text)
+                                ];
+                            case 2:
+                                content = [];
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 3;
+                            case 3:
+                                _state.trys.push([
+                                    3,
+                                    10,
+                                    11,
+                                    12
+                                ]);
+                                _iterator = _this.prompt[Symbol.iterator]();
+                                _state.label = 4;
+                            case 4:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    9
+                                ];
+                                prompt = _step.value;
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                inputs = {};
+                                if (!("inputVariables" in prompt)) {
+                                    throw new Error("Prompt ".concat(prompt, " does not have inputVariables defined."));
+                                }
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                try {
+                                    for(_iterator1 = prompt.inputVariables[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                        item = _step1.value;
+                                        if (!inputs) {
+                                            inputs = _define_property({}, item, input[item]);
+                                        }
+                                        inputs = _object_spread_props(_object_spread({}, inputs), _define_property({}, item, input[item]));
+                                    }
+                                } catch (err) {
+                                    _didIteratorError1 = true;
+                                    _iteratorError1 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                            _iterator1.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError1) {
+                                            throw _iteratorError1;
+                                        }
+                                    }
+                                }
+                                if (!_instanceof(prompt, BaseStringPromptTemplate)) return [
+                                    3,
+                                    6
+                                ];
+                                return [
+                                    4,
+                                    prompt.format(inputs)
+                                ];
+                            case 5:
+                                formatted = _state.sent();
+                                content.push({
+                                    type: "text",
+                                    text: formatted
+                                });
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                if (!_instanceof(prompt, ImagePromptTemplate)) return [
+                                    3,
+                                    8
+                                ];
+                                return [
+                                    4,
+                                    prompt.format(inputs)
+                                ];
+                            case 7:
+                                formatted1 = _state.sent();
+                                content.push({
+                                    type: "image_url",
+                                    image_url: formatted1
+                                });
+                                _state.label = 8;
+                            case 8:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 9:
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 10:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 11:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 12:
+                                return [
+                                    2,
+                                    _this.createMessage(content)
+                                ];
+                            case 13:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "formatMessages",
+            value: function formatMessages(values) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.format(values)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    [
+                                        _state.sent()
+                                    ]
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ], [
+        {
+            key: "_messageClass",
+            value: function _messageClass() {
+                throw new Error("Can not invoke _messageClass from inside _StringImageMessagePromptTemplate");
+            }
+        },
+        {
+            key: "fromTemplate",
+            value: function fromTemplate(template, additionalOptions) {
+                if (typeof template === "string") {
+                    return new this(PromptTemplate.fromTemplate(template));
+                }
+                var prompt = [];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = template[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var item = _step.value;
+                        if (typeof item === "string" || typeof item === "object" && "text" in item) {
+                            var text = "";
+                            if (typeof item === "string") {
+                                text = item;
+                            } else if (typeof item.text === "string") {
+                                var _item_text;
+                                text = (_item_text = item.text) !== null && _item_text !== void 0 ? _item_text : "";
+                            }
+                            prompt.push(PromptTemplate.fromTemplate(text));
+                        } else if (typeof item === "object" && "image_url" in item) {
+                            var _item_image_url;
+                            var imgTemplate = (_item_image_url = item.image_url) !== null && _item_image_url !== void 0 ? _item_image_url : "";
+                            var imgTemplateObject = void 0;
+                            var inputVariables = [];
+                            if (typeof imgTemplate === "string") {
+                                var parsedTemplate = parseFString(imgTemplate);
+                                var variables = parsedTemplate.flatMap(function(item) {
+                                    return item.type === "variable" ? [
+                                        item.name
+                                    ] : [];
+                                });
+                                var _variables_length;
+                                if (((_variables_length = variables === null || variables === void 0 ? void 0 : variables.length) !== null && _variables_length !== void 0 ? _variables_length : 0) > 0) {
+                                    if (variables.length > 1) {
+                                        throw new Error("Only one format variable allowed per image template.\nGot: ".concat(variables, "\nFrom: ").concat(imgTemplate));
+                                    }
+                                    inputVariables = [
+                                        variables[0]
+                                    ];
+                                } else {
+                                    inputVariables = [];
+                                }
+                                imgTemplate = {
+                                    url: imgTemplate
+                                };
+                                imgTemplateObject = new ImagePromptTemplate({
+                                    template: imgTemplate,
+                                    inputVariables: inputVariables
+                                });
+                            } else if (typeof imgTemplate === "object") {
+                                if ("url" in imgTemplate) {
+                                    var parsedTemplate1 = parseFString(imgTemplate.url);
+                                    inputVariables = parsedTemplate1.flatMap(function(item) {
+                                        return item.type === "variable" ? [
+                                            item.name
+                                        ] : [];
+                                    });
+                                } else {
+                                    inputVariables = [];
+                                }
+                                imgTemplateObject = new ImagePromptTemplate({
+                                    template: imgTemplate,
+                                    inputVariables: inputVariables
+                                });
+                            } else {
+                                throw new Error("Invalid image template");
+                            }
+                            prompt.push(imgTemplateObject);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return new this({
+                    prompt: prompt,
+                    additionalOptions: additionalOptions
+                });
+            }
+        }
+    ]);
+    return _StringImageMessagePromptTemplate;
+}(BaseMessagePromptTemplate);
+/**
+ * Class that represents a human message prompt template. It extends the
+ * BaseMessageStringPromptTemplate.
+ * @example
+ * ```typescript
+ * const message = HumanMessagePromptTemplate.fromTemplate("{text}");
+ * const formatted = await message.format({ text: "Hello world!" });
+ *
+ * const chatPrompt = ChatPromptTemplate.fromMessages([message]);
+ * const formattedChatPrompt = await chatPrompt.invoke({
+ *   text: "Hello world!",
+ * });
+ * ```
+ */ var HumanMessagePromptTemplate = /*#__PURE__*/ function(_StringImageMessagePromptTemplate) {
+    _inherits(HumanMessagePromptTemplate, _StringImageMessagePromptTemplate);
+    var _super = _create_super(HumanMessagePromptTemplate);
+    function HumanMessagePromptTemplate() {
+        _class_call_check(this, HumanMessagePromptTemplate);
+        return _super.apply(this, arguments);
+    }
+    _create_class(HumanMessagePromptTemplate, null, [
+        {
+            key: "_messageClass",
+            value: function _messageClass() {
+                return HumanMessage;
+            }
+        },
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "HumanMessagePromptTemplate";
+            }
+        }
+    ]);
+    return HumanMessagePromptTemplate;
+}(_StringImageMessagePromptTemplate);
+/**
+ * Class that represents an AI message prompt template. It extends the
+ * BaseMessageStringPromptTemplate.
+ */ var AIMessagePromptTemplate = /*#__PURE__*/ function(_StringImageMessagePromptTemplate) {
+    _inherits(AIMessagePromptTemplate, _StringImageMessagePromptTemplate);
+    var _super = _create_super(AIMessagePromptTemplate);
+    function AIMessagePromptTemplate() {
+        _class_call_check(this, AIMessagePromptTemplate);
+        return _super.apply(this, arguments);
+    }
+    _create_class(AIMessagePromptTemplate, null, [
+        {
+            key: "_messageClass",
+            value: function _messageClass() {
+                return AIMessage;
+            }
+        },
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "AIMessagePromptTemplate";
+            }
+        }
+    ]);
+    return AIMessagePromptTemplate;
+}(_StringImageMessagePromptTemplate);
+/**
+ * Class that represents a system message prompt template. It extends the
+ * BaseMessageStringPromptTemplate.
+ * @example
+ * ```typescript
+ * const message = SystemMessagePromptTemplate.fromTemplate("{text}");
+ * const formatted = await message.format({ text: "Hello world!" });
+ *
+ * const chatPrompt = ChatPromptTemplate.fromMessages([message]);
+ * const formattedChatPrompt = await chatPrompt.invoke({
+ *   text: "Hello world!",
+ * });
+ * ```
+ */ var SystemMessagePromptTemplate = /*#__PURE__*/ function(_StringImageMessagePromptTemplate) {
+    _inherits(SystemMessagePromptTemplate, _StringImageMessagePromptTemplate);
+    var _super = _create_super(SystemMessagePromptTemplate);
+    function SystemMessagePromptTemplate() {
+        _class_call_check(this, SystemMessagePromptTemplate);
+        return _super.apply(this, arguments);
+    }
+    _create_class(SystemMessagePromptTemplate, null, [
+        {
+            key: "_messageClass",
+            value: function _messageClass() {
+                return SystemMessage;
+            }
+        },
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "SystemMessagePromptTemplate";
+            }
+        }
+    ]);
+    return SystemMessagePromptTemplate;
+}(_StringImageMessagePromptTemplate);
+function _isBaseMessagePromptTemplate(baseMessagePromptTemplateLike) {
+    return typeof baseMessagePromptTemplateLike.formatMessages === "function";
+}
+function _coerceMessagePromptTemplateLike(messagePromptTemplateLike) {
+    if (_isBaseMessagePromptTemplate(messagePromptTemplateLike) || isBaseMessage(messagePromptTemplateLike)) {
+        return messagePromptTemplateLike;
+    }
+    var message = coerceMessageLikeToMessage(messagePromptTemplateLike);
+    if (message._getType() === "human") {
+        return HumanMessagePromptTemplate.fromTemplate(message.content);
+    } else if (message._getType() === "ai") {
+        return AIMessagePromptTemplate.fromTemplate(message.content);
+    } else if (message._getType() === "system") {
+        return SystemMessagePromptTemplate.fromTemplate(message.content);
+    } else if (ChatMessage.isInstance(message)) {
+        return ChatMessagePromptTemplate.fromTemplate(message.content, message.role);
+    } else {
+        throw new Error('Could not coerce message prompt template from input. Received message type: "'.concat(message._getType(), '".'));
+    }
+}
+function isMessagesPlaceholder(x) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return x.constructor.lc_name() === "MessagesPlaceholder";
+}
+/**
+ * Class that represents a chat prompt. It extends the
+ * BaseChatPromptTemplate and uses an array of BaseMessagePromptTemplate
+ * instances to format a series of messages for a conversation.
+ * @example
+ * ```typescript
+ * const message = SystemMessagePromptTemplate.fromTemplate("{text}");
+ * const chatPrompt = ChatPromptTemplate.fromMessages([
+ *   ["ai", "You are a helpful assistant."],
+ *   message,
+ * ]);
+ * const formattedChatPrompt = await chatPrompt.invoke({
+ *   text: "Hello world!",
+ * });
+ * ```
+ */ var ChatPromptTemplate = /*#__PURE__*/ function(BaseChatPromptTemplate) {
+    _inherits(ChatPromptTemplate, BaseChatPromptTemplate);
+    var _super = _create_super(ChatPromptTemplate);
+    function ChatPromptTemplate(input) {
+        _class_call_check(this, ChatPromptTemplate);
+        var _this;
+        _this = _super.call(this, input);
+        Object.defineProperty(_assert_this_initialized(_this), "promptMessages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_assert_this_initialized(_this), "validateTemplate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.assign(_assert_this_initialized(_this), input);
+        if (_this.validateTemplate) {
+            var inputVariablesMessages = new Set();
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = _this.promptMessages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var promptMessage = _step.value;
+                    // eslint-disable-next-line no-instanceof/no-instanceof
+                    if (_instanceof(promptMessage, BaseMessage)) continue;
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = promptMessage.inputVariables[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var inputVariable = _step1.value;
+                            inputVariablesMessages.add(inputVariable);
+                        }
+                    } 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;
+                    }
+                }
+            }
+            var totalInputVariables = _this.inputVariables;
+            var inputVariablesInstance = new Set(_this.partialVariables ? totalInputVariables.concat(Object.keys(_this.partialVariables)) : totalInputVariables);
+            var difference = new Set(_to_consumable_array(inputVariablesInstance).filter(function(x) {
+                return !inputVariablesMessages.has(x);
+            }));
+            if (difference.size > 0) {
+                throw new Error("Input variables `".concat(_to_consumable_array(difference), "` are not used in any of the prompt messages."));
+            }
+            var otherDifference = new Set(_to_consumable_array(inputVariablesMessages).filter(function(x) {
+                return !inputVariablesInstance.has(x);
+            }));
+            if (otherDifference.size > 0) {
+                throw new Error("Input variables `".concat(_to_consumable_array(otherDifference), "` are used in prompt messages but not in the prompt template."));
+            }
+        }
+        return _this;
+    }
+    _create_class(ChatPromptTemplate, [
+        {
+            key: "lc_aliases",
+            get: function get() {
+                return {
+                    promptMessages: "messages"
+                };
+            }
+        },
+        {
+            key: "_getPromptType",
+            value: function _getPromptType() {
+                return "chat";
+            }
+        },
+        {
+            key: "_parseImagePrompts",
+            value: function _parseImagePrompts(message, inputValues) {
+                return _async_to_generator(function() {
+                    var formattedMessageContent;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (typeof message.content === "string") {
+                                    return [
+                                        2,
+                                        message
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    Promise.all(message.content.map(function() {
+                                        var _ref = _async_to_generator(function(item) {
+                                            var imageUrl, promptTemplatePlaceholder, formattedUrl;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        if (item.type !== "image_url") {
+                                                            return [
+                                                                2,
+                                                                item
+                                                            ];
+                                                        }
+                                                        imageUrl = "";
+                                                        if (typeof item.image_url === "string") {
+                                                            imageUrl = item.image_url;
+                                                        } else {
+                                                            imageUrl = item.image_url.url;
+                                                        }
+                                                        promptTemplatePlaceholder = PromptTemplate.fromTemplate(imageUrl);
+                                                        return [
+                                                            4,
+                                                            promptTemplatePlaceholder.format(inputValues)
+                                                        ];
+                                                    case 1:
+                                                        formattedUrl = _state.sent();
+                                                        if (typeof item.image_url !== "string" && "url" in item.image_url) {
+                                                            // eslint-disable-next-line no-param-reassign
+                                                            item.image_url.url = formattedUrl;
+                                                        } else {
+                                                            // eslint-disable-next-line no-param-reassign
+                                                            item.image_url = formattedUrl;
+                                                        }
+                                                        return [
+                                                            2,
+                                                            item
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(item) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 1:
+                                formattedMessageContent = _state.sent();
+                                // eslint-disable-next-line no-param-reassign
+                                message.content = formattedMessageContent;
+                                return [
+                                    2,
+                                    message
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "formatMessages",
+            value: function formatMessages(values) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var allValues, resultMessages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.mergePartialAndUserVariables(values)
+                                ];
+                            case 1:
+                                allValues = _state.sent();
+                                resultMessages = [];
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    7,
+                                    8,
+                                    9
+                                ]);
+                                _loop = function() {
+                                    var promptMessage, _, inputValues, message;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                promptMessage = _step.value;
+                                                if (!_instanceof(promptMessage, BaseMessage)) return [
+                                                    3,
+                                                    2
+                                                ];
+                                                _ = resultMessages.push;
+                                                return [
+                                                    4,
+                                                    _this._parseImagePrompts(promptMessage, allValues)
+                                                ];
+                                            case 1:
+                                                _.apply(resultMessages, [
+                                                    _state.sent()
+                                                ]);
+                                                return [
+                                                    3,
+                                                    4
+                                                ];
+                                            case 2:
+                                                inputValues = promptMessage.inputVariables.reduce(function(acc, inputVariable) {
+                                                    if (!(inputVariable in allValues) && !(isMessagesPlaceholder(promptMessage) && promptMessage.optional)) {
+                                                        throw new Error("Missing value for input variable `".concat(inputVariable.toString(), "`"));
+                                                    }
+                                                    acc[inputVariable] = allValues[inputVariable];
+                                                    return acc;
+                                                }, {});
+                                                return [
+                                                    4,
+                                                    promptMessage.formatMessages(inputValues)
+                                                ];
+                                            case 3:
+                                                message = _state.sent();
+                                                resultMessages = resultMessages.concat(message);
+                                                _state.label = 4;
+                                            case 4:
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                };
+                                _iterator = _this.promptMessages[Symbol.iterator]();
+                                _state.label = 3;
+                            case 3:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    6
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_loop())
+                                ];
+                            case 4:
+                                _state.sent();
+                                _state.label = 5;
+                            case 5:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    3
+                                ];
+                            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,
+                                    resultMessages
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "partial",
+            value: function partial(values) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var newInputVariables, _this_partialVariables, newPartialVariables, promptDict;
+                    return _ts_generator(this, function(_state) {
+                        // This is implemented in a way it doesn't require making
+                        // BaseMessagePromptTemplate aware of .partial()
+                        newInputVariables = _this.inputVariables.filter(function(iv) {
+                            return !(iv in values);
+                        });
+                        newPartialVariables = _object_spread({}, (_this_partialVariables = _this.partialVariables) !== null && _this_partialVariables !== void 0 ? _this_partialVariables : {}, values);
+                        promptDict = _object_spread_props(_object_spread({}, _this), {
+                            inputVariables: newInputVariables,
+                            partialVariables: newPartialVariables
+                        });
+                        return [
+                            2,
+                            new ChatPromptTemplate(promptDict)
+                        ];
+                    });
+                })();
+            }
+        }
+    ], [
+        {
+            key: "lc_name",
+            value: function lc_name() {
+                return "ChatPromptTemplate";
+            }
+        },
+        {
+            key: "fromTemplate",
+            value: /**
+     * Load prompt template from a template f-string
+     */ function fromTemplate(template) {
+                var prompt = PromptTemplate.fromTemplate(template);
+                var humanTemplate = new HumanMessagePromptTemplate({
+                    prompt: prompt
+                });
+                return this.fromMessages([
+                    humanTemplate
+                ]);
+            }
+        },
+        {
+            key: "fromMessages",
+            value: /**
+     * Create a chat model-specific prompt from individual chat messages
+     * or message-like tuples.
+     * @param promptMessages Messages to be passed to the chat model
+     * @returns A new ChatPromptTemplate
+     */ function fromMessages(promptMessages, extra) {
+                var flattenedMessages = promptMessages.reduce(function(acc, promptMessage) {
+                    return acc.concat(// eslint-disable-next-line no-instanceof/no-instanceof
+                    _instanceof(promptMessage, ChatPromptTemplate) ? promptMessage.promptMessages : [
+                        _coerceMessagePromptTemplateLike(promptMessage)
+                    ]);
+                }, []);
+                var flattenedPartialVariables = promptMessages.reduce(function(acc, promptMessage) {
+                    return(// eslint-disable-next-line no-instanceof/no-instanceof
+                    _instanceof(promptMessage, ChatPromptTemplate) ? Object.assign(acc, promptMessage.partialVariables) : acc);
+                }, Object.create(null));
+                var inputVariables = new Set();
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = flattenedMessages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var promptMessage = _step.value;
+                        // eslint-disable-next-line no-instanceof/no-instanceof
+                        if (_instanceof(promptMessage, BaseMessage)) continue;
+                        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                        try {
+                            for(var _iterator1 = promptMessage.inputVariables[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                var inputVariable = _step1.value;
+                                if (inputVariable in flattenedPartialVariables) {
+                                    continue;
+                                }
+                                inputVariables.add(inputVariable);
+                            }
+                        } 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;
+                        }
+                    }
+                }
+                return new this(_object_spread_props(_object_spread({}, extra), {
+                    inputVariables: _to_consumable_array(inputVariables),
+                    promptMessages: flattenedMessages,
+                    partialVariables: flattenedPartialVariables
+                }));
+            }
+        },
+        {
+            key: "fromPromptMessages",
+            value: /** @deprecated Renamed to .fromMessages */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            function fromPromptMessages(promptMessages) {
+                return this.fromMessages(promptMessages);
+            }
+        }
+    ]);
+    return ChatPromptTemplate;
+}(BaseChatPromptTemplate);
+
+export { BaseChatPromptTemplate as B, ChatPromptTemplate as C, HumanMessagePromptTemplate as H, SystemMessagePromptTemplate as S };