@promptbook/remote-server 0.86.31 → 0.88.0-10

package/umd/index.umd.js

@@ -28,7 +28,7 @@
      * @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
@@ -1718,6 +1718,57 @@
      * 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
      *
@@ -1790,21 +1841,43 @@
     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 rxjs.BehaviorSubject({});
+        let status = 'RUNNING';
+        const createdAt = new Date();
+        let updatedAt = createdAt;
+        const errors = [];
+        const warnings = [];
+        let currentValue = {};
+        const partialResultSubject = new rxjs.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);
                 }
             }
@@ -1821,12 +1894,33 @@
         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]
             },
         };
     }
@@ -1901,27 +1995,6 @@
      * 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.
@@ -3969,7 +4042,7 @@
      * @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();
@@ -5050,7 +5123,7 @@
                         Last result:
                         ${block($ongoingTaskResult.$resultString === null
                     ? 'null'
-                    : $ongoingTaskResult.$resultString
+                    : spaceTrim.spaceTrim($ongoingTaskResult.$resultString)
                         .split('\n')
                         .map((line) => `> ${line}`)
                         .join('\n'))}
@@ -5943,6 +6016,623 @@
      * 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.spaceTrim(value);
+        if (!/^```[a-z]*(.*)```$/is.test(value)) {
+            return value;
+        }
+        value = value.replace(/^```[a-z]*/i, '');
+        value = value.replace(/```$/i, '');
+        value = spaceTrim.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.spaceTrim(value);
+        value = value.replace(/```$/g, '');
+        value = spaceTrim.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.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.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__default["default"]((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 waitasecond.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__default["default"](_);
+            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__default["default"]((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__default["default"]((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__default["default"]((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__default["default"]((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.
      *
@@ -6014,7 +6704,7 @@
                 llm,
                 fs,
                 scrapers: await $provideScrapersForNode({ fs, llm, executables }),
-                // TODO: Allow when `JavascriptExecutionTools` more secure *(without eval)*> script: [new JavascriptExecutionTools()],
+                script: await $provideScriptingForNode({}),
             };
             return tools;
         }
@@ -6025,6 +6715,7 @@
             next();
         });
         const runningExecutionTasks = [];
+        // <- TODO: [🤬] Identify the users
         // TODO: [🧠] Do here some garbage collection of finished tasks
         app.get(['/', rootPath], async (request, response) => {
             var _a;
@@ -6119,23 +6810,60 @@
                     .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));