@promptbook/remote-server 0.100.0-4 → 0.100.0-41

package/README.md

@@ -18,6 +18,7 @@ Write AI applications using plain human language across multiple models and plat
 
 ## 🌟 New Features
 
+-   🚀 **GPT-5 Support** - Now includes OpenAI's most advanced language model with unprecedented reasoning capabilities and 200K context window
 -   💡 VS Code support for `.book` files with syntax highlighting and IntelliSense
 -   🐳 Official Docker image (`hejny/promptbook`) for seamless containerized usage
 -   🔥 Native support for OpenAI `o3-mini`, GPT-4 and other leading LLMs

package/esm/index.es.js

@@ -33,7 +33,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.100.0-4';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.0-41';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -216,6 +216,12 @@ let DEFAULT_IS_VERBOSE = false;
  * @public exported from `@promptbook/core`
  */
 const DEFAULT_IS_AUTO_INSTALLED = false;
+/**
+ * Default simulated duration for a task in milliseconds (used for progress reporting)
+ *
+ * @public exported from `@promptbook/core`
+ */
+const DEFAULT_TASK_SIMULATED_DURATION_MS = 5 * 60 * 1000; // 5 minutes
 /**
  * Indicates whether pipeline logic validation is enabled. When true, the pipeline logic is checked for consistency.
  *
@@ -2000,7 +2006,7 @@ function assertsTaskSuccessful(executionResult) {
  * @private internal helper function
  */
 function createTask(options) {
-    const { taskType, taskProcessCallback } = options;
+    const { taskType, taskProcessCallback, tldrProvider } = 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   */)}`;
@@ -2073,6 +2079,78 @@ function createTask(options) {
             return status;
             // <- Note: [1] --||--
         },
+        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);
+            }
+            // Fallback to default implementation
+            const cv = currentValue;
+            // If explicit percent is provided, use it
+            let percentRaw = (_f = (_d = (_b = (_a = cv === null || cv === void 0 ? void 0 : cv.tldr) === null || _a === void 0 ? void 0 : _a.percent) !== null && _b !== void 0 ? _b : (_c = cv === null || cv === void 0 ? void 0 : cv.usage) === null || _c === void 0 ? void 0 : _c.percent) !== null && _d !== void 0 ? _d : (_e = cv === null || cv === void 0 ? void 0 : cv.progress) === null || _e === void 0 ? void 0 : _e.percent) !== null && _f !== void 0 ? _f : cv === null || cv === void 0 ? void 0 : cv.percent;
+            // Simulate progress if not provided
+            if (typeof percentRaw !== 'number') {
+                // Simulate progress: evenly split across subtasks, based on elapsed time
+                const now = new Date();
+                const elapsedMs = now.getTime() - createdAt.getTime();
+                const totalMs = DEFAULT_TASK_SIMULATED_DURATION_MS;
+                // If subtasks are defined, split progress evenly
+                const subtaskCount = Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks) ? cv.subtasks.length : 1;
+                const completedSubtasks = Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks)
+                    ? cv.subtasks.filter((s) => s.done || s.completed).length
+                    : 0;
+                // Progress from completed subtasks
+                const subtaskProgress = subtaskCount > 0 ? completedSubtasks / subtaskCount : 0;
+                // Progress from elapsed time for current subtask
+                const timeProgress = Math.min(elapsedMs / totalMs, 1);
+                // Combine: completed subtasks + time progress for current subtask
+                percentRaw = Math.min(subtaskProgress + (1 / subtaskCount) * timeProgress, 1);
+                if (status === 'FINISHED')
+                    percentRaw = 1;
+                if (status === 'ERROR')
+                    percentRaw = 0;
+            }
+            // Clamp to [0,1]
+            let percent = Number(percentRaw) || 0;
+            if (percent < 0)
+                percent = 0;
+            if (percent > 1)
+                percent = 1;
+            // Build a short message: prefer explicit tldr.message, then common summary/message fields, then errors/warnings, then status
+            const messageFromResult = (_k = (_j = (_h = (_g = cv === null || cv === void 0 ? void 0 : cv.tldr) === null || _g === void 0 ? void 0 : _g.message) !== null && _h !== void 0 ? _h : cv === null || cv === void 0 ? void 0 : cv.message) !== null && _j !== void 0 ? _j : cv === null || cv === void 0 ? void 0 : cv.summary) !== null && _k !== void 0 ? _k : cv === null || cv === void 0 ? void 0 : cv.statusMessage;
+            let message = messageFromResult;
+            if (!message) {
+                // If subtasks, show current subtask
+                if (Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks) && cv.subtasks.length > 0) {
+                    const current = cv.subtasks.find((s) => !s.done && !s.completed);
+                    if (current && current.title) {
+                        message = `Working on ${current.title}`;
+                    }
+                }
+                if (!message) {
+                    if (errors.length) {
+                        message = errors[errors.length - 1].message || 'Error';
+                    }
+                    else if (warnings.length) {
+                        message = warnings[warnings.length - 1].message || 'Warning';
+                    }
+                    else if (status === 'FINISHED') {
+                        message = 'Finished';
+                    }
+                    else if (status === 'ERROR') {
+                        message = 'Error';
+                    }
+                    else {
+                        message = 'Running';
+                    }
+                }
+            }
+            return {
+                percent: percent,
+                message,
+            };
+        },
         get createdAt() {
             return createdAt;
             // <- Note: [1] --||--
@@ -5282,7 +5360,7 @@ function validatePromptResult(options) {
  */
 async function executeAttempts(options) {
     const { jokerParameterNames, priority, maxAttempts, // <- Note: [💂]
-    preparedContent, parameters, task, preparedPipeline, tools, $executionReport, pipelineIdentification, maxExecutionAttempts, } = options;
+    preparedContent, parameters, task, preparedPipeline, tools, $executionReport, pipelineIdentification, maxExecutionAttempts, onProgress, } = options;
     const $ongoingTaskResult = {
         $result: null,
         $resultString: null,
@@ -5526,6 +5604,10 @@ async function executeAttempts(options) {
                 result: $ongoingTaskResult.$resultString,
                 error: error,
             });
+            // Report failed attempt
+            onProgress({
+                errors: [error],
+            });
         }
         finally {
             if (!isJokerAttempt &&
@@ -6407,6 +6489,71 @@ function createPipelineExecutor(options) {
                 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,
+            };
+        },
     });
     //        <- TODO: Make types such as there is no need to do `as` for `createTask`
     return pipelineExecutor;
@@ -8144,7 +8291,7 @@ function startRemoteServer(options) {
     });
     function exportExecutionTask(executionTask, isFull) {
         // <- TODO: [🧠] This should be maybe method of `ExecutionTask` itself
-        const { taskType, promptbookVersion, taskId, title, status, errors, warnings, createdAt, updatedAt, currentValue, } = executionTask;
+        const { taskType, promptbookVersion, taskId, title, status, errors, tldr, warnings, createdAt, updatedAt, currentValue, } = executionTask;
         if (isFull) {
             return {
                 taskId,
@@ -8152,6 +8299,7 @@ function startRemoteServer(options) {
                 taskType,
                 promptbookVersion,
                 status,
+                tldr,
                 errors: errors.map(serializeError),
                 warnings: warnings.map(serializeError),
                 createdAt,
@@ -8166,6 +8314,7 @@ function startRemoteServer(options) {
                 taskType,
                 promptbookVersion,
                 status,
+                tldr,
                 createdAt,
                 updatedAt,
             };