@promptbook/remote-server 0.86.30 → 0.88.0-1

package/esm/index.es.js

@@ -31,7 +31,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @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
@@ -3966,6 +3966,83 @@ function valueToString(value) {
     }
 }
 
+/**
+ * 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((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
  *
@@ -3975,24 +4052,26 @@ function valueToString(value) {
  * @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);
     }
@@ -5867,6 +5946,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.
  *
@@ -5938,7 +6634,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;
     }
@@ -5949,6 +6645,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;
@@ -6046,8 +6743,18 @@ function startRemoteServer(options) {
     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
@@ -6059,7 +6766,7 @@ function startRemoteServer(options) {
     });
     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));