@promptbook/remote-server 0.88.0-1 → 0.88.0-8

package/esm/index.es.js

@@ -7,7 +7,7 @@ import { forTime } from 'waitasecond';
 import { spawn } from 'child_process';
 import { stat, access, constants, readFile, writeFile, readdir, mkdir } from 'fs/promises';
 import { join, basename, dirname } from 'path';
-import { BehaviorSubject } from 'rxjs';
+import { Subject } from 'rxjs';
 import { randomBytes } from 'crypto';
 import { format } from 'prettier';
 import parserHtml from 'prettier/parser-html';
@@ -31,7 +31,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.88.0-1';
+const PROMPTBOOK_ENGINE_VERSION = '0.88.0-8';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1793,21 +1793,41 @@ function assertsTaskSuccessful(executionResult) {
 function createTask(options) {
     const { taskType, taskProcessCallback } = options;
     const taskId = `${taskType.toLowerCase().substring(0, 4)}-${$randomToken(8 /* <- TODO: To global config + Use Base58 to avoid simmilar char conflicts   */)}`;
-    const partialResultSubject = new BehaviorSubject({});
+    let status = 'RUNNING';
+    const createdAt = new Date();
+    let updatedAt = createdAt;
+    const errors = [];
+    const warnings = [];
+    const currentValue = {};
+    const partialResultSubject = new Subject();
+    // <- Note: Not using `BehaviorSubject` because on error we can't access the last value
     const finalResultPromise = /* not await */ taskProcessCallback((newOngoingResult) => {
+        Object.assign(currentValue, newOngoingResult);
         partialResultSubject.next(newOngoingResult);
     });
     finalResultPromise
         .catch((error) => {
+        errors.push(error);
         partialResultSubject.error(error);
     })
-        .then((value) => {
-        if (value) {
+        .then((executionResult) => {
+        if (executionResult) {
             try {
-                assertsTaskSuccessful(value);
-                partialResultSubject.next(value);
+                updatedAt = new Date();
+                errors.push(...executionResult.errors);
+                warnings.push(...executionResult.warnings);
+                // <- TODO: !!! Only unique errors and warnings should be added (or filtered)
+                // TODO: [🧠] !!! errors, warning, isSuccessful  are redundant both in `ExecutionTask` and `ExecutionTask.currentValue`
+                //            Also maybe move `ExecutionTask.currentValue.usage` -> `ExecutionTask.usage`
+                //            And delete `ExecutionTask.currentValue.preparedPipeline`
+                assertsTaskSuccessful(executionResult);
+                status = 'FINISHED';
+                Object.assign(currentValue, executionResult);
+                partialResultSubject.next(executionResult);
             }
             catch (error) {
+                status = 'ERROR';
+                errors.push(error);
                 partialResultSubject.error(error);
             }
         }
@@ -1824,12 +1844,33 @@ function createTask(options) {
     return {
         taskType,
         taskId,
+        get status() {
+            return status;
+            // <- Note: [1] Theese must be getters to allow changing the value in the future
+        },
+        get createdAt() {
+            return createdAt;
+            // <- Note: [1]
+        },
+        get updatedAt() {
+            return updatedAt;
+            // <- Note: [1]
+        },
         asPromise,
         asObservable() {
             return partialResultSubject.asObservable();
         },
+        get errors() {
+            return errors;
+            // <- Note: [1]
+        },
+        get warnings() {
+            return warnings;
+            // <- Note: [1]
+        },
         get currentValue() {
-            return partialResultSubject.value;
+            return currentValue;
+            // <- Note: [1]
         },
     };
 }
@@ -5053,7 +5094,7 @@ async function executeAttempts(options) {
                         Last result:
                         ${block($ongoingTaskResult.$resultString === null
                     ? 'null'
-                    : $ongoingTaskResult.$resultString
+                    : spaceTrim($ongoingTaskResult.$resultString)
                         .split('\n')
                         .map((line) => `> ${line}`)
                         .join('\n'))}
@@ -6740,8 +6781,35 @@ function startRemoteServer(options) {
                 .send({ error: serializeError(error) });
         }
     });
+    function exportExecutionTask(executionTask, isFull) {
+        // <- TODO: [🧠] This should be maybe method of `ExecutionTask` itself
+        const { taskType, taskId, status, errors, warnings, createdAt, updatedAt, currentValue } = executionTask;
+        if (isFull) {
+            return {
+                nonce: '✨',
+                taskId,
+                taskType,
+                status,
+                errors: errors.map(serializeError),
+                warnings: warnings.map(serializeError),
+                createdAt,
+                updatedAt,
+                currentValue,
+            };
+        }
+        else {
+            return {
+                nonce: '✨',
+                taskId,
+                taskType,
+                status,
+                createdAt,
+                updatedAt,
+            };
+        }
+    }
     app.get(`${rootPath}/executions`, async (request, response) => {
-        response.send(runningExecutionTasks);
+        response.send(runningExecutionTasks.map((runningExecutionTask) => exportExecutionTask(runningExecutionTask, false)));
     });
     app.get(`${rootPath}/executions/last`, async (request, response) => {
         // TODO: [🤬] Filter only for user
@@ -6749,20 +6817,20 @@ function startRemoteServer(options) {
             response.status(404).send('No execution tasks found');
             return;
         }
-        const lastExecution = runningExecutionTasks[runningExecutionTasks.length - 1];
-        response.send(lastExecution);
+        const lastExecutionTask = runningExecutionTasks[runningExecutionTasks.length - 1];
+        response.send(exportExecutionTask(lastExecutionTask, true));
     });
     app.get(`${rootPath}/executions/:taskId`, async (request, response) => {
         const { taskId } = request.params;
         // TODO: [🤬] Filter only for user
-        const execution = runningExecutionTasks.find((executionTask) => executionTask.taskId === taskId);
-        if (execution === undefined) {
+        const executionTask = runningExecutionTasks.find((executionTask) => executionTask.taskId === taskId);
+        if (executionTask === undefined) {
             response
                 .status(404)
                 .send(`Execution "${taskId}" not found`);
             return;
         }
-        response.send(execution.currentValue);
+        response.send(exportExecutionTask(executionTask, true));
     });
     app.post(`${rootPath}/executions/new`, async (request, response) => {
         try {