@promptbook/core 0.23.2 → 0.24.0-1.0

package/esm/index.es.js

@@ -1,4 +1,4 @@
-import { capitalize, normalizeTo_SCREAMING_CASE, normalizeTo_PascalCase, normalizeTo_camelCase } from 'n12';
+import { capitalize, normalizeTo_SCREAMING_CASE, normalizeTo_PascalCase, normalizeTo_camelCase, removeDiacritics } from 'n12';
 import spaceTrim from 'spacetrim';
 
 /*! *****************************************************************************
@@ -342,6 +342,14 @@ function removeContentComments(content) {
  */
 var ExecutionTypes = ['PROMPT_TEMPLATE', 'SIMPLE_TEMPLATE', 'SCRIPT', 'PROMPT_DIALOG'];
 
+/**
+ * Units of text measurement
+ */
+var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'PARAGRAPHS', 'LINES', 'PAGES'];
+/**
+ * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
+ */
+
 /**
  * Removes Markdown formatting tags from a string.
  *
@@ -358,10 +366,73 @@ function removeMarkdownFormatting(str) {
     return str;
 }
 
+/**
+ * Function parseNumber will parse number from string
+ *
+ * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
+ * Note: it also works only with decimal numbers
+ */
+function parseNumber(value) {
+    var originalValue = value;
+    if (typeof value === 'number') {
+        value = value.toString(); // <- TODO: Maybe more efficient way to do this
+    }
+    if (typeof value !== 'string') {
+        return 0;
+    }
+    value = value.trim();
+    if (value.startsWith('+')) {
+        return parseNumber(value.substring(1));
+    }
+    if (value.startsWith('-')) {
+        var number = parseNumber(value.substring(1));
+        if (number === 0) {
+            return 0; // <- Note: To prevent -0
+        }
+        return -number;
+    }
+    value = value.replace(/,/g, '.');
+    value = value.toUpperCase();
+    if (value === '') {
+        return 0;
+    }
+    if (value === '♾' || value.startsWith('INF')) {
+        return Infinity;
+    }
+    if (value.includes('/')) {
+        var _a = __read(value.split('/'), 2), numerator_ = _a[0], denominator_ = _a[1];
+        var numerator = parseNumber(numerator_);
+        var denominator = parseNumber(denominator_);
+        if (denominator === 0) {
+            throw new Error("Unable to parse number from \"".concat(originalValue, "\" because denominator is zero"));
+        }
+        return numerator / denominator;
+    }
+    if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
+        return 0;
+    }
+    if (value.includes('E')) {
+        var _b = __read(value.split('E'), 2), significand = _b[0], exponent = _b[1];
+        return parseNumber(significand) * Math.pow(10, parseNumber(exponent));
+    }
+    if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
+        throw new Error("Unable to parse number from \"".concat(originalValue, "\""));
+    }
+    var num = parseFloat(value);
+    if (isNaN(num)) {
+        throw new Error("Unexpected NaN when parsing number from \"".concat(originalValue, "\""));
+    }
+    return num;
+}
+/**
+ * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
+ */
+
 /**
  * Parses one line of ul/ol to command
  */
 function parseCommand(listItem) {
+    var e_1, _a;
     if (listItem.includes('\n') || listItem.includes('\r')) {
         throw new Error('Command can not contain new line characters:');
     }
@@ -468,7 +539,7 @@ function parseCommand(listItem) {
             throw new Error(spaceTrim("\n                        Invalid parameter in command:\n\n                        - ".concat(listItem, "\n                    ")));
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        var _a = parametersMatch.groups, parameterName = _a.parameterName, parameterDescription = _a.parameterDescription;
+        var _b = parametersMatch.groups, parameterName = _b.parameterName, parameterDescription = _b.parameterDescription;
         if (parameterDescription && parameterDescription.match(/\{(?<parameterName>[a-z0-9_]+)\}/im)) {
             throw new Error(spaceTrim("\n                        Parameter {".concat(parameterName, "} can not contain another parameter in description:\n\n                        - ").concat(listItem, "\n                    ")));
         }
@@ -490,6 +561,74 @@ function parseCommand(listItem) {
             functionName: functionName,
         };
     }
+    else if (type.startsWith('EXPECT')) {
+        try {
+            listItemParts.shift();
+            var sign = void 0;
+            var signRaw = listItemParts.shift();
+            if (/^exact/i.test(signRaw)) {
+                sign = 'EXACTLY';
+            }
+            else if (/^min/i.test(signRaw)) {
+                sign = 'MINIMUM';
+            }
+            else if (/^max/i.test(signRaw)) {
+                sign = 'MAXIMUM';
+            }
+            else {
+                throw new Error("Invalid sign \"".concat(signRaw, "\""));
+            }
+            var amountRaw = listItemParts.shift();
+            var amount = parseNumber(amountRaw);
+            if (amount < 0) {
+                throw new Error('Amount must be positive number or zero');
+            }
+            if (amount !== Math.floor(amount)) {
+                throw new Error('Amount must be whole number');
+            }
+            var unitRaw = listItemParts.shift();
+            var unit = undefined;
+            try {
+                for (var EXPECTATION_UNITS_1 = __values(EXPECTATION_UNITS), EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next(); !EXPECTATION_UNITS_1_1.done; EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next()) {
+                    var existingUnit = EXPECTATION_UNITS_1_1.value;
+                    var existingUnitText = existingUnit;
+                    existingUnitText = existingUnitText.substring(0, existingUnitText.length - 1);
+                    if (existingUnitText === 'CHARACTER') {
+                        existingUnitText = 'CHAR';
+                    }
+                    if (new RegExp("^".concat(existingUnitText.toLowerCase())).test(unitRaw.toLowerCase()) ||
+                        new RegExp("^".concat(unitRaw.toLowerCase())).test(existingUnitText.toLowerCase())) {
+                        if (unit !== undefined) {
+                            throw new Error("Ambiguous unit \"".concat(unitRaw, "\""));
+                        }
+                        unit = existingUnit;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (EXPECTATION_UNITS_1_1 && !EXPECTATION_UNITS_1_1.done && (_a = EXPECTATION_UNITS_1.return)) _a.call(EXPECTATION_UNITS_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (unit === undefined) {
+                throw new Error("Invalid unit \"".concat(unitRaw, "\""));
+            }
+            return {
+                type: 'EXPECT',
+                sign: sign,
+                unit: unit,
+                amount: amount,
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            throw new Error(spaceTrim("\n                  Invalid EXPECT command; ".concat(error.message, ":\n\n                  - ").concat(listItem, "\n              ")));
+        }
+    }
     else {
         throw new Error(spaceTrim("\n                    Unknown command:\n\n                    - ".concat(listItem, "\n\n                    Supported commands are:\n                    - Execute\n                    - Model\n                    - Parameter\n                    - Input parameter\n                    - Output parameter\n                    - PTBK Version\n                ")));
     }
@@ -598,6 +737,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
         var postprocessingCommands = [];
         var listItems_3 = extractAllListItemsFromMarkdown(section.content);
         var executionType = 'PROMPT_TEMPLATE';
+        var expectations = {};
         var isExecutionTypeChanged = false;
         try {
             for (var listItems_2 = (e_3 = void 0, __values(listItems_3)), listItems_2_1 = listItems_2.next(); !listItems_2_1.done; listItems_2_1 = listItems_2.next()) {
@@ -621,6 +761,23 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
                     case 'POSTPROCESS':
                         postprocessingCommands.push(command);
                         break;
+                    case 'EXPECT':
+                        // eslint-disable-next-line no-case-declarations
+                        var unit = command.unit.toLowerCase();
+                        expectations[unit] = expectations[unit] || {};
+                        if (command.sign === 'MINIMUM' || command.sign === 'EXACTLY') {
+                            if (expectations[unit].min !== undefined) {
+                                throw new Error("Already defined minumum ".concat(expectations[unit].min, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                            }
+                            expectations[unit].min = command.amount;
+                        } /* not else */
+                        if (command.sign === 'MAXIMUM' || command.sign === 'EXACTLY') {
+                            if (expectations[unit].max !== undefined) {
+                                throw new Error("Already defined maximum ".concat(expectations[unit].max, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                            }
+                            expectations[unit].max = command.amount;
+                        }
+                        break;
                     default:
                         throw new Error("Command ".concat(command.type, " is not allowed in the block of the prompt template ONLY at the head of the prompt template pipeline"));
                 }
@@ -684,6 +841,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
             title: section.title,
             description: description_1,
             executionType: executionType,
+            expectations: expectations,
             modelRequirements: templateModelRequirements,
             contentLanguage: executionType === 'SCRIPT' ? language : undefined,
             content: content,
@@ -817,8 +975,11 @@ function validatePromptTemplatePipelineJson(ptp) {
  * @see https://github.com/webgptorg/promptbook#prompt-template-pipeline
  */
 var PromptTemplatePipeline = /** @class */ (function () {
-    function PromptTemplatePipeline(ptbkUrl, parameters, promptTemplates) {
+    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) {
@@ -863,7 +1024,7 @@ var PromptTemplatePipeline = /** @class */ (function () {
      */
     PromptTemplatePipeline.fromJson = function (ptbkjson) {
         validatePromptTemplatePipelineJson(ptbkjson);
-        return new PromptTemplatePipeline(ptbkjson.ptbkUrl ? new URL(ptbkjson.ptbkUrl) : null, Object.fromEntries(ptbkjson.parameters.map(function (parameter) { return [parameter.name, parameter]; })), ptbkjson.promptTemplates);
+        return new PromptTemplatePipeline(ptbkjson.ptbkUrl ? new URL(ptbkjson.ptbkUrl) : null, ptbkjson.title, ptbkjson.ptbkVersion, ptbkjson.ptbkVersion, Object.fromEntries(ptbkjson.parameters.map(function (parameter) { return [parameter.name, parameter]; })), ptbkjson.promptTemplates);
     };
     Object.defineProperty(PromptTemplatePipeline.prototype, "entryPromptTemplate", {
         /**
@@ -920,6 +1081,74 @@ var PromptTemplatePipeline = /** @class */ (function () {
  * 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
+ */
+function countCharacters(text) {
+    // Remove null characters
+    text = text.replace(/\0/g, '');
+    // Replace emojis (and also ZWJ sequence) with hyphens
+    text = text.replace(/(\p{Emoji})\p{Modifier_Symbol}/gu, '$1');
+    text = text.replace(/(\p{Emoji})[\u{FE00}-\u{FE0F}]/gu, '$1');
+    text = text.replace(/\p{Emoji}(\u{200D}\p{Emoji})*/gu, '-');
+    return text.length;
+}
+
+/**
+ * Counts number of lines in the text
+ */
+function countLines(text) {
+    if (text === '') {
+        return 0;
+    }
+    return text.split('\n').length;
+}
+
+/**
+ * Counts number of pages in the text
+ */
+function countPages(text) {
+    var sentencesPerPage = 5; // Assuming each page has 5 sentences
+    var sentences = text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; });
+    var pageCount = Math.ceil(sentences.length / sentencesPerPage);
+    return pageCount;
+}
+
+/**
+ * Counts number of paragraphs in the text
+ */
+function countParagraphs(text) {
+    return text.split(/\n\s*\n/).filter(function (paragraph) { return paragraph.trim() !== ''; }).length;
+}
+
+/**
+ * Counts number of sentences in the text
+ */
+function countSentences(text) {
+    return text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; }).length;
+}
+
+/**
+ * Counts number of words in the text
+ */
+function countWords(text) {
+    text = text.replace(/[\p{Emoji}]/gu, 'a');
+    text = removeDiacritics(text);
+    return text.split(/[^a-zа-я0-9]+/i).filter(function (word) { return word.length > 0; }).length;
+}
+
+/**
+ * Index of all counter functions
+ */
+var CountUtils = {
+    CHARACTERS: countCharacters,
+    WORDS: countWords,
+    SENTENCES: countSentences,
+    PARAGRAPHS: countParagraphs,
+    LINES: countLines,
+    PAGES: countPages,
+};
+
 /**
  * All possible emoji chars like "🍆", "🍡", "🍤"...
  * Note: this will be needed to update annually - now updated at 2022-01-19
@@ -1043,19 +1272,31 @@ function replaceParameters(template, parameters) {
  */
 function createPtpExecutor(options) {
     var _this = this;
-    var ptp = options.ptp, tools = options.tools;
+    var ptp = options.ptp, tools = options.tools, settings = options.settings;
     var ptpExecutor = function (inputParameters, onProgress) { return __awaiter(_this, void 0, void 0, function () {
-        var parametersToPass, currentTemplate, _loop_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var parametersToPass, currentTemplate, executionReport, _loop_1, error_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.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,
+                        ptbkUsedVersion: PTBK_VERSION,
+                        ptbkRequestedVersion: ptp.ptbkVersion || undefined,
+                        description: ptp.description || undefined,
+                        promptExecutions: [],
+                    };
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 5, , 6]);
                     _loop_1 = function () {
-                        var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, promptResult, scriptExecutionErrors, isScriptExecutionSuccessful, _b, _c, _d, _e, scriptTools, error_1, e_1_1;
-                        var e_1, _f, _g;
-                        return __generator(this, function (_h) {
-                            switch (_h.label) {
+                        var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, result, resultString, naturalExecutionError, scriptExecutionErrors, isScriptExecutionSuccessful, _c, attempt, _d, _e, _f, _g, unit, _h, max, min, amount, error_2, _j, _k, scriptTools, error_3, e_1_1;
+                        var e_2, _l, e_1, _m, _o;
+                        return __generator(this, function (_p) {
+                            switch (_p.label) {
                                 case 0:
                                     resultingParameter = ptp.getResultingParameter(currentTemplate.name);
                                     name_1 = "ptp-executor-frame-".concat(currentTemplate.name);
@@ -1071,27 +1312,30 @@ function createPtpExecutor(options) {
                                             parameterValue: null,
                                         })];
                                 case 1:
-                                    _h.sent();
-                                    _h.label = 2;
+                                    _p.sent();
+                                    _p.label = 2;
                                 case 2:
                                     prompt_1 = void 0;
                                     chatThread = void 0;
                                     completionResult = void 0;
-                                    promptResult = null;
+                                    result = null;
+                                    resultString = null;
+                                    naturalExecutionError = null;
                                     isScriptExecutionSuccessful = void 0;
-                                    _b = currentTemplate.executionType;
-                                    switch (_b) {
+                                    _c = currentTemplate.executionType;
+                                    switch (_c) {
                                         case 'SIMPLE_TEMPLATE': return [3 /*break*/, 3];
                                         case 'PROMPT_TEMPLATE': return [3 /*break*/, 4];
-                                        case 'SCRIPT': return [3 /*break*/, 11];
-                                        case 'PROMPT_DIALOG': return [3 /*break*/, 22];
+                                        case 'SCRIPT': return [3 /*break*/, 18];
+                                        case 'PROMPT_DIALOG': return [3 /*break*/, 29];
                                     }
-                                    return [3 /*break*/, 24];
+                                    return [3 /*break*/, 31];
                                 case 3:
-                                    promptResult = replaceParameters(currentTemplate.content, parametersToPass);
-                                    return [3 /*break*/, 25];
+                                    resultString = replaceParameters(currentTemplate.content, parametersToPass);
+                                    return [3 /*break*/, 32];
                                 case 4:
                                     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),
@@ -1099,28 +1343,88 @@ function createPtpExecutor(options) {
                                         content: replaceParameters(currentTemplate.content, parametersToPass),
                                         modelRequirements: currentTemplate.modelRequirements,
                                     };
-                                    _c = currentTemplate.modelRequirements.modelVariant;
-                                    switch (_c) {
-                                        case 'CHAT': return [3 /*break*/, 5];
-                                        case 'COMPLETION': return [3 /*break*/, 7];
-                                    }
-                                    return [3 /*break*/, 9];
-                                case 5: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
+                                    attempt = 0;
+                                    _p.label = 5;
+                                case 5:
+                                    if (!(attempt < settings.maxNaturalExecutionAttempts)) return [3 /*break*/, 17];
+                                    result = null;
+                                    resultString = null;
+                                    naturalExecutionError = null;
+                                    _p.label = 6;
                                 case 6:
-                                    chatThread = _h.sent();
-                                    // TODO: Use all information from chatThread like "model"
-                                    // TODO: [🍬] Destroy chatThread
-                                    promptResult = chatThread.content;
-                                    return [3 /*break*/, 10];
-                                case 7: return [4 /*yield*/, tools.natural.gptComplete(prompt_1)];
+                                    _p.trys.push([6, 13, 14, 15]);
+                                    _d = currentTemplate.modelRequirements.modelVariant;
+                                    switch (_d) {
+                                        case 'CHAT': return [3 /*break*/, 7];
+                                        case 'COMPLETION': return [3 /*break*/, 9];
+                                    }
+                                    return [3 /*break*/, 11];
+                                case 7: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
                                 case 8:
-                                    completionResult = _h.sent();
-                                    // TODO: Use all information from chatThread like "model"
-                                    promptResult = completionResult.content;
-                                    return [3 /*break*/, 10];
-                                case 9: throw new Error("Unknown model variant \"".concat(currentTemplate.modelRequirements.modelVariant, "\""));
-                                case 10: return [3 /*break*/, 25];
-                                case 11:
+                                    chatThread = _p.sent();
+                                    // TODO: [🍬] Destroy chatThread
+                                    result = chatThread;
+                                    resultString = chatThread.content;
+                                    return [3 /*break*/, 12];
+                                case 9: return [4 /*yield*/, tools.natural.gptComplete(prompt_1)];
+                                case 10:
+                                    completionResult = _p.sent();
+                                    result = completionResult;
+                                    resultString = completionResult.content;
+                                    return [3 /*break*/, 12];
+                                case 11: throw new Error("Unknown model variant \"".concat(currentTemplate.modelRequirements.modelVariant, "\""));
+                                case 12:
+                                    try {
+                                        // TODO: !!!!!! Here should postprocessing happen
+                                        for (_e = (e_2 = void 0, __values(Object.entries(currentTemplate.expectations))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                            _g = __read(_f.value, 2), unit = _g[0], _h = _g[1], max = _h.max, min = _h.min;
+                                            amount = CountUtils[unit.toUpperCase()](resultString);
+                                            if (min && amount < min) {
+                                                throw new Error("Expected at least ".concat(min, " ").concat(unit, " but got ").concat(amount));
+                                            } /* not else */
+                                            if (max && amount > max) {
+                                                throw new Error("Expected at most ".concat(max, " ").concat(unit, " but got ").concat(amount));
+                                            }
+                                        }
+                                    }
+                                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                    finally {
+                                        try {
+                                            if (_f && !_f.done && (_l = _e.return)) _l.call(_e);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                    }
+                                    return [3 /*break*/, 15];
+                                case 13:
+                                    error_2 = _p.sent();
+                                    if (!(error_2 instanceof Error)) {
+                                        throw error_2;
+                                    }
+                                    naturalExecutionError = error_2;
+                                    return [3 /*break*/, 15];
+                                case 14:
+                                    executionReport.promptExecutions.push({
+                                        prompt: {
+                                            title: prompt_1.title,
+                                            content: prompt_1.content,
+                                            modelRequirements: prompt_1.modelRequirements,
+                                            // <- Note: Do want to pass ONLY wanted information to the report
+                                        },
+                                        result: result /* <- !!!!! Look what is exposed here and probbably also filter out */ ||
+                                            undefined,
+                                        error: naturalExecutionError || undefined,
+                                    });
+                                    return [7 /*endfinally*/];
+                                case 15:
+                                    if (result !== null && naturalExecutionError === null) {
+                                        return [3 /*break*/, 32];
+                                    }
+                                    _p.label = 16;
+                                case 16:
+                                    attempt++;
+                                    return [3 /*break*/, 5];
+                                case 17: throw new Error(spaceTrim(function (block) { return "\n                                    Natural execution failed ".concat(settings.maxNaturalExecutionAttempts, "x\n\n                                    ").concat(block((naturalExecutionError === null || naturalExecutionError === void 0 ? void 0 : naturalExecutionError.message) || ''), "\n                                "); }));
+                                case 18:
                                     if (tools.script.length === 0) {
                                         throw new Error('No script execution tools are available');
                                     }
@@ -1129,50 +1433,50 @@ function createPtpExecutor(options) {
                                     }
                                     scriptExecutionErrors = [];
                                     isScriptExecutionSuccessful = false;
-                                    _h.label = 12;
-                                case 12:
-                                    _h.trys.push([12, 19, 20, 21]);
-                                    _d = (e_1 = void 0, __values(tools.script)), _e = _d.next();
-                                    _h.label = 13;
-                                case 13:
-                                    if (!!_e.done) return [3 /*break*/, 18];
-                                    scriptTools = _e.value;
-                                    _h.label = 14;
-                                case 14:
-                                    _h.trys.push([14, 16, , 17]);
+                                    _p.label = 19;
+                                case 19:
+                                    _p.trys.push([19, 26, 27, 28]);
+                                    _j = (e_1 = void 0, __values(tools.script)), _k = _j.next();
+                                    _p.label = 20;
+                                case 20:
+                                    if (!!_k.done) return [3 /*break*/, 25];
+                                    scriptTools = _k.value;
+                                    _p.label = 21;
+                                case 21:
+                                    _p.trys.push([21, 23, , 24]);
                                     return [4 /*yield*/, scriptTools.execute({
                                             scriptLanguage: currentTemplate.contentLanguage,
                                             script: currentTemplate.content,
                                             parameters: parametersToPass,
                                         })];
-                                case 15:
-                                    promptResult = _h.sent();
+                                case 22:
+                                    resultString = _p.sent();
                                     isScriptExecutionSuccessful = true;
-                                    return [3 /*break*/, 18];
-                                case 16:
-                                    error_1 = _h.sent();
-                                    if (!(error_1 instanceof Error)) {
-                                        throw error_1;
+                                    return [3 /*break*/, 25];
+                                case 23:
+                                    error_3 = _p.sent();
+                                    if (!(error_3 instanceof Error)) {
+                                        throw error_3;
                                     }
-                                    scriptExecutionErrors.push(error_1);
-                                    return [3 /*break*/, 17];
-                                case 17:
-                                    _e = _d.next();
-                                    return [3 /*break*/, 13];
-                                case 18: return [3 /*break*/, 21];
-                                case 19:
-                                    e_1_1 = _h.sent();
+                                    scriptExecutionErrors.push(error_3);
+                                    return [3 /*break*/, 24];
+                                case 24:
+                                    _k = _j.next();
+                                    return [3 /*break*/, 20];
+                                case 25: return [3 /*break*/, 28];
+                                case 26:
+                                    e_1_1 = _p.sent();
                                     e_1 = { error: e_1_1 };
-                                    return [3 /*break*/, 21];
-                                case 20:
+                                    return [3 /*break*/, 28];
+                                case 27:
                                     try {
-                                        if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
+                                        if (_k && !_k.done && (_m = _j.return)) _m.call(_j);
                                     }
                                     finally { if (e_1) throw e_1.error; }
                                     return [7 /*endfinally*/];
-                                case 21:
+                                case 28:
                                     if (isScriptExecutionSuccessful) {
-                                        return [3 /*break*/, 25];
+                                        return [3 /*break*/, 32];
                                     }
                                     if (scriptExecutionErrors.length === 1) {
                                         throw scriptExecutionErrors[0];
@@ -1180,20 +1484,20 @@ function createPtpExecutor(options) {
                                     else {
                                         throw new Error(spaceTrim(function (block) { return "\n                                        Script execution failed ".concat(scriptExecutionErrors.length, " times\n\n                                        ").concat(block(scriptExecutionErrors.map(function (error) { return '- ' + error.message; }).join('\n\n')), "\n                                    "); }));
                                     }
-                                case 22: return [4 /*yield*/, tools.userInterface.promptDialog({
+                                case 29: return [4 /*yield*/, tools.userInterface.promptDialog({
                                         prompt: replaceParameters(currentTemplate.description || '', parametersToPass),
                                         defaultValue: replaceParameters(currentTemplate.content, parametersToPass),
                                         // TODO: [🧠] !! Figure out how to define placeholder in .ptbk.md file
                                         placeholder: undefined,
                                     })];
-                                case 23:
-                                    promptResult = _h.sent();
-                                    return [3 /*break*/, 25];
-                                case 24: 
+                                case 30:
+                                    resultString = _p.sent();
+                                    return [3 /*break*/, 32];
+                                case 31: 
                                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                 throw new Error("Unknown execution type \"".concat(currentTemplate.executionType, "\""));
-                                case 25:
-                                    if (promptResult === null) {
+                                case 32:
+                                    if (resultString === null) {
                                         //              <- TODO: [🥨] Make some NeverShouldHappenError
                                         throw new Error('Something went wrong and prompt result is null');
                                     }
@@ -1205,23 +1509,40 @@ function createPtpExecutor(options) {
                                             isDone: true,
                                             executionType: currentTemplate.executionType,
                                             parameterName: resultingParameter.name,
-                                            parameterValue: promptResult,
+                                            parameterValue: resultString,
                                         });
                                     }
-                                    parametersToPass = __assign(__assign({}, parametersToPass), (_g = {}, _g[resultingParameter.name] = promptResult /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _g));
+                                    parametersToPass = __assign(__assign({}, parametersToPass), (_o = {}, _o[resultingParameter.name] = resultString /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _o));
                                     currentTemplate = ptp.getFollowingPromptTemplate(currentTemplate.name);
                                     return [2 /*return*/];
                             }
                         });
                     };
-                    _a.label = 1;
-                case 1:
-                    if (!(currentTemplate !== null)) return [3 /*break*/, 3];
-                    return [5 /*yield**/, _loop_1()];
+                    _b.label = 2;
                 case 2:
-                    _a.sent();
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/, parametersToPass];
+                    if (!(currentTemplate !== null)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, _loop_1()];
+                case 3:
+                    _b.sent();
+                    return [3 /*break*/, 2];
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    error_1 = _b.sent();
+                    if (!(error_1 instanceof Error)) {
+                        throw error_1;
+                    }
+                    return [2 /*return*/, {
+                            isSuccessful: false,
+                            errors: [error_1],
+                            executionReport: executionReport,
+                            outputParameters: parametersToPass,
+                        }];
+                case 6: return [2 /*return*/, {
+                        isSuccessful: true,
+                        errors: [],
+                        executionReport: executionReport,
+                        outputParameters: parametersToPass,
+                    }];
             }
         });
     }); };
@@ -1242,8 +1563,8 @@ function createPtpExecutor(options) {
  * @see https://github.com/webgptorg/promptbook#prompt-template-pipeline-library
  */
 var PromptTemplatePipelineLibrary = /** @class */ (function () {
-    function PromptTemplatePipelineLibrary(promptTemplatePipelines) {
-        this.promptTemplatePipelines = promptTemplatePipelines;
+    function PromptTemplatePipelineLibrary(options) {
+        this.options = options;
     }
     /**
      * Constructs PromptTemplatePipeline from any sources
@@ -1254,13 +1575,13 @@ var PromptTemplatePipelineLibrary = /** @class */ (function () {
      * @param ptbkSources contents of .ptbk.md or .ptbk.json files
      * @returns PromptTemplatePipelineLibrary
      */
-    PromptTemplatePipelineLibrary.fromSources = function (ptbkSources) {
+    PromptTemplatePipelineLibrary.fromSources = function (ptbkSources, settings) {
         var e_1, _a;
-        var promptTemplatePipelines = {};
+        var library = {};
         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];
-                promptTemplatePipelines[name_1] = PromptTemplatePipeline.fromSource(source);
+                library[name_1] = PromptTemplatePipeline.fromSource(source);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -1270,13 +1591,13 @@ var PromptTemplatePipelineLibrary = /** @class */ (function () {
             }
             finally { if (e_1) throw e_1.error; }
         }
-        return new PromptTemplatePipelineLibrary(promptTemplatePipelines);
+        return new PromptTemplatePipelineLibrary({ library: library, settings: settings });
     };
     /**
      * Gets prompt template pipeline by name
      */
     PromptTemplatePipelineLibrary.prototype.getPtp = function (name) {
-        var promptTemplatePipeline = this.promptTemplatePipelines[name];
+        var promptTemplatePipeline = this.options.library[name];
         if (!promptTemplatePipeline) {
             throw new Error("Prompt template pipeline with name \"".concat(name, "\" not found"));
         }
@@ -1293,7 +1614,7 @@ var PromptTemplatePipelineLibrary = /** @class */ (function () {
      */
     PromptTemplatePipelineLibrary.prototype.createExecutor = function (name, tools) {
         var ptp = this.getPtp(name);
-        return createPtpExecutor({ ptp: ptp, tools: tools });
+        return createPtpExecutor({ ptp: ptp, tools: tools, settings: this.options.settings });
     };
     return PromptTemplatePipelineLibrary;
 }());