@promptbook/core 0.23.2 → 0.24.0-1.0

package/umd/index.umd.js

@@ -349,6 +349,14 @@
      */
     var ExecutionTypes = ['PROMPT_TEMPLATE', 'SIMPLE_TEMPLATE', 'SCRIPT', 'PROMPT_DIALOG'];
 
+    /**
+     * Units of text measurement
+     */
+    var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'PARAGRAPHS', 'LINES', 'PAGES'];
+    /**
+     * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
+     */
+
     /**
      * Removes Markdown formatting tags from a string.
      *
@@ -365,10 +373,73 @@
         return str;
     }
 
+    /**
+     * Function parseNumber will parse number from string
+     *
+     * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
+     * Note: it also works only with decimal numbers
+     */
+    function parseNumber(value) {
+        var originalValue = value;
+        if (typeof value === 'number') {
+            value = value.toString(); // <- TODO: Maybe more efficient way to do this
+        }
+        if (typeof value !== 'string') {
+            return 0;
+        }
+        value = value.trim();
+        if (value.startsWith('+')) {
+            return parseNumber(value.substring(1));
+        }
+        if (value.startsWith('-')) {
+            var number = parseNumber(value.substring(1));
+            if (number === 0) {
+                return 0; // <- Note: To prevent -0
+            }
+            return -number;
+        }
+        value = value.replace(/,/g, '.');
+        value = value.toUpperCase();
+        if (value === '') {
+            return 0;
+        }
+        if (value === '♾' || value.startsWith('INF')) {
+            return Infinity;
+        }
+        if (value.includes('/')) {
+            var _a = __read(value.split('/'), 2), numerator_ = _a[0], denominator_ = _a[1];
+            var numerator = parseNumber(numerator_);
+            var denominator = parseNumber(denominator_);
+            if (denominator === 0) {
+                throw new Error("Unable to parse number from \"".concat(originalValue, "\" because denominator is zero"));
+            }
+            return numerator / denominator;
+        }
+        if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
+            return 0;
+        }
+        if (value.includes('E')) {
+            var _b = __read(value.split('E'), 2), significand = _b[0], exponent = _b[1];
+            return parseNumber(significand) * Math.pow(10, parseNumber(exponent));
+        }
+        if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
+            throw new Error("Unable to parse number from \"".concat(originalValue, "\""));
+        }
+        var num = parseFloat(value);
+        if (isNaN(num)) {
+            throw new Error("Unexpected NaN when parsing number from \"".concat(originalValue, "\""));
+        }
+        return num;
+    }
+    /**
+     * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
+     */
+
     /**
      * Parses one line of ul/ol to command
      */
     function parseCommand(listItem) {
+        var e_1, _a;
         if (listItem.includes('\n') || listItem.includes('\r')) {
             throw new Error('Command can not contain new line characters:');
         }
@@ -475,7 +546,7 @@
                 throw new Error(spaceTrim__default["default"]("\n                        Invalid parameter in command:\n\n                        - ".concat(listItem, "\n                    ")));
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            var _a = parametersMatch.groups, parameterName = _a.parameterName, parameterDescription = _a.parameterDescription;
+            var _b = parametersMatch.groups, parameterName = _b.parameterName, parameterDescription = _b.parameterDescription;
             if (parameterDescription && parameterDescription.match(/\{(?<parameterName>[a-z0-9_]+)\}/im)) {
                 throw new Error(spaceTrim__default["default"]("\n                        Parameter {".concat(parameterName, "} can not contain another parameter in description:\n\n                        - ").concat(listItem, "\n                    ")));
             }
@@ -497,6 +568,74 @@
                 functionName: functionName,
             };
         }
+        else if (type.startsWith('EXPECT')) {
+            try {
+                listItemParts.shift();
+                var sign = void 0;
+                var signRaw = listItemParts.shift();
+                if (/^exact/i.test(signRaw)) {
+                    sign = 'EXACTLY';
+                }
+                else if (/^min/i.test(signRaw)) {
+                    sign = 'MINIMUM';
+                }
+                else if (/^max/i.test(signRaw)) {
+                    sign = 'MAXIMUM';
+                }
+                else {
+                    throw new Error("Invalid sign \"".concat(signRaw, "\""));
+                }
+                var amountRaw = listItemParts.shift();
+                var amount = parseNumber(amountRaw);
+                if (amount < 0) {
+                    throw new Error('Amount must be positive number or zero');
+                }
+                if (amount !== Math.floor(amount)) {
+                    throw new Error('Amount must be whole number');
+                }
+                var unitRaw = listItemParts.shift();
+                var unit = undefined;
+                try {
+                    for (var EXPECTATION_UNITS_1 = __values(EXPECTATION_UNITS), EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next(); !EXPECTATION_UNITS_1_1.done; EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next()) {
+                        var existingUnit = EXPECTATION_UNITS_1_1.value;
+                        var existingUnitText = existingUnit;
+                        existingUnitText = existingUnitText.substring(0, existingUnitText.length - 1);
+                        if (existingUnitText === 'CHARACTER') {
+                            existingUnitText = 'CHAR';
+                        }
+                        if (new RegExp("^".concat(existingUnitText.toLowerCase())).test(unitRaw.toLowerCase()) ||
+                            new RegExp("^".concat(unitRaw.toLowerCase())).test(existingUnitText.toLowerCase())) {
+                            if (unit !== undefined) {
+                                throw new Error("Ambiguous unit \"".concat(unitRaw, "\""));
+                            }
+                            unit = existingUnit;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (EXPECTATION_UNITS_1_1 && !EXPECTATION_UNITS_1_1.done && (_a = EXPECTATION_UNITS_1.return)) _a.call(EXPECTATION_UNITS_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (unit === undefined) {
+                    throw new Error("Invalid unit \"".concat(unitRaw, "\""));
+                }
+                return {
+                    type: 'EXPECT',
+                    sign: sign,
+                    unit: unit,
+                    amount: amount,
+                };
+            }
+            catch (error) {
+                if (!(error instanceof Error)) {
+                    throw error;
+                }
+                throw new Error(spaceTrim__default["default"]("\n                  Invalid EXPECT command; ".concat(error.message, ":\n\n                  - ").concat(listItem, "\n              ")));
+            }
+        }
         else {
             throw new Error(spaceTrim__default["default"]("\n                    Unknown command:\n\n                    - ".concat(listItem, "\n\n                    Supported commands are:\n                    - Execute\n                    - Model\n                    - Parameter\n                    - Input parameter\n                    - Output parameter\n                    - PTBK Version\n                ")));
         }
@@ -605,6 +744,7 @@
             var postprocessingCommands = [];
             var listItems_3 = extractAllListItemsFromMarkdown(section.content);
             var executionType = 'PROMPT_TEMPLATE';
+            var expectations = {};
             var isExecutionTypeChanged = false;
             try {
                 for (var listItems_2 = (e_3 = void 0, __values(listItems_3)), listItems_2_1 = listItems_2.next(); !listItems_2_1.done; listItems_2_1 = listItems_2.next()) {
@@ -628,6 +768,23 @@
                         case 'POSTPROCESS':
                             postprocessingCommands.push(command);
                             break;
+                        case 'EXPECT':
+                            // eslint-disable-next-line no-case-declarations
+                            var unit = command.unit.toLowerCase();
+                            expectations[unit] = expectations[unit] || {};
+                            if (command.sign === 'MINIMUM' || command.sign === 'EXACTLY') {
+                                if (expectations[unit].min !== undefined) {
+                                    throw new Error("Already defined minumum ".concat(expectations[unit].min, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                                }
+                                expectations[unit].min = command.amount;
+                            } /* not else */
+                            if (command.sign === 'MAXIMUM' || command.sign === 'EXACTLY') {
+                                if (expectations[unit].max !== undefined) {
+                                    throw new Error("Already defined maximum ".concat(expectations[unit].max, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                                }
+                                expectations[unit].max = command.amount;
+                            }
+                            break;
                         default:
                             throw new Error("Command ".concat(command.type, " is not allowed in the block of the prompt template ONLY at the head of the prompt template pipeline"));
                     }
@@ -691,6 +848,7 @@
                 title: section.title,
                 description: description_1,
                 executionType: executionType,
+                expectations: expectations,
                 modelRequirements: templateModelRequirements,
                 contentLanguage: executionType === 'SCRIPT' ? language : undefined,
                 content: content,
@@ -824,8 +982,11 @@
      * @see https://github.com/webgptorg/promptbook#prompt-template-pipeline
      */
     var PromptTemplatePipeline = /** @class */ (function () {
-        function PromptTemplatePipeline(ptbkUrl, parameters, promptTemplates) {
+        function PromptTemplatePipeline(ptbkUrl, title, ptbkVersion, description, parameters, promptTemplates) {
             this.ptbkUrl = ptbkUrl;
+            this.title = title;
+            this.ptbkVersion = ptbkVersion;
+            this.description = description;
             this.parameters = parameters;
             this.promptTemplates = promptTemplates;
             if (promptTemplates.length === 0) {
@@ -870,7 +1031,7 @@
          */
         PromptTemplatePipeline.fromJson = function (ptbkjson) {
             validatePromptTemplatePipelineJson(ptbkjson);
-            return new PromptTemplatePipeline(ptbkjson.ptbkUrl ? new URL(ptbkjson.ptbkUrl) : null, Object.fromEntries(ptbkjson.parameters.map(function (parameter) { return [parameter.name, parameter]; })), ptbkjson.promptTemplates);
+            return new PromptTemplatePipeline(ptbkjson.ptbkUrl ? new URL(ptbkjson.ptbkUrl) : null, ptbkjson.title, ptbkjson.ptbkVersion, ptbkjson.ptbkVersion, Object.fromEntries(ptbkjson.parameters.map(function (parameter) { return [parameter.name, parameter]; })), ptbkjson.promptTemplates);
         };
         Object.defineProperty(PromptTemplatePipeline.prototype, "entryPromptTemplate", {
             /**
@@ -927,6 +1088,74 @@
      * TODO: [🧠] Each PromptTemplatePipeline should have its unique hash to be able to compare them and execute on server ONLY the desired ones
      */
 
+    /**
+     * Counts number of characters in the text
+     */
+    function countCharacters(text) {
+        // Remove null characters
+        text = text.replace(/\0/g, '');
+        // Replace emojis (and also ZWJ sequence) with hyphens
+        text = text.replace(/(\p{Emoji})\p{Modifier_Symbol}/gu, '$1');
+        text = text.replace(/(\p{Emoji})[\u{FE00}-\u{FE0F}]/gu, '$1');
+        text = text.replace(/\p{Emoji}(\u{200D}\p{Emoji})*/gu, '-');
+        return text.length;
+    }
+
+    /**
+     * Counts number of lines in the text
+     */
+    function countLines(text) {
+        if (text === '') {
+            return 0;
+        }
+        return text.split('\n').length;
+    }
+
+    /**
+     * Counts number of pages in the text
+     */
+    function countPages(text) {
+        var sentencesPerPage = 5; // Assuming each page has 5 sentences
+        var sentences = text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; });
+        var pageCount = Math.ceil(sentences.length / sentencesPerPage);
+        return pageCount;
+    }
+
+    /**
+     * Counts number of paragraphs in the text
+     */
+    function countParagraphs(text) {
+        return text.split(/\n\s*\n/).filter(function (paragraph) { return paragraph.trim() !== ''; }).length;
+    }
+
+    /**
+     * Counts number of sentences in the text
+     */
+    function countSentences(text) {
+        return text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; }).length;
+    }
+
+    /**
+     * Counts number of words in the text
+     */
+    function countWords(text) {
+        text = text.replace(/[\p{Emoji}]/gu, 'a');
+        text = n12.removeDiacritics(text);
+        return text.split(/[^a-zа-я0-9]+/i).filter(function (word) { return word.length > 0; }).length;
+    }
+
+    /**
+     * Index of all counter functions
+     */
+    var CountUtils = {
+        CHARACTERS: countCharacters,
+        WORDS: countWords,
+        SENTENCES: countSentences,
+        PARAGRAPHS: countParagraphs,
+        LINES: countLines,
+        PAGES: countPages,
+    };
+
     /**
      * All possible emoji chars like "🍆", "🍡", "🍤"...
      * Note: this will be needed to update annually - now updated at 2022-01-19
@@ -1050,19 +1279,31 @@
      */
     function createPtpExecutor(options) {
         var _this = this;
-        var ptp = options.ptp, tools = options.tools;
+        var ptp = options.ptp, tools = options.tools, settings = options.settings;
         var ptpExecutor = function (inputParameters, onProgress) { return __awaiter(_this, void 0, void 0, function () {
-            var parametersToPass, currentTemplate, _loop_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var parametersToPass, currentTemplate, executionReport, _loop_1, error_1;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         parametersToPass = inputParameters;
                         currentTemplate = ptp.entryPromptTemplate;
+                        executionReport = {
+                            ptbkUrl: ((_a = ptp.ptbkUrl) === null || _a === void 0 ? void 0 : _a.href) || undefined,
+                            title: ptp.title || undefined,
+                            ptbkUsedVersion: PTBK_VERSION,
+                            ptbkRequestedVersion: ptp.ptbkVersion || undefined,
+                            description: ptp.description || undefined,
+                            promptExecutions: [],
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 5, , 6]);
                         _loop_1 = function () {
-                            var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, promptResult, scriptExecutionErrors, isScriptExecutionSuccessful, _b, _c, _d, _e, scriptTools, error_1, e_1_1;
-                            var e_1, _f, _g;
-                            return __generator(this, function (_h) {
-                                switch (_h.label) {
+                            var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, result, resultString, naturalExecutionError, scriptExecutionErrors, isScriptExecutionSuccessful, _c, attempt, _d, _e, _f, _g, unit, _h, max, min, amount, error_2, _j, _k, scriptTools, error_3, e_1_1;
+                            var e_2, _l, e_1, _m, _o;
+                            return __generator(this, function (_p) {
+                                switch (_p.label) {
                                     case 0:
                                         resultingParameter = ptp.getResultingParameter(currentTemplate.name);
                                         name_1 = "ptp-executor-frame-".concat(currentTemplate.name);
@@ -1078,27 +1319,30 @@
                                                 parameterValue: null,
                                             })];
                                     case 1:
-                                        _h.sent();
-                                        _h.label = 2;
+                                        _p.sent();
+                                        _p.label = 2;
                                     case 2:
                                         prompt_1 = void 0;
                                         chatThread = void 0;
                                         completionResult = void 0;
-                                        promptResult = null;
+                                        result = null;
+                                        resultString = null;
+                                        naturalExecutionError = null;
                                         isScriptExecutionSuccessful = void 0;
-                                        _b = currentTemplate.executionType;
-                                        switch (_b) {
+                                        _c = currentTemplate.executionType;
+                                        switch (_c) {
                                             case 'SIMPLE_TEMPLATE': return [3 /*break*/, 3];
                                             case 'PROMPT_TEMPLATE': return [3 /*break*/, 4];
-                                            case 'SCRIPT': return [3 /*break*/, 11];
-                                            case 'PROMPT_DIALOG': return [3 /*break*/, 22];
+                                            case 'SCRIPT': return [3 /*break*/, 18];
+                                            case 'PROMPT_DIALOG': return [3 /*break*/, 29];
                                         }
-                                        return [3 /*break*/, 24];
+                                        return [3 /*break*/, 31];
                                     case 3:
-                                        promptResult = replaceParameters(currentTemplate.content, parametersToPass);
-                                        return [3 /*break*/, 25];
+                                        resultString = replaceParameters(currentTemplate.content, parametersToPass);
+                                        return [3 /*break*/, 32];
                                     case 4:
                                         prompt_1 = {
+                                            title: currentTemplate.title,
                                             ptbkUrl: "".concat(ptp.ptbkUrl
                                                 ? ptp.ptbkUrl.href
                                                 : 'anonymous' /* <- [🧠] !!!! How to deal with anonymous PTPs, do here some auto-url like SHA-256 based ad-hoc identifier? */, "#").concat(currentTemplate.name),
@@ -1106,28 +1350,88 @@
                                             content: replaceParameters(currentTemplate.content, parametersToPass),
                                             modelRequirements: currentTemplate.modelRequirements,
                                         };
-                                        _c = currentTemplate.modelRequirements.modelVariant;
-                                        switch (_c) {
-                                            case 'CHAT': return [3 /*break*/, 5];
-                                            case 'COMPLETION': return [3 /*break*/, 7];
-                                        }
-                                        return [3 /*break*/, 9];
-                                    case 5: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
+                                        attempt = 0;
+                                        _p.label = 5;
+                                    case 5:
+                                        if (!(attempt < settings.maxNaturalExecutionAttempts)) return [3 /*break*/, 17];
+                                        result = null;
+                                        resultString = null;
+                                        naturalExecutionError = null;
+                                        _p.label = 6;
                                     case 6:
-                                        chatThread = _h.sent();
-                                        // TODO: Use all information from chatThread like "model"
-                                        // TODO: [🍬] Destroy chatThread
-                                        promptResult = chatThread.content;
-                                        return [3 /*break*/, 10];
-                                    case 7: return [4 /*yield*/, tools.natural.gptComplete(prompt_1)];
+                                        _p.trys.push([6, 13, 14, 15]);
+                                        _d = currentTemplate.modelRequirements.modelVariant;
+                                        switch (_d) {
+                                            case 'CHAT': return [3 /*break*/, 7];
+                                            case 'COMPLETION': return [3 /*break*/, 9];
+                                        }
+                                        return [3 /*break*/, 11];
+                                    case 7: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
                                     case 8:
-                                        completionResult = _h.sent();
-                                        // TODO: Use all information from chatThread like "model"
-                                        promptResult = completionResult.content;
-                                        return [3 /*break*/, 10];
-                                    case 9: throw new Error("Unknown model variant \"".concat(currentTemplate.modelRequirements.modelVariant, "\""));
-                                    case 10: return [3 /*break*/, 25];
-                                    case 11:
+                                        chatThread = _p.sent();
+                                        // TODO: [🍬] Destroy chatThread
+                                        result = chatThread;
+                                        resultString = chatThread.content;
+                                        return [3 /*break*/, 12];
+                                    case 9: return [4 /*yield*/, tools.natural.gptComplete(prompt_1)];
+                                    case 10:
+                                        completionResult = _p.sent();
+                                        result = completionResult;
+                                        resultString = completionResult.content;
+                                        return [3 /*break*/, 12];
+                                    case 11: throw new Error("Unknown model variant \"".concat(currentTemplate.modelRequirements.modelVariant, "\""));
+                                    case 12:
+                                        try {
+                                            // TODO: !!!!!! Here should postprocessing happen
+                                            for (_e = (e_2 = void 0, __values(Object.entries(currentTemplate.expectations))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                                _g = __read(_f.value, 2), unit = _g[0], _h = _g[1], max = _h.max, min = _h.min;
+                                                amount = CountUtils[unit.toUpperCase()](resultString);
+                                                if (min && amount < min) {
+                                                    throw new Error("Expected at least ".concat(min, " ").concat(unit, " but got ").concat(amount));
+                                                } /* not else */
+                                                if (max && amount > max) {
+                                                    throw new Error("Expected at most ".concat(max, " ").concat(unit, " but got ").concat(amount));
+                                                }
+                                            }
+                                        }
+                                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                        finally {
+                                            try {
+                                                if (_f && !_f.done && (_l = _e.return)) _l.call(_e);
+                                            }
+                                            finally { if (e_2) throw e_2.error; }
+                                        }
+                                        return [3 /*break*/, 15];
+                                    case 13:
+                                        error_2 = _p.sent();
+                                        if (!(error_2 instanceof Error)) {
+                                            throw error_2;
+                                        }
+                                        naturalExecutionError = error_2;
+                                        return [3 /*break*/, 15];
+                                    case 14:
+                                        executionReport.promptExecutions.push({
+                                            prompt: {
+                                                title: prompt_1.title,
+                                                content: prompt_1.content,
+                                                modelRequirements: prompt_1.modelRequirements,
+                                                // <- Note: Do want to pass ONLY wanted information to the report
+                                            },
+                                            result: result /* <- !!!!! Look what is exposed here and probbably also filter out */ ||
+                                                undefined,
+                                            error: naturalExecutionError || undefined,
+                                        });
+                                        return [7 /*endfinally*/];
+                                    case 15:
+                                        if (result !== null && naturalExecutionError === null) {
+                                            return [3 /*break*/, 32];
+                                        }
+                                        _p.label = 16;
+                                    case 16:
+                                        attempt++;
+                                        return [3 /*break*/, 5];
+                                    case 17: throw new Error(spaceTrim__default["default"](function (block) { return "\n                                    Natural execution failed ".concat(settings.maxNaturalExecutionAttempts, "x\n\n                                    ").concat(block((naturalExecutionError === null || naturalExecutionError === void 0 ? void 0 : naturalExecutionError.message) || ''), "\n                                "); }));
+                                    case 18:
                                         if (tools.script.length === 0) {
                                             throw new Error('No script execution tools are available');
                                         }
@@ -1136,50 +1440,50 @@
                                         }
                                         scriptExecutionErrors = [];
                                         isScriptExecutionSuccessful = false;
-                                        _h.label = 12;
-                                    case 12:
-                                        _h.trys.push([12, 19, 20, 21]);
-                                        _d = (e_1 = void 0, __values(tools.script)), _e = _d.next();
-                                        _h.label = 13;
-                                    case 13:
-                                        if (!!_e.done) return [3 /*break*/, 18];
-                                        scriptTools = _e.value;
-                                        _h.label = 14;
-                                    case 14:
-                                        _h.trys.push([14, 16, , 17]);
+                                        _p.label = 19;
+                                    case 19:
+                                        _p.trys.push([19, 26, 27, 28]);
+                                        _j = (e_1 = void 0, __values(tools.script)), _k = _j.next();
+                                        _p.label = 20;
+                                    case 20:
+                                        if (!!_k.done) return [3 /*break*/, 25];
+                                        scriptTools = _k.value;
+                                        _p.label = 21;
+                                    case 21:
+                                        _p.trys.push([21, 23, , 24]);
                                         return [4 /*yield*/, scriptTools.execute({
                                                 scriptLanguage: currentTemplate.contentLanguage,
                                                 script: currentTemplate.content,
                                                 parameters: parametersToPass,
                                             })];
-                                    case 15:
-                                        promptResult = _h.sent();
+                                    case 22:
+                                        resultString = _p.sent();
                                         isScriptExecutionSuccessful = true;
-                                        return [3 /*break*/, 18];
-                                    case 16:
-                                        error_1 = _h.sent();
-                                        if (!(error_1 instanceof Error)) {
-                                            throw error_1;
+                                        return [3 /*break*/, 25];
+                                    case 23:
+                                        error_3 = _p.sent();
+                                        if (!(error_3 instanceof Error)) {
+                                            throw error_3;
                                         }
-                                        scriptExecutionErrors.push(error_1);
-                                        return [3 /*break*/, 17];
-                                    case 17:
-                                        _e = _d.next();
-                                        return [3 /*break*/, 13];
-                                    case 18: return [3 /*break*/, 21];
-                                    case 19:
-                                        e_1_1 = _h.sent();
+                                        scriptExecutionErrors.push(error_3);
+                                        return [3 /*break*/, 24];
+                                    case 24:
+                                        _k = _j.next();
+                                        return [3 /*break*/, 20];
+                                    case 25: return [3 /*break*/, 28];
+                                    case 26:
+                                        e_1_1 = _p.sent();
                                         e_1 = { error: e_1_1 };
-                                        return [3 /*break*/, 21];
-                                    case 20:
+                                        return [3 /*break*/, 28];
+                                    case 27:
                                         try {
-                                            if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
+                                            if (_k && !_k.done && (_m = _j.return)) _m.call(_j);
                                         }
                                         finally { if (e_1) throw e_1.error; }
                                         return [7 /*endfinally*/];
-                                    case 21:
+                                    case 28:
                                         if (isScriptExecutionSuccessful) {
-                                            return [3 /*break*/, 25];
+                                            return [3 /*break*/, 32];
                                         }
                                         if (scriptExecutionErrors.length === 1) {
                                             throw scriptExecutionErrors[0];
@@ -1187,20 +1491,20 @@
                                         else {
                                             throw new Error(spaceTrim__default["default"](function (block) { return "\n                                        Script execution failed ".concat(scriptExecutionErrors.length, " times\n\n                                        ").concat(block(scriptExecutionErrors.map(function (error) { return '- ' + error.message; }).join('\n\n')), "\n                                    "); }));
                                         }
-                                    case 22: return [4 /*yield*/, tools.userInterface.promptDialog({
+                                    case 29: return [4 /*yield*/, tools.userInterface.promptDialog({
                                             prompt: replaceParameters(currentTemplate.description || '', parametersToPass),
                                             defaultValue: replaceParameters(currentTemplate.content, parametersToPass),
                                             // TODO: [🧠] !! Figure out how to define placeholder in .ptbk.md file
                                             placeholder: undefined,
                                         })];
-                                    case 23:
-                                        promptResult = _h.sent();
-                                        return [3 /*break*/, 25];
-                                    case 24: 
+                                    case 30:
+                                        resultString = _p.sent();
+                                        return [3 /*break*/, 32];
+                                    case 31: 
                                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                     throw new Error("Unknown execution type \"".concat(currentTemplate.executionType, "\""));
-                                    case 25:
-                                        if (promptResult === null) {
+                                    case 32:
+                                        if (resultString === null) {
                                             //              <- TODO: [🥨] Make some NeverShouldHappenError
                                             throw new Error('Something went wrong and prompt result is null');
                                         }
@@ -1212,23 +1516,40 @@
                                                 isDone: true,
                                                 executionType: currentTemplate.executionType,
                                                 parameterName: resultingParameter.name,
-                                                parameterValue: promptResult,
+                                                parameterValue: resultString,
                                             });
                                         }
-                                        parametersToPass = __assign(__assign({}, parametersToPass), (_g = {}, _g[resultingParameter.name] = promptResult /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _g));
+                                        parametersToPass = __assign(__assign({}, parametersToPass), (_o = {}, _o[resultingParameter.name] = resultString /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _o));
                                         currentTemplate = ptp.getFollowingPromptTemplate(currentTemplate.name);
                                         return [2 /*return*/];
                                 }
                             });
                         };
-                        _a.label = 1;
-                    case 1:
-                        if (!(currentTemplate !== null)) return [3 /*break*/, 3];
-                        return [5 /*yield**/, _loop_1()];
+                        _b.label = 2;
                     case 2:
-                        _a.sent();
-                        return [3 /*break*/, 1];
-                    case 3: return [2 /*return*/, parametersToPass];
+                        if (!(currentTemplate !== null)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1()];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 2];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        error_1 = _b.sent();
+                        if (!(error_1 instanceof Error)) {
+                            throw error_1;
+                        }
+                        return [2 /*return*/, {
+                                isSuccessful: false,
+                                errors: [error_1],
+                                executionReport: executionReport,
+                                outputParameters: parametersToPass,
+                            }];
+                    case 6: return [2 /*return*/, {
+                            isSuccessful: true,
+                            errors: [],
+                            executionReport: executionReport,
+                            outputParameters: parametersToPass,
+                        }];
                 }
             });
         }); };
@@ -1249,8 +1570,8 @@
      * @see https://github.com/webgptorg/promptbook#prompt-template-pipeline-library
      */
     var PromptTemplatePipelineLibrary = /** @class */ (function () {
-        function PromptTemplatePipelineLibrary(promptTemplatePipelines) {
-            this.promptTemplatePipelines = promptTemplatePipelines;
+        function PromptTemplatePipelineLibrary(options) {
+            this.options = options;
         }
         /**
          * Constructs PromptTemplatePipeline from any sources
@@ -1261,13 +1582,13 @@
          * @param ptbkSources contents of .ptbk.md or .ptbk.json files
          * @returns PromptTemplatePipelineLibrary
          */
-        PromptTemplatePipelineLibrary.fromSources = function (ptbkSources) {
+        PromptTemplatePipelineLibrary.fromSources = function (ptbkSources, settings) {
             var e_1, _a;
-            var promptTemplatePipelines = {};
+            var library = {};
             try {
                 for (var _b = __values(Object.entries(ptbkSources)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var _d = __read(_c.value, 2), name_1 = _d[0], source = _d[1];
-                    promptTemplatePipelines[name_1] = PromptTemplatePipeline.fromSource(source);
+                    library[name_1] = PromptTemplatePipeline.fromSource(source);
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -1277,13 +1598,13 @@
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            return new PromptTemplatePipelineLibrary(promptTemplatePipelines);
+            return new PromptTemplatePipelineLibrary({ library: library, settings: settings });
         };
         /**
          * Gets prompt template pipeline by name
          */
         PromptTemplatePipelineLibrary.prototype.getPtp = function (name) {
-            var promptTemplatePipeline = this.promptTemplatePipelines[name];
+            var promptTemplatePipeline = this.options.library[name];
             if (!promptTemplatePipeline) {
                 throw new Error("Prompt template pipeline with name \"".concat(name, "\" not found"));
             }
@@ -1300,7 +1621,7 @@
          */
         PromptTemplatePipelineLibrary.prototype.createExecutor = function (name, tools) {
             var ptp = this.getPtp(name);
-            return createPtpExecutor({ ptp: ptp, tools: tools });
+            return createPtpExecutor({ ptp: ptp, tools: tools, settings: this.options.settings });
         };
         return PromptTemplatePipelineLibrary;
     }());