@promptbook/core 0.52.0-0 → 0.52.0-10

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';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-core"] = {}, global.spaceTrim, global.prettier, global.parserHtml, global.moment));
+})(this, (function (exports, spaceTrim, prettier, parserHtml, 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.51.0';
+    var PROMPTBOOK_VERSION = '0.52.0-9';
 
     /**
      * 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,6 +1296,61 @@
         return normalizedName;
     }
 
+    /* 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
      *
@@ -1854,6 +1869,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
      *
@@ -2183,63 +2279,176 @@
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        // Note: Detect circular dependencies
+        var resovedParameters = promptbook.parameters
+            .filter(function (_a) {
+            var isInput = _a.isInput;
+            return isInput;
+        })
+            .map(function (_a) {
+            var name = _a.name;
+            return name;
+        });
+        var unresovedTemplates = __spreadArray([], __read(promptbook.promptTemplates), false);
+        var loopLimit = LOOP_LIMIT;
+        var _loop_2 = function () {
+            if (loopLimit-- < 0) {
+                throw new UnexpectedError('Loop limit reached during detection of circular dependencies in `validatePromptbookJson`');
+            }
+            var currentlyResovedTemplates = unresovedTemplates.filter(function (template) {
+                return template.dependentParameterNames.every(function (name) { return resovedParameters.includes(name); });
+            });
+            if (currentlyResovedTemplates.length === 0) {
+                throw new PromptbookLogicError(spaceTrim.spaceTrim(function (block) { return "\n\n                        Can not resolve some parameters\n                        It may be circular dependencies\n\n                        Can not resolve:\n                        ".concat(block(unresovedTemplates
+                    .map(function (_a) {
+                    var resultingParameterName = _a.resultingParameterName, dependentParameterNames = _a.dependentParameterNames;
+                    return "- {".concat(resultingParameterName, "} depends on ").concat(dependentParameterNames
+                        .map(function (dependentParameterName) { return "{".concat(dependentParameterName, "}"); })
+                        .join(', '));
+                })
+                    .join('\n')), "\n\n                        Resolved:\n                        ").concat(block(resovedParameters.map(function (name) { return "- {".concat(name, "}"); }).join('\n')), "\n                    "); }));
+            }
+            resovedParameters = __spreadArray(__spreadArray([], __read(resovedParameters), false), __read(currentlyResovedTemplates.map(function (_a) {
+                var resultingParameterName = _a.resultingParameterName;
+                return resultingParameterName;
+            })), false);
+            unresovedTemplates = unresovedTemplates.filter(function (template) { return !currentlyResovedTemplates.includes(template); });
+        };
+        while (unresovedTemplates.length > 0) {
+            _loop_2();
+        }
+        return promptbook;
+    }
+    /**
+     * TODO: [🧠] Work with promptbookVersion
+     * TODO: Use here some json-schema, Zod or something similar and change it to:
+     *     > /**
+     *     >  * Validates PromptbookJson if it is logically valid.
+     *     >  *
+     *     >  * It checks:
+     *     >  * -   it has a valid structure
+     *     >  * -   ...
+     *     >  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 (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_1) throw e_1.error; }
         }
-        // Note: Detect circular dependencies
-        var resovedParameters = promptbook.parameters
-            .filter(function (_a) {
-            var isInput = _a.isInput;
-            return isInput;
-        })
-            .map(function (_a) {
-            var name = _a.name;
-            return name;
-        });
-        var unresovedTemplates = __spreadArray([], __read(promptbook.promptTemplates), false);
-        var loopLimit = LOOP_LIMIT;
-        var _loop_2 = function () {
-            if (loopLimit-- < 0) {
-                throw new UnexpectedError('Loop limit reached during detection of circular dependencies in `validatePromptbookJson`');
-            }
-            var currentlyResovedTemplates = unresovedTemplates.filter(function (template) {
-                return template.dependentParameterNames.every(function (name) { return resovedParameters.includes(name); });
-            });
-            if (currentlyResovedTemplates.length === 0) {
-                throw new PromptbookLogicError(spaceTrim.spaceTrim(function (block) { return "\n\n                        Can not resolve some parameters\n                        It may be circular dependencies\n\n                        Can not resolve:\n                        ".concat(block(unresovedTemplates
-                    .map(function (_a) {
-                    var resultingParameterName = _a.resultingParameterName, dependentParameterNames = _a.dependentParameterNames;
-                    return "- {".concat(resultingParameterName, "} depends on ").concat(dependentParameterNames
-                        .map(function (dependentParameterName) { return "{".concat(dependentParameterName, "}"); })
-                        .join(', '));
-                })
-                    .join('\n')), "\n\n                        Resolved:\n                        ").concat(block(resovedParameters.map(function (name) { return "- {".concat(name, "}"); }).join('\n')), "\n                    "); }));
+    }
+    /**
+     * 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;
             }
-            resovedParameters = __spreadArray(__spreadArray([], __read(resovedParameters), false), __read(currentlyResovedTemplates.map(function (_a) {
-                var resultingParameterName = _a.resultingParameterName;
-                return resultingParameterName;
-            })), false);
-            unresovedTemplates = unresovedTemplates.filter(function (template) { return !currentlyResovedTemplates.includes(template); });
-        };
-        while (unresovedTemplates.length > 0) {
-            _loop_2();
+            return false;
         }
-        return promptbook;
     }
     /**
-     * TODO: [🧠] Work with promptbookVersion
-     * TODO: Use here some json-schema, Zod or something similar and change it to:
-     *     > /**
-     *     >  * Validates PromptbookJson if it is logically valid.
-     *     >  *
-     *     >  * It checks:
-     *     >  * -   it has a valid structure
-     *     >  * -   ...
-     *     >  ex port function validatePromptbookJson(promptbook: unknown): asserts promptbook is PromptbookJson {
+     * TODO: [💝] Unite object for expecting amount and format
      */
 
     /**
@@ -2761,6 +2970,137 @@
      * TODO: [🧠][3] transparent = (report intermediate parameters) / opaque execution = (report only output parameters) progress reporting mode
      */
 
+    /**
+     * 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 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;
+        }
+        /**
+         * 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);
+        };
+        /**
+         * 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.
@@ -2822,6 +3162,19 @@
         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");
+
     /**
      * This error indicates that promptbook not found in the library
      */
@@ -3050,6 +3403,37 @@
      * 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
+     * Note: The function does NOT return promise it returns the library directly which dynamically loads promptbooks when needed
+     *       SO during the construction syntax and logic sources IS NOT validated
+     *
+     * @param path - path to the directory with promptbooks
+     * @param options - Misc options for the library
+     * @returns PromptbookLibrary
+     */
+    function createPromptbookLibraryFromDirectory(path, options) {
+        var _this = this;
+        if (!isRunningInNode()) {
+            throw new Error('Function `createPromptbookLibraryFromDirectory` can only be run in Node.js environment because it reads the file system.');
+        }
+        var _a = (options || {}).isRecursive, isRecursive = _a === void 0 ? true : _a;
+        return createPromptbookLibraryFromPromise(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                //const { readdir } = await import('fs/promises');
+                //const readdirResult = await readdir(path);
+                // TODO: !!! Implement
+                console.info('createPromptbookLibraryFromDirectory', { path: path, isRecursive: isRecursive /*, readdirResult/*/ });
+                throw new Error('Not implemented yet');
+            });
+        }); });
+    }
+    /***
+     * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
+     */
+
     /**
      * Creates PromptbookLibrary as a subset of another PromptbookLibrary
      *
@@ -3132,15 +3516,340 @@
      * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
      */
 
+    /**
+     * Format either small or big number
+     *
+     * @private within the library
+     */
+    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);
+            }
+        }
+        return value.toString();
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+            }
+        };
+        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,
+                });
+            });
+            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                    "); });
+            }
+        };
+        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.createPromptbookLibraryFromDirectory = createPromptbookLibraryFromDirectory;
     exports.createPromptbookLibraryFromPromise = createPromptbookLibraryFromPromise;
     exports.createPromptbookLibraryFromSources = createPromptbookLibraryFromSources;
     exports.createPromptbookSublibrary = createPromptbookSublibrary;
+    exports.executionReportJsonToString = executionReportJsonToString;
+    exports.isPassingExpectations = isPassingExpectations;
+    exports.prettifyPromptbookString = prettifyPromptbookString;
     exports.promptbookJsonToString = promptbookJsonToString;
     exports.promptbookStringToJson = promptbookStringToJson;
     exports.validatePromptbookJson = validatePromptbookJson;