@promptbook/core 0.25.0 → 0.27.0-0

package/esm/index.es.js

@@ -1,4 +1,4 @@
-import { capitalize, normalizeTo_SCREAMING_CASE, normalizeTo_PascalCase, normalizeTo_camelCase, removeDiacritics } from 'n12';
+import { capitalize, normalizeTo_SCREAMING_CASE, normalizeTo_PascalCase, removeDiacritics } from 'n12';
 import spaceTrim from 'spacetrim';
 
 /*! *****************************************************************************
@@ -15,6 +15,22 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
 
 var __assign = function() {
     __assign = Object.assign || function __assign(t) {
@@ -561,6 +577,12 @@ function parseCommand(listItem) {
             functionName: functionName,
         };
     }
+    else if (type.startsWith('EXPECT_JSON')) {
+        return {
+            type: 'EXPECT_FORMAT',
+            format: 'JSON',
+        };
+    }
     else if (type.startsWith('EXPECT')) {
         try {
             listItemParts.shift();
@@ -616,7 +638,7 @@ function parseCommand(listItem) {
                 throw new Error("Invalid unit \"".concat(unitRaw, "\""));
             }
             return {
-                type: 'EXPECT',
+                type: 'EXPECT_AMOUNT',
                 sign: sign,
                 unit: unit,
                 amount: amount,
@@ -731,13 +753,14 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
         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()) {
@@ -759,24 +782,30 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
                         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"));
@@ -790,7 +819,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
             }
             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');
@@ -820,57 +849,25 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
         if (description_1 === '') {
             description_1 = undefined;
         }
-        var getParameterName = function (i) {
-            var parameterName = postprocessingCommands.length <= i
-                ? resultingParameterName
-                : 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(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: 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: 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()) {
@@ -891,9 +888,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
 /**
  * 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
  */
 
 /**
@@ -1024,7 +1019,7 @@ var PromptTemplatePipeline = /** @class */ (function () {
      */
     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", {
         /**
@@ -1149,6 +1144,25 @@ var CountUtils = {
     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
@@ -1265,6 +1279,23 @@ function replaceParameters(template, parameters) {
     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.
  *
@@ -1273,7 +1304,7 @@ function replaceParameters(template, parameters) {
 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;
@@ -1294,10 +1325,10 @@ function createPtpExecutor(options) {
                 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);
@@ -1313,47 +1344,46 @@ function createPtpExecutor(options) {
                                             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];
@@ -1362,122 +1392,71 @@ function createPtpExecutor(options) {
                                     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(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];
@@ -1485,19 +1464,149 @@ function createPtpExecutor(options) {
                                     else {
                                         throw new Error(spaceTrim(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(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');
@@ -1513,7 +1622,7 @@ function createPtpExecutor(options) {
                                             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*/];
                             }