@promptbook/deepseek 0.84.0-16

package/umd/index.umd.js

@@ -0,0 +1,1178 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('spacetrim')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'spacetrim'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-deepseek"] = {}, global.colors, global.spaceTrim));
+})(this, (function (exports, colors, spaceTrim) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
+    var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim);
+
+    // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
+    /**
+     * The version of the Book language
+     *
+     * @generated
+     * @see https://github.com/webgptorg/book
+     */
+    var BOOK_LANGUAGE_VERSION = '1.0.0';
+    /**
+     * The version of the Promptbook engine
+     *
+     * @generated
+     * @see https://github.com/webgptorg/promptbook
+     */
+    var PROMPTBOOK_ENGINE_VERSION = '0.84.0-15';
+    /**
+     * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        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 __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.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    /**
+     * Detects if the code is running in jest environment
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    var $isRunningInJest = new Function("\n    try {\n        return process.env.JEST_WORKER_ID !== undefined;\n    } catch (e) {\n        return false;\n    }\n");
+
+    /**
+     * This error indicates errors during the execution of the pipeline
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var PipelineExecutionError = /** @class */ (function (_super) {
+        __extends(PipelineExecutionError, _super);
+        function PipelineExecutionError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PipelineExecutionError';
+            Object.setPrototypeOf(_this, PipelineExecutionError.prototype);
+            return _this;
+        }
+        return PipelineExecutionError;
+    }(Error));
+
+    /**
+     * Freezes the given object and all its nested objects recursively
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it mutates given object
+     * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
+     *
+     * @returns The same object as the input, but deeply frozen
+     * @public exported from `@promptbook/utils`
+     */
+    function $deepFreeze(objectValue) {
+        var e_1, _a;
+        if (Array.isArray(objectValue)) {
+            return Object.freeze(objectValue.map(function (item) { return $deepFreeze(item); }));
+        }
+        var propertyNames = Object.getOwnPropertyNames(objectValue);
+        try {
+            for (var propertyNames_1 = __values(propertyNames), propertyNames_1_1 = propertyNames_1.next(); !propertyNames_1_1.done; propertyNames_1_1 = propertyNames_1.next()) {
+                var propertyName = propertyNames_1_1.value;
+                var value = objectValue[propertyName];
+                if (value && typeof value === 'object') {
+                    $deepFreeze(value);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (propertyNames_1_1 && !propertyNames_1_1.done && (_a = propertyNames_1.return)) _a.call(propertyNames_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        Object.freeze(objectValue);
+        return objectValue;
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Represents the usage with no resources consumed
+     *
+     * @public exported from `@promptbook/core`
+     */
+    $deepFreeze({
+        price: { value: 0 },
+        input: {
+            tokensCount: { value: 0 },
+            charactersCount: { value: 0 },
+            wordsCount: { value: 0 },
+            sentencesCount: { value: 0 },
+            linesCount: { value: 0 },
+            paragraphsCount: { value: 0 },
+            pagesCount: { value: 0 },
+        },
+        output: {
+            tokensCount: { value: 0 },
+            charactersCount: { value: 0 },
+            wordsCount: { value: 0 },
+            sentencesCount: { value: 0 },
+            linesCount: { value: 0 },
+            paragraphsCount: { value: 0 },
+            pagesCount: { value: 0 },
+        },
+    });
+    /**
+     * Represents the usage with unknown resources consumed
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var UNCERTAIN_USAGE = $deepFreeze({
+        price: { value: 0, isUncertain: true },
+        input: {
+            tokensCount: { value: 0, isUncertain: true },
+            charactersCount: { value: 0, isUncertain: true },
+            wordsCount: { value: 0, isUncertain: true },
+            sentencesCount: { value: 0, isUncertain: true },
+            linesCount: { value: 0, isUncertain: true },
+            paragraphsCount: { value: 0, isUncertain: true },
+            pagesCount: { value: 0, isUncertain: true },
+        },
+        output: {
+            tokensCount: { value: 0, isUncertain: true },
+            charactersCount: { value: 0, isUncertain: true },
+            wordsCount: { value: 0, isUncertain: true },
+            sentencesCount: { value: 0, isUncertain: true },
+            linesCount: { value: 0, isUncertain: true },
+            paragraphsCount: { value: 0, isUncertain: true },
+            pagesCount: { value: 0, isUncertain: true },
+        },
+    });
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Simple wrapper `new Date().toISOString()`
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic because it depends on the current time
+     *
+     * @returns string_date branded type
+     * @public exported from `@promptbook/utils`
+     */
+    function $getCurrentDate() {
+        return new Date().toISOString();
+    }
+
+    /**
+     * Name for the Promptbook
+     *
+     * TODO: [🗽] Unite branding and make single place for it
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var NAME = "Promptbook";
+    /**
+     * Email of the responsible person
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var ADMIN_EMAIL = 'pavol@ptbk.io';
+    /**
+     * Name of the responsible person for the Promptbook on GitHub
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var ADMIN_GITHUB_NAME = 'hejny';
+    // <- TODO: [🧠] Better system for generator warnings - not always "code" and "by `@promptbook/cli`"
+    /**
+     * The maximum number of iterations for a loops
+     *
+     * @private within the repository - too low-level in comparison with other `MAX_...`
+     */
+    var LOOP_LIMIT = 1000;
+    /**
+     * Strings to represent various values in the context of parameter values
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    var VALUE_STRINGS = {
+        empty: '(nothing; empty string)',
+        null: '(no value; null)',
+        undefined: '(unknown value; undefined)',
+        nan: '(not a number; NaN)',
+        infinity: '(infinity; ∞)',
+        negativeInfinity: '(negative infinity; -∞)',
+        unserializable: '(unserializable value)',
+    };
+    /**
+     * Small number limit
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    var SMALL_NUMBER = 0.001;
+    // <- TODO: [🧜‍♂️]
+    /**
+     * @@@
+     *
+     * @public exported from `@promptbook/core`
+     */
+    Object.freeze({
+        delimiter: ',',
+        quoteChar: '"',
+        newline: '\n',
+        skipEmptyLines: true,
+    });
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * TODO: [🧠][🧜‍♂️] Maybe join remoteUrl and path into single value
+     */
+
+    /**
+     * Orders JSON object by keys
+     *
+     * @returns The same type of object as the input re-ordered
+     * @public exported from `@promptbook/utils`
+     */
+    function orderJson(options) {
+        var value = options.value, order = options.order;
+        var orderedValue = __assign(__assign({}, (order === undefined ? {} : Object.fromEntries(order.map(function (key) { return [key, undefined]; })))), value);
+        return orderedValue;
+    }
+
+    /**
+     * Make error report URL for the given error
+     *
+     * @private private within the repository
+     */
+    function getErrorReportUrl(error) {
+        var report = {
+            title: "\uD83D\uDC1C Error report from ".concat(NAME),
+            body: spaceTrim__default["default"](function (block) { return "\n\n\n            `".concat(error.name || 'Error', "` has occurred in the [").concat(NAME, "], please look into it @").concat(ADMIN_GITHUB_NAME, ".\n\n            ```\n            ").concat(block(error.message || '(no error message)'), "\n            ```\n\n\n            ## More info:\n\n            - **Promptbook engine version:** ").concat(PROMPTBOOK_ENGINE_VERSION, "\n            - **Book language version:** ").concat(BOOK_LANGUAGE_VERSION, "\n            - **Time:** ").concat(new Date().toISOString(), "\n\n            <details>\n            <summary>Stack trace:</summary>\n\n            ## Stack trace:\n\n            ```stacktrace\n            ").concat(block(error.stack || '(empty)'), "\n            ```\n            </details>\n\n        "); }),
+        };
+        var reportUrl = new URL("https://github.com/webgptorg/promptbook/issues/new");
+        reportUrl.searchParams.set('labels', 'bug');
+        reportUrl.searchParams.set('assignees', ADMIN_GITHUB_NAME);
+        reportUrl.searchParams.set('title', report.title);
+        reportUrl.searchParams.set('body', report.body);
+        return reportUrl;
+    }
+
+    /**
+     * This error type indicates that the error should not happen and its last check before crashing with some other error
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var UnexpectedError = /** @class */ (function (_super) {
+        __extends(UnexpectedError, _super);
+        function UnexpectedError(message) {
+            var _this = _super.call(this, spaceTrim.spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This error should not happen.\n                    It's probbably a bug in the pipeline collection\n\n                    Please report issue:\n                    ").concat(block(getErrorReportUrl(new Error(message)).href), "\n\n                    Or contact us on ").concat(ADMIN_EMAIL, "\n\n                "); })) || this;
+            _this.name = 'UnexpectedError';
+            Object.setPrototypeOf(_this, UnexpectedError.prototype);
+            return _this;
+        }
+        return UnexpectedError;
+    }(Error));
+
+    /**
+     * Checks if the value is [🚉] serializable as JSON
+     * If not, throws an UnexpectedError with a rich error message and tracking
+     *
+     * - Almost all primitives are serializable BUT:
+     * - `undefined` is not serializable
+     * - `NaN` is not serializable
+     * - Objects and arrays are serializable if all their properties are serializable
+     * - Functions are not serializable
+     * - Circular references are not serializable
+     * - `Date` objects are not serializable
+     * - `Map` and `Set` objects are not serializable
+     * - `RegExp` objects are not serializable
+     * - `Error` objects are not serializable
+     * - `Symbol` objects are not serializable
+     * - And much more...
+     *
+     * @throws UnexpectedError if the value is not serializable as JSON
+     * @public exported from `@promptbook/utils`
+     */
+    function checkSerializableAsJson(options) {
+        var e_1, _a;
+        var value = options.value, name = options.name, message = options.message;
+        if (value === undefined) {
+            throw new UnexpectedError("".concat(name, " is undefined"));
+        }
+        else if (value === null) {
+            return;
+        }
+        else if (typeof value === 'boolean') {
+            return;
+        }
+        else if (typeof value === 'number' && !isNaN(value)) {
+            return;
+        }
+        else if (typeof value === 'string') {
+            return;
+        }
+        else if (typeof value === 'symbol') {
+            throw new UnexpectedError("".concat(name, " is symbol"));
+        }
+        else if (typeof value === 'function') {
+            throw new UnexpectedError("".concat(name, " is function"));
+        }
+        else if (typeof value === 'object' && Array.isArray(value)) {
+            for (var i = 0; i < value.length; i++) {
+                checkSerializableAsJson({ name: "".concat(name, "[").concat(i, "]"), value: value[i], message: message });
+            }
+        }
+        else if (typeof value === 'object') {
+            if (value instanceof Date) {
+                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is Date\n\n                        Use `string_date_iso8601` instead\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n                    "); }));
+            }
+            else if (value instanceof Map) {
+                throw new UnexpectedError("".concat(name, " is Map"));
+            }
+            else if (value instanceof Set) {
+                throw new UnexpectedError("".concat(name, " is Set"));
+            }
+            else if (value instanceof RegExp) {
+                throw new UnexpectedError("".concat(name, " is RegExp"));
+            }
+            else if (value instanceof Error) {
+                throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                        `".concat(name, "` is unserialized Error\n\n                        Use function `serializeError`\n\n                        Additional message for `").concat(name, "`:\n                        ").concat(block(message || '(nothing)'), "\n\n                    "); }));
+            }
+            else {
+                try {
+                    for (var _b = __values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var _d = __read(_c.value, 2), subName = _d[0], subValue = _d[1];
+                        if (subValue === undefined) {
+                            // Note: undefined in object is serializable - it is just omited
+                            continue;
+                        }
+                        checkSerializableAsJson({ name: "".concat(name, ".").concat(subName), value: subValue, message: message });
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                try {
+                    JSON.stringify(value); // <- TODO: [0]
+                }
+                catch (error) {
+                    if (!(error instanceof Error)) {
+                        throw error;
+                    }
+                    throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                            `".concat(name, "` is not serializable\n\n                            ").concat(block(error.stack || error.message), "\n\n                            Additional message for `").concat(name, "`:\n                            ").concat(block(message || '(nothing)'), "\n                        "); }));
+                }
+                /*
+                TODO: [0] Is there some more elegant way to check circular references?
+                const seen = new Set();
+                const stack = [{ value }];
+                while (stack.length > 0) {
+                    const { value } = stack.pop()!;
+                    if (typeof value === 'object' && value !== null) {
+                        if (seen.has(value)) {
+                            throw new UnexpectedError(`${name} has circular reference`);
+                        }
+                        seen.add(value);
+                        if (Array.isArray(value)) {
+                            stack.push(...value.map((value) => ({ value })));
+                        } else {
+                            stack.push(...Object.values(value).map((value) => ({ value })));
+                        }
+                    }
+                }
+                */
+                return;
+            }
+        }
+        else {
+            throw new UnexpectedError(spaceTrim__default["default"](function (block) { return "\n                    `".concat(name, "` is unknown type\n\n                    Additional message for `").concat(name, "`:\n                    ").concat(block(message || '(nothing)'), "\n                "); }));
+        }
+    }
+    /**
+     * TODO: Can be return type more type-safe? like `asserts options.value is JsonValue`
+     * TODO: [🧠][main] !!3 In-memory cache of same values to prevent multiple checks
+     * Note: [🐠] This is how `checkSerializableAsJson` + `isSerializableAsJson` together can just retun true/false or rich error message
+     */
+
+    /**
+     * @@@
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function deepClone(objectValue) {
+        return JSON.parse(JSON.stringify(objectValue));
+        /*
+        TODO: [🧠] Is there a better implementation?
+        > const propertyNames = Object.getOwnPropertyNames(objectValue);
+        > for (const propertyName of propertyNames) {
+        >     const value = (objectValue as really_any)[propertyName];
+        >     if (value && typeof value === 'object') {
+        >         deepClone(value);
+        >     }
+        > }
+        > return Object.assign({}, objectValue);
+        */
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Utility to export a JSON object from a function
+     *
+     * 1) Checks if the value is serializable as JSON
+     * 2) Makes a deep clone of the object
+     * 2) Orders the object properties
+     * 2) Deeply freezes the cloned object
+     *
+     * Note: This function does not mutates the given object
+     *
+     * @returns The same type of object as the input but read-only and re-ordered
+     * @public exported from `@promptbook/utils`
+     */
+    function exportJson(options) {
+        var name = options.name, value = options.value, order = options.order, message = options.message;
+        checkSerializableAsJson({ name: name, value: value, message: message });
+        var orderedValue = 
+        // TODO: Fix error "Type instantiation is excessively deep and possibly infinite."
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        order === undefined
+            ? deepClone(value)
+            : orderJson({
+                value: value,
+                // <- Note: checkSerializableAsJson asserts that the value is serializable as JSON
+                order: order,
+            });
+        $deepFreeze(orderedValue);
+        return orderedValue;
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Nonce which is used for replacing things in strings
+     *
+     * @private within the repository
+     */
+    var REPLACING_NONCE = 'ptbkauk42kV2dzao34faw7FudQUHYPtW';
+    /**
+     * @@@
+     *
+     * @private within the repository
+     */
+    var RESERVED_PARAMETER_MISSING_VALUE = 'MISSING-' + REPLACING_NONCE;
+    /**
+     * @@@
+     *
+     * @private within the repository
+     */
+    var RESERVED_PARAMETER_RESTRICTED = 'RESTRICTED-' + REPLACING_NONCE;
+    /**
+     * The names of the parameters that are reserved for special purposes
+     *
+     * @public exported from `@promptbook/core`
+     */
+    exportJson({
+        name: 'RESERVED_PARAMETER_NAMES',
+        message: "The names of the parameters that are reserved for special purposes",
+        value: [
+            'content',
+            'context',
+            'knowledge',
+            'examples',
+            'modelName',
+            'currentDate',
+            // <- TODO: list here all command names
+            // <- TODO: Add more like 'date', 'modelName',...
+            // <- TODO: Add [emoji] + instructions ACRY when adding new reserved parameter
+        ],
+    });
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * This error type indicates that some limit was reached
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var LimitReachedError = /** @class */ (function (_super) {
+        __extends(LimitReachedError, _super);
+        function LimitReachedError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'LimitReachedError';
+            Object.setPrototypeOf(_this, LimitReachedError.prototype);
+            return _this;
+        }
+        return LimitReachedError;
+    }(Error));
+
+    /**
+     * Format either small or big number
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function numberToString(value) {
+        if (value === 0) {
+            return '0';
+        }
+        else if (Number.isNaN(value)) {
+            return VALUE_STRINGS.nan;
+        }
+        else if (value === Infinity) {
+            return VALUE_STRINGS.infinity;
+        }
+        else if (value === -Infinity) {
+            return VALUE_STRINGS.negativeInfinity;
+        }
+        for (var exponent = 0; exponent < 15; exponent++) {
+            var factor = Math.pow(10, exponent);
+            var valueRounded = Math.round(value * factor) / factor;
+            if (Math.abs(value - valueRounded) / value < SMALL_NUMBER) {
+                return valueRounded.toFixed(exponent);
+            }
+        }
+        return value.toString();
+    }
+
+    /**
+     * Function `valueToString` will convert the given value to string
+     * This is useful and used in the `templateParameters` function
+     *
+     * Note: This function is not just calling `toString` method
+     *       It's more complex and can handle this conversion specifically for LLM models
+     *       See `VALUE_STRINGS`
+     *
+     * Note: There are 2 similar functions
+     * - `valueToString` converts value to string for LLM models as human-readable string
+     * - `asSerializable` converts value to string to preserve full information to be able to convert it back
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function valueToString(value) {
+        try {
+            if (value === '') {
+                return VALUE_STRINGS.empty;
+            }
+            else if (value === null) {
+                return VALUE_STRINGS.null;
+            }
+            else if (value === undefined) {
+                return VALUE_STRINGS.undefined;
+            }
+            else if (typeof value === 'string') {
+                return value;
+            }
+            else if (typeof value === 'number') {
+                return numberToString(value);
+            }
+            else if (value instanceof Date) {
+                return value.toISOString();
+            }
+            else {
+                return JSON.stringify(value);
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            console.error(error);
+            return VALUE_STRINGS.unserializable;
+        }
+    }
+
+    /**
+     * Replaces parameters in template with values from parameters object
+     *
+     * Note: This function is not places strings into string,
+     *       It's more complex and can handle this operation specifically for LLM models
+     *
+     * @param template the template with parameters in {curly} braces
+     * @param parameters the object with parameters
+     * @returns the template with replaced parameters
+     * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
+     * @public exported from `@promptbook/utils`
+     */
+    function templateParameters(template, parameters) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(Object.entries(parameters)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), parameterName = _d[0], parameterValue = _d[1];
+                if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
+                    throw new UnexpectedError("Parameter `{".concat(parameterName, "}` has missing value"));
+                }
+                else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
+                    // TODO: [🍵]
+                    throw new UnexpectedError("Parameter `{".concat(parameterName, "}` is restricted to use"));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var replacedTemplates = template;
+        var match;
+        var loopLimit = LOOP_LIMIT;
+        var _loop_1 = function () {
+            if (loopLimit-- < 0) {
+                throw new LimitReachedError('Loop limit reached during parameters replacement in `templateParameters`');
+            }
+            var precol = match.groups.precol;
+            var parameterName = match.groups.parameterName;
+            if (parameterName === '') {
+                return "continue";
+            }
+            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
+                throw new PipelineExecutionError('Parameter is already opened or not closed');
+            }
+            if (parameters[parameterName] === undefined) {
+                throw new PipelineExecutionError("Parameter `{".concat(parameterName, "}` is not defined"));
+            }
+            var parameterValue = parameters[parameterName];
+            if (parameterValue === undefined) {
+                throw new PipelineExecutionError("Parameter `{".concat(parameterName, "}` is not defined"));
+            }
+            parameterValue = valueToString(parameterValue);
+            // Escape curly braces in parameter values to prevent prompt-injection
+            parameterValue = parameterValue.replace(/[{}]/g, '\\$&');
+            if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
+                parameterValue = parameterValue
+                    .split('\n')
+                    .map(function (line, index) { return (index === 0 ? line : "".concat(precol).concat(line)); })
+                    .join('\n');
+            }
+            replacedTemplates =
+                replacedTemplates.substring(0, match.index + precol.length) +
+                    parameterValue +
+                    replacedTemplates.substring(match.index + precol.length + parameterName.length + 2);
+        };
+        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
+            .exec(replacedTemplates))) {
+            _loop_1();
+        }
+        // [💫] Check if there are parameters that are not closed properly
+        if (/{\w+$/.test(replacedTemplates)) {
+            throw new PipelineExecutionError('Parameter is not closed');
+        }
+        // [💫] Check if there are parameters that are not opened properly
+        if (/^\w+}/.test(replacedTemplates)) {
+            throw new PipelineExecutionError('Parameter is not opened');
+        }
+        return replacedTemplates;
+    }
+
+    /**
+     * Function `asSerializable` will convert values which are not serializable to serializable values
+     * It walks deeply through the object and converts all values
+     *
+     * For example:
+     * - `Date` objects will be converted to string
+     *
+     * Note: There are 2 similar functions
+     * - `valueToString` converts value to string for LLM models as human-readable string
+     * - `asSerializable` converts value to string to preserve full information to be able to convert it back
+     *
+     * @private Internal helper function
+     */
+    function asSerializable(value) {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        else if (Array.isArray(value)) {
+            return value.map(asSerializable);
+        }
+        else if (value !== null && typeof value === 'object') {
+            var result = {};
+            for (var key in value) {
+                if (Object.prototype.hasOwnProperty.call(value, key)) {
+                    result[key] = asSerializable(value[key]);
+                }
+            }
+            return result;
+        }
+        else {
+            return value;
+        }
+    }
+
+    /**
+     * Adapter which creates Promptbook execution tools from Vercel provider
+     *
+     * @public exported from `@promptbook/vercel`
+     */
+    function createExecutionToolsFromVercelProvider(options) {
+        var title = options.title, description = options.description;
+        var vercelProvider = options.vercelProvider, availableModels = options.availableModels, userId = options.userId, _a = options.additionalChatSettings, additionalChatSettings = _a === void 0 ? {} : _a;
+        if (!/Vercel/i.test(title)) {
+            title = "".concat(title, " (through Vercel)");
+        } /* not else */
+        if (description === undefined) {
+            description = "Implementation of ".concat(title, " through Vercel");
+        } /* not else */
+        if (!/Vercel/i.test(description)) {
+            description = "".concat(description, " (through Vercel)");
+        } /* not else */
+        return {
+            title: title,
+            description: description,
+            checkConfiguration: function () {
+                // Note: There is no way how to check configuration of Vercel provider
+                return Promise.resolve();
+            },
+            listModels: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        return [2 /*return*/, availableModels];
+                    });
+                });
+            },
+            callChatModel: function (prompt) {
+                var _a;
+                return __awaiter(this, void 0, void 0, function () {
+                    var content, parameters, modelRequirements, modelName, model, rawPromptContent, rawRequest, start, rawResponse, complete, usage;
+                    var _this = this;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                content = prompt.content, parameters = prompt.parameters, modelRequirements = prompt.modelRequirements;
+                                if (modelRequirements.modelVariant !== 'CHAT') {
+                                    throw new PipelineExecutionError('Use callChatModel only for CHAT variant');
+                                }
+                                modelName = modelRequirements.modelName ||
+                                    ((_a = availableModels.find(function (_a) {
+                                        var modelVariant = _a.modelVariant;
+                                        return modelVariant === 'CHAT';
+                                    })) === null || _a === void 0 ? void 0 : _a.modelName);
+                                if (!modelName) {
+                                    throw new PipelineExecutionError(spaceTrim__default["default"]("\n                        Can not determine which model to use.\n\n                        You need to provide at least one of:\n                        1) In `createExecutionToolsFromVercelProvider` options, provide `availableModels` with at least one model\n                        2) In `prompt.modelRequirements`, provide `modelName` with the name of the model to use\n\n                    "));
+                                }
+                                return [4 /*yield*/, vercelProvider.chat(modelName, __assign({ user: (userId === null || userId === void 0 ? void 0 : userId.toString()) || undefined }, additionalChatSettings))];
+                            case 1:
+                                model = _b.sent();
+                                rawPromptContent = templateParameters(content, __assign(__assign({}, parameters), { modelName: modelName }));
+                                rawRequest = {
+                                    // <- TODO: [☂]
+                                    inputFormat: 'messages',
+                                    mode: {
+                                        type: 'regular',
+                                        tools: [
+                                        /* <- TODO: Pass the tools */
+                                        ],
+                                    },
+                                    prompt: __spreadArray(__spreadArray([], __read((modelRequirements.systemMessage === undefined
+                                        ? []
+                                        : [
+                                            {
+                                                role: 'system',
+                                                content: modelRequirements.systemMessage,
+                                            },
+                                        ])), false), [
+                                        {
+                                            role: 'user',
+                                            content: [
+                                                {
+                                                    type: 'text',
+                                                    text: rawPromptContent,
+                                                },
+                                            ],
+                                        },
+                                    ], false),
+                                };
+                                start = $getCurrentDate();
+                                if (options.isVerbose) {
+                                    console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
+                                }
+                                return [4 /*yield*/, (function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, model.doGenerate(rawRequest)];
+                                            case 1: return [2 /*return*/, _a.sent()];
+                                        }
+                                    }); }); })().catch(function (error) {
+                                        // <- Note: This weird structure is here to catch errors in both sync and async `doGenerate`
+                                        if (options.isVerbose) {
+                                            console.info(colors__default["default"].bgRed('error'), error);
+                                        }
+                                        throw error;
+                                    })];
+                            case 2:
+                                rawResponse = _b.sent();
+                                return [4 /*yield*/, model.doGenerate(rawRequest)];
+                            case 3:
+                                _b.sent();
+                                if (options.isVerbose) {
+                                    console.info(colors__default["default"].bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
+                                }
+                                if (rawResponse.text === undefined) {
+                                    throw new PipelineExecutionError('No response message');
+                                }
+                                complete = $getCurrentDate();
+                                usage = UNCERTAIN_USAGE;
+                                return [2 /*return*/, exportJson({
+                                        name: 'promptResult',
+                                        message: "Result of `createExecutionToolsFromVercelProvider.callChatModel`",
+                                        value: {
+                                            content: rawResponse.text,
+                                            modelName: modelName,
+                                            timing: {
+                                                start: start,
+                                                complete: complete,
+                                            },
+                                            usage: usage,
+                                            rawPromptContent: rawPromptContent,
+                                            rawRequest: rawRequest,
+                                            rawResponse: asSerializable(rawResponse),
+                                            // <- [🗯]
+                                        },
+                                    })];
+                        }
+                    });
+                });
+            },
+        };
+    }
+
+    /**
+     * Execution Tools for calling Deepseek API.
+     *
+     * @public exported from `@promptbook/deepseek`
+     */
+    var createDeepseekExecutionTools = Object.assign(function (options) {
+        if ($isRunningInJest()) {
+            // Note: [🔘]
+            throw new Error('DeepseekExecutionTools are not supported in Jest environment');
+        }
+        // Note: [🔘] Maybe there is same compatibility problem as in '@ai-sdk/deepseek'
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        var createDeepSeek = require('@ai-sdk/deepseek').createDeepSeek;
+        var deepseekVercelProvider = createDeepSeek(__assign({}, options));
+        return createExecutionToolsFromVercelProvider(__assign({ title: 'Deepseek', description: 'Implementation of Deepseek models', vercelProvider: deepseekVercelProvider, availableModels: [
+                // TODO: [🕘] Maybe list models in same way as in other providers - in separate file with metadata
+                'deepseek-chat',
+                'deepseek-reasoner',
+                // <- TODO: !!!!!! Picking of default model
+            ].map(function (modelName) { return ({ modelName: modelName, modelVariant: 'CHAT' }); }) }, options));
+    }, {
+        packageName: '@promptbook/deepseek',
+        className: 'DeepseekExecutionTools',
+    });
+    /**
+     * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
+     */
+
+    /**
+     * This error type indicates that some part of the code is not implemented yet
+     *
+     * @public exported from `@promptbook/core`
+     */
+    var NotYetImplementedError = /** @class */ (function (_super) {
+        __extends(NotYetImplementedError, _super);
+        function NotYetImplementedError(message) {
+            var _this = _super.call(this, spaceTrim.spaceTrim(function (block) { return "\n                    ".concat(block(message), "\n\n                    Note: This feature is not implemented yet but it will be soon.\n\n                    If you want speed up the implementation or just read more, look here:\n                    https://github.com/webgptorg/promptbook\n\n                    Or contact us on pavol@ptbk.io\n\n                "); })) || this;
+            _this.name = 'NotYetImplementedError';
+            Object.setPrototypeOf(_this, NotYetImplementedError.prototype);
+            return _this;
+        }
+        return NotYetImplementedError;
+    }(Error));
+
+    /**
+     * @@@
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it access global scope
+     *
+     *  @private internal function of `$Register`
+     */
+    function $getGlobalScope() {
+        return Function('return this')();
+    }
+
+    /**
+     * @@@
+     *
+     * @param text @@@
+     * @returns @@@
+     * @example 'HELLO_WORLD'
+     * @example 'I_LOVE_PROMPTBOOK'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_SCREAMING_CASE(text) {
+        var e_1, _a;
+        var charType;
+        var lastCharType = 'OTHER';
+        var normalizedName = '';
+        try {
+            for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+                var char = text_1_1.value;
+                var normalizedChar = void 0;
+                if (/^[a-z]$/.test(char)) {
+                    charType = 'LOWERCASE';
+                    normalizedChar = char.toUpperCase();
+                }
+                else if (/^[A-Z]$/.test(char)) {
+                    charType = 'UPPERCASE';
+                    normalizedChar = char;
+                }
+                else if (/^[0-9]$/.test(char)) {
+                    charType = 'NUMBER';
+                    normalizedChar = char;
+                }
+                else {
+                    charType = 'OTHER';
+                    normalizedChar = '_';
+                }
+                if (charType !== lastCharType &&
+                    !(lastCharType === 'UPPERCASE' && charType === 'LOWERCASE') &&
+                    !(lastCharType === 'NUMBER') &&
+                    !(charType === 'NUMBER')) {
+                    normalizedName += '_';
+                }
+                normalizedName += normalizedChar;
+                lastCharType = charType;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        normalizedName = normalizedName.replace(/_+/g, '_');
+        normalizedName = normalizedName.replace(/_?\/_?/g, '/');
+        normalizedName = normalizedName.replace(/^_/, '');
+        normalizedName = normalizedName.replace(/_$/, '');
+        return normalizedName;
+    }
+    /**
+     * TODO: Tests
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'Moje tabule' })).toEqual('/VtG7sR9rRJqwNEdM2/Moje tabule');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'ěščřžžýáíúů' })).toEqual('/VtG7sR9rRJqwNEdM2/escrzyaieuu');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj_ahojAhoj    ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj-ahoj-ahoj-ahoj');
+     * TODO: [🌺] Use some intermediate util splitWords
+     */
+
+    /**
+     * @@@
+     *
+     * @param text @@@
+     * @returns @@@
+     * @example 'hello_world'
+     * @example 'i_love_promptbook'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_snake_case(text) {
+        return normalizeTo_SCREAMING_CASE(text).toLowerCase();
+    }
+
+    /**
+     * Register is @@@
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it accesses and adds variables in global scope.
+     *
+     * @private internal utility, exported are only signleton instances of this class
+     */
+    var $Register = /** @class */ (function () {
+        function $Register(registerName) {
+            this.registerName = registerName;
+            var storageName = "_promptbook_".concat(normalizeTo_snake_case(registerName));
+            var globalScope = $getGlobalScope();
+            if (globalScope[storageName] === undefined) {
+                globalScope[storageName] = [];
+            }
+            else if (!Array.isArray(globalScope[storageName])) {
+                throw new UnexpectedError("Expected (global) ".concat(storageName, " to be an array, but got ").concat(typeof globalScope[storageName]));
+            }
+            this.storage = globalScope[storageName];
+        }
+        $Register.prototype.list = function () {
+            // <- TODO: ReadonlyDeep<ReadonlyArray<TRegistered>>
+            return this.storage;
+        };
+        $Register.prototype.register = function (registered) {
+            var packageName = registered.packageName, className = registered.className;
+            var existingRegistrationIndex = this.storage.findIndex(function (item) { return item.packageName === packageName && item.className === className; });
+            var existingRegistration = this.storage[existingRegistrationIndex];
+            if (!existingRegistration) {
+                this.storage.push(registered);
+            }
+            else {
+                this.storage[existingRegistrationIndex] = registered;
+            }
+            return {
+                registerName: this.registerName,
+                packageName: packageName,
+                className: className,
+                get isDestroyed() {
+                    return false;
+                },
+                destroy: function () {
+                    throw new NotYetImplementedError("Registration to ".concat(this.registerName, " is permanent in this version of Promptbook"));
+                },
+            };
+        };
+        return $Register;
+    }());
+
+    /**
+     * @@@
+     *
+     * Note: `$` is used to indicate that this interacts with the global scope
+     * @singleton Only one instance of each register is created per build, but thare can be more @@@
+     * @public exported from `@promptbook/core`
+     */
+    var $llmToolsRegister = new $Register('llm_execution_tools_constructors');
+    /**
+     * TODO: [®] DRY Register logic
+     */
+
+    /**
+     * Registration of LLM provider
+     *
+     * Warning: This is not useful for the end user, it is just a side effect of the mechanism that handles all available LLM tools
+     *
+     * @public exported from `@promptbook/deepseek`
+     * @public exported from `@promptbook/wizzard`
+     * @public exported from `@promptbook/cli`
+     */
+    var _DeepseekRegistration = $llmToolsRegister.register(createDeepseekExecutionTools);
+    /**
+     * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    exports.BOOK_LANGUAGE_VERSION = BOOK_LANGUAGE_VERSION;
+    exports.PROMPTBOOK_ENGINE_VERSION = PROMPTBOOK_ENGINE_VERSION;
+    exports._DeepseekRegistration = _DeepseekRegistration;
+    exports.createDeepseekExecutionTools = createDeepseekExecutionTools;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map