@promptbook/core 0.29.0 → 0.30.0-0

package/esm/index.es.js

@@ -108,6 +108,16 @@ function __read(o, n) {
         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));
 }
 
 /**
@@ -134,6 +144,35 @@ var DEFAULT_MODEL_REQUIREMENTS = {
  */
 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.
  *
@@ -768,10 +807,11 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
         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 = [];
@@ -785,6 +825,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
                 switch (command.type) {
                     case 'JOKER':
                         jokers.push(command.parameterName);
+                        dependentParameterNames.push(command.parameterName);
                         break;
                     case 'EXECUTE':
                         if (isExecutionTypeChanged) {
@@ -798,6 +839,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
                         templateModelRequirements[command.key] = command.value;
                         break;
                     case 'PARAMETER':
+                        // Note: This is just for detecting resulitng parameter name
                         addParam(command);
                         break;
                     case 'POSTPROCESS':
@@ -838,7 +880,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
             }
             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');
@@ -877,10 +919,24 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
         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: normalizeTo_PascalCase(section.title),
             title: section.title,
             description: description_1,
+            dependentParameterNames: dependentParameterNames,
             executionType: executionType,
             jokers: jokers,
             postprocessing: postprocessing,
@@ -928,7 +984,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
  * @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;
@@ -937,52 +993,37 @@ function validatePromptTemplatePipelineJson(ptp) {
         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, ")"));
                         }
@@ -994,12 +1035,12 @@ function validatePromptTemplatePipelineJson(ptp) {
                         }
                     }
                 }
-                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);
@@ -1008,10 +1049,42 @@ function validatePromptTemplatePipelineJson(ptp) {
     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(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
@@ -1025,124 +1098,6 @@ function validatePromptTemplatePipelineJson(ptp) {
  *     >  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
  */
@@ -1335,11 +1290,11 @@ function replaceParameters(template, parameters) {
             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');
     }
@@ -1372,370 +1327,408 @@ function createPtpExecutor(options) {
     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(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(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(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(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;
                     }
@@ -1745,7 +1738,7 @@ function createPtpExecutor(options) {
                             executionReport: executionReport,
                             outputParameters: parametersToPass,
                         }];
-                case 6: return [2 /*return*/, {
+                case 7: return [2 /*return*/, {
                         isSuccessful: true,
                         errors: [],
                         executionReport: executionReport,
@@ -1791,7 +1784,15 @@ var PromptTemplatePipelineLibrary = /** @class */ (function () {
         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 }; }
@@ -1957,5 +1958,5 @@ var SimplePromptInterfaceTools = /** @class */ (function () {
     return SimplePromptInterfaceTools;
 }());
 
-export { CallbackInterfaceTools, ExecutionTypes, MockedEchoNaturalExecutionTools, PTBK_VERSION, PromptTemplatePipeline, PromptTemplatePipelineLibrary, SimplePromptInterfaceTools, createPtpExecutor, promptTemplatePipelineStringToJson, validatePromptTemplatePipelineJson };
+export { CallbackInterfaceTools, ExecutionTypes, MockedEchoNaturalExecutionTools, PTBK_VERSION, PromptTemplatePipelineLibrary, SimplePromptInterfaceTools, createPtpExecutor, promptTemplatePipelineStringToJson, validatePromptTemplatePipelineJson };
 //# sourceMappingURL=index.es.js.map