@promptbook/wizard 0.100.0-44 → 0.100.0-46

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('crypto'), require('socket.io-client'), require('@anthropic-ai/sdk'), require('bottleneck'), require('colors'), require('@azure/openai'), require('openai'), require('fs/promises'), require('child_process'), require('waitasecond'), require('crypto-js'), require('crypto-js/enc-hex'), require('path'), require('prettier'), require('prettier/parser-html'), require('rxjs'), require('crypto-js/sha256'), require('mime-types'), require('papaparse'), require('@mozilla/readability'), require('jsdom'), require('showdown'), require('dotenv'), require('jszip')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'crypto', 'socket.io-client', '@anthropic-ai/sdk', 'bottleneck', 'colors', '@azure/openai', 'openai', 'fs/promises', 'child_process', 'waitasecond', 'crypto-js', 'crypto-js/enc-hex', 'path', 'prettier', 'prettier/parser-html', 'rxjs', 'crypto-js/sha256', 'mime-types', 'papaparse', '@mozilla/readability', 'jsdom', 'showdown', 'dotenv', 'jszip'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-wizard"] = {}, global.spaceTrim, global.crypto, global.socket_ioClient, global.Anthropic, global.Bottleneck, global.colors, global.openai, global.OpenAI, global.promises, global.child_process, global.waitasecond, global.cryptoJs, global.hexEncoder, global.path, global.prettier, global.parserHtml, global.rxjs, global.sha256, global.mimeTypes, global.papaparse, global.readability, global.jsdom, global.showdown, global.dotenv, global.JSZip));
-})(this, (function (exports, spaceTrim, crypto, socket_ioClient, Anthropic, Bottleneck, colors, openai, OpenAI, promises, child_process, waitasecond, cryptoJs, hexEncoder, path, prettier, parserHtml, rxjs, sha256, mimeTypes, papaparse, readability, jsdom, showdown, dotenv, JSZip) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('crypto'), require('socket.io-client'), require('@anthropic-ai/sdk'), require('bottleneck'), require('colors'), require('@azure/openai'), require('openai'), require('fs/promises'), require('child_process'), require('waitasecond'), require('crypto-js'), require('crypto-js/enc-hex'), require('path'), require('prettier/parser-html'), require('prettier/parser-markdown'), require('prettier/standalone'), require('rxjs'), require('crypto-js/sha256'), require('mime-types'), require('papaparse'), require('@mozilla/readability'), require('jsdom'), require('showdown'), require('dotenv'), require('jszip')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'crypto', 'socket.io-client', '@anthropic-ai/sdk', 'bottleneck', 'colors', '@azure/openai', 'openai', 'fs/promises', 'child_process', 'waitasecond', 'crypto-js', 'crypto-js/enc-hex', 'path', 'prettier/parser-html', 'prettier/parser-markdown', 'prettier/standalone', 'rxjs', 'crypto-js/sha256', 'mime-types', 'papaparse', '@mozilla/readability', 'jsdom', 'showdown', 'dotenv', 'jszip'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-wizard"] = {}, global.spaceTrim, global.crypto, global.socket_ioClient, global.Anthropic, global.Bottleneck, global.colors, global.openai, global.OpenAI, global.promises, global.child_process, global.waitasecond, global.cryptoJs, global.hexEncoder, global.path, global.parserHtml, global.parserMarkdown, global.standalone, global.rxjs, global.sha256, global.mimeTypes, global.papaparse, global.readability, global.jsdom, global.showdown, global.dotenv, global.JSZip));
+})(this, (function (exports, spaceTrim, crypto, socket_ioClient, Anthropic, Bottleneck, colors, openai, OpenAI, promises, child_process, waitasecond, cryptoJs, hexEncoder, path, parserHtml, parserMarkdown, standalone, rxjs, sha256, mimeTypes, papaparse, readability, jsdom, showdown, dotenv, JSZip) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -31,6 +31,7 @@
     var OpenAI__default = /*#__PURE__*/_interopDefaultLegacy(OpenAI);
     var hexEncoder__default = /*#__PURE__*/_interopDefaultLegacy(hexEncoder);
     var parserHtml__default = /*#__PURE__*/_interopDefaultLegacy(parserHtml);
+    var parserMarkdown__default = /*#__PURE__*/_interopDefaultLegacy(parserMarkdown);
     var sha256__default = /*#__PURE__*/_interopDefaultLegacy(sha256);
     var dotenv__namespace = /*#__PURE__*/_interopNamespace(dotenv);
     var JSZip__default = /*#__PURE__*/_interopDefaultLegacy(JSZip);
@@ -49,7 +50,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-44';
+    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-46';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -337,6 +338,13 @@
      * @public exported from `@promptbook/core`
      */
     const DEFAULT_MAX_REQUESTS_PER_MINUTE = 60;
+    /**
+     * API request timeout in milliseconds
+     * Can be overridden via API_REQUEST_TIMEOUT environment variable
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const API_REQUEST_TIMEOUT = parseInt(process.env.API_REQUEST_TIMEOUT || '90000');
     /**
      * Indicates whether pipeline logic validation is enabled. When true, the pipeline logic is checked for consistency.
      *
@@ -4565,7 +4573,18 @@
                 const openAiOptions = { ...this.options };
                 delete openAiOptions.isVerbose;
                 delete openAiOptions.userId;
-                this.client = new OpenAI__default["default"](openAiOptions);
+                // Enhanced configuration for better ECONNRESET handling
+                const enhancedOptions = {
+                    ...openAiOptions,
+                    timeout: API_REQUEST_TIMEOUT,
+                    maxRetries: CONNECTION_RETRIES_LIMIT,
+                    defaultHeaders: {
+                        Connection: 'keep-alive',
+                        'Keep-Alive': 'timeout=30, max=100',
+                        ...openAiOptions.defaultHeaders,
+                    },
+                };
+                this.client = new OpenAI__default["default"](enhancedOptions);
             }
             return this.client;
         }
@@ -4653,7 +4672,7 @@
                 console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
             const rawResponse = await this.limiter
-                .schedule(() => client.chat.completions.create(rawRequest))
+                .schedule(() => this.makeRequestWithRetry(() => client.chat.completions.create(rawRequest)))
                 .catch((error) => {
                 assertsError(error);
                 if (this.options.isVerbose) {
@@ -4729,7 +4748,7 @@
                 console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
             const rawResponse = await this.limiter
-                .schedule(() => client.completions.create(rawRequest))
+                .schedule(() => this.makeRequestWithRetry(() => client.completions.create(rawRequest)))
                 .catch((error) => {
                 assertsError(error);
                 if (this.options.isVerbose) {
@@ -4793,7 +4812,7 @@
                 console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
             const rawResponse = await this.limiter
-                .schedule(() => client.embeddings.create(rawRequest))
+                .schedule(() => this.makeRequestWithRetry(() => client.embeddings.create(rawRequest)))
                 .catch((error) => {
                 assertsError(error);
                 if (this.options.isVerbose) {
@@ -4851,6 +4870,76 @@
             }
             return model;
         }
+        // <- Note: [🤖] getDefaultXxxModel
+        /**
+         * Makes a request with retry logic for network errors like ECONNRESET
+         */
+        async makeRequestWithRetry(requestFn) {
+            let lastError;
+            for (let attempt = 1; attempt <= CONNECTION_RETRIES_LIMIT; attempt++) {
+                try {
+                    return await requestFn();
+                }
+                catch (error) {
+                    assertsError(error);
+                    lastError = error;
+                    // Check if this is a retryable network error
+                    const isRetryableError = this.isRetryableNetworkError(error);
+                    if (!isRetryableError || attempt === CONNECTION_RETRIES_LIMIT) {
+                        if (this.options.isVerbose) {
+                            console.info(colors__default["default"].bgRed('Final error after retries'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}:`, error);
+                        }
+                        throw error;
+                    }
+                    // Calculate exponential backoff delay
+                    const baseDelay = 1000; // 1 second
+                    const backoffDelay = baseDelay * Math.pow(2, attempt - 1);
+                    const jitterDelay = Math.random() * 500; // Add some randomness
+                    const totalDelay = backoffDelay + jitterDelay;
+                    if (this.options.isVerbose) {
+                        console.info(colors__default["default"].bgYellow('Retrying request'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}, waiting ${Math.round(totalDelay)}ms:`, error.message);
+                    }
+                    // Wait before retrying
+                    await new Promise((resolve) => setTimeout(resolve, totalDelay));
+                }
+            }
+            throw lastError;
+        }
+        /**
+         * Determines if an error is retryable (network-related errors)
+         */
+        isRetryableNetworkError(error) {
+            const errorMessage = error.message.toLowerCase();
+            const errorCode = error.code;
+            // Network connection errors that should be retried
+            const retryableErrors = [
+                'econnreset',
+                'enotfound',
+                'econnrefused',
+                'etimedout',
+                'socket hang up',
+                'network error',
+                'fetch failed',
+                'connection reset',
+                'connection refused',
+                'timeout',
+            ];
+            // Check error message
+            if (retryableErrors.some((retryableError) => errorMessage.includes(retryableError))) {
+                return true;
+            }
+            // Check error code
+            if (errorCode && retryableErrors.includes(errorCode.toLowerCase())) {
+                return true;
+            }
+            // Check for specific HTTP status codes that are retryable
+            const errorWithStatus = error;
+            const httpStatus = errorWithStatus.status || errorWithStatus.statusCode;
+            if (httpStatus && [429, 500, 502, 503, 504].includes(httpStatus)) {
+                return true;
+            }
+            return false;
+        }
     }
     /**
      * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`
@@ -6291,9 +6380,9 @@
      */
     function prettifyMarkdown(content) {
         try {
-            return prettier.format(content, {
+            return standalone.format(content, {
                 parser: 'markdown',
-                plugins: [parserHtml__default["default"]],
+                plugins: [parserMarkdown__default["default"], parserHtml__default["default"]],
                 // TODO: DRY - make some import or auto-copy of .prettierrc
                 endOfLine: 'lf',
                 tabWidth: 4,
@@ -7182,7 +7271,7 @@
      * @private internal helper function
      */
     function createTask(options) {
-        const { taskType, taskProcessCallback, tldrProvider } = options;
+        const { taskType, taskProcessCallback } = options;
         let { title } = options;
         // TODO: [🐙] DRY
         const taskId = `${taskType.toLowerCase().substring(0, 4)}-${$randomToken(8 /* <- TODO: To global config + Use Base58 to avoid similar char conflicts   */)}`;
@@ -7192,6 +7281,7 @@
         const errors = [];
         const warnings = [];
         let currentValue = {};
+        let customTldr = null;
         const partialResultSubject = new rxjs.Subject();
         // <- Note: Not using `BehaviorSubject` because on error we can't access the last value
         const finalResultPromise = /* not await */ taskProcessCallback((newOngoingResult) => {
@@ -7202,6 +7292,9 @@
             Object.assign(currentValue, newOngoingResult);
             // <- TODO: assign deep
             partialResultSubject.next(newOngoingResult);
+        }, (tldrInfo) => {
+            customTldr = tldrInfo;
+            updatedAt = new Date();
         });
         finalResultPromise
             .catch((error) => {
@@ -7257,9 +7350,9 @@
             },
             get tldr() {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-                // Use custom tldr provider if available
-                if (tldrProvider) {
-                    return tldrProvider(createdAt, status, currentValue, errors, warnings);
+                // Use custom tldr if available
+                if (customTldr) {
+                    return customTldr;
                 }
                 // Fallback to default implementation
                 const cv = currentValue;
@@ -7758,7 +7851,7 @@
         const result = await preparePersonaExecutor({
             availableModels /* <- Note: Passing as JSON */,
             personaDescription,
-        }).asPromise();
+        }).asPromise({ isCrashedOnError: true });
         const { outputParameters } = result;
         const { modelsRequirements: modelsRequirementsJson } = outputParameters;
         let modelsRequirementsUnchecked = jsonParse(modelsRequirementsJson);
@@ -8371,7 +8464,7 @@
             });
             const result = await prepareTitleExecutor({
                 book: sources.map(({ content }) => content).join('\n\n'),
-            }).asPromise();
+            }).asPromise({ isCrashedOnError: true });
             const { outputParameters } = result;
             const { title: titleRaw } = outputParameters;
             if (isVerbose) {
@@ -10320,80 +10413,74 @@
                 });
             });
         };
-        const pipelineExecutor = (inputParameters) => createTask({
-            taskType: 'EXECUTION',
-            title: pipeline.title,
-            taskProcessCallback(updateOngoingResult) {
-                return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
-                    updateOngoingResult(newOngoingResult);
-                });
-            },
-            tldrProvider(createdAt, status, currentValue, errors) {
-                var _a;
-                // Better progress estimation based on pipeline structure
-                const cv = currentValue;
-                // Handle finished/error states
-                if (status === 'FINISHED') {
-                    return {
-                        percent: 1,
-                        message: 'Finished',
-                    };
-                }
-                if (status === 'ERROR') {
-                    const errorMessage = errors.length > 0 ? errors[errors.length - 1].message : 'Error';
-                    return {
-                        percent: 0,
-                        message: errorMessage,
-                    };
-                }
-                // Calculate progress based on pipeline tasks
-                const totalTasks = pipeline.tasks.length;
-                let completedTasks = 0;
-                let currentTaskName = '';
-                // Check execution report for completed tasks
-                if ((_a = cv === null || cv === void 0 ? void 0 : cv.executionReport) === null || _a === void 0 ? void 0 : _a.promptExecutions) {
-                    const executedTaskTitles = new Set(cv.executionReport.promptExecutions.map((execution) => execution.prompt.title));
-                    // Count completed tasks by matching titles
-                    const completedTasksByTitle = pipeline.tasks.filter(task => executedTaskTitles.has(task.title));
-                    completedTasks = completedTasksByTitle.length;
-                    // Find current task being executed (first task not yet completed)
-                    const remainingTasks = pipeline.tasks.filter(task => !executedTaskTitles.has(task.title));
-                    if (remainingTasks.length > 0) {
-                        currentTaskName = remainingTasks[0].name;
-                    }
-                }
-                // Calculate progress percentage
-                let percent = totalTasks > 0 ? completedTasks / totalTasks : 0;
-                // Add time-based progress for current task (assuming 5 minutes total)
-                if (completedTasks < totalTasks) {
-                    const elapsedMs = new Date().getTime() - createdAt.getTime();
-                    const totalMs = 5 * 60 * 1000; // 5 minutes
-                    const timeProgress = Math.min(elapsedMs / totalMs, 1);
-                    // Add partial progress for current task
-                    percent += (1 / totalTasks) * timeProgress;
-                }
-                // Clamp to [0,1]
-                percent = Math.min(Math.max(percent, 0), 1);
-                // Generate message
-                let message = '';
-                if (currentTaskName) {
-                    // Find the task to get its title
-                    const currentTask = pipeline.tasks.find(task => task.name === currentTaskName);
-                    const taskTitle = (currentTask === null || currentTask === void 0 ? void 0 : currentTask.title) || currentTaskName;
-                    message = `Working on task ${taskTitle}`;
-                }
-                else if (completedTasks === 0) {
-                    message = 'Starting pipeline execution';
-                }
-                else {
-                    message = `Processing pipeline (${completedTasks}/${totalTasks} tasks completed)`;
-                }
-                return {
-                    percent,
-                    message,
-                };
-            },
-        });
+        const pipelineExecutor = (inputParameters) => {
+            const startTime = new Date().getTime();
+            return createTask({
+                taskType: 'EXECUTION',
+                title: pipeline.title,
+                taskProcessCallback(updateOngoingResult, updateTldr) {
+                    return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
+                        var _a, _b;
+                        updateOngoingResult(newOngoingResult);
+                        // Calculate and update tldr based on pipeline progress
+                        const cv = newOngoingResult;
+                        // Calculate progress based on parameters resolved vs total parameters
+                        const totalParameters = pipeline.parameters.filter(p => !p.isInput).length;
+                        let resolvedParameters = 0;
+                        let currentTaskTitle = '';
+                        // Get the resolved parameters from output parameters
+                        if (cv === null || cv === void 0 ? void 0 : cv.outputParameters) {
+                            // Count how many output parameters have non-empty values
+                            resolvedParameters = Object.values(cv.outputParameters).filter(value => value !== undefined && value !== null && String(value).trim() !== '').length;
+                        }
+                        // Try to determine current task from execution report
+                        if (((_a = cv === null || cv === void 0 ? void 0 : cv.executionReport) === null || _a === void 0 ? void 0 : _a.promptExecutions) && cv.executionReport.promptExecutions.length > 0) {
+                            const lastExecution = cv.executionReport.promptExecutions[cv.executionReport.promptExecutions.length - 1];
+                            if ((_b = lastExecution === null || lastExecution === void 0 ? void 0 : lastExecution.prompt) === null || _b === void 0 ? void 0 : _b.title) {
+                                currentTaskTitle = lastExecution.prompt.title;
+                            }
+                        }
+                        // Calculate base progress percentage
+                        let percent = totalParameters > 0 ? resolvedParameters / totalParameters : 0;
+                        // Add time-based progress for current task if we haven't completed all parameters
+                        if (resolvedParameters < totalParameters) {
+                            const elapsedMs = new Date().getTime() - startTime;
+                            const estimatedTotalMs = totalParameters * 30 * 1000; // Estimate 30 seconds per parameter
+                            const timeProgress = Math.min(elapsedMs / estimatedTotalMs, 0.9); // Cap at 90% for time-based progress
+                            // If we have time progress but no parameter progress, show time progress
+                            if (percent === 0 && timeProgress > 0) {
+                                percent = Math.min(timeProgress, 0.1); // Show some progress but not more than 10%
+                            }
+                            else if (percent < 1) {
+                                // Add partial progress for current task
+                                const taskProgress = totalParameters > 0 ? (1 / totalParameters) * 0.5 : 0; // 50% of task progress
+                                percent = Math.min(percent + taskProgress, 0.95); // Cap at 95% until fully complete
+                            }
+                        }
+                        // Clamp to [0,1]
+                        percent = Math.min(Math.max(percent, 0), 1);
+                        // Generate message
+                        let message = '';
+                        if (currentTaskTitle) {
+                            message = `Executing: ${currentTaskTitle}`;
+                        }
+                        else if (resolvedParameters === 0) {
+                            message = 'Starting pipeline execution';
+                        }
+                        else if (resolvedParameters < totalParameters) {
+                            message = `Processing pipeline (${resolvedParameters}/${totalParameters} parameters resolved)`;
+                        }
+                        else {
+                            message = 'Completing pipeline execution';
+                        }
+                        updateTldr({
+                            percent: percent,
+                            message,
+                        });
+                    });
+                },
+            });
+        };
         //        <- TODO: Make types such as there is no need to do `as` for `createTask`
         return pipelineExecutor;
     }
@@ -10478,7 +10565,9 @@
                 },
             });
             const knowledgeContent = await source.asText();
-            const result = await prepareKnowledgeFromMarkdownExecutor({ knowledgeContent }).asPromise();
+            const result = await prepareKnowledgeFromMarkdownExecutor({ knowledgeContent }).asPromise({
+                isCrashedOnError: true,
+            });
             const { outputParameters } = result;
             const { knowledgePieces: knowledgePiecesRaw } = outputParameters;
             const knowledgeTextPieces = (knowledgePiecesRaw || '').split('\n---\n');
@@ -10502,12 +10591,16 @@
               ];
               */
                 try {
-                    const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise();
+                    const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise({
+                        isCrashedOnError: true,
+                    });
                     const { title: titleRaw = 'Untitled' } = titleResult.outputParameters;
                     title = spaceTrim__default["default"](titleRaw) /* <- TODO: Maybe do in pipeline */;
                     name = titleToName(title);
                     // --- Keywords
-                    const keywordsResult = await prepareKeywordsExecutor({ knowledgePieceContent }).asPromise();
+                    const keywordsResult = await prepareKeywordsExecutor({ knowledgePieceContent }).asPromise({
+                        isCrashedOnError: true,
+                    });
                     const { keywords: keywordsRaw = '' } = keywordsResult.outputParameters;
                     keywords = (keywordsRaw || '')
                         .split(',')
@@ -13174,31 +13267,23 @@
         return content;
     }
 
+    /**
+     * @private internal for `preserve`
+     */
+    const _preserved = [];
     /**
      * Does nothing, but preserves the function in the bundle
      * Compiler is tricked into thinking the function is used
      *
      * @param value any function to preserve
      * @returns nothing
-     * @private internal function of `JavascriptExecutionTools` and `JavascriptEvalExecutionTools`
-     */
-    function preserve(func) {
-        // Note: NOT calling the function
-        (async () => {
-            // TODO: [💩] Change to `await forEver` or `forTime(Infinity)`
-            await waitasecond.forTime(100000000);
-            // [1]
-            try {
-                await func();
-            }
-            finally {
-                // do nothing
-            }
-        })();
+     * @private within the repository
+     */
+    function $preserve(...value) {
+        _preserved.push(...value);
     }
     /**
-     * TODO: Probably remove in favour of `keepImported`
-     * TODO: [1] This maybe does memory leak
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
     // Note: [💎]
@@ -13226,25 +13311,25 @@
             // Note: [💎]
             // Note: Using direct eval, following variables are in same scope as eval call so they are accessible from inside the evaluated script:
             const spaceTrim = (_) => spaceTrim__default["default"](_);
-            preserve(spaceTrim);
+            $preserve(spaceTrim);
             const removeQuotes$1 = removeQuotes;
-            preserve(removeQuotes$1);
+            $preserve(removeQuotes$1);
             const unwrapResult$1 = unwrapResult;
-            preserve(unwrapResult$1);
+            $preserve(unwrapResult$1);
             const trimEndOfCodeBlock$1 = trimEndOfCodeBlock;
-            preserve(trimEndOfCodeBlock$1);
+            $preserve(trimEndOfCodeBlock$1);
             const trimCodeBlock$1 = trimCodeBlock;
-            preserve(trimCodeBlock$1);
+            $preserve(trimCodeBlock$1);
             // TODO: DRY [🍯]
             const trim = (str) => str.trim();
-            preserve(trim);
+            $preserve(trim);
             // TODO: DRY [🍯]
             const reverse = (str) => str.split('').reverse().join('');
-            preserve(reverse);
+            $preserve(reverse);
             const removeEmojis$1 = removeEmojis;
-            preserve(removeEmojis$1);
+            $preserve(removeEmojis$1);
             const prettifyMarkdown$1 = prettifyMarkdown;
-            preserve(prettifyMarkdown$1);
+            $preserve(prettifyMarkdown$1);
             //-------[n12:]---
             const capitalize$1 = capitalize;
             const decapitalize$1 = decapitalize;
@@ -13260,18 +13345,18 @@
             // TODO: DRY [🍯]
             Array.from(parseKeywordsFromString(input)).join(', '); /* <- TODO: [🧠] What is the best format comma list, bullet list,...? */
             const normalizeTo_SCREAMING_CASE$1 = normalizeTo_SCREAMING_CASE;
-            preserve(capitalize$1);
-            preserve(decapitalize$1);
-            preserve(nameToUriPart$1);
-            preserve(nameToUriParts$1);
-            preserve(removeDiacritics$1);
-            preserve(normalizeWhitespaces$1);
-            preserve(normalizeToKebabCase$1);
-            preserve(normalizeTo_camelCase$1);
-            preserve(normalizeTo_snake_case$1);
-            preserve(normalizeTo_PascalCase$1);
-            preserve(parseKeywords);
-            preserve(normalizeTo_SCREAMING_CASE$1);
+            $preserve(capitalize$1);
+            $preserve(decapitalize$1);
+            $preserve(nameToUriPart$1);
+            $preserve(nameToUriParts$1);
+            $preserve(removeDiacritics$1);
+            $preserve(normalizeWhitespaces$1);
+            $preserve(normalizeToKebabCase$1);
+            $preserve(normalizeTo_camelCase$1);
+            $preserve(normalizeTo_snake_case$1);
+            $preserve(normalizeTo_PascalCase$1);
+            $preserve(parseKeywords);
+            $preserve(normalizeTo_SCREAMING_CASE$1);
             //-------[/n12]---
             if (!script.includes('return')) {
                 script = `return ${script}`;
@@ -17320,7 +17405,7 @@
             // ▶ Create executor - the function that will execute the Pipeline
             const pipelineExecutor = createPipelineExecutor({ pipeline, tools });
             // 🚀▶ Execute the Pipeline
-            const result = await pipelineExecutor(inputParameters).asPromise();
+            const result = await pipelineExecutor(inputParameters).asPromise({ isCrashedOnError: true });
             const { outputParameters } = result;
             const outputParametersLength = Object.keys(outputParameters).length;
             let resultString;