@promptbook/remote-server 0.100.0-44 → 0.100.0-46

package/esm/index.es.js

@@ -11,8 +11,9 @@ import { spawn } from 'child_process';
 import { stat, access, constants, readFile, writeFile, readdir, mkdir } from 'fs/promises';
 import { join, basename, dirname } from 'path';
 import { Subject } from 'rxjs';
-import { format } from 'prettier';
 import parserHtml from 'prettier/parser-html';
+import parserMarkdown from 'prettier/parser-markdown';
+import { format } from 'prettier/standalone';
 import hexEncoder from 'crypto-js/enc-hex';
 import sha256 from 'crypto-js/sha256';
 import { SHA256 } from 'crypto-js';
@@ -33,7 +34,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
@@ -222,6 +223,13 @@ const DEFAULT_IS_AUTO_INSTALLED = false;
  * @public exported from `@promptbook/core`
  */
 const DEFAULT_TASK_SIMULATED_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * API request timeout in milliseconds
+ * Can be overridden via API_REQUEST_TIMEOUT environment variable
+ *
+ * @public exported from `@promptbook/core`
+ */
+parseInt(process.env.API_REQUEST_TIMEOUT || '90000');
 /**
  * Indicates whether pipeline logic validation is enabled. When true, the pipeline logic is checked for consistency.
  *
@@ -2006,7 +2014,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   */)}`;
@@ -2016,6 +2024,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) => {
@@ -2026,6 +2035,9 @@ function createTask(options) {
         Object.assign(currentValue, newOngoingResult);
         // <- TODO: assign deep
         partialResultSubject.next(newOngoingResult);
+    }, (tldrInfo) => {
+        customTldr = tldrInfo;
+        updatedAt = new Date();
     });
     finalResultPromise
         .catch((error) => {
@@ -2081,9 +2093,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;
@@ -2356,7 +2368,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,
@@ -3098,7 +3110,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);
@@ -4249,7 +4261,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) {
@@ -6481,80 +6493,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;
 }
@@ -7161,31 +7167,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: [💎]
@@ -7213,25 +7211,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;
@@ -7247,18 +7245,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}`;