@promptbook/core 0.52.0-3 → 0.52.0-30

package/umd/index.umd.js

@@ -1,13 +1,14 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('prettier'), require('prettier/parser-html'), require('moment')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'prettier', 'prettier/parser-html', 'moment'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-core"] = {}, global.spaceTrim, global.prettier, global.parserHtml));
-})(this, (function (exports, spaceTrim, prettier, parserHtml) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('prettier'), require('prettier/parser-html'), require('path'), require('moment')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'prettier', 'prettier/parser-html', 'path', 'moment'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-core"] = {}, global.spaceTrim, global.prettier, global.parserHtml, global.path, global.moment));
+})(this, (function (exports, spaceTrim, prettier, parserHtml, path, moment) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
     var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim);
     var parserHtml__default = /*#__PURE__*/_interopDefaultLegacy(parserHtml);
+    var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -453,7 +454,7 @@
     /**
      * The version of the Promptbook library
      */
-    var PROMPTBOOK_VERSION = '0.52.0-2';
+    var PROMPTBOOK_VERSION = '0.52.0-29';
 
     /**
      * Parses the template and returns the list of all parameter names
@@ -575,38 +576,6 @@
      * TODO: [🔣] If script require contentLanguage
      */
 
-    /**
-     * Prettify the html code
-     *
-     * @param content raw html code
-     * @returns formatted html code
-     */
-    function prettifyMarkdown(content) {
-        try {
-            return prettier.format(content, {
-                parser: 'markdown',
-                plugins: [parserHtml__default["default"]],
-                // TODO: DRY - make some import or auto-copy of .prettierrc
-                endOfLine: 'lf',
-                tabWidth: 4,
-                singleQuote: true,
-                trailingComma: 'all',
-                arrowParens: 'always',
-                printWidth: 120,
-                htmlWhitespaceSensitivity: 'ignore',
-                jsxBracketSameLine: false,
-                bracketSpacing: true,
-            });
-        }
-        catch (error) {
-            console.error('There was an error with prettifying the markdown, using the original as the fallback', {
-                error: error,
-                html: content,
-            });
-            return content;
-        }
-    }
-
     /**
      * Removes emojis from a string and fix whitespaces
      *
@@ -632,6 +601,64 @@
         return value;
     }
 
+    /**
+     * Creates a Mermaid graph based on the promptbook
+     *
+     * Note: The result is not wrapped in a Markdown code block
+     */
+    function renderPromptbookMermaid(promptbookJson, options) {
+        var _a = (options || {}).linkPromptTemplate, linkPromptTemplate = _a === void 0 ? function () { return null; } : _a;
+        var parameterNameToTemplateName = function (parameterName) {
+            var parameter = promptbookJson.parameters.find(function (parameter) { return parameter.name === parameterName; });
+            if (!parameter) {
+                throw new UnexpectedError("Could not find {".concat(parameterName, "}"));
+            }
+            if (parameter.isInput) {
+                return 'input';
+            }
+            var template = promptbookJson.promptTemplates.find(function (template) { return template.resultingParameterName === parameterName; });
+            if (!template) {
+                throw new Error("Could not find template for {".concat(parameterName, "}"));
+            }
+            return normalizeTo_camelCase('template-' + titleToName(template.title));
+        };
+        var promptbookMermaid = spaceTrim.spaceTrim(function (block) { return "\n\n            %% \uD83D\uDD2E Tip: Open this on GitHub or in the VSCode website to see the Mermaid graph visually\n\n            flowchart LR\n              subgraph \"".concat(promptbookJson.title, "\"\n\n                  direction TB\n\n                  input((Input)):::input\n                  ").concat(block(promptbookJson.promptTemplates
+            .flatMap(function (_a) {
+            var title = _a.title, dependentParameterNames = _a.dependentParameterNames, resultingParameterName = _a.resultingParameterName;
+            return __spreadArray([
+                "".concat(parameterNameToTemplateName(resultingParameterName), "(\"").concat(title, "\")")
+            ], __read(dependentParameterNames.map(function (dependentParameterName) {
+                return "".concat(parameterNameToTemplateName(dependentParameterName), "--\"{").concat(dependentParameterName, "}\"-->").concat(parameterNameToTemplateName(resultingParameterName));
+            })), false);
+        })
+            .join('\n')), "\n\n                  ").concat(block(promptbookJson.parameters
+            .filter(function (_a) {
+            var isOutput = _a.isOutput;
+            return isOutput;
+        })
+            .map(function (_a) {
+            var name = _a.name;
+            return "".concat(parameterNameToTemplateName(name), "--\"{").concat(name, "}\"-->output");
+        })
+            .join('\n')), "\n                  output((Output)):::output\n\n                  ").concat(block(promptbookJson.promptTemplates
+            .map(function (promptTemplate) {
+            var link = linkPromptTemplate(promptTemplate);
+            if (link === null) {
+                return '';
+            }
+            var href = link.href, title = link.title;
+            var templateName = parameterNameToTemplateName(promptTemplate.resultingParameterName);
+            return "click ".concat(templateName, " href \"").concat(href, "\" \"").concat(title, "\";");
+        })
+            .filter(function (line) { return line !== ''; })
+            .join('\n')), "\n\n                  classDef input color: grey;\n                  classDef output color: grey;\n\n              end;\n\n        "); });
+        return promptbookMermaid;
+    }
+    /**
+     * TODO: Maybe use some Mermaid library instead of string templating
+     * TODO: [🕌] When more than 2 functionalities, split into separate functions
+     */
+
     /**
      * Function parseNumber will parse number from string
      *
@@ -714,35 +741,80 @@
     }(Error));
 
     /**
-     * This error indicates errors during the execution of the promptbook
+     * This error occurs during the parameter replacement in the template
+     *
+     * Note: This is a kindof subtype of PromptbookExecutionError because it occurs during the execution of the pipeline
      */
-    var PromptbookExecutionError = /** @class */ (function (_super) {
-        __extends(PromptbookExecutionError, _super);
-        function PromptbookExecutionError(message) {
+    var TemplateError = /** @class */ (function (_super) {
+        __extends(TemplateError, _super);
+        function TemplateError(message) {
             var _this = _super.call(this, message) || this;
-            _this.name = 'PromptbookExecutionError';
-            Object.setPrototypeOf(_this, PromptbookExecutionError.prototype);
+            _this.name = 'TemplateError';
+            Object.setPrototypeOf(_this, TemplateError.prototype);
             return _this;
         }
-        return PromptbookExecutionError;
+        return TemplateError;
     }(Error));
 
     /**
-     * This error occurs when some expectation is not met in the execution of the pipeline
+     * Replaces parameters in template with values from parameters object
      *
-     * @private Always catched and rethrown as `PromptbookExecutionError`
-     * Note: This is a kindof subtype of PromptbookExecutionError
+     * @param template the template with parameters in {curly} braces
+     * @param parameters the object with parameters
+     * @returns the template with replaced parameters
+     * @throws {TemplateError} if parameter is not defined, not closed, or not opened
+     *
+     * @private within the createPromptbookExecutor
      */
-    var ExpectError = /** @class */ (function (_super) {
-        __extends(ExpectError, _super);
-        function ExpectError(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = 'ExpectError';
-            Object.setPrototypeOf(_this, ExpectError.prototype);
-            return _this;
+    function replaceParameters(template, parameters) {
+        var replacedTemplate = template;
+        var match;
+        var loopLimit = LOOP_LIMIT;
+        var _loop_1 = function () {
+            if (loopLimit-- < 0) {
+                throw new UnexpectedError('Loop limit reached during parameters replacement in `replaceParameters`');
+            }
+            var precol = match.groups.precol;
+            var parameterName = match.groups.parameterName;
+            if (parameterName === '') {
+                return "continue";
+            }
+            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
+                throw new TemplateError('Parameter is already opened or not closed');
+            }
+            if (parameters[parameterName] === undefined) {
+                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
+            }
+            var parameterValue = parameters[parameterName];
+            if (parameterValue === undefined) {
+                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
+            }
+            parameterValue = parameterValue.toString();
+            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');
+            }
+            replacedTemplate =
+                replacedTemplate.substring(0, match.index + precol.length) +
+                    parameterValue +
+                    replacedTemplate.substring(match.index + precol.length + parameterName.length + 2);
+        };
+        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
+            .exec(replacedTemplate))) {
+            _loop_1();
         }
-        return ExpectError;
-    }(Error));
+        // [💫] Check if there are parameters that are not closed properly
+        if (/{\w+$/.test(replacedTemplate)) {
+            throw new TemplateError('Parameter is not closed');
+        }
+        // [💫] Check if there are parameters that are not opened properly
+        if (/^\w+}/.test(replacedTemplate)) {
+            throw new TemplateError('Parameter is not opened');
+        }
+        return replacedTemplate;
+    }
 
     /**
      * Counts number of characters in the text
@@ -1070,118 +1142,6 @@
         PAGES: countPages,
     };
 
-    /**
-     * Function checkExpectations will check if the expectations on given value are met
-     *
-     * Note: There are two simmilar functions:
-     * - `checkExpectations` which throws an error if the expectations are not met
-     * - `isPassingExpectations` which returns a boolean
-     *
-     * @throws {ExpectError} if the expectations are not met
-     * @returns {void} Nothing
-     */
-    function checkExpectations(expectations, value) {
-        var e_1, _a;
-        try {
-            for (var _b = __values(Object.entries(expectations)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), unit = _d[0], _e = _d[1], max = _e.max, min = _e.min;
-                var amount = CountUtils[unit.toUpperCase()](value);
-                if (min && amount < min) {
-                    throw new ExpectError("Expected at least ".concat(min, " ").concat(unit, " but got ").concat(amount));
-                } /* not else */
-                if (max && amount > max) {
-                    throw new ExpectError("Expected at most ".concat(max, " ").concat(unit, " but got ").concat(amount));
-                }
-            }
-        }
-        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; }
-        }
-    }
-    /**
-     * TODO: [💝] Unite object for expecting amount and format
-     */
-
-    /**
-     * This error occurs during the parameter replacement in the template
-     *
-     * Note: This is a kindof subtype of PromptbookExecutionError because it occurs during the execution of the pipeline
-     */
-    var TemplateError = /** @class */ (function (_super) {
-        __extends(TemplateError, _super);
-        function TemplateError(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = 'TemplateError';
-            Object.setPrototypeOf(_this, TemplateError.prototype);
-            return _this;
-        }
-        return TemplateError;
-    }(Error));
-
-    /**
-     * Replaces parameters in template with values from parameters object
-     *
-     * @param template the template with parameters in {curly} braces
-     * @param parameters the object with parameters
-     * @returns the template with replaced parameters
-     * @throws {TemplateError} if parameter is not defined, not closed, or not opened
-     *
-     * @private within the createPromptbookExecutor
-     */
-    function replaceParameters(template, parameters) {
-        var replacedTemplate = template;
-        var match;
-        var loopLimit = LOOP_LIMIT;
-        var _loop_1 = function () {
-            if (loopLimit-- < 0) {
-                throw new UnexpectedError('Loop limit reached during parameters replacement in `replaceParameters`');
-            }
-            var precol = match.groups.precol;
-            var parameterName = match.groups.parameterName;
-            if (parameterName === '') {
-                return "continue";
-            }
-            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
-                throw new TemplateError('Parameter is already opened or not closed');
-            }
-            if (parameters[parameterName] === undefined) {
-                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
-            }
-            var parameterValue = parameters[parameterName];
-            if (parameterValue === undefined) {
-                throw new TemplateError("Parameter {".concat(parameterName, "} is not defined"));
-            }
-            parameterValue = parameterValue.toString();
-            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');
-            }
-            replacedTemplate =
-                replacedTemplate.substring(0, match.index + precol.length) +
-                    parameterValue +
-                    replacedTemplate.substring(match.index + precol.length + parameterName.length + 2);
-        };
-        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
-            .exec(replacedTemplate))) {
-            _loop_1();
-        }
-        // [💫] Check if there are parameters that are not closed properly
-        if (/{\w+$/.test(replacedTemplate)) {
-            throw new TemplateError('Parameter is not closed');
-        }
-        // [💫] Check if there are parameters that are not opened properly
-        if (/^\w+}/.test(replacedTemplate)) {
-            throw new TemplateError('Parameter is not opened');
-        }
-        return replacedTemplate;
-    }
-
     /**
      * Function isValidJsonString will tell you if the string is valid JSON or not
      */
@@ -1336,15 +1296,70 @@
         return normalizedName;
     }
 
-    /**
-     * Execution type describes the way how the block is executed
-     *
-     * @see https://github.com/webgptorg/promptbook#execution-type
-     */
-    var ExecutionTypes = [
-        'PROMPT_TEMPLATE',
-        'SIMPLE_TEMPLATE',
-        'SCRIPT',
+    /* tslint:disable */
+    function normalizeTo_camelCase(sentence, __firstLetterCapital) {
+        var e_1, _a;
+        if (__firstLetterCapital === void 0) { __firstLetterCapital = false; }
+        var charType;
+        var lastCharType = null;
+        var normalizedName = '';
+        try {
+            for (var sentence_1 = __values(sentence), sentence_1_1 = sentence_1.next(); !sentence_1_1.done; sentence_1_1 = sentence_1.next()) {
+                var char = sentence_1_1.value;
+                var normalizedChar = void 0;
+                if (/^[a-z]$/.test(char)) {
+                    charType = 'LOWERCASE';
+                    normalizedChar = char;
+                }
+                else if (/^[A-Z]$/.test(char)) {
+                    charType = 'UPPERCASE';
+                    normalizedChar = char.toLowerCase();
+                }
+                else if (/^[0-9]$/.test(char)) {
+                    charType = 'NUMBER';
+                    normalizedChar = char;
+                }
+                else {
+                    charType = 'OTHER';
+                    normalizedChar = '';
+                }
+                if (!lastCharType) {
+                    if (__firstLetterCapital) {
+                        normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
+                    }
+                }
+                else if (charType !== lastCharType &&
+                    !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
+                    !(lastCharType === 'NUMBER') &&
+                    !(charType === 'NUMBER')) {
+                    normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
+                }
+                normalizedName += normalizedChar;
+                lastCharType = charType;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (sentence_1_1 && !sentence_1_1.done && (_a = sentence_1.return)) _a.call(sentence_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return normalizedName;
+    }
+    /**
+     * TODO: [🌺] Use some intermediate util splitWords
+     */
+
+    /**
+     * Execution type describes the way how the block is executed
+     *
+     * @see https://github.com/webgptorg/promptbook#execution-type
+     */
+    var ExecutionTypes = [
+        'PROMPT_TEMPLATE',
+        'SIMPLE_TEMPLATE',
+        'SCRIPT',
         'PROMPT_DIALOG',
         // <- [🥻] Insert here when making new command
     ];
@@ -1816,6 +1831,9 @@
                 postprocessing = undefined;
             }
             dependentParameterNames = union(dependentParameterNames, extractParametersFromPromptTemplate(__assign(__assign({}, section), { description: description_1, executionType: executionType, content: content })));
+            if (templateModelRequirements.modelVariant === undefined) {
+                templateModelRequirements.modelVariant = 'CHAT';
+            }
             promptbookJson.promptTemplates.push({
                 name: titleToName(section.title),
                 title: section.title,
@@ -1854,6 +1872,87 @@
      * TODO: [🧠] Parameter flags - isInput, isOutput, isInternal
      */
 
+    /**
+     * Add or modify an auto-generated section in a markdown file
+     *
+     * @private within the library
+     */
+    function addAutoGeneratedSection(content, options) {
+        var sectionName = options.sectionName, sectionContent = options.sectionContent;
+        var warningLine = "<!-- \u26A0\uFE0F WARNING: This section was auto-generated -->";
+        var sectionRegex = new RegExp("<!--".concat(sectionName, "-->([\\s\\S]*?)<!--/").concat(sectionName, "-->"), 'g');
+        var sectionMatch = content.match(sectionRegex);
+        if (sectionMatch) {
+            return content.replace(sectionRegex, spaceTrim.spaceTrim(function (block) { return "\n                    <!--".concat(sectionName, "-->\n                    ").concat(block(warningLine), "\n                    ").concat(block(sectionContent), "\n                    <!--/").concat(sectionName, "-->\n                "); }));
+        }
+        var placeForSection = removeContentComments(content).match(/^##.*$/im);
+        if (!placeForSection) {
+            throw new Error("No place where to put the section <!--".concat(sectionName, "-->"));
+        }
+        var _a = __read(placeForSection, 1), heading = _a[0];
+        return content.replace(heading, "<!--".concat(sectionName, "-->\n").concat(warningLine, "\n").concat(sectionContent, "\n<!--/").concat(sectionName, "-->\n\n").concat(heading));
+    }
+
+    /**
+     * Prettify the html code
+     *
+     * @param content raw html code
+     * @returns formatted html code
+     */
+    function prettifyMarkdown(content) {
+        try {
+            return prettier.format(content, {
+                parser: 'markdown',
+                plugins: [parserHtml__default["default"]],
+                // TODO: DRY - make some import or auto-copy of .prettierrc
+                endOfLine: 'lf',
+                tabWidth: 4,
+                singleQuote: true,
+                trailingComma: 'all',
+                arrowParens: 'always',
+                printWidth: 120,
+                htmlWhitespaceSensitivity: 'ignore',
+                jsxBracketSameLine: false,
+                bracketSpacing: true,
+            });
+        }
+        catch (error) {
+            console.error('There was an error with prettifying the markdown, using the original as the fallback', {
+                error: error,
+                html: content,
+            });
+            return content;
+        }
+    }
+
+    /**
+     * Prettyfies Promptbook string and adds Mermaid graph
+     */
+    function prettifyPromptbookString(promptbookString, options) {
+        var isGraphAdded = options.isGraphAdded, isPrettifyed = options.isPrettifyed;
+        if (isGraphAdded) {
+            var promptbookJson = promptbookStringToJson(promptbookString);
+            var promptbookMermaid_1 = renderPromptbookMermaid(promptbookJson, {
+                linkPromptTemplate: function (promptTemplate) {
+                    return { href: "#".concat(promptTemplate.name), title: promptTemplate.title };
+                },
+            });
+            var promptbookMermaidBlock = spaceTrim.spaceTrim(function (block) { return "\n            ```mermaid\n            ".concat(block(promptbookMermaid_1), "\n            ```\n        "); });
+            promptbookString = addAutoGeneratedSection(promptbookString, {
+                sectionName: 'Graph',
+                sectionContent: promptbookMermaidBlock,
+            });
+        }
+        if (isPrettifyed) {
+            promptbookString = prettifyMarkdown(promptbookString);
+        }
+        return promptbookString;
+    }
+    /**
+     * TODO: Maybe use some Mermaid library instead of string templating
+     * TODO: [🕌] When more than 2 functionalities, split into separate functions
+     */
+
     /**
      * Converts promptbook in JSON format to string format
      *
@@ -2080,6 +2179,7 @@
      * @throws {PromptbookLogicError} on logical error in the promptbook
      */
     function validatePromptbookJson(promptbook) {
+        // TODO: [🧠] Maybe test if promptbook is a promise and make specific error case for that
         var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
         if (promptbook.promptbookUrl !== undefined) {
             if (!isValidUrl(promptbook.promptbookUrl)) {
@@ -2087,6 +2187,16 @@
                 throw new PromptbookLogicError("Invalid promptbook URL \"".concat(promptbook.promptbookUrl, "\""));
             }
         }
+        // TODO: [🧠] Maybe do here some propper JSON-schema / ZOD checking
+        if (!Array.isArray(promptbook.parameters)) {
+            // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
+            throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n                Promptbook is valid JSON but with wrong structure\n\n                promptbook.parameters expected to be an array, but got ".concat(typeof promptbook.parameters, "\n            ")));
+        }
+        // TODO: [🧠] Maybe do here some propper JSON-schema / ZOD checking
+        if (!Array.isArray(promptbook.promptTemplates)) {
+            // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
+            throw new PromptbookSyntaxError(spaceTrim.spaceTrim("\n              Promptbook is valid JSON but with wrong structure\n\n              promptbook.promptTemplates expected to be an array, but got ".concat(typeof promptbook.promptTemplates, "\n          ")));
+        }
         var _loop_1 = function (parameter) {
             if (parameter.isInput && parameter.isOutput) {
                 throw new PromptbookLogicError("Parameter {".concat(parameter.name, "} can not be both input and output"));
@@ -2133,9 +2243,8 @@
                 }
                 definedParameters.add(template.resultingParameterName);
                 if (template.executionType === 'PROMPT_TEMPLATE' &&
-                    (template.modelRequirements.modelVariant === undefined ||
-                        template.modelRequirements.modelName === undefined)) {
-                    throw new PromptbookLogicError(spaceTrim.spaceTrim("\n\n                  You must specify MODEL VARIANT and MODEL NAME in the prompt template \"".concat(template.title, "\"\n\n                  For example:\n                  - MODEL VARIANT Chat\n                  - MODEL NAME `gpt-4-1106-preview`\n\n              ")));
+                    (template.modelRequirements.modelVariant === undefined)) {
+                    throw new PromptbookLogicError(spaceTrim.spaceTrim("\n\n                  You must specify MODEL VARIANT in the prompt template \"".concat(template.title, "\"\n\n                  For example:\n                  - MODEL VARIANT Chat\n                  - MODEL NAME `gpt-4-1106-preview`\n\n              ")));
                 }
                 if (template.jokers && template.jokers.length > 0) {
                     if (!template.expectFormat &&
@@ -2242,6 +2351,119 @@
      *     >  ex port function validatePromptbookJson(promptbook: unknown): asserts promptbook is PromptbookJson {
      */
 
+    /**
+     * This error indicates errors during the execution of the promptbook
+     */
+    var PromptbookExecutionError = /** @class */ (function (_super) {
+        __extends(PromptbookExecutionError, _super);
+        function PromptbookExecutionError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'PromptbookExecutionError';
+            Object.setPrototypeOf(_this, PromptbookExecutionError.prototype);
+            return _this;
+        }
+        return PromptbookExecutionError;
+    }(Error));
+
+    /**
+     * Asserts that the execution of a promptnook is successful
+     *
+     * @param executionResult - The partial result of the promptnook execution
+     * @throws {PromptbookExecutionError} If the execution is not successful or if multiple errors occurred
+     */
+    function assertsExecutionSuccessful(executionResult) {
+        var isSuccessful = executionResult.isSuccessful, errors = executionResult.errors;
+        if (isSuccessful === true) {
+            return;
+        }
+        if (errors.length === 0) {
+            throw new PromptbookExecutionError("Promptnook Execution failed because of unknown reason");
+        }
+        else if (errors.length === 1) {
+            throw errors[0];
+        }
+        else {
+            throw new PromptbookExecutionError(spaceTrim.spaceTrim(function (block) { return "\n                    Multiple errors occurred during promptnook execution\n\n                    ".concat(block(errors.map(function (error) { return '- ' + error.message; }).join('\n')), "\n                "); }));
+        }
+    }
+    /**
+     * TODO: [🧠] Can this return type be better typed than void
+     */
+
+    /**
+     * This error occurs when some expectation is not met in the execution of the pipeline
+     *
+     * @private Always catched and rethrown as `PromptbookExecutionError`
+     * Note: This is a kindof subtype of PromptbookExecutionError
+     */
+    var ExpectError = /** @class */ (function (_super) {
+        __extends(ExpectError, _super);
+        function ExpectError(message) {
+            var _this = _super.call(this, message) || this;
+            _this.name = 'ExpectError';
+            Object.setPrototypeOf(_this, ExpectError.prototype);
+            return _this;
+        }
+        return ExpectError;
+    }(Error));
+
+    /**
+     * Function checkExpectations will check if the expectations on given value are met
+     *
+     * Note: There are two simmilar functions:
+     * - `checkExpectations` which throws an error if the expectations are not met
+     * - `isPassingExpectations` which returns a boolean
+     *
+     * @throws {ExpectError} if the expectations are not met
+     * @returns {void} Nothing
+     */
+    function checkExpectations(expectations, value) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(Object.entries(expectations)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), unit = _d[0], _e = _d[1], max = _e.max, min = _e.min;
+                var amount = CountUtils[unit.toUpperCase()](value);
+                if (min && amount < min) {
+                    throw new ExpectError("Expected at least ".concat(min, " ").concat(unit, " but got ").concat(amount));
+                } /* not else */
+                if (max && amount > max) {
+                    throw new ExpectError("Expected at most ".concat(max, " ").concat(unit, " but got ").concat(amount));
+                }
+            }
+        }
+        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; }
+        }
+    }
+    /**
+     * Function checkExpectations will check if the expectations on given value are met
+     *
+     * Note: There are two simmilar functions:
+     * - `checkExpectations` which throws an error if the expectations are not met
+     * - `isPassingExpectations` which returns a boolean
+     *
+     * @returns {boolean} True if the expectations are met
+     */
+    function isPassingExpectations(expectations, value) {
+        try {
+            checkExpectations(expectations, value);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof ExpectError)) {
+                throw error;
+            }
+            return false;
+        }
+    }
+    /**
+     * TODO: [💝] Unite object for expecting amount and format
+     */
+
     /**
      * Creates executor function from promptbook and execution tools.
      *
@@ -2323,7 +2545,7 @@
                                     title: currentTemplate.title,
                                     promptbookUrl: "".concat(promptbook.promptbookUrl
                                         ? promptbook.promptbookUrl
-                                        : 'anonymous' /* <- [🧠][🈴] How to deal with anonymous PROMPTBOOKs, do here some auto-url like SHA-256 based ad-hoc identifier? */, "#").concat(currentTemplate.name),
+                                        : 'anonymous' /* <- TODO: [🧠] How to deal with anonymous PROMPTBOOKs, do here some auto-url like SHA-256 based ad-hoc identifier? */, "#").concat(currentTemplate.name),
                                     parameters: parametersToPass,
                                     content: replaceParameters(currentTemplate.content, parametersToPass) /* <- [2] */,
                                     modelRequirements: currentTemplate.modelRequirements,
@@ -2762,47 +2984,178 @@
      */
 
     /**
-     * Delagates the user interaction to a async callback function
-     * You need to provide your own implementation of this callback function and its bind to UI.
+     * Multiple LLM Execution Tools is a proxy server that uses multiple execution tools internally and exposes the executor interface externally.
+     *
+     * @see https://github.com/webgptorg/promptbook#multiple-server
      */
-    var CallbackInterfaceTools = /** @class */ (function () {
-        function CallbackInterfaceTools(options) {
-            this.options = options;
+    var MultipleLlmExecutionTools = /** @class */ (function () {
+        /**
+         * Gets array of execution tools in order of priority
+         */
+        function MultipleLlmExecutionTools() {
+            var llmExecutionTools = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                llmExecutionTools[_i] = arguments[_i];
+            }
+            this.llmExecutionTools = llmExecutionTools;
         }
         /**
-         * Trigger the custom callback function
+         * Calls the best available chat model
          */
-        CallbackInterfaceTools.prototype.promptDialog = function (options) {
-            return __awaiter(this, void 0, void 0, function () {
-                var answer;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, this.options.callback(options)];
-                        case 1:
-                            answer = _a.sent();
-                            if (this.options.isVerbose) {
-                                console.info(spaceTrim.spaceTrim(function (block) { return "\n                        \uD83D\uDCD6 ".concat(block(options.promptTitle), "\n                        \uD83D\uDC64 ").concat(block(answer), "\n                    "); }));
-                            }
-                            return [2 /*return*/, answer];
-                    }
-                });
-            });
+        MultipleLlmExecutionTools.prototype.gptChat = function (prompt) {
+            return this.gptCommon(prompt);
         };
-        return CallbackInterfaceTools;
-    }());
-
-    /**
-     * Wrapper around `window.prompt` synchronous function that interacts with the user via browser prompt
-     *
-     * Warning: It is used for testing and mocking
-     *          **NOT intended to use in the production** due to its synchronous nature.
-     */
-    var SimplePromptInterfaceTools = /** @class */ (function () {
-        function SimplePromptInterfaceTools(options) {
-            this.options = options;
-        }
         /**
-         * Trigger window.PROMPT DIALOG
+         * Calls the best available completion model
+         */
+        MultipleLlmExecutionTools.prototype.gptComplete = function (prompt) {
+            return this.gptCommon(prompt);
+        };
+        /**
+         * Calls the best available model
+         */
+        MultipleLlmExecutionTools.prototype.gptCommon = function (prompt) {
+            return __awaiter(this, void 0, void 0, function () {
+                var errors, _a, _b, llmExecutionTools, error_1, e_1_1;
+                var e_1, _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            errors = [];
+                            _d.label = 1;
+                        case 1:
+                            _d.trys.push([1, 11, 12, 13]);
+                            _a = __values(this.llmExecutionTools), _b = _a.next();
+                            _d.label = 2;
+                        case 2:
+                            if (!!_b.done) return [3 /*break*/, 10];
+                            llmExecutionTools = _b.value;
+                            _d.label = 3;
+                        case 3:
+                            _d.trys.push([3, 8, , 9]);
+                            if (!(prompt.modelRequirements.modelVariant === 'CHAT')) return [3 /*break*/, 5];
+                            return [4 /*yield*/, llmExecutionTools.gptChat(prompt)];
+                        case 4: return [2 /*return*/, _d.sent()];
+                        case 5:
+                            if (!(prompt.modelRequirements.modelVariant === 'COMPLETION')) return [3 /*break*/, 7];
+                            return [4 /*yield*/, llmExecutionTools.gptComplete(prompt)];
+                        case 6: return [2 /*return*/, _d.sent()];
+                        case 7: return [3 /*break*/, 9];
+                        case 8:
+                            error_1 = _d.sent();
+                            if (!(error_1 instanceof Error)) {
+                                throw error_1;
+                            }
+                            errors.push(error_1);
+                            return [3 /*break*/, 9];
+                        case 9:
+                            _b = _a.next();
+                            return [3 /*break*/, 2];
+                        case 10: return [3 /*break*/, 13];
+                        case 11:
+                            e_1_1 = _d.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 13];
+                        case 12:
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                            return [7 /*endfinally*/];
+                        case 13: throw new Error(spaceTrim__default["default"](function (block) { return "\n                  All execution tools failed:\n                  \n                  ".concat(block(errors.map(function (error) { return "- ".concat(error.name || 'Error', ": ").concat(error.message); }).join('\n')), "\n            \n            "); }));
+                    }
+                });
+            });
+        };
+        /**
+         * List all available models that can be used
+         * This liost is a combination of all available models from all execution tools
+         */
+        MultipleLlmExecutionTools.prototype.listModels = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var availableModels, _a, _b, llmExecutionTools, models, e_2_1;
+                var e_2, _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            availableModels = [];
+                            _d.label = 1;
+                        case 1:
+                            _d.trys.push([1, 6, 7, 8]);
+                            _a = __values(this.llmExecutionTools), _b = _a.next();
+                            _d.label = 2;
+                        case 2:
+                            if (!!_b.done) return [3 /*break*/, 5];
+                            llmExecutionTools = _b.value;
+                            return [4 /*yield*/, llmExecutionTools.listModels()];
+                        case 3:
+                            models = _d.sent();
+                            availableModels.push.apply(availableModels, __spreadArray([], __read(models), false));
+                            _d.label = 4;
+                        case 4:
+                            _b = _a.next();
+                            return [3 /*break*/, 2];
+                        case 5: return [3 /*break*/, 8];
+                        case 6:
+                            e_2_1 = _d.sent();
+                            e_2 = { error: e_2_1 };
+                            return [3 /*break*/, 8];
+                        case 7:
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                            return [7 /*endfinally*/];
+                        case 8: return [2 /*return*/, availableModels];
+                    }
+                });
+            });
+        };
+        return MultipleLlmExecutionTools;
+    }());
+
+    /**
+     * Delagates the user interaction to a async callback function
+     * You need to provide your own implementation of this callback function and its bind to UI.
+     */
+    var CallbackInterfaceTools = /** @class */ (function () {
+        function CallbackInterfaceTools(options) {
+            this.options = options;
+        }
+        /**
+         * Trigger the custom callback function
+         */
+        CallbackInterfaceTools.prototype.promptDialog = function (options) {
+            return __awaiter(this, void 0, void 0, function () {
+                var answer;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.options.callback(options)];
+                        case 1:
+                            answer = _a.sent();
+                            if (this.options.isVerbose) {
+                                console.info(spaceTrim.spaceTrim(function (block) { return "\n                        \uD83D\uDCD6 ".concat(block(options.promptTitle), "\n                        \uD83D\uDC64 ").concat(block(answer), "\n                    "); }));
+                            }
+                            return [2 /*return*/, answer];
+                    }
+                });
+            });
+        };
+        return CallbackInterfaceTools;
+    }());
+
+    /**
+     * Wrapper around `window.prompt` synchronous function that interacts with the user via browser prompt
+     *
+     * Warning: It is used for testing and mocking
+     *          **NOT intended to use in the production** due to its synchronous nature.
+     */
+    var SimplePromptInterfaceTools = /** @class */ (function () {
+        function SimplePromptInterfaceTools(options) {
+            this.options = options;
+        }
+        /**
+         * Trigger window.PROMPT DIALOG
          */
         SimplePromptInterfaceTools.prototype.promptDialog = function (options) {
             return __awaiter(this, void 0, void 0, function () {
@@ -2822,6 +3175,36 @@
         return SimplePromptInterfaceTools;
     }());
 
+    /**
+     * Detects if the code is running in a browser environment in main thread (Not in a web worker)
+     */
+    new Function("\n    try {\n        return this === window;\n    } catch (e) {\n        return false;\n    }\n");
+    /**
+     * Detects if the code is running in a Node.js environment
+     */
+    var isRunningInNode = new Function("\n    try {\n        return this === global;\n    } catch (e) {\n        return false;\n    }\n");
+    /**
+     * Detects if the code is running in a web worker
+     */
+    new Function("\n    try {\n        if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {\n            return true;\n        } else {\n            return false;\n        }\n    } catch (e) {\n        return false;\n    }\n");
+
+    /**
+     * Returns the same value that is passed as argument.
+     * No side effects.
+     *
+     * Note: It can be usefull for leveling indentation
+     *
+     * @param value any values
+     * @returns the same values
+     */
+    function just(value) {
+        if (value === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return undefined;
+        }
+        return value;
+    }
+
     /**
      * This error indicates that promptbook not found in the library
      */
@@ -2879,6 +3262,12 @@
                         throw new PromptbookReferenceError(spaceTrim.spaceTrim("\n                        Promptbook with name \"".concat(promptbook.title, "\" does not have defined URL\n\n                        Note: Promptbooks without URLs are called anonymous promptbooks\n                              They can be used as standalone promptbooks, but they cannot be referenced by other promptbooks\n                              And also they cannot be used in the promptbook library\n\n                    ")));
                     }
                     validatePromptbookJson(promptbook);
+                    // Note: [🦄]
+                    if (this.library.has(promptbook.promptbookUrl) &&
+                        promptbookJsonToString(promptbook) !==
+                            promptbookJsonToString(this.library.get(promptbook.promptbookUrl))) {
+                        throw new PromptbookReferenceError(spaceTrim.spaceTrim("\n                        Promptbook with URL \"".concat(promptbook.promptbookUrl, "\" is already in the library\n\n                        Note: Promptbooks with the same URL are not allowed\n                        Note: Automatically check whether the promptbooks are the same BUT they are DIFFERENT\n\n                    ")));
+                    }
                     this.library.set(promptbook.promptbookUrl, promptbook);
                 }
             }
@@ -2905,6 +3294,9 @@
             var _this = this;
             var promptbook = this.library.get(url);
             if (!promptbook) {
+                if (this.listPromptbooks().length === 0) {
+                    throw new PromptbookNotFoundError(spaceTrim.spaceTrim("\n                            Promptbook with url \"".concat(url, "\" not found\n\n                            No promptbooks available\n                        ")));
+                }
                 throw new PromptbookNotFoundError(spaceTrim.spaceTrim(function (block) { return "\n                        Promptbook with url \"".concat(url, "\" not found\n\n                        Available promptbooks:\n                        ").concat(block(_this.listPromptbooks()
                     .map(function (promptbookUrl) { return "- ".concat(promptbookUrl); })
                     .join('\n')), "\n\n                    "); }));
@@ -2977,11 +3369,11 @@
      * Note: The function does NOT return promise it returns the library directly which waits for the sources to be resolved
      *       when error occurs in given promise or factory function, it is thrown during `listPromptbooks` or `getPromptbookByUrl` call
      *
+     * Note: Consider using  `createPromptbookLibraryFromDirectory` or `createPromptbookLibraryFromUrl`
      *
      * @param promptbookSourcesPromiseOrFactory
      * @returns PromptbookLibrary
-     *
-     * @deprecated Consider using `createPromptbookLibraryFromUrl` or `createPromptbookLibraryFromDirectory`
+     * @private Just internal tool for other constructor functions
      */
     function createPromptbookLibraryFromPromise(promptbookSourcesPromiseOrFactory) {
         var library;
@@ -3050,6 +3442,228 @@
      * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
      */
 
+    /**
+     * Constructs Promptbook from given directory
+     *
+     * Note: Works only in Node.js environment because it reads the file system
+     *
+     * @param path - path to the directory with promptbooks
+     * @param options - Misc options for the library
+     * @returns PromptbookLibrary
+     */
+    function createPromptbookLibraryFromDirectory(path, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, isRecursive, _c, isVerbose, _d, isLazyLoaded, library;
+            var _this = this;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!isRunningInNode()) {
+                            throw new Error('Function `createPromptbookLibraryFromDirectory` can only be run in Node.js environment because it reads the file system.');
+                        }
+                        _a = options || {}, _b = _a.isRecursive, isRecursive = _b === void 0 ? true : _b, _c = _a.isVerbose, isVerbose = _c === void 0 ? false : _c, _d = _a.isLazyLoaded, isLazyLoaded = _d === void 0 ? false : _d;
+                        library = createPromptbookLibraryFromPromise(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var fsPromises, readFile, fileNames, promptbooks, fileNames_1, fileNames_1_1, fileName, promptbook, promptbookString, _a, _b, e_1_1;
+                            var e_1, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        if (isVerbose) {
+                                            console.info("Creating promptbook library from path ".concat(path));
+                                        }
+                                        fsPromises = require(just('fs/promises') /* <- Note: [1] */);
+                                        readFile = fsPromises.readFile;
+                                        return [4 /*yield*/, listAllFiles(path, isRecursive)];
+                                    case 1:
+                                        fileNames = _d.sent();
+                                        if (isVerbose) {
+                                            console.info('createPromptbookLibraryFromDirectory', { path: path, isRecursive: isRecursive, fileNames: fileNames });
+                                        }
+                                        promptbooks = [];
+                                        _d.label = 2;
+                                    case 2:
+                                        _d.trys.push([2, 11, 12, 13]);
+                                        fileNames_1 = __values(fileNames), fileNames_1_1 = fileNames_1.next();
+                                        _d.label = 3;
+                                    case 3:
+                                        if (!!fileNames_1_1.done) return [3 /*break*/, 10];
+                                        fileName = fileNames_1_1.value;
+                                        promptbook = null;
+                                        if (!fileName.endsWith('.ptbk.md')) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, readFile(fileName, 'utf8')];
+                                    case 4:
+                                        promptbookString = (_d.sent());
+                                        promptbook = promptbookStringToJson(promptbookString);
+                                        return [3 /*break*/, 8];
+                                    case 5:
+                                        if (!fileName.endsWith('.ptbk.json')) return [3 /*break*/, 7];
+                                        if (isVerbose) {
+                                            console.info("Loading ".concat(fileName));
+                                        }
+                                        _b = (_a = JSON).parse;
+                                        return [4 /*yield*/, readFile(fileName, 'utf8')];
+                                    case 6:
+                                        // TODO: Handle non-valid JSON files
+                                        promptbook = _b.apply(_a, [_d.sent()]);
+                                        return [3 /*break*/, 8];
+                                    case 7:
+                                        if (isVerbose) {
+                                            console.info("Skipping file ".concat(fileName));
+                                        }
+                                        _d.label = 8;
+                                    case 8:
+                                        // ---
+                                        if (promptbook !== null) {
+                                            if (!promptbook.promptbookUrl) {
+                                                if (isVerbose) {
+                                                    console.info("Not loading ".concat(fileName, " - missing URL"));
+                                                }
+                                            }
+                                            else {
+                                                if (isVerbose) {
+                                                    console.info("Loading ".concat(fileName));
+                                                }
+                                                // Note: [🦄] Promptbook with same url uniqueness will be checked automatically in SimplePromptbookLibrary
+                                                promptbooks.push(promptbook);
+                                            }
+                                        }
+                                        _d.label = 9;
+                                    case 9:
+                                        fileNames_1_1 = fileNames_1.next();
+                                        return [3 /*break*/, 3];
+                                    case 10: return [3 /*break*/, 13];
+                                    case 11:
+                                        e_1_1 = _d.sent();
+                                        e_1 = { error: e_1_1 };
+                                        return [3 /*break*/, 13];
+                                    case 12:
+                                        try {
+                                            if (fileNames_1_1 && !fileNames_1_1.done && (_c = fileNames_1.return)) _c.call(fileNames_1);
+                                        }
+                                        finally { if (e_1) throw e_1.error; }
+                                        return [7 /*endfinally*/];
+                                    case 13: return [2 /*return*/, promptbooks];
+                                }
+                            });
+                        }); });
+                        if (!(isLazyLoaded === false)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, library.listPromptbooks()];
+                    case 1:
+                        _e.sent();
+                        _e.label = 2;
+                    case 2: return [2 /*return*/, library];
+                }
+            });
+        });
+    }
+    /**
+     * Reads all files in the directory
+     *
+     * @param path
+     * @param isRecursive
+     * @returns List of all files in the directory
+     * @private internal function for `createPromptbookLibraryFromDirectory`
+     */
+    function listAllFiles(path$1, isRecursive) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fsPromises, readdir, dirents, fileNames, _a, _b, dirent, subPath, _c, _d, _e, _f, e_2_1;
+            var e_2, _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        fsPromises = require(just('fs/promises') /* <- Note: [1] */);
+                        readdir = fsPromises.readdir;
+                        return [4 /*yield*/, readdir(path$1, {
+                                withFileTypes: true /* Note: This is not working: recursive: isRecursive */,
+                            })];
+                    case 1:
+                        dirents = _h.sent();
+                        fileNames = dirents.filter(function (dirent) { return dirent.isFile(); }).map(function (_a) {
+                            var name = _a.name;
+                            return path.join(path$1, name);
+                        });
+                        if (!isRecursive) return [3 /*break*/, 9];
+                        _h.label = 2;
+                    case 2:
+                        _h.trys.push([2, 7, 8, 9]);
+                        _a = __values(dirents.filter(function (dirent) { return dirent.isDirectory(); })), _b = _a.next();
+                        _h.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        dirent = _b.value;
+                        subPath = path.join(path$1, dirent.name);
+                        _d = (_c = fileNames.push).apply;
+                        _e = [fileNames];
+                        _f = [[]];
+                        return [4 /*yield*/, listAllFiles(subPath, isRecursive)];
+                    case 4:
+                        _d.apply(_c, _e.concat([__spreadArray.apply(void 0, _f.concat([__read.apply(void 0, [(_h.sent())]), false]))]));
+                        _h.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _h.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/, fileNames];
+                }
+            });
+        });
+    }
+    /***
+     * TODO: [🧠] Maybe do not do hacks like [1] and just create package @promptbook/node
+     *       [🍓][🚯] maybe make `@promptbook/library` package
+     * TODO: Fix the dynamic import issue in Webpack (! Not working !)
+     *     > ./node_modules/@promptbook/core/esm/index.es.js
+     *     > Critical dependency: the request of a dependency is an expression
+     *
+     * Note: [1] Using require(just('fs/promises')) to allow
+     *     the `@promptbook/core` work for both Node.js and browser environments
+     */
+
+    /**
+     * Constructs Promptbook from remote Promptbase URL
+
+     * @returns PromptbookLibrary
+     */
+    function createPromptbookLibraryFromUrl(url, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, isVerbose, _c, isLazyLoaded, library;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = options || {}, _b = _a.isVerbose, isVerbose = _b === void 0 ? false : _b, _c = _a.isLazyLoaded, isLazyLoaded = _c === void 0 ? false : _c;
+                        library = createPromptbookLibraryFromPromise(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                if (isVerbose) {
+                                    console.info("Creating promptbook library from url ".concat(url.toString()));
+                                }
+                                throw new Error('Not implemented yet');
+                            });
+                        }); });
+                        if (!(isLazyLoaded === false)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, library.listPromptbooks()];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2: return [2 /*return*/, library];
+                }
+            });
+        });
+    }
+    /***
+     * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
+     */
+
     /**
      * Creates PromptbookLibrary as a subset of another PromptbookLibrary
      *
@@ -3133,146 +3747,348 @@
      */
 
     /**
-     * Multiple LLM Execution Tools is a proxy server that uses multiple execution tools internally and exposes the executor interface externally.
+     * Just testing imports and compatibility
+     */
+    function justTestFsImport() {
+        return __awaiter(this, void 0, void 0, function () {
+            var files;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!isRunningInNode()) {
+                            throw new Error('Function `testFiles` can only be run in Node.js environment because it reads the file system.');
+                        }
+                        return [4 /*yield*/, require(just('glob-promise'))('/**/*')];
+                    case 1:
+                        files = _a.sent();
+                        console.info('testFiles', { files: files });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * TODO: !!! Remove this file
+     */
+
+    /**
+     * Format either small or big number
      *
-     * @see https://github.com/webgptorg/promptbook#multiple-server
+     * @private within the library
      */
-    var MultipleLlmExecutionTools = /** @class */ (function () {
-        /**
-         * Gets array of execution tools in order of priority
-         */
-        function MultipleLlmExecutionTools() {
-            var llmExecutionTools = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                llmExecutionTools[_i] = arguments[_i];
+    function formatNumber(value) {
+        if (value === 0) {
+            return '0';
+        }
+        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 <
+                0.001 /* <- TODO: Pass as option, pass to executionReportJsonToString as option */) {
+                return valueRounded.toFixed(exponent);
             }
-            this.llmExecutionTools = llmExecutionTools;
         }
-        /**
-         * Calls the best available chat model
-         */
-        MultipleLlmExecutionTools.prototype.gptChat = function (prompt) {
-            return this.gptCommon(prompt);
-        };
-        /**
-         * Calls the best available completion model
-         */
-        MultipleLlmExecutionTools.prototype.gptComplete = function (prompt) {
-            return this.gptCommon(prompt);
+        return value.toString();
+    }
+
+    /**
+     * Create a markdown table from a 2D array of strings
+     *
+     * @private within the library
+     */
+    function createMarkdownTable(table) {
+        var columnWidths = table.reduce(function (widths, row) {
+            row.forEach(function (cell, columnIndex) {
+                var cellLength = cell.length;
+                if (!widths[columnIndex] || cellLength > widths[columnIndex]) {
+                    widths[columnIndex] = cellLength;
+                }
+            });
+            return widths;
+        }, []);
+        var header = "| ".concat(table[0]
+            .map(function (cell, columnIndex) { return cell.padEnd(columnWidths[columnIndex]); })
+            .join(' | '), " |");
+        var separator = "|".concat(columnWidths.map(function (width) { return '-'.repeat(width + 2); }).join('|'), "|");
+        var rows = table.slice(1).map(function (row) {
+            var paddedRow = row.map(function (cell, columnIndex) {
+                return cell.padEnd(columnWidths[columnIndex]);
+            });
+            return "| ".concat(paddedRow.join(' | '), " |");
+        });
+        return __spreadArray([header, separator], __read(rows), false).join('\n');
+    }
+
+    /**
+     * Function createMarkdownChart will draw a chart in markdown from ⬛+🟦 tiles
+     *
+     * @private within the library
+     */
+    function createMarkdownChart(options) {
+        var e_1, _a;
+        var nameHeader = options.nameHeader, valueHeader = options.valueHeader, items = options.items, width = options.width, unitName = options.unitName;
+        var from = Math.min.apply(Math, __spreadArray([], __read(items.map(function (item) { return item.from; })), false));
+        var to = Math.max.apply(Math, __spreadArray([], __read(items.map(function (item) { return item.to; })), false));
+        var scale = width / (to - from);
+        var table = [[nameHeader, valueHeader]];
+        try {
+            for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
+                var item = items_1_1.value;
+                var before = Math.round((item.from - from) * scale);
+                var during = Math.round((item.to - item.from) * scale);
+                var after = width - before - during;
+                table.push([removeEmojis(item.title).trim(), '░'.repeat(before) + '█'.repeat(during) + '░'.repeat(after)]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var legend = "_Note: Each \u2588 represents ".concat(formatNumber(1 / scale), " ").concat(unitName, ", width of ").concat(valueHeader.toLowerCase(), " is ").concat(formatNumber(to - from), " ").concat(unitName, " = ").concat(width, " squares_");
+        return createMarkdownTable(table) + '\n\n' + legend;
+    }
+    /**
+     * TODO: Maybe use Mermain Gant Diagrams
+     *       @see https://jojozhuang.github.io/tutorial/mermaid-cheat-sheet/
+     */
+
+    /**
+     * Function escapeMarkdownBlock will escape markdown block if needed
+     * It is useful when you want have block in block
+     */
+    function escapeMarkdownBlock(value) {
+        return value.replace(/```/g, '\\`\\`\\`');
+    }
+
+    /**
+     * Default options for generating an execution report string
+     */
+    var ExecutionReportStringOptionsDefaults = {
+        taxRate: 0,
+        chartsWidth: 36,
+    };
+
+    /**
+     * The thresholds for the relative time in the `moment` library.
+     *
+     * @see https://momentjscom.readthedocs.io/en/latest/moment/07-customization/13-relative-time-threshold/
+     */
+    var MOMENT_ARG_THRESHOLDS = {
+        ss: 3, // <- least number of seconds to be counted in seconds, minus 1. Must be set after setting the `s` unit or without setting the `s` unit.
+    };
+
+    /**
+     * Count the duration of working time
+     *
+     * @private within the library
+     */
+    function countWorkingDuration(items) {
+        var e_1, _a;
+        var steps = Array.from(new Set(items.flatMap(function (item) { return [item.from, item.to]; })));
+        steps.sort(function (a, b) { return a - b; });
+        var intervals = steps.map(function (step, index) { return [step, steps[index + 1] || 0]; }).slice(0, -1);
+        var duration = 0;
+        var _loop_1 = function (interval) {
+            var _b = __read(interval, 2), from = _b[0], to = _b[1];
+            if (items.some(function (item) { return item.from < to && item.to > from; })) {
+                duration += to - from;
+            }
         };
-        /**
-         * Calls the best available model
-         */
-        MultipleLlmExecutionTools.prototype.gptCommon = function (prompt) {
-            return __awaiter(this, void 0, void 0, function () {
-                var errors, _a, _b, llmExecutionTools, error_1, e_1_1;
-                var e_1, _c;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            errors = [];
-                            _d.label = 1;
-                        case 1:
-                            _d.trys.push([1, 11, 12, 13]);
-                            _a = __values(this.llmExecutionTools), _b = _a.next();
-                            _d.label = 2;
-                        case 2:
-                            if (!!_b.done) return [3 /*break*/, 10];
-                            llmExecutionTools = _b.value;
-                            _d.label = 3;
-                        case 3:
-                            _d.trys.push([3, 8, , 9]);
-                            if (!(prompt.modelRequirements.modelVariant === 'CHAT')) return [3 /*break*/, 5];
-                            return [4 /*yield*/, llmExecutionTools.gptChat(prompt)];
-                        case 4: return [2 /*return*/, _d.sent()];
-                        case 5:
-                            if (!(prompt.modelRequirements.modelVariant === 'COMPLETION')) return [3 /*break*/, 7];
-                            return [4 /*yield*/, llmExecutionTools.gptComplete(prompt)];
-                        case 6: return [2 /*return*/, _d.sent()];
-                        case 7: return [3 /*break*/, 9];
-                        case 8:
-                            error_1 = _d.sent();
-                            if (!(error_1 instanceof Error)) {
-                                throw error_1;
-                            }
-                            errors.push(error_1);
-                            return [3 /*break*/, 9];
-                        case 9:
-                            _b = _a.next();
-                            return [3 /*break*/, 2];
-                        case 10: return [3 /*break*/, 13];
-                        case 11:
-                            e_1_1 = _d.sent();
-                            e_1 = { error: e_1_1 };
-                            return [3 /*break*/, 13];
-                        case 12:
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                            return [7 /*endfinally*/];
-                        case 13: throw new Error(spaceTrim__default["default"](function (block) { return "\n                  All execution tools failed:\n                  \n                  ".concat(block(errors.map(function (error) { return "- ".concat(error.name || 'Error', ": ").concat(error.message); }).join('\n')), "\n            \n            "); }));
-                    }
+        try {
+            for (var intervals_1 = __values(intervals), intervals_1_1 = intervals_1.next(); !intervals_1_1.done; intervals_1_1 = intervals_1.next()) {
+                var interval = intervals_1_1.value;
+                _loop_1(interval);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (intervals_1_1 && !intervals_1_1.done && (_a = intervals_1.return)) _a.call(intervals_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return duration;
+    }
+
+    /**
+     * Converts execution report from JSON to string format
+     */
+    function executionReportJsonToString(executionReportJson, options) {
+        var e_1, _a;
+        var _b, _c, _d, _e, _f, _g;
+        var _h = __assign(__assign({}, ExecutionReportStringOptionsDefaults), (options || {})), taxRate = _h.taxRate, chartsWidth = _h.chartsWidth;
+        var executionReportString = spaceTrim.spaceTrim(function (block) { return "\n            # ".concat(executionReportJson.title || 'Execution report', "\n\n            ").concat(block(executionReportJson.description || ''), "\n          "); });
+        var headerList = [];
+        if (executionReportJson.promptbookUrl) {
+            headerList.push("PROMPTBOOK URL ".concat(executionReportJson.promptbookUrl));
+        }
+        headerList.push("PROMPTBOOK VERSION ".concat(executionReportJson.promptbookUsedVersion) +
+            (!executionReportJson.promptbookRequestedVersion
+                ? ''
+                : " *(requested ".concat(executionReportJson.promptbookRequestedVersion, ")*")));
+        if (executionReportJson.promptExecutions.length !== 0) {
+            // TODO: What if startedAt OR/AND completedAt is not defined?
+            var startedAt = moment__default["default"](Math.min.apply(Math, __spreadArray([], __read(executionReportJson.promptExecutions
+                .filter(function (promptExecution) { var _a, _b; return (_b = (_a = promptExecution.result) === null || _a === void 0 ? void 0 : _a.timing) === null || _b === void 0 ? void 0 : _b.start; })
+                .map(function (promptExecution) { return moment__default["default"](promptExecution.result.timing.start).valueOf(); })), false)));
+            var completedAt = moment__default["default"](Math.max.apply(Math, __spreadArray([], __read(executionReportJson.promptExecutions
+                .filter(function (promptExecution) { var _a, _b; return (_b = (_a = promptExecution.result) === null || _a === void 0 ? void 0 : _a.timing) === null || _b === void 0 ? void 0 : _b.complete; })
+                .map(function (promptExecution) { return moment__default["default"](promptExecution.result.timing.complete).valueOf(); })), false)));
+            var timingItems = executionReportJson.promptExecutions.map(function (promptExecution) {
+                var _a, _b, _c, _d;
+                return ({
+                    title: promptExecution.prompt.title,
+                    from: moment__default["default"]((_b = (_a = promptExecution.result) === null || _a === void 0 ? void 0 : _a.timing) === null || _b === void 0 ? void 0 : _b.start).valueOf() / 1000,
+                    to: moment__default["default"]((_d = (_c = promptExecution.result) === null || _c === void 0 ? void 0 : _c.timing) === null || _d === void 0 ? void 0 : _d.complete).valueOf() / 1000,
                 });
             });
-        };
-        /**
-         * List all available models that can be used
-         * This liost is a combination of all available models from all execution tools
-         */
-        MultipleLlmExecutionTools.prototype.listModels = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                var availableModels, _a, _b, llmExecutionTools, models, e_2_1;
-                var e_2, _c;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            availableModels = [];
-                            _d.label = 1;
-                        case 1:
-                            _d.trys.push([1, 6, 7, 8]);
-                            _a = __values(this.llmExecutionTools), _b = _a.next();
-                            _d.label = 2;
-                        case 2:
-                            if (!!_b.done) return [3 /*break*/, 5];
-                            llmExecutionTools = _b.value;
-                            return [4 /*yield*/, llmExecutionTools.listModels()];
-                        case 3:
-                            models = _d.sent();
-                            availableModels.push.apply(availableModels, __spreadArray([], __read(models), false));
-                            _d.label = 4;
-                        case 4:
-                            _b = _a.next();
-                            return [3 /*break*/, 2];
-                        case 5: return [3 /*break*/, 8];
-                        case 6:
-                            e_2_1 = _d.sent();
-                            e_2 = { error: e_2_1 };
-                            return [3 /*break*/, 8];
-                        case 7:
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                            return [7 /*endfinally*/];
-                        case 8: return [2 /*return*/, availableModels];
-                    }
+            var costItems = executionReportJson.promptExecutions
+                .filter(function (promptExecution) { var _a, _b; return typeof ((_b = (_a = promptExecution.result) === null || _a === void 0 ? void 0 : _a.usage) === null || _b === void 0 ? void 0 : _b.price) === 'number'; })
+                .map(function (promptExecution) {
+                var _a, _b;
+                return ({
+                    title: promptExecution.prompt.title,
+                    from: 0,
+                    to: ((_b = (_a = promptExecution.result) === null || _a === void 0 ? void 0 : _a.usage) === null || _b === void 0 ? void 0 : _b.price) * (1 + taxRate),
                 });
             });
+            var duration = moment__default["default"].duration(completedAt.diff(startedAt));
+            var llmDuration = moment__default["default"].duration(countWorkingDuration(timingItems) * 1000);
+            var executionsWithKnownCost = executionReportJson.promptExecutions.filter(function (promptExecution) { var _a, _b; return (((_b = (_a = promptExecution.result) === null || _a === void 0 ? void 0 : _a.usage) === null || _b === void 0 ? void 0 : _b.price) || 'UNKNOWN') !== 'UNKNOWN'; });
+            var cost = executionsWithKnownCost.reduce(function (cost, promptExecution) { return cost + (promptExecution.result.usage.price || 0); }, 0);
+            headerList.push("STARTED AT ".concat(moment__default["default"](startedAt).format("YYYY-MM-DD HH:mm:ss")));
+            headerList.push("COMPLETED AT ".concat(moment__default["default"](completedAt).format("YYYY-MM-DD HH:mm:ss")));
+            headerList.push("TOTAL DURATION ".concat(duration.humanize(MOMENT_ARG_THRESHOLDS)));
+            headerList.push("TOTAL LLM DURATION ".concat(llmDuration.humanize(MOMENT_ARG_THRESHOLDS)));
+            headerList.push("TOTAL COST $".concat(formatNumber(cost * (1 + taxRate))) +
+                (executionsWithKnownCost.length === executionReportJson.promptExecutions.length
+                    ? ''
+                    : " *(Some cost is unknown)*") +
+                (taxRate !== 0 ? " *(with tax ".concat(taxRate * 100, "%)*") : ''));
+            executionReportString += '\n\n' + headerList.map(function (header) { return "- ".concat(header); }).join('\n');
+            executionReportString +=
+                '\n\n' +
+                    '## 🗃 Index' +
+                    '\n\n' +
+                    executionReportJson.promptExecutions
+                        .map(function (promptExecution) {
+                        // TODO: Make some better system to convert hedings to links
+                        var hash = normalizeToKebabCase(promptExecution.prompt.title);
+                        if (/^\s*\p{Extended_Pictographic}/u.test(promptExecution.prompt.title)) {
+                            hash = '-' + hash;
+                        }
+                        // TODO: Make working hash link for the template in md + pdf
+                        return "- [".concat(promptExecution.prompt.title, "](#").concat(hash, ")");
+                    })
+                        .join('\n');
+            executionReportString +=
+                '\n\n' +
+                    '## ⌚ Time chart' +
+                    '\n\n' +
+                    createMarkdownChart({
+                        nameHeader: 'Template',
+                        valueHeader: 'Timeline',
+                        items: timingItems,
+                        width: chartsWidth,
+                        unitName: 'seconds',
+                    });
+            executionReportString +=
+                '\n\n' +
+                    '## 💸 Cost chart' +
+                    '\n\n' +
+                    createMarkdownChart({
+                        nameHeader: 'Template',
+                        valueHeader: 'Cost',
+                        items: costItems,
+                        width: chartsWidth,
+                        unitName: 'USD',
+                    });
+        }
+        else {
+            headerList.push("TOTAL COST $0 *(Nothing executed)*");
+        }
+        var _loop_1 = function (promptExecution) {
+            executionReportString += '\n\n\n\n' + "## ".concat(promptExecution.prompt.title);
+            var templateList = [];
+            // TODO: What if startedAt OR/AND completedAt is not defined?
+            var startedAt = moment__default["default"]((_c = (_b = promptExecution.result) === null || _b === void 0 ? void 0 : _b.timing) === null || _c === void 0 ? void 0 : _c.start);
+            var completedAt = moment__default["default"]((_e = (_d = promptExecution.result) === null || _d === void 0 ? void 0 : _d.timing) === null || _e === void 0 ? void 0 : _e.complete);
+            var duration = moment__default["default"].duration(completedAt.diff(startedAt));
+            // Not need here:
+            // > templateList.push(`STARTED AT ${moment(startedAt).calendar()}`);
+            templateList.push("DURATION ".concat(duration.humanize(MOMENT_ARG_THRESHOLDS)));
+            if (typeof ((_g = (_f = promptExecution.result) === null || _f === void 0 ? void 0 : _f.usage) === null || _g === void 0 ? void 0 : _g.price) === 'number') {
+                templateList.push("COST $".concat(formatNumber(promptExecution.result.usage.price * (1 + taxRate))) +
+                    (taxRate !== 0 ? " *(with tax ".concat(taxRate * 100, "%)*") : ''));
+            }
+            else {
+                templateList.push("COST UNKNOWN");
+            }
+            executionReportString += '\n\n' + templateList.map(function (header) { return "- ".concat(header); }).join('\n');
+            /*
+              -   MODEL VARIANT ${promptExecution.prompt.modelRequirements.modelVariant}
+                    -   MODEL NAME \`${promptExecution.result?.model}\` (requested \`${
+                        promptExecution.prompt.modelRequirements.modelName
+
+            */
+            if (just(true)) {
+                executionReportString +=
+                    '\n\n\n\n' +
+                        spaceTrim.spaceTrim(function (block) { return "\n\n                        ### Prompt\n\n                        ```\n                        ".concat(block(escapeMarkdownBlock(promptExecution.prompt.content)), "\n                        ```\n\n                    "); });
+            }
+            if (promptExecution.result && promptExecution.result.content) {
+                executionReportString +=
+                    '\n\n\n\n' +
+                        spaceTrim.spaceTrim(function (block) { return "\n\n                        ### Result\n\n                        ```\n                        ".concat(block(escapeMarkdownBlock(promptExecution.result.content)), "\n                        ```\n                    "); });
+            }
+            if (promptExecution.error && promptExecution.error.message) {
+                executionReportString +=
+                    '\n\n\n\n' +
+                        spaceTrim.spaceTrim(function (block) { return "\n\n                        ### Error\n\n                        ```\n                        ".concat(block(escapeMarkdownBlock(promptExecution.error.message)), "\n                        ```\n\n                    "); });
+            }
         };
-        return MultipleLlmExecutionTools;
-    }());
+        try {
+            for (var _j = __values(executionReportJson.promptExecutions), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var promptExecution = _k.value;
+                _loop_1(promptExecution);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_a = _j.return)) _a.call(_j);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        executionReportString = prettifyMarkdown(executionReportString);
+        return executionReportString;
+    }
+    /**
+     * TODO: Add mermaid chart for every report
+     * TODO: [🧠] Allow to filter out some parts of the report by options
+     */
 
     exports.CallbackInterfaceTools = CallbackInterfaceTools;
+    exports.ExecutionReportStringOptionsDefaults = ExecutionReportStringOptionsDefaults;
     exports.ExecutionTypes = ExecutionTypes;
     exports.MultipleLlmExecutionTools = MultipleLlmExecutionTools;
     exports.PROMPTBOOK_VERSION = PROMPTBOOK_VERSION;
     exports.SimplePromptInterfaceTools = SimplePromptInterfaceTools;
     exports.SimplePromptbookLibrary = SimplePromptbookLibrary;
+    exports.assertsExecutionSuccessful = assertsExecutionSuccessful;
+    exports.checkExpectations = checkExpectations;
     exports.createPromptbookExecutor = createPromptbookExecutor;
-    exports.createPromptbookLibraryFromPromise = createPromptbookLibraryFromPromise;
+    exports.createPromptbookLibraryFromDirectory = createPromptbookLibraryFromDirectory;
     exports.createPromptbookLibraryFromSources = createPromptbookLibraryFromSources;
+    exports.createPromptbookLibraryFromUrl = createPromptbookLibraryFromUrl;
     exports.createPromptbookSublibrary = createPromptbookSublibrary;
+    exports.executionReportJsonToString = executionReportJsonToString;
+    exports.isPassingExpectations = isPassingExpectations;
+    exports.justTestFsImport = justTestFsImport;
+    exports.prettifyPromptbookString = prettifyPromptbookString;
     exports.promptbookJsonToString = promptbookJsonToString;
     exports.promptbookStringToJson = promptbookStringToJson;
     exports.validatePromptbookJson = validatePromptbookJson;