@promptbook/core 0.29.0 → 0.30.0-0

package/umd/index.umd.js

@@ -115,6 +115,16 @@
             finally { if (e) throw e.error; }
         }
         return ar;
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
     }
 
     /**
@@ -141,6 +151,35 @@
      */
     var SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
 
+    /**
+     * Parses the template and returns the list of all parameter names
+     *
+     * @param template the template with parameters in {curly} braces
+     * @returns the list of parameter names
+     */
+    function extractParameters(template) {
+        var e_1, _a;
+        var matches = template.matchAll(/{\w+}/g);
+        var parameterNames = [];
+        try {
+            for (var matches_1 = __values(matches), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
+                var match = matches_1_1.value;
+                var parameterName = match[0].slice(1, -1);
+                if (!parameterNames.includes(parameterName)) {
+                    parameterNames.push(parameterName);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (matches_1_1 && !matches_1_1.done && (_a = matches_1.return)) _a.call(matches_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return parameterNames;
+    }
+
     /**
      * Computes the deepness of the markdown structure.
      *
@@ -775,10 +814,11 @@
             finally { if (e_1) throw e_1.error; }
         }
         var _loop_1 = function (section) {
-            var e_3, _e;
+            var e_3, _e, e_4, _f;
             // TODO: Parse prompt template description (the content out of the codeblock and lists)
             var templateModelRequirements = __assign({}, defaultModelRequirements);
             var listItems_3 = extractAllListItemsFromMarkdown(section.content);
+            var dependentParameterNames = [];
             var executionType = 'PROMPT_TEMPLATE';
             var jokers = [];
             var postprocessing = [];
@@ -792,6 +832,7 @@
                     switch (command.type) {
                         case 'JOKER':
                             jokers.push(command.parameterName);
+                            dependentParameterNames.push(command.parameterName);
                             break;
                         case 'EXECUTE':
                             if (isExecutionTypeChanged) {
@@ -805,6 +846,7 @@
                             templateModelRequirements[command.key] = command.value;
                             break;
                         case 'PARAMETER':
+                            // Note: This is just for detecting resulitng parameter name
                             addParam(command);
                             break;
                         case 'POSTPROCESS':
@@ -845,7 +887,7 @@
                 }
                 finally { if (e_3) throw e_3.error; }
             }
-            var _f = extractOneBlockFromMarkdown(section.content), language = _f.language, content = _f.content;
+            var _g = extractOneBlockFromMarkdown(section.content), language = _g.language, content = _g.content;
             if (executionType === 'SCRIPT') {
                 if (!language) {
                     throw new Error('You must specify the language of the script in the prompt template');
@@ -884,10 +926,24 @@
             if (Object.keys(postprocessing).length === 0) {
                 postprocessing = undefined;
             }
+            try {
+                for (var _h = (e_4 = void 0, __values(__spreadArray(__spreadArray(__spreadArray([], __read(extractParameters(section.title)), false), __read(extractParameters(description_1 || '')), false), __read(extractParameters(content)), false))), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var parameterName = _j.value;
+                    dependentParameterNames.push(parameterName);
+                }
+            }
+            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; }
+            }
             ptbJson.promptTemplates.push({
                 name: n12.normalizeTo_PascalCase(section.title),
                 title: section.title,
                 description: description_1,
+                dependentParameterNames: dependentParameterNames,
                 executionType: executionType,
                 jokers: jokers,
                 postprocessing: postprocessing,
@@ -935,7 +991,7 @@
      * @throws {Error} if invalid
      */
     function validatePromptTemplatePipelineJson(ptp) {
-        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+        var e_1, _a, e_2, _b, e_3, _c;
         var definedParameters = new Set(ptp.parameters.filter(function (_a) {
             var isInput = _a.isInput;
             return isInput;
@@ -944,52 +1000,37 @@
             return name;
         }));
         try {
-            for (var _e = __values(ptp.promptTemplates), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var template = _f.value;
-                try {
-                    for (var _g = (e_2 = void 0, __values(Array.from(template.content.matchAll(/\{(?<parameterName>[a-z0-9_]+)\}/gi)))), _h = _g.next(); !_h.done; _h = _g.next()) {
-                        var match = _h.value;
-                        var parameterName = match.groups.parameterName;
-                        if (!definedParameters.has(parameterName)) {
-                            throw new Error("Parameter {".concat(parameterName, "} used before defined"));
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
+            // Note: Check each template individually
+            for (var _d = __values(ptp.promptTemplates), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var template = _e.value;
                 if (definedParameters.has(template.resultingParameterName)) {
                     throw new Error("Parameter {".concat(template.resultingParameterName, "} is defined multiple times"));
                 }
                 if (template.jokers && template.jokers.length > 0) {
+                    if (!template.expectFormat &&
+                        !template.expectAmount /* <- TODO: Require at least 1 -> min <- expectation to use jokers */) {
+                        throw new Error("Joker parameters are used but no expectations are defined");
+                    }
                     try {
-                        for (var _j = (e_3 = void 0, __values(template.jokers)), _k = _j.next(); !_k.done; _k = _j.next()) {
-                            var joker = _k.value;
-                            if (!definedParameters.has(joker)) {
-                                throw new Error("Joker parameter {".concat(joker, "} used before defined"));
+                        for (var _f = (e_2 = void 0, __values(template.jokers)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                            var joker = _g.value;
+                            if (!template.dependentParameterNames.includes(joker)) {
+                                throw new Error("Parameter {".concat(joker, "} is used as joker but not in dependentParameterNames"));
                             }
                         }
                     }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
                     finally {
                         try {
-                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
                         }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                    if (!template.expectFormat &&
-                        !template.expectAmount /* <- TODO: Require at least 1 -> min <- expectation to use jokers */) {
-                        throw new Error("Joker parameters are used but no expectations are defined");
+                        finally { if (e_2) throw e_2.error; }
                     }
                 }
                 if (template.expectAmount) {
                     try {
-                        for (var _l = (e_4 = void 0, __values(Object.entries(template.expectAmount))), _m = _l.next(); !_m.done; _m = _l.next()) {
-                            var _o = __read(_m.value, 2), unit = _o[0], _p = _o[1], min = _p.min, max = _p.max;
+                        for (var _h = (e_3 = void 0, __values(Object.entries(template.expectAmount))), _j = _h.next(); !_j.done; _j = _h.next()) {
+                            var _k = __read(_j.value, 2), unit = _k[0], _l = _k[1], min = _l.min, max = _l.max;
                             if (min !== undefined && max !== undefined && min > max) {
                                 throw new Error("Min expectation (=".concat(min, ") of ").concat(unit, " is higher than max expectation (=").concat(max, ")"));
                             }
@@ -1001,12 +1042,12 @@
                             }
                         }
                     }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
                     finally {
                         try {
-                            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
                         }
-                        finally { if (e_4) throw e_4.error; }
+                        finally { if (e_3) throw e_3.error; }
                     }
                 }
                 definedParameters.add(template.resultingParameterName);
@@ -1015,10 +1056,42 @@
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
             }
             finally { if (e_1) throw e_1.error; }
         }
+        // Note: Detect circular dependencies
+        var resovedParameters = ptp.parameters.filter(function (_a) {
+            var isInput = _a.isInput;
+            return isInput;
+        }).map(function (_a) {
+            var name = _a.name;
+            return name;
+        });
+        var unresovedTemplates = __spreadArray([], __read(ptp.promptTemplates), false);
+        var _loop_1 = function () {
+            var currentlyResovedTemplates = unresovedTemplates.filter(function (template) {
+                return template.dependentParameterNames.every(function (name) { return resovedParameters.includes(name); });
+            });
+            if (currentlyResovedTemplates.length === 0) {
+                throw new Error(spaceTrim__default["default"](function (block) { return "\n\n                        Can not resolve some parameters\n                        It may be circular dependencies\n\n                        Can not resolve:\n                        ".concat(block(unresovedTemplates
+                    .map(function (_a) {
+                    var resultingParameterName = _a.resultingParameterName, dependentParameterNames = _a.dependentParameterNames;
+                    return "- {".concat(resultingParameterName, "} depends on ").concat(dependentParameterNames
+                        .map(function (dependentParameterName) { return "{".concat(dependentParameterName, "}"); })
+                        .join(', '));
+                })
+                    .join('\n')), "\n\n                        Resolved:\n                        ").concat(block(resovedParameters.map(function (name) { return "- {".concat(name, "}"); }).join('\n')), "\n                    "); }));
+            }
+            resovedParameters = __spreadArray(__spreadArray([], __read(resovedParameters), false), __read(currentlyResovedTemplates.map(function (_a) {
+                var resultingParameterName = _a.resultingParameterName;
+                return resultingParameterName;
+            })), false);
+            unresovedTemplates = unresovedTemplates.filter(function (template) { return !currentlyResovedTemplates.includes(template); });
+        };
+        while (unresovedTemplates.length > 0) {
+            _loop_1();
+        }
     }
     /**
      * TODO: [🧠] Work with ptbkVersion
@@ -1032,124 +1105,6 @@
      *     >  ex port function validatePromptTemplatePipelineJson(ptp: unknown): asserts ptp is PromptTemplatePipelineJson {
      */
 
-    /**
-     * Prompt template pipeline is the **core concept of this library**.
-     * It represents a series of prompt templates chained together to form a pipeline / one big prompt template with input and result parameters.
-     *
-     * It can have 3 formats:
-     * -   **.ptbk.md file** in custom markdown format described above
-     * -   **JSON** format, parsed from the .ptbk.md file
-     * -   _(this)_ **Object** which is created from JSON format and bound with tools around (but not the execution logic)
-     *
-     * @see https://github.com/webgptorg/promptbook#prompt-template-pipeline
-     */
-    var PromptTemplatePipeline = /** @class */ (function () {
-        function PromptTemplatePipeline(ptbkUrl, title, ptbkVersion, description, parameters, promptTemplates) {
-            this.ptbkUrl = ptbkUrl;
-            this.title = title;
-            this.ptbkVersion = ptbkVersion;
-            this.description = description;
-            this.parameters = parameters;
-            this.promptTemplates = promptTemplates;
-            if (promptTemplates.length === 0) {
-                throw new Error('Prompt template pipeline must have at least one prompt template');
-            }
-        }
-        /**
-         * Constructs PromptTemplatePipeline from any source
-         *
-         * Note: During the construction syntax and logic of source is validated
-         *
-         * @param source content of .ptbk.md or .ptbk.json file
-         * @returns PromptTemplatePipeline
-         */
-        PromptTemplatePipeline.fromSource = function (ptbkSource) {
-            if (typeof ptbkSource === 'string') {
-                return PromptTemplatePipeline.fromString(ptbkSource);
-            }
-            else {
-                return PromptTemplatePipeline.fromJson(ptbkSource);
-            }
-        };
-        /**
-         * Constructs PromptTemplatePipeline from markdown source
-         *
-         * Note: During the construction syntax and logic of source is validated
-         *
-         * @param ptbkString content of .ptbk.md file
-         * @returns PromptTemplatePipeline
-         */
-        PromptTemplatePipeline.fromString = function (ptbkString) {
-            var ptbkjson = promptTemplatePipelineStringToJson(ptbkString);
-            return PromptTemplatePipeline.fromJson(ptbkjson);
-        };
-        /**
-         * Constructs PromptTemplatePipeline from JSON source
-         *
-         * Note: During the construction the source is logic validated
-         *
-         * @param ptbkjson content of .ptbk.json file parsed into JSON
-         * @returns PromptTemplatePipeline
-         */
-        PromptTemplatePipeline.fromJson = function (ptbkjson) {
-            validatePromptTemplatePipelineJson(ptbkjson);
-            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", {
-            /**
-             * Returns the first prompt template in the pipeline
-             */
-            get: function () {
-                return this.promptTemplates[0];
-            },
-            enumerable: false,
-            configurable: true
-        });
-        /**
-         * Gets the parameter that is the result of given prompt template
-         */
-        PromptTemplatePipeline.prototype.getResultingParameter = function (promptTemplateName) {
-            var index = this.promptTemplates.findIndex(function (_a) {
-                var name = _a.name;
-                return name === promptTemplateName;
-            });
-            if (index === -1) {
-                throw new Error('Prompt template is not in this pipeline');
-            }
-            var resultingParameterName = this.promptTemplates[index].resultingParameterName;
-            var resultingParameter = this.parameters[resultingParameterName];
-            if (!resultingParameter) {
-                //              <- TODO: [🥨] Make some NeverShouldHappenError
-                throw new Error("Resulting parameter of prompt template ".concat(promptTemplateName, " {").concat(resultingParameterName, "} is not defined"));
-            }
-            return resultingParameter;
-        };
-        /**
-         * Gets the following prompt template in the pipeline or null if there is no following prompt template and this is the last one
-         */
-        PromptTemplatePipeline.prototype.getFollowingPromptTemplate = function (promptTemplateName) {
-            var index = this.promptTemplates.findIndex(function (_a) {
-                var name = _a.name;
-                return name === promptTemplateName;
-            });
-            if (index === -1) {
-                throw new Error('Prompt template is not in this pipeline');
-            }
-            if (index === this.promptTemplates.length - 1) {
-                return null;
-            }
-            return this.promptTemplates[index + 1];
-        };
-        return PromptTemplatePipeline;
-    }());
-    /**
-     * TODO: !! [👐][🧠] Split of PromptTemplatePipeline,PromptTemplatePipelineLibrary between interface and class
-     * TODO: !! [👐] Make parameters and promptTemplates private WHEN split between interface and class
-     * TODO: !! Add generic type for entry and result parameters
-     * TODO: Can be Array elegantly typed such as it must have at least one element?
-     * TODO: [🧠] Each PromptTemplatePipeline should have its unique hash to be able to compare them and execute on server ONLY the desired ones
-     */
-
     /**
      * Counts number of characters in the text
      */
@@ -1342,11 +1297,11 @@
                 finally { if (e_1) throw e_1.error; }
             }
         }
-        // Check if there are parameters that are not closed properly
+        // [💫] Check if there are parameters that are not closed properly
         if (/{\w+$/.test(replacedTemplate)) {
             throw new Error('Parameter is not closed');
         }
-        // Check if there are parameters that are not opened properly
+        // [💫] Check if there are parameters that are not opened properly
         if (/^\w+}/.test(replacedTemplate)) {
             throw new Error('Parameter is not opened');
         }
@@ -1379,370 +1334,408 @@
         var _this = this;
         var ptp = options.ptp, tools = options.tools, _a = options.settings, settings = _a === void 0 ? {} : _a;
         var _b = settings.maxExecutionAttempts, maxExecutionAttempts = _b === void 0 ? 3 : _b;
+        validatePromptTemplatePipelineJson(ptp);
         var ptpExecutor = function (inputParameters, onProgress) { return __awaiter(_this, void 0, void 0, function () {
-            var parametersToPass, currentTemplate, executionReport, priority, _loop_1, error_1;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            function executeSingleTemplate(currentTemplate) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var name, title, priority, prompt, chatThread, completionResult, result, resultString, expectError, scriptExecutionErrors, maxAttempts, jokers, attempt, isJokerAttempt, joker, _a, _b, _c, _d, scriptTools, error_2, e_1_1, _e, _f, functionName, postprocessingError, _g, _h, scriptTools, error_3, e_2_1, e_3_1, _j, _k, _l, unit, _m, max, min, amount, error_4;
+                    var e_1, _o, e_3, _p, e_2, _q, e_4, _r, _s;
+                    return __generator(this, function (_t) {
+                        switch (_t.label) {
+                            case 0:
+                                console.log('!!!! executeSingleTemplate', currentTemplate.title);
+                                name = "ptp-executor-frame-".concat(currentTemplate.name);
+                                title = removeEmojis(removeMarkdownFormatting(currentTemplate.title));
+                                priority = ptp.promptTemplates.indexOf(currentTemplate);
+                                if (!onProgress) return [3 /*break*/, 2];
+                                return [4 /*yield*/, onProgress({
+                                        name: name,
+                                        title: title,
+                                        isStarted: false,
+                                        isDone: false,
+                                        executionType: currentTemplate.executionType,
+                                        parameterName: currentTemplate.resultingParameterName,
+                                        parameterValue: null,
+                                    })];
+                            case 1:
+                                _t.sent();
+                                _t.label = 2;
+                            case 2:
+                                result = null;
+                                resultString = null;
+                                expectError = null;
+                                maxAttempts = currentTemplate.executionType === 'PROMPT_DIALOG' ? Infinity : maxExecutionAttempts;
+                                jokers = currentTemplate.jokers || [];
+                                attempt = -jokers.length;
+                                _t.label = 3;
+                            case 3:
+                                if (!(attempt < maxAttempts)) return [3 /*break*/, 49];
+                                isJokerAttempt = attempt < 0;
+                                joker = jokers[jokers.length + attempt];
+                                if (isJokerAttempt && !joker) {
+                                    throw new Error("Joker not found in attempt ".concat(attempt));
+                                    //              <- TODO: [🥨] Make some NeverShouldHappenError
+                                }
+                                result = null;
+                                resultString = null;
+                                expectError = null;
+                                if (isJokerAttempt) {
+                                    if (typeof parametersToPass[joker] === 'undefined') {
+                                        throw new Error("Joker parameter {".concat(joker, "} not defined"));
+                                    }
+                                    resultString = parametersToPass[joker];
+                                }
+                                _t.label = 4;
+                            case 4:
+                                _t.trys.push([4, 45, 46, 47]);
+                                if (!!isJokerAttempt) return [3 /*break*/, 27];
+                                _a = currentTemplate.executionType;
+                                switch (_a) {
+                                    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*/, 26];
+                            case 5:
+                                resultString = replaceParameters(currentTemplate.content, parametersToPass);
+                                return [3 /*break*/, 27];
+                            case 6:
+                                prompt = {
+                                    title: currentTemplate.title,
+                                    ptbkUrl: "".concat(ptp.ptbkUrl
+                                        ? ptp.ptbkUrl
+                                        : '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) /* <- [2] */,
+                                    modelRequirements: currentTemplate.modelRequirements,
+                                };
+                                _b = currentTemplate.modelRequirements.modelVariant;
+                                switch (_b) {
+                                    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)];
+                            case 8:
+                                chatThread = _t.sent();
+                                // TODO: [🍬] Destroy chatThread
+                                result = chatThread;
+                                resultString = chatThread.content;
+                                return [3 /*break*/, 12];
+                            case 9: return [4 /*yield*/, tools.natural.gptComplete(prompt)];
+                            case 10:
+                                completionResult = _t.sent();
+                                result = completionResult;
+                                resultString = completionResult.content;
+                                return [3 /*break*/, 12];
+                            case 11: throw new Error("Unknown model variant \"".concat(currentTemplate.modelRequirements.modelVariant, "\""));
+                            case 12: return [3 /*break*/, 27];
+                            case 13:
+                                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 = [];
+                                _t.label = 14;
+                            case 14:
+                                _t.trys.push([14, 21, 22, 23]);
+                                _c = (e_1 = void 0, __values(tools.script)), _d = _c.next();
+                                _t.label = 15;
+                            case 15:
+                                if (!!_d.done) return [3 /*break*/, 20];
+                                scriptTools = _d.value;
+                                _t.label = 16;
+                            case 16:
+                                _t.trys.push([16, 18, , 19]);
+                                return [4 /*yield*/, scriptTools.execute({
+                                        scriptLanguage: currentTemplate.contentLanguage,
+                                        script: currentTemplate.content,
+                                        parameters: parametersToPass,
+                                    })];
+                            case 17:
+                                resultString = _t.sent();
+                                return [3 /*break*/, 20];
+                            case 18:
+                                error_2 = _t.sent();
+                                if (!(error_2 instanceof Error)) {
+                                    throw error_2;
+                                }
+                                scriptExecutionErrors.push(error_2);
+                                return [3 /*break*/, 19];
+                            case 19:
+                                _d = _c.next();
+                                return [3 /*break*/, 15];
+                            case 20: return [3 /*break*/, 23];
+                            case 21:
+                                e_1_1 = _t.sent();
+                                e_1 = { error: e_1_1 };
+                                return [3 /*break*/, 23];
+                            case 22:
+                                try {
+                                    if (_d && !_d.done && (_o = _c.return)) _o.call(_c);
+                                }
+                                finally { if (e_1) throw e_1.error; }
+                                return [7 /*endfinally*/];
+                            case 23:
+                                if (resultString) {
+                                    return [3 /*break*/, 27];
+                                }
+                                if (scriptExecutionErrors.length === 1) {
+                                    throw scriptExecutionErrors[0];
+                                }
+                                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 24: return [4 /*yield*/, tools.userInterface.promptDialog({
+                                    promptTitle: currentTemplate.title,
+                                    promptMessage: replaceParameters(currentTemplate.description || '', parametersToPass),
+                                    defaultValue: replaceParameters(currentTemplate.content, parametersToPass),
+                                    // TODO: [🧠] !! Figure out how to define placeholder in .ptbk.md file
+                                    placeholder: undefined,
+                                    priority: priority /* <- TODO: !!!! Is it ending with 0 */,
+                                })];
+                            case 25:
+                                // TODO: !!!! When making next attempt for `PROMPT DIALOG`, preserve the previous user input
+                                resultString = _t.sent();
+                                return [3 /*break*/, 27];
+                            case 26: throw new Error(
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            "Unknown execution type \"".concat(currentTemplate.executionType, "\""));
+                            case 27:
+                                if (!(!isJokerAttempt && currentTemplate.postprocessing)) return [3 /*break*/, 44];
+                                _t.label = 28;
+                            case 28:
+                                _t.trys.push([28, 42, 43, 44]);
+                                _e = (e_3 = void 0, __values(currentTemplate.postprocessing)), _f = _e.next();
+                                _t.label = 29;
+                            case 29:
+                                if (!!_f.done) return [3 /*break*/, 41];
+                                functionName = _f.value;
+                                // TODO: DRY [1]
+                                scriptExecutionErrors = [];
+                                postprocessingError = null;
+                                _t.label = 30;
+                            case 30:
+                                _t.trys.push([30, 37, 38, 39]);
+                                _g = (e_2 = void 0, __values(tools.script)), _h = _g.next();
+                                _t.label = 31;
+                            case 31:
+                                if (!!_h.done) return [3 /*break*/, 36];
+                                scriptTools = _h.value;
+                                _t.label = 32;
+                            case 32:
+                                _t.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 = _t.sent();
+                                postprocessingError = null;
+                                return [3 /*break*/, 36];
+                            case 34:
+                                error_3 = _t.sent();
+                                if (!(error_3 instanceof Error)) {
+                                    throw error_3;
+                                }
+                                postprocessingError = error_3;
+                                scriptExecutionErrors.push(error_3);
+                                return [3 /*break*/, 35];
+                            case 35:
+                                _h = _g.next();
+                                return [3 /*break*/, 31];
+                            case 36: return [3 /*break*/, 39];
+                            case 37:
+                                e_2_1 = _t.sent();
+                                e_2 = { error: e_2_1 };
+                                return [3 /*break*/, 39];
+                            case 38:
+                                try {
+                                    if (_h && !_h.done && (_q = _g.return)) _q.call(_g);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                                return [7 /*endfinally*/];
+                            case 39:
+                                if (postprocessingError) {
+                                    throw postprocessingError;
+                                }
+                                _t.label = 40;
+                            case 40:
+                                _f = _e.next();
+                                return [3 /*break*/, 29];
+                            case 41: return [3 /*break*/, 44];
+                            case 42:
+                                e_3_1 = _t.sent();
+                                e_3 = { error: e_3_1 };
+                                return [3 /*break*/, 44];
+                            case 43:
+                                try {
+                                    if (_f && !_f.done && (_p = _e.return)) _p.call(_e);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                                return [7 /*endfinally*/];
+                            case 44:
+                                if (currentTemplate.expectFormat) {
+                                    if (currentTemplate.expectFormat === 'JSON') {
+                                        if (!isValidJsonString(resultString || '')) {
+                                            throw new ExpectError('Expected valid JSON string');
+                                        }
+                                    }
+                                }
+                                if (currentTemplate.expectAmount) {
+                                    try {
+                                        for (_j = (e_4 = void 0, __values(Object.entries(currentTemplate.expectAmount))), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                            _l = __read(_k.value, 2), unit = _l[0], _m = _l[1], max = _m.max, min = _m.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 (_k && !_k.done && (_r = _j.return)) _r.call(_j);
+                                        }
+                                        finally { if (e_4) throw e_4.error; }
+                                    }
+                                }
+                                return [3 /*break*/, 49];
+                            case 45:
+                                error_4 = _t.sent();
+                                if (!(error_4 instanceof ExpectError)) {
+                                    throw error_4;
+                                }
+                                expectError = error_4;
+                                return [3 /*break*/, 47];
+                            case 46:
+                                if (!isJokerAttempt &&
+                                    currentTemplate.executionType === 'PROMPT_TEMPLATE' &&
+                                    prompt
+                                //    <- 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.content,
+                                            modelRequirements: prompt.modelRequirements,
+                                            // <- Note: Do want to pass ONLY wanted information to the report
+                                        },
+                                        result: result || undefined,
+                                        error: expectError || undefined,
+                                    });
+                                }
+                                return [7 /*endfinally*/];
+                            case 47:
+                                if (expectError !== null && attempt === maxAttempts - 1) {
+                                    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                          "); }));
+                                }
+                                _t.label = 48;
+                            case 48:
+                                attempt++;
+                                return [3 /*break*/, 3];
+                            case 49:
+                                if (resultString === null) {
+                                    //              <- TODO: [🥨] Make some NeverShouldHappenError
+                                    throw new Error('Something went wrong and prompt result is null');
+                                }
+                                if (onProgress) {
+                                    onProgress({
+                                        name: name,
+                                        title: title,
+                                        isStarted: true,
+                                        isDone: true,
+                                        executionType: currentTemplate.executionType,
+                                        parameterName: currentTemplate.resultingParameterName,
+                                        parameterValue: resultString,
+                                    });
+                                }
+                                parametersToPass = __assign(__assign({}, parametersToPass), (_s = {}, _s[currentTemplate.resultingParameterName] = resultString /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _s));
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            }
+            var parametersToPass, executionReport, resovedParameters_1, unresovedTemplates, works_1, _loop_1, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         parametersToPass = inputParameters;
-                        currentTemplate = ptp.entryPromptTemplate;
                         executionReport = {
-                            ptbkUrl: ((_a = ptp.ptbkUrl) === null || _a === void 0 ? void 0 : _a.href) || undefined,
-                            title: ptp.title || undefined,
+                            ptbkUrl: ptp.ptbkUrl,
+                            title: ptp.title,
                             ptbkUsedVersion: PTBK_VERSION,
-                            ptbkRequestedVersion: ptp.ptbkVersion || undefined,
-                            description: ptp.description || undefined,
+                            ptbkRequestedVersion: ptp.ptbkVersion,
+                            description: ptp.description,
                             promptExecutions: [],
                         };
-                        priority = ptp.promptTemplates.length;
-                        _b.label = 1;
+                        _a.label = 1;
                     case 1:
-                        _b.trys.push([1, 5, , 6]);
+                        _a.trys.push([1, 6, , 7]);
+                        resovedParameters_1 = ptp.parameters
+                            .filter(function (_a) {
+                            var isInput = _a.isInput;
+                            return isInput;
+                        })
+                            .map(function (_a) {
+                            var name = _a.name;
+                            return name;
+                        });
+                        unresovedTemplates = __spreadArray([], __read(ptp.promptTemplates), false);
+                        works_1 = [];
                         _loop_1 = function () {
-                            var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, result, resultString, expectError, scriptExecutionErrors, maxAttempts, jokers, attempt, isJokerAttempt, joker, _c, _d, _e, _f, scriptTools, error_2, e_1_1, _g, _h, functionName, postprocessingError, _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) {
+                            var currentTemplate, work_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
                                     case 0:
-                                        priority--;
-                                        resultingParameter = ptp.getResultingParameter(currentTemplate.name);
-                                        name_1 = "ptp-executor-frame-".concat(currentTemplate.name);
-                                        title = removeEmojis(removeMarkdownFormatting(currentTemplate.title));
-                                        if (!onProgress) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, onProgress({
-                                                name: name_1,
-                                                title: title,
-                                                isStarted: false,
-                                                isDone: false,
-                                                executionType: currentTemplate.executionType,
-                                                parameterName: resultingParameter.name,
-                                                parameterValue: null,
-                                            })];
+                                        currentTemplate = unresovedTemplates.find(function (template) {
+                                            return template.dependentParameterNames.every(function (name) { return resovedParameters_1.includes(name); });
+                                        });
+                                        if (!!currentTemplate) return [3 /*break*/, 2];
+                                        /* [5] */ return [4 /*yield*/, Promise.race(works_1)];
                                     case 1:
-                                        _v.sent();
-                                        _v.label = 2;
-                                    case 2:
-                                        prompt_1 = void 0;
-                                        chatThread = void 0;
-                                        completionResult = void 0;
-                                        result = null;
-                                        resultString = null;
-                                        expectError = null;
-                                        maxAttempts = currentTemplate.executionType === 'PROMPT_DIALOG' ? Infinity : maxExecutionAttempts;
-                                        jokers = currentTemplate.jokers || [];
-                                        attempt = -jokers.length;
-                                        _v.label = 3;
-                                    case 3:
-                                        if (!(attempt < maxAttempts)) return [3 /*break*/, 49];
-                                        isJokerAttempt = attempt < 0;
-                                        joker = jokers[jokers.length + attempt];
-                                        if (isJokerAttempt && !joker) {
-                                            throw new Error("Joker not found in attempt ".concat(attempt));
-                                            //              <- TODO: [🥨] Make some NeverShouldHappenError
-                                        }
-                                        result = null;
-                                        resultString = null;
-                                        expectError = null;
-                                        if (isJokerAttempt) {
-                                            if (typeof parametersToPass[joker] === 'undefined') {
-                                                throw new Error("Joker parameter {".concat(joker, "} not defined"));
-                                            }
-                                            resultString = parametersToPass[joker];
-                                        }
-                                        _v.label = 4;
-                                    case 4:
-                                        _v.trys.push([4, 45, 46, 47]);
-                                        if (!!isJokerAttempt) return [3 /*break*/, 27];
-                                        _c = currentTemplate.executionType;
-                                        switch (_c) {
-                                            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*/, 26];
-                                    case 5:
-                                        resultString = replaceParameters(currentTemplate.content, parametersToPass);
-                                        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),
-                                            parameters: parametersToPass,
-                                            content: replaceParameters(currentTemplate.content, parametersToPass) /* <- [2] */,
-                                            modelRequirements: currentTemplate.modelRequirements,
-                                        };
-                                        _d = currentTemplate.modelRequirements.modelVariant;
-                                        switch (_d) {
-                                            case 'CHAT': return [3 /*break*/, 7];
-                                            case 'COMPLETION': return [3 /*break*/, 9];
-                                        }
-                                        return [3 /*break*/, 11];
-                                    case 7: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
-                                    case 8:
-                                        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 = _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: return [3 /*break*/, 27];
-                                    case 13:
-                                        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 = [];
-                                        _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 17:
-                                        resultString = _v.sent();
-                                        return [3 /*break*/, 20];
-                                    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*/, 23];
-                                    case 22:
-                                        try {
-                                            if (_f && !_f.done && (_q = _e.return)) _q.call(_e);
-                                        }
-                                        finally { if (e_1) throw e_1.error; }
-                                        return [7 /*endfinally*/];
-                                    case 23:
-                                        if (resultString) {
-                                            return [3 /*break*/, 27];
-                                        }
-                                        if (scriptExecutionErrors.length === 1) {
-                                            throw scriptExecutionErrors[0];
-                                        }
-                                        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 24: return [4 /*yield*/, tools.userInterface.promptDialog({
-                                            promptTitle: currentTemplate.title,
-                                            promptMessage: replaceParameters(currentTemplate.description || '', parametersToPass),
-                                            defaultValue: replaceParameters(currentTemplate.content, parametersToPass),
-                                            // TODO: [🧠] !! Figure out how to define placeholder in .ptbk.md file
-                                            placeholder: undefined,
-                                            priority: priority /* <- TODO: !!!! Is it ending with 0 */,
-                                        })];
-                                    case 25:
-                                        // TODO: !!!! When making next attempt for `PROMPT DIALOG`, preserve the previous user input
-                                        resultString = _v.sent();
-                                        return [3 /*break*/, 27];
-                                    case 26: throw new Error(
-                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                    "Unknown execution type \"".concat(currentTemplate.executionType, "\""));
-                                    case 27:
-                                        if (!(!isJokerAttempt && currentTemplate.postprocessing)) return [3 /*break*/, 44];
-                                        _v.label = 28;
-                                    case 28:
-                                        _v.trys.push([28, 42, 43, 44]);
-                                        _g = (e_3 = void 0, __values(currentTemplate.postprocessing)), _h = _g.next();
-                                        _v.label = 29;
-                                    case 29:
-                                        if (!!_h.done) return [3 /*break*/, 41];
-                                        functionName = _h.value;
-                                        // TODO: DRY [1]
-                                        scriptExecutionErrors = [];
-                                        postprocessingError = null;
-                                        _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();
-                                        postprocessingError = null;
-                                        return [3 /*break*/, 36];
-                                    case 34:
-                                        error_3 = _v.sent();
-                                        if (!(error_3 instanceof Error)) {
-                                            throw error_3;
-                                        }
-                                        postprocessingError = 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:
-                                        if (postprocessingError) {
-                                            throw postprocessingError;
-                                        }
-                                        _v.label = 40;
-                                    case 40:
-                                        _h = _g.next();
-                                        return [3 /*break*/, 29];
-                                    case 41: return [3 /*break*/, 44];
-                                    case 42:
-                                        e_3_1 = _v.sent();
-                                        e_3 = { error: e_3_1 };
-                                        return [3 /*break*/, 44];
-                                    case 43:
-                                        try {
-                                            if (_h && !_h.done && (_r = _g.return)) _r.call(_g);
-                                        }
-                                        finally { if (e_3) throw e_3.error; }
-                                        return [7 /*endfinally*/];
-                                    case 44:
-                                        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*/, 49];
-                                    case 45:
-                                        error_4 = _v.sent();
-                                        if (!(error_4 instanceof ExpectError)) {
-                                            throw error_4;
-                                        }
-                                        expectError = error_4;
-                                        return [3 /*break*/, 47];
-                                    case 46:
-                                        if (!isJokerAttempt &&
-                                            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 47:
-                                        if (expectError !== null && attempt === maxAttempts - 1) {
-                                            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 = 48;
-                                    case 48:
-                                        attempt++;
+                                        /* [5] */ _b.sent();
                                         return [3 /*break*/, 3];
-                                    case 49:
-                                        if (resultString === null) {
-                                            //              <- TODO: [🥨] Make some NeverShouldHappenError
-                                            throw new Error('Something went wrong and prompt result is null');
-                                        }
-                                        if (onProgress) {
-                                            onProgress({
-                                                name: name_1,
-                                                title: title,
-                                                isStarted: true,
-                                                isDone: true,
-                                                executionType: currentTemplate.executionType,
-                                                parameterName: resultingParameter.name,
-                                                parameterValue: resultString,
-                                            });
-                                        }
-                                        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*/];
+                                    case 2:
+                                        unresovedTemplates = unresovedTemplates.filter(function (template) { return template !== currentTemplate; });
+                                        work_1 = executeSingleTemplate(currentTemplate)
+                                            .then(function () {
+                                            resovedParameters_1 = resovedParameters_1.filter(function (name) { return !currentTemplate.dependentParameterNames.includes(name); });
+                                        })
+                                            .then(function () {
+                                            works_1 = works_1.filter(function (w) { return w !== work_1; });
+                                        });
+                                        works_1.push(work_1);
+                                        _b.label = 3;
+                                    case 3: return [2 /*return*/];
                                 }
                             });
                         };
-                        _b.label = 2;
+                        _a.label = 2;
                     case 2:
-                        if (!(currentTemplate !== null)) return [3 /*break*/, 4];
+                        if (!(unresovedTemplates.length > 0)) return [3 /*break*/, 4];
                         return [5 /*yield**/, _loop_1()];
                     case 3:
-                        _b.sent();
+                        _a.sent();
                         return [3 /*break*/, 2];
-                    case 4: return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, Promise.all(works_1)];
                     case 5:
-                        error_1 = _b.sent();
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        error_1 = _a.sent();
                         if (!(error_1 instanceof Error)) {
                             throw error_1;
                         }
@@ -1752,7 +1745,7 @@
                                 executionReport: executionReport,
                                 outputParameters: parametersToPass,
                             }];
-                    case 6: return [2 /*return*/, {
+                    case 7: return [2 /*return*/, {
                             isSuccessful: true,
                             errors: [],
                             executionReport: executionReport,
@@ -1798,7 +1791,15 @@
             try {
                 for (var _b = __values(Object.entries(ptbkSources)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var _d = __read(_c.value, 2), name_1 = _d[0], source = _d[1];
-                    library[name_1] = PromptTemplatePipeline.fromSource(source);
+                    if (typeof source === 'string') {
+                        // Note: When directly creating from string, no need to validate the source
+                        //       The validation is performed always before execution
+                        library[name_1] = promptTemplatePipelineStringToJson(source);
+                    }
+                    else {
+                        validatePromptTemplatePipelineJson(source);
+                        library[name_1] = source;
+                    }
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -1968,7 +1969,6 @@
     exports.ExecutionTypes = ExecutionTypes;
     exports.MockedEchoNaturalExecutionTools = MockedEchoNaturalExecutionTools;
     exports.PTBK_VERSION = PTBK_VERSION;
-    exports.PromptTemplatePipeline = PromptTemplatePipeline;
     exports.PromptTemplatePipelineLibrary = PromptTemplatePipelineLibrary;
     exports.SimplePromptInterfaceTools = SimplePromptInterfaceTools;
     exports.createPtpExecutor = createPtpExecutor;