@promptbook/core 0.25.0 → 0.27.0-0

package/umd/index.umd.js

@@ -22,6 +22,22 @@
     OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
 
     var __assign = function() {
         __assign = Object.assign || function __assign(t) {
@@ -568,6 +584,12 @@
                 functionName: functionName,
             };
         }
+        else if (type.startsWith('EXPECT_JSON')) {
+            return {
+                type: 'EXPECT_FORMAT',
+                format: 'JSON',
+            };
+        }
         else if (type.startsWith('EXPECT')) {
             try {
                 listItemParts.shift();
@@ -623,7 +645,7 @@
                     throw new Error("Invalid unit \"".concat(unitRaw, "\""));
                 }
                 return {
-                    type: 'EXPECT',
+                    type: 'EXPECT_AMOUNT',
                     sign: sign,
                     unit: unit,
                     amount: amount,
@@ -738,13 +760,14 @@
             finally { if (e_1) throw e_1.error; }
         }
         var _loop_1 = function (section) {
-            var e_3, _e, e_4, _f;
+            var e_3, _e;
             // TODO: Parse prompt template description (the content out of the codeblock and lists)
             var templateModelRequirements = __assign({}, defaultModelRequirements);
-            var postprocessingCommands = [];
             var listItems_3 = extractAllListItemsFromMarkdown(section.content);
             var executionType = 'PROMPT_TEMPLATE';
-            var expectations = {};
+            var postprocessing = [];
+            var expectAmount = {};
+            var expectFormat = undefined;
             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()) {
@@ -766,24 +789,30 @@
                             addParam(command);
                             break;
                         case 'POSTPROCESS':
-                            postprocessingCommands.push(command);
+                            postprocessing.push(command.functionName);
                             break;
-                        case 'EXPECT':
+                        case 'EXPECT_AMOUNT':
                             // eslint-disable-next-line no-case-declarations
                             var unit = command.unit.toLowerCase();
-                            expectations[unit] = expectations[unit] || {};
+                            expectAmount[unit] = expectAmount[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));
+                                if (expectAmount[unit].min !== undefined) {
+                                    throw new Error("Already defined minumum ".concat(expectAmount[unit].min, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
                                 }
-                                expectations[unit].min = command.amount;
+                                expectAmount[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));
+                                if (expectAmount[unit].max !== undefined) {
+                                    throw new Error("Already defined maximum ".concat(expectAmount[unit].max, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
                                 }
-                                expectations[unit].max = command.amount;
+                                expectAmount[unit].max = command.amount;
+                            }
+                            break;
+                        case 'EXPECT_FORMAT':
+                            if (expectFormat !== undefined && command.format !== expectFormat) {
+                                throw new Error("Expect format is already defined to \"".concat(expectFormat, "\". Now you try to redefine it by \"").concat(command.format, "\"."));
                             }
+                            expectFormat = command.format;
                             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"));
@@ -797,7 +826,7 @@
                 }
                 finally { if (e_3) throw e_3.error; }
             }
-            var _g = extractOneBlockFromMarkdown(section.content), language = _g.language, content = _g.content;
+            var _f = extractOneBlockFromMarkdown(section.content), language = _f.language, content = _f.content;
             if (executionType === 'SCRIPT') {
                 if (!language) {
                     throw new Error('You must specify the language of the script in the prompt template');
@@ -827,57 +856,25 @@
             if (description_1 === '') {
                 description_1 = undefined;
             }
-            var getParameterName = function (i) {
-                var parameterName = postprocessingCommands.length <= i
-                    ? resultingParameterName
-                    : n12.normalizeTo_camelCase("".concat(resultingParameterName, " before ").concat(postprocessingCommands[i].functionName));
-                var isParameterDefined = ptbJson.parameters.some(function (parameter) { return parameter.name === parameterName; });
-                if (!isParameterDefined) {
-                    var parameterDescription = "*(".concat(n12.capitalize(section.title), " postprocessing ").concat(i + 1, "/").concat(postprocessingCommands.length, ")* {").concat(resultingParameterName, "} before `").concat(postprocessingCommands[i].functionName, "`");
-                    addParam({
-                        parameterName: parameterName,
-                        parameterDescription: parameterDescription,
-                        isInputParameter: false,
-                        // TODO:> isPrivate: true,
-                    });
-                }
-                return parameterName;
-            };
+            if (Object.keys(expectAmount).length === 0) {
+                expectAmount = undefined;
+            }
+            if (Object.keys(postprocessing).length === 0) {
+                postprocessing = undefined;
+            }
             ptbJson.promptTemplates.push({
                 name: n12.normalizeTo_PascalCase(section.title),
                 title: section.title,
                 description: description_1,
                 executionType: executionType,
-                expectations: expectations,
+                postprocessing: postprocessing,
+                expectAmount: expectAmount,
+                expectFormat: expectFormat,
                 modelRequirements: templateModelRequirements,
                 contentLanguage: executionType === 'SCRIPT' ? language : undefined,
                 content: content,
-                resultingParameterName: getParameterName(0),
+                resultingParameterName: resultingParameterName,
             });
-            try {
-                for (var _h = (e_4 = void 0, __values(postprocessingCommands.map(function (_a, i) {
-                    var functionName = _a.functionName;
-                    return [functionName, i];
-                }))), _j = _h.next(); !_j.done; _j = _h.next()) {
-                    var _k = __read(_j.value, 2), functionName = _k[0], i = _k[1];
-                    ptbJson.promptTemplates.push({
-                        name: n12.normalizeTo_PascalCase(section.title + ' Postprocessing ' + i),
-                        title: "(".concat(i + 1, "/").concat(postprocessingCommands.length, ") ").concat(section.title, " postprocessing"),
-                        description: "Postprocessing of section ".concat(section.title, " finally with resulting parameter {").concat(resultingParameterName, "}"),
-                        executionType: 'SCRIPT',
-                        contentLanguage: 'javascript',
-                        content: "".concat(functionName, "(").concat(getParameterName(i), ")"),
-                        resultingParameterName: getParameterName(i + 1),
-                    });
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (_j && !_j.done && (_f = _h.return)) _f.call(_h);
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
         };
         try {
             for (var _c = __values(markdownStructure.sections), _d = _c.next(); !_d.done; _d = _c.next()) {
@@ -898,9 +895,7 @@
     /**
      * TODO: Report here line/column of error
      * TODO: Use spaceTrim more effectively
-     * TODO: !!!! Parameter flags - isInput, isOutput, isInternal, isBeforePostprocessing, isBeforeFinal, canonicalName
-     * TODO: !!!! Allow to have non-immutable parameters - suffix them with fooPrevious3 -> fooPrevious2 -> fooPrevious1 -> foo
-     *            This must work with other technial parameters
+     * TODO: [🧠] Parameter flags - isInput, isOutput, isInternal
      */
 
     /**
@@ -1031,7 +1026,7 @@
          */
         PromptTemplatePipeline.fromJson = function (ptbkjson) {
             validatePromptTemplatePipelineJson(ptbkjson);
-            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);
+            return new PromptTemplatePipeline(ptbkjson.ptbkUrl ? new URL(ptbkjson.ptbkUrl) : null, ptbkjson.title, ptbkjson.ptbkVersion, ptbkjson.description || null, Object.fromEntries(ptbkjson.parameters.map(function (parameter) { return [parameter.name, parameter]; })), ptbkjson.promptTemplates);
         };
         Object.defineProperty(PromptTemplatePipeline.prototype, "entryPromptTemplate", {
             /**
@@ -1156,6 +1151,25 @@
         PAGES: countPages,
     };
 
+    /**
+     * Function isValidJsonString will tell you if the string is valid JSON or not
+     */
+    function isValidJsonString(value) {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            if (error.message.includes('Unexpected token')) {
+                return false;
+            }
+            return false;
+        }
+    }
+
     /**
      * All possible emoji chars like "🍆", "🍡", "🍤"...
      * Note: this will be needed to update annually - now updated at 2022-01-19
@@ -1272,6 +1286,23 @@
         return replacedTemplate;
     }
 
+    /**
+     * This error occurs when some expectation is not met in the execution of the pipeline
+     */
+    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));
+    /**
+     * TODO: [🧠] Should be this exported from the library
+     */
+
     /**
      * Creates executor function from prompt template pipeline and execution tools.
      *
@@ -1280,7 +1311,7 @@
     function createPtpExecutor(options) {
         var _this = this;
         var ptp = options.ptp, tools = options.tools, _a = options.settings, settings = _a === void 0 ? {} : _a;
-        var _b = settings.maxNaturalExecutionAttempts, maxNaturalExecutionAttempts = _b === void 0 ? 3 : _b;
+        var _b = settings.maxExecutionAttempts, maxExecutionAttempts = _b === void 0 ? 3 : _b;
         var ptpExecutor = function (inputParameters, onProgress) { return __awaiter(_this, void 0, void 0, function () {
             var parametersToPass, currentTemplate, executionReport, _loop_1, error_1;
             var _a;
@@ -1301,10 +1332,10 @@
                     case 1:
                         _b.trys.push([1, 5, , 6]);
                         _loop_1 = function () {
-                            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) {
+                            var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, result, resultString, expectError, scriptExecutionErrors, attempt, _c, _d, _e, _f, scriptTools, error_2, e_1_1, _g, _h, functionName, _j, _k, scriptTools, error_3, e_2_1, e_3_1, _l, _m, _o, unit, _p, max, min, amount, error_4;
+                            var e_1, _q, e_3, _r, e_2, _s, e_4, _t, _u;
+                            return __generator(this, function (_v) {
+                                switch (_v.label) {
                                     case 0:
                                         resultingParameter = ptp.getResultingParameter(currentTemplate.name);
                                         name_1 = "ptp-executor-frame-".concat(currentTemplate.name);
@@ -1320,47 +1351,46 @@
                                                 parameterValue: null,
                                             })];
                                     case 1:
-                                        _p.sent();
-                                        _p.label = 2;
+                                        _v.sent();
+                                        _v.label = 2;
                                     case 2:
                                         prompt_1 = void 0;
                                         chatThread = void 0;
                                         completionResult = void 0;
                                         result = null;
                                         resultString = null;
-                                        naturalExecutionError = null;
-                                        isScriptExecutionSuccessful = void 0;
+                                        expectError = null;
+                                        attempt = 0;
+                                        _v.label = 3;
+                                    case 3:
+                                        if (!(attempt < maxExecutionAttempts)) return [3 /*break*/, 48];
+                                        result = null;
+                                        resultString = null;
+                                        expectError = null;
+                                        _v.label = 4;
+                                    case 4:
+                                        _v.trys.push([4, 44, 45, 46]);
                                         _c = currentTemplate.executionType;
                                         switch (_c) {
-                                            case 'SIMPLE_TEMPLATE': return [3 /*break*/, 3];
-                                            case 'PROMPT_TEMPLATE': return [3 /*break*/, 4];
-                                            case 'SCRIPT': return [3 /*break*/, 18];
-                                            case 'PROMPT_DIALOG': return [3 /*break*/, 29];
+                                            case 'SIMPLE_TEMPLATE': return [3 /*break*/, 5];
+                                            case 'PROMPT_TEMPLATE': return [3 /*break*/, 6];
+                                            case 'SCRIPT': return [3 /*break*/, 13];
+                                            case 'PROMPT_DIALOG': return [3 /*break*/, 24];
                                         }
-                                        return [3 /*break*/, 31];
-                                    case 3:
+                                        return [3 /*break*/, 26];
+                                    case 5:
                                         resultString = replaceParameters(currentTemplate.content, parametersToPass);
-                                        return [3 /*break*/, 32];
-                                    case 4:
+                                        return [3 /*break*/, 27];
+                                    case 6:
                                         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),
+                                                : 'anonymous' /* <- [🧠] !!! How to deal with anonymous PTPs, do here some auto-url like SHA-256 based ad-hoc identifier? */, "#").concat(currentTemplate.name),
                                             parameters: parametersToPass,
-                                            content: replaceParameters(currentTemplate.content, parametersToPass),
+                                            content: replaceParameters(currentTemplate.content, parametersToPass) /* <- [2] */,
                                             modelRequirements: currentTemplate.modelRequirements,
                                         };
-                                        attempt = 0;
-                                        _p.label = 5;
-                                    case 5:
-                                        if (!(attempt < maxNaturalExecutionAttempts)) return [3 /*break*/, 17];
-                                        result = null;
-                                        resultString = null;
-                                        naturalExecutionError = null;
-                                        _p.label = 6;
-                                    case 6:
-                                        _p.trys.push([6, 13, 14, 15]);
                                         _d = currentTemplate.modelRequirements.modelVariant;
                                         switch (_d) {
                                             case 'CHAT': return [3 /*break*/, 7];
@@ -1369,122 +1399,71 @@
                                         return [3 /*break*/, 11];
                                     case 7: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
                                     case 8:
-                                        chatThread = _p.sent();
+                                        chatThread = _v.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();
+                                        completionResult = _v.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 12: return [3 /*break*/, 27];
                                     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');
                                         }
                                         if (!currentTemplate.contentLanguage) {
                                             throw new Error("Script language is not defined for prompt template \"".concat(currentTemplate.name, "\""));
                                         }
+                                        // TODO: DRY [1]
                                         scriptExecutionErrors = [];
-                                        isScriptExecutionSuccessful = false;
-                                        _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]);
+                                        _v.label = 14;
+                                    case 14:
+                                        _v.trys.push([14, 21, 22, 23]);
+                                        _e = (e_1 = void 0, __values(tools.script)), _f = _e.next();
+                                        _v.label = 15;
+                                    case 15:
+                                        if (!!_f.done) return [3 /*break*/, 20];
+                                        scriptTools = _f.value;
+                                        _v.label = 16;
+                                    case 16:
+                                        _v.trys.push([16, 18, , 19]);
                                         return [4 /*yield*/, scriptTools.execute({
                                                 scriptLanguage: currentTemplate.contentLanguage,
                                                 script: currentTemplate.content,
                                                 parameters: parametersToPass,
                                             })];
-                                    case 22:
-                                        resultString = _p.sent();
-                                        isScriptExecutionSuccessful = true;
-                                        return [3 /*break*/, 25];
-                                    case 23:
-                                        error_3 = _p.sent();
-                                        if (!(error_3 instanceof Error)) {
-                                            throw error_3;
-                                        }
-                                        scriptExecutionErrors.push(error_3);
-                                        return [3 /*break*/, 24];
-                                    case 24:
-                                        _k = _j.next();
+                                    case 17:
+                                        resultString = _v.sent();
                                         return [3 /*break*/, 20];
-                                    case 25: return [3 /*break*/, 28];
-                                    case 26:
-                                        e_1_1 = _p.sent();
+                                    case 18:
+                                        error_2 = _v.sent();
+                                        if (!(error_2 instanceof Error)) {
+                                            throw error_2;
+                                        }
+                                        scriptExecutionErrors.push(error_2);
+                                        return [3 /*break*/, 19];
+                                    case 19:
+                                        _f = _e.next();
+                                        return [3 /*break*/, 15];
+                                    case 20: return [3 /*break*/, 23];
+                                    case 21:
+                                        e_1_1 = _v.sent();
                                         e_1 = { error: e_1_1 };
-                                        return [3 /*break*/, 28];
-                                    case 27:
+                                        return [3 /*break*/, 23];
+                                    case 22:
                                         try {
-                                            if (_k && !_k.done && (_m = _j.return)) _m.call(_j);
+                                            if (_f && !_f.done && (_q = _e.return)) _q.call(_e);
                                         }
                                         finally { if (e_1) throw e_1.error; }
                                         return [7 /*endfinally*/];
-                                    case 28:
-                                        if (isScriptExecutionSuccessful) {
-                                            return [3 /*break*/, 32];
+                                    case 23:
+                                        if (resultString) {
+                                            return [3 /*break*/, 27];
                                         }
                                         if (scriptExecutionErrors.length === 1) {
                                             throw scriptExecutionErrors[0];
@@ -1492,19 +1471,149 @@
                                         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 29: return [4 /*yield*/, tools.userInterface.promptDialog({
+                                    case 24: 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 30:
-                                        resultString = _p.sent();
-                                        return [3 /*break*/, 32];
-                                    case 31: 
+                                    case 25:
+                                        resultString = _v.sent();
+                                        return [3 /*break*/, 27];
+                                    case 26: 
                                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                     throw new Error("Unknown execution type \"".concat(currentTemplate.executionType, "\""));
+                                    case 27:
+                                        if (!currentTemplate.postprocessing) return [3 /*break*/, 43];
+                                        _v.label = 28;
+                                    case 28:
+                                        _v.trys.push([28, 41, 42, 43]);
+                                        _g = (e_3 = void 0, __values(currentTemplate.postprocessing)), _h = _g.next();
+                                        _v.label = 29;
+                                    case 29:
+                                        if (!!_h.done) return [3 /*break*/, 40];
+                                        functionName = _h.value;
+                                        // TODO: DRY [1]
+                                        scriptExecutionErrors = [];
+                                        _v.label = 30;
+                                    case 30:
+                                        _v.trys.push([30, 37, 38, 39]);
+                                        _j = (e_2 = void 0, __values(tools.script)), _k = _j.next();
+                                        _v.label = 31;
+                                    case 31:
+                                        if (!!_k.done) return [3 /*break*/, 36];
+                                        scriptTools = _k.value;
+                                        _v.label = 32;
                                     case 32:
+                                        _v.trys.push([32, 34, , 35]);
+                                        return [4 /*yield*/, scriptTools.execute({
+                                                scriptLanguage: "javascript" /* <- TODO: Try it in each languages; In future allow postprocessing with arbitrary combination of languages to combine */,
+                                                script: "".concat(functionName, "(resultString)"),
+                                                parameters: __assign(__assign({}, parametersToPass), { resultString: resultString }),
+                                            })];
+                                    case 33:
+                                        resultString = _v.sent();
+                                        return [3 /*break*/, 36];
+                                    case 34:
+                                        error_3 = _v.sent();
+                                        if (!(error_3 instanceof Error)) {
+                                            throw error_3;
+                                        }
+                                        scriptExecutionErrors.push(error_3);
+                                        return [3 /*break*/, 35];
+                                    case 35:
+                                        _k = _j.next();
+                                        return [3 /*break*/, 31];
+                                    case 36: return [3 /*break*/, 39];
+                                    case 37:
+                                        e_2_1 = _v.sent();
+                                        e_2 = { error: e_2_1 };
+                                        return [3 /*break*/, 39];
+                                    case 38:
+                                        try {
+                                            if (_k && !_k.done && (_s = _j.return)) _s.call(_j);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                        return [7 /*endfinally*/];
+                                    case 39:
+                                        _h = _g.next();
+                                        return [3 /*break*/, 29];
+                                    case 40: return [3 /*break*/, 43];
+                                    case 41:
+                                        e_3_1 = _v.sent();
+                                        e_3 = { error: e_3_1 };
+                                        return [3 /*break*/, 43];
+                                    case 42:
+                                        try {
+                                            if (_h && !_h.done && (_r = _g.return)) _r.call(_g);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                        return [7 /*endfinally*/];
+                                    case 43:
+                                        if (currentTemplate.expectFormat) {
+                                            if (currentTemplate.expectFormat === 'JSON') {
+                                                if (!isValidJsonString(resultString)) {
+                                                    throw new ExpectError('Expected valid JSON string');
+                                                }
+                                            }
+                                        }
+                                        if (currentTemplate.expectAmount) {
+                                            try {
+                                                for (_l = (e_4 = void 0, __values(Object.entries(currentTemplate.expectAmount))), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                                    _o = __read(_m.value, 2), unit = _o[0], _p = _o[1], max = _p.max, min = _p.min;
+                                                    amount = CountUtils[unit.toUpperCase()](resultString);
+                                                    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_4_1) { e_4 = { error: e_4_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_m && !_m.done && (_t = _l.return)) _t.call(_l);
+                                                }
+                                                finally { if (e_4) throw e_4.error; }
+                                            }
+                                        }
+                                        return [3 /*break*/, 46];
+                                    case 44:
+                                        error_4 = _v.sent();
+                                        if (!(error_4 instanceof ExpectError)) {
+                                            throw error_4;
+                                        }
+                                        expectError = error_4;
+                                        return [3 /*break*/, 46];
+                                    case 45:
+                                        if (currentTemplate.executionType === 'PROMPT_TEMPLATE' &&
+                                            prompt_1
+                                        //    <- Note:  [2] When some expected parameter is not defined, error will occur in replaceParameters
+                                        //              In that case we don’t want to make a report about it because it’s not a natural execution error
+                                        ) {
+                                            // TODO: [🧠] Maybe put other executionTypes into report
+                                            executionReport.promptExecutions.push({
+                                                prompt: {
+                                                    title: currentTemplate.title /* <- Note: If title in promptbook contains emojis, pass it innto report */,
+                                                    content: prompt_1.content,
+                                                    modelRequirements: prompt_1.modelRequirements,
+                                                    // <- Note: Do want to pass ONLY wanted information to the report
+                                                },
+                                                result: result || undefined,
+                                                error: expectError || undefined,
+                                            });
+                                        }
+                                        return [7 /*endfinally*/];
+                                    case 46:
+                                        if (result === null && attempt === maxExecutionAttempts) {
+                                            throw new Error(spaceTrim__default["default"](function (block) { return "\n                                    Natural execution failed ".concat(settings.maxExecutionAttempts, "x\n\n                                    ").concat(block((expectError === null || expectError === void 0 ? void 0 : expectError.message) || ''), "\n                                "); }));
+                                        }
+                                        _v.label = 47;
+                                    case 47:
+                                        attempt++;
+                                        return [3 /*break*/, 3];
+                                    case 48:
                                         if (resultString === null) {
                                             //              <- TODO: [🥨] Make some NeverShouldHappenError
                                             throw new Error('Something went wrong and prompt result is null');
@@ -1520,7 +1629,7 @@
                                                 parameterValue: resultString,
                                             });
                                         }
-                                        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));
+                                        parametersToPass = __assign(__assign({}, parametersToPass), (_u = {}, _u[resultingParameter.name] = resultString /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _u));
                                         currentTemplate = ptp.getFollowingPromptTemplate(currentTemplate.name);
                                         return [2 /*return*/];
                                 }