@promptbook/core 0.26.0 → 0.27.0-1

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) {
@@ -526,7 +542,7 @@ function parseCommand(listItem) {
             };
         }
         else {
-            throw new Error(spaceTrim(function (block) { return "\n                          Unknown model key in command:\n\n                          - ".concat(listItem, "\n\n                          Supported model keys are:\n                          ").concat(block(['variant', 'name'].join(', ')), "\n\n                          Example:\n\n                          - MODEL VARIANT Chat\n                          - MODEL NAME gpt-4\n                    "); }));
+            throw new Error(spaceTrim(function (block) { return "\n                          Unknown model key in command:\n\n                          - ".concat(listItem, "\n\n                          Supported model keys are:\n                          ").concat(block(['variant', 'name'].join(', ')), "\n\n                          Example:\n\n                          - MODEL VARIANT CHAT\n                          - MODEL NAME gpt-4\n                    "); }));
         }
     }
     else if (type.startsWith('PARAM') ||
@@ -636,7 +652,7 @@ function parseCommand(listItem) {
         }
     }
     else {
-        throw new Error(spaceTrim("\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                ")));
+        throw new Error(spaceTrim("\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                ")));
     }
 }
 
@@ -737,12 +753,12 @@ 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 postprocessing = [];
         var expectAmount = {};
         var expectFormat = undefined;
         var isExecutionTypeChanged = false;
@@ -766,7 +782,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
                         addParam(command);
                         break;
                     case 'POSTPROCESS':
-                        postprocessingCommands.push(command);
+                        postprocessing.push(command.functionName);
                         break;
                     case 'EXPECT_AMOUNT':
                         // eslint-disable-next-line no-case-declarations
@@ -803,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');
@@ -833,61 +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,
+            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()) {
@@ -908,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
  */
 
 /**
@@ -1041,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", {
         /**
@@ -1301,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.
  *
@@ -1309,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;
@@ -1330,14 +1325,21 @@ 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);
                                     title = removeEmojis(removeMarkdownFormatting(currentTemplate.title));
+                                    console.info('🛬 currentTemplate', {
+                                        currentTemplate: currentTemplate,
+                                        resultingParameter: resultingParameter,
+                                        name: name_1,
+                                        title: title,
+                                        parametersToPass: __assign({}, parametersToPass),
+                                    });
                                     if (!onProgress) return [3 /*break*/, 2];
                                     return [4 /*yield*/, onProgress({
                                             name: name_1,
@@ -1349,180 +1351,129 @@ 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];
+                                    console.info('🛬 currentTemplate attempt', attempt);
+                                    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:
+                                    console.info('🛬 currentTemplate attempt SIMPLE_TEMPLATE');
                                     resultString = replaceParameters(currentTemplate.content, parametersToPass);
-                                    return [3 /*break*/, 32];
-                                case 4:
+                                    return [3 /*break*/, 27];
+                                case 6:
+                                    console.info('🛬 currentTemplate attempt PROMPT_TEMPLATE');
                                     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];
                                         case 'COMPLETION': return [3 /*break*/, 9];
                                     }
                                     return [3 /*break*/, 11];
-                                case 7: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
+                                case 7:
+                                    console.info('🛬 currentTemplate attempt PROMPT_TEMPLATE CHAT');
+                                    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 9:
+                                    console.info('🛬 currentTemplate attempt PROMPT_TEMPLATE COMPLETION');
+                                    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:
-                                    // TODO: !!!!!! Here should postprocessing happen
-                                    if (currentTemplate.expectFormat) {
-                                        if (currentTemplate.expectFormat === 'JSON') {
-                                            if (!isValidJsonString(resultString)) {
-                                                throw new Error('Expected valid JSON string');
-                                            }
-                                        }
-                                    }
-                                    if (currentTemplate.expectAmount) {
-                                        try {
-                                            for (_e = (e_2 = void 0, __values(Object.entries(currentTemplate.expectAmount))), _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 11:
+                                    console.info('🛬 currentTemplate attempt PROMPT_TEMPLATE UNKNOWN');
+                                    throw new Error("Unknown model variant \"".concat(currentTemplate.modelRequirements.modelVariant, "\""));
+                                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:
+                                    console.info('🛬 currentTemplate attempt SCRIPT');
                                     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];
@@ -1530,19 +1481,164 @@ 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({
-                                        prompt: replaceParameters(currentTemplate.description || '', parametersToPass),
-                                        defaultValue: replaceParameters(currentTemplate.content, parametersToPass),
-                                        // TODO: [🧠] !! Figure out how to define placeholder in .ptbk.md file
-                                        placeholder: undefined,
-                                    })];
+                                case 24:
+                                    console.info('🛬 currentTemplate attempt PROMPT_DIALOG');
+                                    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 25:
+                                    resultString = _v.sent();
+                                    return [3 /*break*/, 27];
+                                case 26:
+                                    console.info('🛬 currentTemplate attempt UNKNOWN');
+                                    // 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];
+                                    console.info('🛬 currentTemplate attempt postprocessing');
+                                    _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;
+                                    console.info('🛬 currentTemplate attempt postprocessing', functionName);
+                                    // TODO: DRY [1]
+                                    scriptExecutionErrors = [];
+                                    _v.label = 30;
                                 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, "\""));
+                                    _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]);
+                                    console.info('🛬 currentTemplate attempt postprocessing', functionName, {
+                                        scriptTools: scriptTools,
+                                    });
+                                    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) {
+                                        console.info('🛬 currentTemplate attempt expectFormat');
+                                        if (currentTemplate.expectFormat === 'JSON') {
+                                            if (!isValidJsonString(resultString)) {
+                                                throw new ExpectError('Expected valid JSON string');
+                                            }
+                                        }
+                                    }
+                                    if (currentTemplate.expectAmount) {
+                                        console.info('🛬 currentTemplate attempt 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);
+                                                console.info('🛬 currentTemplate attempt expectAmount', { unit: unit, max: max, min: min, amount: amount });
+                                                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();
+                                    console.info('🛬 currentTemplate attempt catch', { error: error_4 });
+                                    if (!(error_4 instanceof ExpectError)) {
+                                        throw error_4;
+                                    }
+                                    expectError = error_4;
+                                    return [3 /*break*/, 46];
+                                case 45:
+                                    console.info('🛬 currentTemplate attempt finally', { currentTemplate: currentTemplate, result: result, expectError: expectError });
+                                    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
+                                    ) {
+                                        console.info('🛬 currentTemplate attempt finally PROMPT_TEMPLATE', { prompt: prompt_1 });
+                                        // 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) {
+                                        console.info('🛬 currentTemplate attempt fail', { attempt: attempt, maxExecutionAttempts: 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');
@@ -1558,7 +1654,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*/];
                             }