@promptbook/remote-server 0.86.30 → 0.88.0-1

package/umd/index.umd.js

@@ -28,7 +28,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.86.30';
+    const PROMPTBOOK_ENGINE_VERSION = '0.88.0-1';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3963,6 +3963,83 @@
         }
     }
 
+    /**
+     * Parses the given script and returns the list of all used variables that are not defined in the script
+     *
+     * @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/javascript`
+     */
+    function extractVariablesFromJavascript(script) {
+        const variables = new Set();
+        const originalScript = script;
+        script = `(()=>{${script}})()`;
+        try {
+            for (let i = 0; i < LOOP_LIMIT; i++)
+                try {
+                    eval(script); // <- TODO: Use `JavascriptExecutionTools.execute` here
+                }
+                catch (error) {
+                    if (!(error instanceof ReferenceError)) {
+                        throw error;
+                    }
+                    /*
+                    Note: Parsing the error
+                          🌟 Most devices:
+                          [PipelineUrlError: thing is not defined]
+
+                          🍏 iPhone`s Safari:
+                          [PipelineUrlError: Can't find variable: thing]
+                    */
+                    let variableName = undefined;
+                    if (error.message.startsWith(`Can't`)) {
+                        // 🍏 Case
+                        variableName = error.message.split(' ').pop();
+                    }
+                    else {
+                        // 🌟 Case
+                        variableName = error.message.split(' ').shift();
+                    }
+                    if (variableName === undefined) {
+                        throw error;
+                    }
+                    if (script.includes(variableName + '(')) {
+                        script = `const ${variableName} = ()=>'';` + script;
+                    }
+                    else {
+                        variables.add(variableName);
+                        script = `const ${variableName} = '';` + script;
+                    }
+                }
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            throw new ParseError(spaceTrim.spaceTrim((block) => `
+                    Can not extract variables from the script
+                    ${block(error.stack || error.message)}
+
+                    Found variables:
+                    ${Array.from(variables)
+            .map((variableName, i) => `${i + 1}) ${variableName}`)
+            .join('\n')}
+
+
+                    The script:
+
+                    \`\`\`javascript
+                    ${block(originalScript)}
+                    \`\`\`
+                `));
+        }
+        return variables;
+    }
+    /**
+     * TODO: [🔣] Support for multiple languages - python, java,...
+     */
+
     /**
      * Parses the task and returns the set of all used parameters
      *
@@ -3972,24 +4049,26 @@
      * @public exported from `@promptbook/core` <- Note: [👖] This utility is so tightly interconnected with the Promptbook that it is not exported as util but in core
      */
     function extractParameterNamesFromTask(task) {
-        const { title, description, /* [🙊] taskType,*/ content, preparedContent, jokerParameterNames, foreach } = task;
+        const { title, description, taskType, content, preparedContent, jokerParameterNames, foreach } = task;
         const parameterNames = new Set();
+        let contentParameters;
+        if (taskType !== 'SCRIPT_TASK') {
+            contentParameters = extractParameterNames(content);
+        }
+        else {
+            // TODO: What if script is not javascript?
+            // const { contentLanguage } = task;
+            // if (contentLanguage !== 'javascript') {
+            contentParameters = extractVariablesFromJavascript(content);
+        }
         for (const parameterName of [
             ...extractParameterNames(title),
             ...extractParameterNames(description || ''),
-            ...extractParameterNames(content),
+            ...contentParameters,
             ...extractParameterNames(preparedContent || ''),
         ]) {
             parameterNames.add(parameterName);
         }
-        /*/
-        // TODO: [🙊] Fix `extractVariablesFromScript` or delete
-        if (taskType === 'SCRIPT_TASK') {
-            for (const parameterName of extractVariablesFromScript(content)) {
-                parameterNames.add(parameterName);
-            }
-        }
-        /**/
         for (const jokerName of jokerParameterNames || []) {
             parameterNames.add(jokerName);
         }
@@ -5864,6 +5943,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.
      *
@@ -5935,7 +6631,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;
         }
@@ -5946,6 +6642,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;
@@ -6043,8 +6740,18 @@
         app.get(`${rootPath}/executions`, async (request, response) => {
             response.send(runningExecutionTasks);
         });
+        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 lastExecution = runningExecutionTasks[runningExecutionTasks.length - 1];
+            response.send(lastExecution);
+        });
         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) {
                 response
@@ -6056,7 +6763,7 @@
         });
         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));