@promptbook/remote-server 0.86.31 → 0.88.0-10

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.86.31';
+const PROMPTBOOK_ENGINE_VERSION = '0.88.0-10';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1721,6 +1721,57 @@ function $randomToken(randomness) {
  * TODO: Maybe use nanoid instead https://github.com/ai/nanoid
  */
 
+/**
+ * Function isValidJsonString will tell you if the string is valid JSON or not
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function isValidJsonString(value /* <- [👨‍⚖️] */) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        if (error.message.includes('Unexpected token')) {
+            return false;
+        }
+        return false;
+    }
+}
+
+/**
+ * Recursively converts JSON strings to JSON objects
+
+ * @public exported from `@promptbook/utils`
+ */
+function jsonStringsToJsons(object) {
+    if (object === null) {
+        return object;
+    }
+    if (Array.isArray(object)) {
+        return object.map(jsonStringsToJsons);
+    }
+    if (typeof object !== 'object') {
+        return object;
+    }
+    const newObject = { ...object };
+    for (const [key, value] of Object.entries(object)) {
+        if (typeof value === 'string' && isValidJsonString(value)) {
+            newObject[key] = JSON.parse(value);
+        }
+        else {
+            newObject[key] = jsonStringsToJsons(value);
+        }
+    }
+    return newObject;
+}
+/**
+ * TODO: Type the return type correctly
+ */
+
 /**
  * Deserializes the error object
  *
@@ -1793,21 +1844,43 @@ 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 = [];
+    let 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);
+        // <- TODO: assign deep
         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';
+                currentValue = jsonStringsToJsons(executionResult);
+                // <- TODO: [🧠] Is this a good idea to convert JSON strins to JSONs?
+                partialResultSubject.next(executionResult);
             }
             catch (error) {
+                status = 'ERROR';
+                errors.push(error);
                 partialResultSubject.error(error);
             }
         }
@@ -1824,12 +1897,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]
         },
     };
 }
@@ -1904,27 +1998,6 @@ function isValidFilePath(filename) {
  * TODO: [🍏] Implement for MacOs
  */
 
-/**
- * Function isValidJsonString will tell you if the string is valid JSON or not
- *
- * @public exported from `@promptbook/utils`
- */
-function isValidJsonString(value /* <- [👨‍⚖️] */) {
-    try {
-        JSON.parse(value);
-        return true;
-    }
-    catch (error) {
-        if (!(error instanceof Error)) {
-            throw error;
-        }
-        if (error.message.includes('Unexpected token')) {
-            return false;
-        }
-        return false;
-    }
-}
-
 /**
  * Function `validatePipelineString` will validate the if the string is a valid pipeline string
  * It does not check if the string is fully logically correct, but if it is a string that can be a pipeline string or the string looks completely different.
@@ -3972,7 +4045,7 @@ function valueToString(value) {
  * @param script from which to extract the variables
  * @returns the list of variable names
  * @throws {ParseError} if the script is invalid
- * @public exported from `@promptbook/execute-javascript`
+ * @public exported from `@promptbook/javascript`
  */
 function extractVariablesFromJavascript(script) {
     const variables = new Set();
@@ -5053,7 +5126,7 @@ async function executeAttempts(options) {
                         Last result:
                         ${block($ongoingTaskResult.$resultString === null
                     ? 'null'
-                    : $ongoingTaskResult.$resultString
+                    : spaceTrim($ongoingTaskResult.$resultString)
                         .split('\n')
                         .map((line) => `> ${line}`)
                         .join('\n'))}
@@ -5946,6 +6019,623 @@ async function $provideScrapersForNode(tools, options) {
  * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */
 
+/**
+ * @@@
+ *
+ * @param text @@@
+ * @param _isFirstLetterCapital @@@
+ * @returns @@@
+ * @example 'helloWorld'
+ * @example 'iLovePromptbook'
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeTo_camelCase(text, _isFirstLetterCapital = false) {
+    let charType;
+    let lastCharType = null;
+    let normalizedName = '';
+    for (const char of text) {
+        let normalizedChar;
+        if (/^[a-z]$/.test(char)) {
+            charType = 'LOWERCASE';
+            normalizedChar = char;
+        }
+        else if (/^[A-Z]$/.test(char)) {
+            charType = 'UPPERCASE';
+            normalizedChar = char.toLowerCase();
+        }
+        else if (/^[0-9]$/.test(char)) {
+            charType = 'NUMBER';
+            normalizedChar = char;
+        }
+        else {
+            charType = 'OTHER';
+            normalizedChar = '';
+        }
+        if (!lastCharType) {
+            if (_isFirstLetterCapital) {
+                normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
+            }
+        }
+        else if (charType !== lastCharType &&
+            !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
+            !(lastCharType === 'NUMBER') &&
+            !(charType === 'NUMBER')) {
+            normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
+        }
+        normalizedName += normalizedChar;
+        lastCharType = charType;
+    }
+    return normalizedName;
+}
+/**
+ * TODO: [🌺] Use some intermediate util splitWords
+ */
+
+/**
+ * Detects if the code is running in a browser environment in main thread (Not in a web worker)
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+ *
+ * @public exported from `@promptbook/utils`
+ */
+new Function(`
+    try {
+        return this === window;
+    } catch (e) {
+        return false;
+    }
+`);
+/**
+ * TODO: [🎺]
+ */
+
+/**
+ * Detects if the code is running in jest environment
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+ *
+ * @public exported from `@promptbook/utils`
+ */
+new Function(`
+    try {
+        return process.env.JEST_WORKER_ID !== undefined;
+    } catch (e) {
+        return false;
+    }
+`);
+/**
+ * TODO: [🎺]
+ */
+
+/**
+ * Detects if the code is running in a web worker
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+ *
+ * @public exported from `@promptbook/utils`
+ */
+new Function(`
+    try {
+        if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
+            return true;
+        } else {
+            return false;
+        }
+    } catch (e) {
+        return false;
+    }
+`);
+/**
+ * TODO: [🎺]
+ */
+
+/**
+ * Makes first letter of a string uppercase
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function decapitalize(word) {
+    return word.substring(0, 1).toLowerCase() + word.substring(1);
+}
+
+/**
+ * Parses keywords from a string
+ *
+ * @param {string} input
+ * @returns {Set} of keywords without diacritics in lowercase
+ * @public exported from `@promptbook/utils`
+ */
+function parseKeywordsFromString(input) {
+    const keywords = normalizeTo_SCREAMING_CASE(removeDiacritics(input))
+        .toLowerCase()
+        .split(/[^a-z0-9]+/gs)
+        .filter((value) => value);
+    return new Set(keywords);
+}
+
+/**
+ * @@@
+ *
+ * @param name @@@
+ * @returns @@@
+ * @example @@@
+ * @public exported from `@promptbook/utils`
+ */
+function nameToUriPart(name) {
+    let uriPart = name;
+    uriPart = uriPart.toLowerCase();
+    uriPart = removeDiacritics(uriPart);
+    uriPart = uriPart.replace(/[^a-zA-Z0-9]+/g, '-');
+    uriPart = uriPart.replace(/^-+/, '');
+    uriPart = uriPart.replace(/-+$/, '');
+    return uriPart;
+}
+
+/**
+ * @@@
+ *
+ * @param name @@@
+ * @returns @@@
+ * @example @@@
+ * @public exported from `@promptbook/utils`
+ */
+function nameToUriParts(name) {
+    return nameToUriPart(name)
+        .split('-')
+        .filter((value) => value !== '');
+}
+
+/**
+ *
+ * @param text @public exported from `@promptbook/utils`
+ * @returns
+ * @example 'HelloWorld'
+ * @example 'ILovePromptbook'
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeTo_PascalCase(text) {
+    return normalizeTo_camelCase(text, true);
+}
+
+/**
+ * Take every whitespace (space, new line, tab) and replace it with a single space
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeWhitespaces(sentence) {
+    return sentence.replace(/\s+/gs, ' ').trim();
+}
+
+/**
+ * Removes quotes from a string
+ *
+ * Tip: This is very usefull for post-processing of the result of the LLM model
+ * Note: This function removes only the same quotes from the beginning and the end of the string
+ * Note: There are two simmilar functions:
+ * - `removeQuotes` which removes only bounding quotes
+ * - `unwrapResult` which removes whole introduce sentence
+ *
+ * @param text optionally quoted text
+ * @returns text without quotes
+ * @public exported from `@promptbook/utils`
+ */
+function removeQuotes(text) {
+    if (text.startsWith('"') && text.endsWith('"')) {
+        return text.slice(1, -1);
+    }
+    if (text.startsWith('\'') && text.endsWith('\'')) {
+        return text.slice(1, -1);
+    }
+    return text;
+}
+
+/**
+ * Function trimCodeBlock will trim starting and ending code block from the string if it is present.
+ *
+ * Note: This is usefull for post-processing of the result of the chat LLM model
+ *       when the model wraps the result in the (markdown) code block.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function trimCodeBlock(value) {
+    value = spaceTrim(value);
+    if (!/^```[a-z]*(.*)```$/is.test(value)) {
+        return value;
+    }
+    value = value.replace(/^```[a-z]*/i, '');
+    value = value.replace(/```$/i, '');
+    value = spaceTrim(value);
+    return value;
+}
+
+/**
+ * Function trimEndOfCodeBlock will remove ending code block from the string if it is present.
+ *
+ * Note: This is usefull for post-processing of the result of the completion LLM model
+ *       if you want to start code block in the prompt but you don't want to end it in the result.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function trimEndOfCodeBlock(value) {
+    value = spaceTrim(value);
+    value = value.replace(/```$/g, '');
+    value = spaceTrim(value);
+    return value;
+}
+
+/**
+ * Removes quotes and optional introduce text from a string
+ *
+ * Tip: This is very usefull for post-processing of the result of the LLM model
+ * Note: This function trims the text and removes whole introduce sentence if it is present
+ * Note: There are two simmilar functions:
+ * - `removeQuotes` which removes only bounding quotes
+ * - `unwrapResult` which removes whole introduce sentence
+ *
+ * @param text optionally quoted text
+ * @returns text without quotes
+ * @public exported from `@promptbook/utils`
+ */
+function unwrapResult(text, options) {
+    const { isTrimmed = true, isIntroduceSentenceRemoved = true } = options || {};
+    let trimmedText = text;
+    // Remove leading and trailing spaces and newlines
+    if (isTrimmed) {
+        trimmedText = spaceTrim(trimmedText);
+    }
+    let processedText = trimmedText;
+    if (isIntroduceSentenceRemoved) {
+        const introduceSentenceRegex = /^[a-zěščřžýáíéúů:\s]*:\s*/i;
+        if (introduceSentenceRegex.test(text)) {
+            // Remove the introduce sentence and quotes by replacing it with an empty string
+            processedText = processedText.replace(introduceSentenceRegex, '');
+        }
+        processedText = spaceTrim(processedText);
+    }
+    if (processedText.length < 3) {
+        return trimmedText;
+    }
+    if (processedText.includes('\n')) {
+        return trimmedText;
+    }
+    // Remove the quotes by extracting the substring without the first and last characters
+    const unquotedText = processedText.slice(1, -1);
+    // Check if the text starts and ends with quotes
+    if ([
+        ['"', '"'],
+        ["'", "'"],
+        ['`', '`'],
+        ['*', '*'],
+        ['_', '_'],
+        ['„', '“'],
+        ['«', '»'] /* <- QUOTES to config */,
+    ].some(([startQuote, endQuote]) => {
+        if (!processedText.startsWith(startQuote)) {
+            return false;
+        }
+        if (!processedText.endsWith(endQuote)) {
+            return false;
+        }
+        if (unquotedText.includes(startQuote) && !unquotedText.includes(endQuote)) {
+            return false;
+        }
+        if (!unquotedText.includes(startQuote) && unquotedText.includes(endQuote)) {
+            return false;
+        }
+        return true;
+    })) {
+        return unwrapResult(unquotedText, { isTrimmed: false, isIntroduceSentenceRemoved: false });
+    }
+    else {
+        return processedText;
+    }
+}
+/**
+ * TODO: [🧠] Should this also unwrap the (parenthesis)
+ */
+
+/**
+ * Extracts exactly ONE code block from markdown.
+ *
+ * - When there are multiple or no code blocks the function throws a `ParseError`
+ *
+ * Note: There are multiple simmilar function:
+ * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
+ * - `extractJsonBlock` extracts exactly one valid JSON code block
+ * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+ * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+ *
+ * @param markdown any valid markdown
+ * @returns code block with language and content
+ * @public exported from `@promptbook/markdown-utils`
+ * @throws {ParseError} if there is not exactly one code block in the markdown
+ */
+function extractOneBlockFromMarkdown(markdown) {
+    const codeBlocks = extractAllBlocksFromMarkdown(markdown);
+    if (codeBlocks.length !== 1) {
+        throw new ParseError(spaceTrim$1((block) => `
+                    There should be exactly 1 code block in task section, found ${codeBlocks.length} code blocks
+
+                    ${block(codeBlocks.map((block, i) => `Block ${i + 1}:\n${block.content}`).join('\n\n\n'))}
+                `));
+    }
+    return codeBlocks[0];
+}
+/***
+ * TODO: [🍓][🌻] Decide of this is internal utility, external util OR validator/postprocessor
+ */
+
+/**
+ * Extracts code block from markdown.
+ *
+ * - When there are multiple or no code blocks the function throws a `ParseError`
+ *
+ * Note: There are multiple simmilar function:
+ * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
+ * - `extractJsonBlock` extracts exactly one valid JSON code block
+ * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+ * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+ *
+ * @public exported from `@promptbook/markdown-utils`
+ * @throws {ParseError} if there is not exactly one code block in the markdown
+ */
+function extractBlock(markdown) {
+    const { content } = extractOneBlockFromMarkdown(markdown);
+    return content;
+}
+
+/**
+ * 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 something better
+        await forTime(100000000);
+        // [1]
+        try {
+            await func();
+        }
+        finally {
+            // do nothing
+        }
+    })();
+}
+/**
+ * TODO: Probbably remove in favour of `keepImported`
+ * TODO: [1] This maybe does memory leak
+ */
+
+// Note: [💎]
+/**
+ * ScriptExecutionTools for JavaScript implemented via eval
+ *
+ * Warning: It is used for testing and mocking
+ *          **NOT intended to use in the production** due to its unsafe nature, use `JavascriptExecutionTools` instead.
+ *
+ * @public exported from `@promptbook/javascript`
+ */
+class JavascriptEvalExecutionTools {
+    constructor(options) {
+        this.options = options || {};
+    }
+    /**
+     * Executes a JavaScript
+     */
+    async execute(options) {
+        const { scriptLanguage, parameters } = options;
+        let { script } = options;
+        if (scriptLanguage !== 'javascript') {
+            throw new PipelineExecutionError(`Script language ${scriptLanguage} not supported to be executed by 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 = (_) => spaceTrim$1(_);
+        preserve(spaceTrim);
+        const removeQuotes$1 = removeQuotes;
+        preserve(removeQuotes$1);
+        const unwrapResult$1 = unwrapResult;
+        preserve(unwrapResult$1);
+        const trimEndOfCodeBlock$1 = trimEndOfCodeBlock;
+        preserve(trimEndOfCodeBlock$1);
+        const trimCodeBlock$1 = trimCodeBlock;
+        preserve(trimCodeBlock$1);
+        // TODO: DRY [🍯]
+        const trim = (str) => str.trim();
+        preserve(trim);
+        // TODO: DRY [🍯]
+        const reverse = (str) => str.split('').reverse().join('');
+        preserve(reverse);
+        const removeEmojis$1 = removeEmojis;
+        preserve(removeEmojis$1);
+        const prettifyMarkdown$1 = prettifyMarkdown;
+        preserve(prettifyMarkdown$1);
+        //-------[n12:]---
+        const capitalize$1 = capitalize;
+        const decapitalize$1 = decapitalize;
+        const nameToUriPart$1 = nameToUriPart;
+        const nameToUriParts$1 = nameToUriParts;
+        const removeDiacritics$1 = removeDiacritics;
+        const normalizeWhitespaces$1 = normalizeWhitespaces;
+        const normalizeToKebabCase$1 = normalizeToKebabCase;
+        const normalizeTo_camelCase$1 = normalizeTo_camelCase;
+        const normalizeTo_snake_case$1 = normalizeTo_snake_case;
+        const normalizeTo_PascalCase$1 = normalizeTo_PascalCase;
+        const parseKeywords = (input) => 
+        // 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);
+        //-------[/n12]---
+        if (!script.includes('return')) {
+            script = `return ${script}`;
+        }
+        // TODO: DRY [🍯]
+        const buildinFunctions = {
+            // TODO: [🍯] DRY all these functions across the file
+            spaceTrim,
+            removeQuotes: removeQuotes$1,
+            unwrapResult: unwrapResult$1,
+            trimEndOfCodeBlock: trimEndOfCodeBlock$1,
+            trimCodeBlock: trimCodeBlock$1,
+            trim,
+            reverse,
+            removeEmojis: removeEmojis$1,
+            prettifyMarkdown: prettifyMarkdown$1,
+            capitalize: capitalize$1,
+            decapitalize: decapitalize$1,
+            nameToUriPart: nameToUriPart$1,
+            nameToUriParts: nameToUriParts$1,
+            removeDiacritics: removeDiacritics$1,
+            normalizeWhitespaces: normalizeWhitespaces$1,
+            normalizeToKebabCase: normalizeToKebabCase$1,
+            normalizeTo_camelCase: normalizeTo_camelCase$1,
+            normalizeTo_snake_case: normalizeTo_snake_case$1,
+            normalizeTo_PascalCase: normalizeTo_PascalCase$1,
+            parseKeywords,
+            normalizeTo_SCREAMING_CASE: normalizeTo_SCREAMING_CASE$1,
+            extractBlock, // <- [🍓] Remove balast in all other functions, use this one as example
+        };
+        const buildinFunctionsStatement = Object.keys(buildinFunctions)
+            .map((functionName) => 
+        // Note: Custom functions are exposed to the current scope as variables
+        `const ${functionName} = buildinFunctions.${functionName};`)
+            .join('\n');
+        // TODO: DRY [🍯]
+        const customFunctions = this.options.functions || {};
+        const customFunctionsStatement = Object.keys(customFunctions)
+            .map((functionName) => 
+        // Note: Custom functions are exposed to the current scope as variables
+        `const ${functionName} = customFunctions.${functionName};`)
+            .join('\n');
+        // script = templateParameters(script, parameters);
+        // <- TODO: [🧠][🥳] Should be this is one of two variants how to use parameters in script
+        const statementToEvaluate = spaceTrim$1((block) => `
+
+                // Build-in functions:
+                ${block(buildinFunctionsStatement)}
+
+                // Custom functions:
+                ${block(customFunctionsStatement || '// -- No custom functions --')}
+
+                // The script:
+                ${block(Object.entries(parameters)
+            .map(([key, value]) => `const ${key} = ${JSON.stringify(value)};`)
+            .join('\n'))}
+                (()=>{ ${script} })()
+            `);
+        if (this.options.isVerbose) {
+            console.info(spaceTrim$1((block) => `
+                        🚀 Evaluating ${scriptLanguage} script:
+
+                        ${block(statementToEvaluate)}`));
+        }
+        let result;
+        try {
+            result = await eval(statementToEvaluate);
+            if (typeof result !== 'string') {
+                throw new PipelineExecutionError(`Script must return a string, but returned ${valueToString(result)}`);
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            if (error instanceof ReferenceError) {
+                const undefinedName = error.message.split(' ')[0];
+                /*
+                Note: Remapping error
+                      From: [PipelineUrlError: thing is not defined],
+                      To:   [PipelineExecutionError: Parameter `{thing}` is not defined],
+                */
+                if (!statementToEvaluate.includes(undefinedName + '(')) {
+                    throw new PipelineExecutionError(spaceTrim$1((block) => `
+
+                                Parameter \`{${undefinedName}}\` is not defined
+
+                                This happen during evaluation of the javascript, which has access to the following parameters as javascript variables:
+
+                                ${block(Object.keys(parameters)
+                        .map((key) => `  - ${key}\n`)
+                        .join(''))}
+
+                                The script is:
+                                \`\`\`javascript
+                                ${block(script)}
+                                \`\`\`
+
+                                Original error message:
+                                ${block(error.message)}
+
+
+                            `));
+                }
+                else {
+                    throw new PipelineExecutionError(spaceTrim$1((block) => `
+                                  Function ${undefinedName}() is not defined
+
+                                  -  Make sure that the function is one of built-in functions
+                                  -  Or you have to defined the function during construction of JavascriptEvalExecutionTools
+
+                                  Original error message:
+                                  ${block(error.message)}
+
+                            `));
+                }
+            }
+            throw error;
+        }
+        if (typeof result !== 'string') {
+            throw new PipelineExecutionError(`Script must return a string, but ${valueToString(result)}`);
+        }
+        return result;
+    }
+}
+/**
+ * TODO: Put predefined functions (like removeQuotes, spaceTrim, etc.) into annotation OR pass into constructor
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */
+
+/**
+ * Placeholder for better implementation of JavascriptExecutionTools - some propper sandboxing
+ *
+ * @alias JavascriptExecutionTools
+ * @public exported from `@promptbook/javascript`
+ */
+const JavascriptExecutionTools = JavascriptEvalExecutionTools;
+
+/**
+ * Provides script execution tools
+ *
+ * @public exported from `@promptbook/node`
+ */
+async function $provideScriptingForNode(options) {
+    if (!$isRunningInNode()) {
+        throw new EnvironmentMismatchError('Function `$provideScriptingForNode` works only in Node.js environment');
+    }
+    // TODO: [🔱] Do here auto-installation
+    return [new JavascriptExecutionTools(options)];
+}
+/**
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ */
+
 /**
  * Remote server is a proxy server that uses its execution tools internally and exposes the executor interface externally.
  *
@@ -6017,7 +6707,7 @@ function startRemoteServer(options) {
             llm,
             fs,
             scrapers: await $provideScrapersForNode({ fs, llm, executables }),
-            // TODO: Allow when `JavascriptExecutionTools` more secure *(without eval)*> script: [new JavascriptExecutionTools()],
+            script: await $provideScriptingForNode({}),
         };
         return tools;
     }
@@ -6028,6 +6718,7 @@ function startRemoteServer(options) {
         next();
     });
     const runningExecutionTasks = [];
+    // <- TODO: [🤬] Identify the users
     // TODO: [🧠] Do here some garbage collection of finished tasks
     app.get(['/', rootPath], async (request, response) => {
         var _a;
@@ -6122,23 +6813,60 @@ 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
+        if (runningExecutionTasks.length === 0) {
+            response.status(404).send('No execution tasks found');
+            return;
+        }
+        const lastExecutionTask = runningExecutionTasks[runningExecutionTasks.length - 1];
+        response.send(exportExecutionTask(lastExecutionTask, true));
     });
     app.get(`${rootPath}/executions/:taskId`, async (request, response) => {
         const { taskId } = request.params;
-        const execution = runningExecutionTasks.find((executionTask) => executionTask.taskId === taskId);
-        if (execution === undefined) {
+        // TODO: [🤬] Filter only for user
+        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 {
-            const { inputParameters, identification } = request.body;
+            const { inputParameters, identification /* <- [🤬] */ } = request.body;
             const pipelineUrl = request.body.pipelineUrl || request.body.book;
             // TODO: [🧠] Check `pipelineUrl` and `inputParameters` here or it should be responsibility of `collection.getPipelineByUrl` and `pipelineExecutor`
             const pipeline = await (collection === null || collection === void 0 ? void 0 : collection.getPipelineByUrl(pipelineUrl));