@promptbook/wizard 0.100.0-44 → 0.100.0-46

package/esm/index.es.js

@@ -12,8 +12,9 @@ import { forTime } from 'waitasecond';
 import { SHA256 } from 'crypto-js';
 import hexEncoder from 'crypto-js/enc-hex';
 import { basename, join, dirname, relative } from 'path';
-import { format } from 'prettier';
 import parserHtml from 'prettier/parser-html';
+import parserMarkdown from 'prettier/parser-markdown';
+import { format } from 'prettier/standalone';
 import { Subject } from 'rxjs';
 import sha256 from 'crypto-js/sha256';
 import { lookup, extension } from 'mime-types';
@@ -38,7 +39,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @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
@@ -326,6 +327,13 @@ const DEFAULT_TASK_SIMULATED_DURATION_MS = 5 * 60 * 1000; // 5 minutes
  * @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.
  *
@@ -4554,7 +4562,18 @@ class OpenAiCompatibleExecutionTools {
             const openAiOptions = { ...this.options };
             delete openAiOptions.isVerbose;
             delete openAiOptions.userId;
-            this.client = new OpenAI(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(enhancedOptions);
         }
         return this.client;
     }
@@ -4642,7 +4661,7 @@ class OpenAiCompatibleExecutionTools {
             console.info(colors.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) {
@@ -4718,7 +4737,7 @@ class OpenAiCompatibleExecutionTools {
             console.info(colors.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) {
@@ -4782,7 +4801,7 @@ class OpenAiCompatibleExecutionTools {
             console.info(colors.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) {
@@ -4840,6 +4859,76 @@ class OpenAiCompatibleExecutionTools {
         }
         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.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.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`
@@ -6282,7 +6371,7 @@ function prettifyMarkdown(content) {
     try {
         return format(content, {
             parser: 'markdown',
-            plugins: [parserHtml],
+            plugins: [parserMarkdown, parserHtml],
             // TODO: DRY - make some import or auto-copy of .prettierrc
             endOfLine: 'lf',
             tabWidth: 4,
@@ -7171,7 +7260,7 @@ function assertsTaskSuccessful(executionResult) {
  * @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   */)}`;
@@ -7181,6 +7270,7 @@ function createTask(options) {
     const errors = [];
     const warnings = [];
     let currentValue = {};
+    let customTldr = null;
     const partialResultSubject = new Subject();
     // <- Note: Not using `BehaviorSubject` because on error we can't access the last value
     const finalResultPromise = /* not await */ taskProcessCallback((newOngoingResult) => {
@@ -7191,6 +7281,9 @@ function createTask(options) {
         Object.assign(currentValue, newOngoingResult);
         // <- TODO: assign deep
         partialResultSubject.next(newOngoingResult);
+    }, (tldrInfo) => {
+        customTldr = tldrInfo;
+        updatedAt = new Date();
     });
     finalResultPromise
         .catch((error) => {
@@ -7246,9 +7339,9 @@ function createTask(options) {
         },
         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;
@@ -7747,7 +7840,7 @@ async function preparePersona(personaDescription, tools, options) {
     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);
@@ -8360,7 +8453,7 @@ async function preparePipeline(pipeline, tools, options) {
         });
         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) {
@@ -10309,80 +10402,74 @@ function createPipelineExecutor(options) {
             });
         });
     };
-    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;
 }
@@ -10467,7 +10554,9 @@ class MarkdownScraper {
             },
         });
         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');
@@ -10491,12 +10580,16 @@ class MarkdownScraper {
           ];
           */
             try {
-                const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise();
+                const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise({
+                    isCrashedOnError: true,
+                });
                 const { title: titleRaw = 'Untitled' } = titleResult.outputParameters;
                 title = spaceTrim(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(',')
@@ -13163,31 +13256,23 @@ function extractBlock(markdown) {
     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 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: [💎]
@@ -13215,25 +13300,25 @@ class JavascriptEvalExecutionTools {
         // 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$1 = (_) => spaceTrim(_);
-        preserve(spaceTrim$1);
+        $preserve(spaceTrim$1);
         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;
@@ -13249,18 +13334,18 @@ class JavascriptEvalExecutionTools {
         // 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}`;
@@ -17309,7 +17394,7 @@ class Wizard {
         // ▶ 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;