@promptbook/markdown-utils 0.100.0-45 → 0.100.0-47

package/esm/index.es.js

@@ -1,6 +1,7 @@
 import spaceTrim, { spaceTrim as spaceTrim$1 } from 'spacetrim';
-import { format } from 'prettier';
 import parserHtml from 'prettier/parser-html';
+import parserMarkdown from 'prettier/parser-markdown';
+import { format } from 'prettier/standalone';
 import { randomBytes } from 'crypto';
 import { Subject } from 'rxjs';
 import { forTime } from 'waitasecond';
@@ -25,7 +26,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.100.0-45';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.0-47';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -353,6 +354,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.
  *
@@ -693,7 +701,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,
@@ -2850,7 +2858,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);
@@ -4001,7 +4009,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) {
@@ -6114,64 +6122,74 @@ function createPipelineExecutor(options) {
             });
         });
     };
-    const pipelineExecutor = (inputParameters) => createTask({
-        taskType: 'EXECUTION',
-        title: pipeline.title,
-        taskProcessCallback(updateOngoingResult, updateTldr) {
-            return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
-                var _a;
-                updateOngoingResult(newOngoingResult);
-                // Calculate and update tldr based on pipeline progress
-                const cv = newOngoingResult;
-                // 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;
+    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;
                     }
-                }
-                // 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() - new Date().getTime(); // Will be overridden by actual elapsed time in task
-                    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)`;
-                }
-                updateTldr({
-                    percent: percent,
-                    message,
+                    // 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;
 }
@@ -6256,7 +6274,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');
@@ -6280,12 +6300,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(',')