@promptbook/cli 0.104.0-1 → 0.104.0-11

package/esm/index.es.js

@@ -10,11 +10,11 @@ import hexEncoder from 'crypto-js/enc-hex';
 import sha256 from 'crypto-js/sha256';
 import { randomBytes } from 'crypto';
 import { io } from 'socket.io-client';
+import { SHA256 } from 'crypto-js';
 import { Subject } from 'rxjs';
 import { spawn } from 'child_process';
 import JSZip from 'jszip';
 import { parse, unparse } from 'papaparse';
-import { SHA256 } from 'crypto-js';
 import { lookup, extension } from 'mime-types';
 import glob from 'glob-promise';
 import moment from 'moment';
@@ -47,7 +47,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.104.0-1';
+const PROMPTBOOK_ENGINE_VERSION = '0.104.0-11';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -57,6 +57,8 @@ const PROMPTBOOK_ENGINE_VERSION = '0.104.0-1';
  * Core Promptbook server configuration.
  *
  * This server is also used for auto-federation in the Agents Server.
+ *
+ * @public exported from `@promptbook/core`
  */
 const CORE_SERVER = {
     title: 'Promptbook Core',
@@ -1373,13 +1375,14 @@ class EnvironmentMismatchError extends Error {
  *
  * @public exported from `@promptbook/utils`
  */
-const $isRunningInNode = new Function(`
+function $isRunningInNode() {
     try {
-        return this === global;
-    } catch (e) {
+        return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+    }
+    catch (e) {
         return false;
     }
-`);
+}
 /**
  * TODO: [🎺]
  */
@@ -1391,13 +1394,14 @@ const $isRunningInNode = new Function(`
  *
  * @public exported from `@promptbook/utils`
  */
-const $isRunningInBrowser = new Function(`
+function $isRunningInBrowser() {
     try {
-        return this === window;
-    } catch (e) {
+        return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    }
+    catch (e) {
         return false;
     }
-`);
+}
 /**
  * TODO: [🎺]
  */
@@ -1409,13 +1413,15 @@ const $isRunningInBrowser = new Function(`
  *
  * @public exported from `@promptbook/utils`
  */
-const $isRunningInJest = new Function(`
+function $isRunningInJest() {
+    var _a;
     try {
-        return process.env.JEST_WORKER_ID !== undefined;
-    } catch (e) {
+        return typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.JEST_WORKER_ID) !== undefined;
+    }
+    catch (e) {
         return false;
     }
-`);
+}
 /**
  * TODO: [🎺]
  */
@@ -1427,17 +1433,17 @@ const $isRunningInJest = new Function(`
  *
  * @public exported from `@promptbook/utils`
  */
-const $isRunningInWebWorker = new Function(`
+function $isRunningInWebWorker() {
     try {
-        if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
-            return true;
-        } else {
-            return false;
-        }
-    } catch (e) {
+        // Note: Check for importScripts which is specific to workers
+        //       and not available in the main browser thread
+        return (typeof self !== 'undefined' &&
+            typeof self.importScripts === 'function');
+    }
+    catch (e) {
         return false;
     }
-`);
+}
 /**
  * TODO: [🎺]
  */
@@ -1955,7 +1961,7 @@ function $registeredLlmToolsMessage() {
                                 ${i + 1}) **${title}** \`${className}\` from \`${packageName}\`
                                     ${morePieces.join('; ')}
                             `);
-        if ($isRunningInNode) {
+        if ($isRunningInNode()) {
             if (isInstalled && isFullyConfigured) {
                 providerMessage = colors.green(providerMessage);
             }
@@ -3717,6 +3723,7 @@ class RemoteLlmExecutionTools {
     }
 }
 /**
+ * TODO: !!!! Deprecate pipeline server and all of its components
  * TODO: Maybe use `$exportJson`
  * TODO: [🧠][🛍] Maybe not `isAnonymous: boolean` BUT `mode: 'ANONYMOUS'|'COLLECTION'`
  * TODO: [🍓] Allow to list compatible models with each variant
@@ -3726,280 +3733,1166 @@ class RemoteLlmExecutionTools {
  */
 
 /**
- * Function isValidJsonString will tell you if the string is valid JSON or not
+ * Normalizes a given text to camelCase format.
  *
- * @param value The string to check
- * @returns `true` if the string is a valid JSON string, false otherwise
+ * Note: [🔂] This function is idempotent.
  *
+ * @param text The text to be normalized.
+ * @param _isFirstLetterCapital Whether the first letter should be capitalized.
+ * @returns The camelCase formatted string.
+ * @example 'helloWorld'
+ * @example 'iLovePromptbook'
  * @public exported from `@promptbook/utils`
  */
-function isValidJsonString(value /* <- [👨‍⚖️] */) {
-    try {
-        JSON.parse(value);
-        return true;
-    }
-    catch (error) {
-        assertsError(error);
-        if (error.message.includes('Unexpected token')) {
-            return false;
+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;
         }
-        return false;
+        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;
 }
-
 /**
- * Makes first letter of a string uppercase
- *
- * Note: [🔂] This function is idempotent.
- *
- * @public exported from `@promptbook/utils`
+ * TODO: [🌺] Use some intermediate util splitWords
  */
-function capitalize(word) {
-    return word.substring(0, 1).toUpperCase() + word.substring(1);
-}
 
 /**
- * Extracts all code blocks from markdown.
+ * Creates a Mermaid graph based on the promptbook
  *
- * Note: There are multiple similar functions:
- * - `extractBlock` just extracts the content of the code block which is also used as built-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
+ * Note: The result is not wrapped in a Markdown code block
  *
- * @param markdown any valid markdown
- * @returns code blocks with language and content
- * @throws {ParseError} if block is not closed properly
- * @public exported from `@promptbook/markdown-utils`
+ * @public exported from `@promptbook/utils`
  */
-function extractAllBlocksFromMarkdown(markdown) {
-    const codeBlocks = [];
-    const lines = markdown.split('\n');
-    // Note: [0] Ensure that the last block notated by gt > will be closed
-    lines.push('');
-    let currentCodeBlock = null;
-    for (const line of lines) {
-        if (line.startsWith('> ') || line === '>') {
-            if (currentCodeBlock === null) {
-                currentCodeBlock = { blockNotation: '>', language: null, content: '' };
-            } /* not else */
-            if (currentCodeBlock.blockNotation === '>') {
-                if (currentCodeBlock.content !== '') {
-                    currentCodeBlock.content += '\n';
-                }
-                currentCodeBlock.content += line.slice(2);
-            }
+function renderPromptbookMermaid(pipelineJson, options) {
+    const { linkTask = () => null } = options || {};
+    const MERMAID_PREFIX = 'pipeline_';
+    const MERMAID_KNOWLEDGE_NAME = MERMAID_PREFIX + 'knowledge';
+    const MERMAID_RESERVED_NAME = MERMAID_PREFIX + 'reserved';
+    const MERMAID_INPUT_NAME = MERMAID_PREFIX + 'input';
+    const MERMAID_OUTPUT_NAME = MERMAID_PREFIX + 'output';
+    const parameterNameToTaskName = (parameterName) => {
+        if (parameterName === 'knowledge') {
+            return MERMAID_KNOWLEDGE_NAME;
         }
-        else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '>' /* <- Note: [0] */) {
-            codeBlocks.push(currentCodeBlock);
-            currentCodeBlock = null;
+        else if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
+            return MERMAID_RESERVED_NAME;
         }
-        /* not else */
-        if (line.startsWith('```')) {
-            const language = line.slice(3).trim() || null;
-            if (currentCodeBlock === null) {
-                currentCodeBlock = { blockNotation: '```', language, content: '' };
-            }
-            else {
-                if (language !== null) {
-                    throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed and already opening new ${language} code block`);
-                }
-                codeBlocks.push(currentCodeBlock);
-                currentCodeBlock = null;
-            }
+        const parameter = pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
+        if (!parameter) {
+            throw new UnexpectedError(`Could not find {${parameterName}}`);
+            // <- TODO: This causes problems when {knowledge} and other reserved parameters are used
         }
-        else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '```') {
-            if (currentCodeBlock.content !== '') {
-                currentCodeBlock.content += '\n';
-            }
-            currentCodeBlock.content += line.split('\\`\\`\\`').join('```') /* <- TODO: Maybe make proper unescape */;
+        if (parameter.isInput) {
+            return MERMAID_INPUT_NAME;
         }
-    }
-    if (currentCodeBlock !== null) {
-        throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
-    }
-    return codeBlocks;
+        const task = pipelineJson.tasks.find((task) => task.resultingParameterName === parameterName);
+        if (!task) {
+            throw new Error(`Could not find task for {${parameterName}}`);
+        }
+        return MERMAID_PREFIX + (task.name || normalizeTo_camelCase('task-' + titleToName(task.title)));
+    };
+    const inputAndIntermediateParametersMermaid = pipelineJson.tasks
+        .flatMap(({ title, dependentParameterNames, resultingParameterName }) => [
+        `${parameterNameToTaskName(resultingParameterName)}("${title}")`,
+        ...dependentParameterNames.map((dependentParameterName) => `${parameterNameToTaskName(dependentParameterName)}--"{${dependentParameterName}}"-->${parameterNameToTaskName(resultingParameterName)}`),
+    ])
+        .join('\n');
+    const outputParametersMermaid = pipelineJson.parameters
+        .filter(({ isOutput }) => isOutput)
+        .map(({ name }) => `${parameterNameToTaskName(name)}--"{${name}}"-->${MERMAID_OUTPUT_NAME}`)
+        .join('\n');
+    const linksMermaid = pipelineJson.tasks
+        .map((task) => {
+        const link = linkTask(task);
+        if (link === null) {
+            return '';
+        }
+        const { href, title } = link;
+        const taskName = parameterNameToTaskName(task.resultingParameterName);
+        return `click ${taskName} href "${href}" "${title}";`;
+    })
+        .filter((line) => line !== '')
+        .join('\n');
+    const interactionPointsMermaid = Object.entries({
+        [MERMAID_INPUT_NAME]: 'Input',
+        [MERMAID_OUTPUT_NAME]: 'Output',
+        [MERMAID_RESERVED_NAME]: 'Other',
+        [MERMAID_KNOWLEDGE_NAME]: 'Knowledge',
+    })
+        .filter(([MERMAID_NAME]) => (inputAndIntermediateParametersMermaid + outputParametersMermaid).includes(MERMAID_NAME))
+        .map(([MERMAID_NAME, title]) => `${MERMAID_NAME}((${title})):::${MERMAID_NAME}`)
+        .join('\n');
+    const promptbookMermaid = spaceTrim$1((block) => `
+
+            %% 🔮 Tip: Open this on GitHub or in the VSCode website to see the Mermaid graph visually
+
+            flowchart LR
+              subgraph "${pipelineJson.title}"
+
+                  %% Basic configuration
+                  direction TB
+
+                  %% Interaction points from pipeline to outside
+                  ${block(interactionPointsMermaid)}
+
+                  %% Input and intermediate parameters
+                  ${block(inputAndIntermediateParametersMermaid)}
+
+
+                  %% Output parameters
+                  ${block(outputParametersMermaid)}
+
+                  %% Links
+                  ${block(linksMermaid)}
+
+                  %% Styles
+                  classDef ${MERMAID_INPUT_NAME} color: grey;
+                  classDef ${MERMAID_OUTPUT_NAME} color: grey;
+                  classDef ${MERMAID_RESERVED_NAME} color: grey;
+                  classDef ${MERMAID_KNOWLEDGE_NAME} color: grey;
+
+              end;
+
+        `);
+    return promptbookMermaid;
 }
 /**
- * TODO: Maybe name for `blockNotation` instead of  '```' and '>'
+ * TODO: [🧠] FOREACH in mermaid graph
+ * TODO: [🧠] Knowledge in mermaid graph
+ * TODO: [🧠] Personas in mermaid graph
+ * TODO: Maybe use some Mermaid package instead of string templating
+ * TODO: [🕌] When more than 2 functionalities, split into separate functions
  */
 
 /**
- * Extracts  extracts exactly one valid JSON code block
- *
- * - When given string is a valid JSON as it is, it just returns it
- * - When there is no JSON code block the function throws a `ParseError`
- * - When there are multiple JSON code blocks the function throws a `ParseError`
- *
- * Note: It is not important if marked as ```json BUT if it is VALID JSON
- * Note: There are multiple similar 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
+ * Serializes an error into a [🚉] JSON-serializable object
  *
- * @public exported from `@promptbook/markdown-utils`
- * @throws {ParseError} if there is no valid JSON block in the markdown
+ * @public exported from `@promptbook/utils`
  */
-function extractJsonBlock(markdown) {
-    if (isValidJsonString(markdown)) {
-        return markdown;
-    }
-    const codeBlocks = extractAllBlocksFromMarkdown(markdown);
-    const jsonBlocks = codeBlocks.filter(({ content }) => isValidJsonString(content));
-    if (jsonBlocks.length === 0) {
-        throw new Error('There is no valid JSON block in the markdown');
+function serializeError(error) {
+    const { name, message, stack } = error;
+    const { id } = error;
+    if (!Object.keys(ALL_ERRORS).includes(name)) {
+        console.error(spaceTrim$2((block) => `
+
+                    Cannot serialize error with name "${name}"
+
+                    Authors of Promptbook probably forgot to add this error into the list of errors:
+                    https://github.com/webgptorg/promptbook/blob/main/src/errors/0-index.ts
+
+
+                    ${block(stack || message)}
+
+                `));
+    }
+    return {
+        name: name,
+        message,
+        stack,
+        id, // Include id in the serialized object
+    };
+}
+
+/**
+ * Async version of Array.forEach
+ *
+ * @param array - Array to iterate over
+ * @param options - Options for the function
+ * @param callbackfunction - Function to call for each item
+ * @public exported from `@promptbook/utils`
+ * @deprecated [🪂] Use queues instead
+ */
+async function forEachAsync(array, options, callbackfunction) {
+    const { maxParallelCount = Infinity } = options;
+    let index = 0;
+    let runningTasks = [];
+    const tasks = [];
+    for (const item of array) {
+        const currentIndex = index++;
+        const task = callbackfunction(item, currentIndex, array);
+        tasks.push(task);
+        runningTasks.push(task);
+        /* not await */ Promise.resolve(task).then(() => {
+            runningTasks = runningTasks.filter((t) => t !== task);
+        });
+        if (maxParallelCount < runningTasks.length) {
+            await Promise.race(runningTasks);
+        }
+    }
+    await Promise.all(tasks);
+}
+
+/**
+ * Function to check if a string is valid CSV
+ *
+ * @param value The string to check
+ * @returns `true` if the string is a valid CSV string, false otherwise
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function isValidCsvString(value) {
+    try {
+        // A simple check for CSV format: at least one comma and no invalid characters
+        if (value.includes(',') && /^[\w\s,"']+$/.test(value)) {
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        assertsError(error);
+        return false;
+    }
+}
+
+/**
+ * Function isValidJsonString will tell you if the string is valid JSON or not
+ *
+ * @param value The string to check
+ * @returns `true` if the string is a valid JSON string, false otherwise
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function isValidJsonString(value /* <- [👨‍⚖️] */) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch (error) {
+        assertsError(error);
+        if (error.message.includes('Unexpected token')) {
+            return false;
+        }
+        return false;
+    }
+}
+
+/**
+ * Function to check if a string is valid XML
+ *
+ * @param value
+ * @returns `true` if the string is a valid XML string, false otherwise
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function isValidXmlString(value) {
+    try {
+        const parser = new DOMParser();
+        const parsedDocument = parser.parseFromString(value, 'application/xml');
+        const parserError = parsedDocument.getElementsByTagName('parsererror');
+        if (parserError.length > 0) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        assertsError(error);
+        return false;
+    }
+}
+
+/**
+ * Format either small or big number
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function numberToString(value) {
+    if (value === 0) {
+        return '0';
+    }
+    else if (Number.isNaN(value)) {
+        return VALUE_STRINGS.nan;
+    }
+    else if (value === Infinity) {
+        return VALUE_STRINGS.infinity;
+    }
+    else if (value === -Infinity) {
+        return VALUE_STRINGS.negativeInfinity;
+    }
+    for (let exponent = 0; exponent < 15; exponent++) {
+        const factor = 10 ** exponent;
+        const valueRounded = Math.round(value * factor) / factor;
+        if (Math.abs(value - valueRounded) / value < SMALL_NUMBER) {
+            return valueRounded.toFixed(exponent);
+        }
+    }
+    return value.toString();
+}
+
+/**
+ * Function `valueToString` will convert the given value to string
+ * This is useful and used in the `templateParameters` function
+ *
+ * Note: This function is not just calling `toString` method
+ *       It's more complex and can handle this conversion specifically for LLM models
+ *       See `VALUE_STRINGS`
+ *
+ * Note: There are 2 similar functions
+ * - `valueToString` converts value to string for LLM models as human-readable string
+ * - `asSerializable` converts value to string to preserve full information to be able to convert it back
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function valueToString(value) {
+    try {
+        if (value === '') {
+            return VALUE_STRINGS.empty;
+        }
+        else if (value === null) {
+            return VALUE_STRINGS.null;
+        }
+        else if (value === undefined) {
+            return VALUE_STRINGS.undefined;
+        }
+        else if (typeof value === 'string') {
+            return value;
+        }
+        else if (typeof value === 'number') {
+            return numberToString(value);
+        }
+        else if (value instanceof Date) {
+            return value.toISOString();
+        }
+        else {
+            try {
+                return JSON.stringify(value);
+            }
+            catch (error) {
+                if (error instanceof TypeError && error.message.includes('circular structure')) {
+                    return VALUE_STRINGS.circular;
+                }
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        assertsError(error);
+        console.error(error);
+        return VALUE_STRINGS.unserializable;
+    }
+}
+
+/**
+ * Replaces parameters in template with values from parameters object
+ *
+ * Note: This function is not places strings into string,
+ *       It's more complex and can handle this operation specifically for LLM models
+ *
+ * @param template the template with parameters in {curly} braces
+ * @param parameters the object with parameters
+ * @returns the template with replaced parameters
+ * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
+ * @public exported from `@promptbook/utils`
+ */
+function templateParameters(template, parameters) {
+    for (const [parameterName, parameterValue] of Object.entries(parameters)) {
+        if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
+            throw new UnexpectedError(`Parameter \`{${parameterName}}\` has missing value`);
+        }
+        else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
+            // TODO: [🍵]
+            throw new UnexpectedError(`Parameter \`{${parameterName}}\` is restricted to use`);
+        }
+    }
+    let replacedTemplates = template;
+    let match;
+    let loopLimit = LOOP_LIMIT;
+    while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
+        .exec(replacedTemplates))) {
+        if (loopLimit-- < 0) {
+            throw new LimitReachedError('Loop limit reached during parameters replacement in `templateParameters`');
+        }
+        const precol = match.groups.precol;
+        const parameterName = match.groups.parameterName;
+        if (parameterName === '') {
+            // Note: Skip empty placeholders. It's used to avoid confusion with JSON-like strings
+            continue;
+        }
+        if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
+            throw new PipelineExecutionError('Parameter is already opened or not closed');
+        }
+        if (parameters[parameterName] === undefined) {
+            throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
+        }
+        let parameterValue = parameters[parameterName];
+        if (parameterValue === undefined) {
+            throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
+        }
+        parameterValue = valueToString(parameterValue);
+        // Escape curly braces in parameter values to prevent prompt-injection
+        parameterValue = parameterValue.replace(/[{}]/g, '\\$&');
+        if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
+            parameterValue = parameterValue
+                .split('\n')
+                .map((line, index) => (index === 0 ? line : `${precol}${line}`))
+                .join('\n');
+        }
+        replacedTemplates =
+            replacedTemplates.substring(0, match.index + precol.length) +
+                parameterValue +
+                replacedTemplates.substring(match.index + precol.length + parameterName.length + 2);
+    }
+    // [💫] Check if there are parameters that are not closed properly
+    if (/{\w+$/.test(replacedTemplates)) {
+        throw new PipelineExecutionError('Parameter is not closed');
+    }
+    // [💫] Check if there are parameters that are not opened properly
+    if (/^\w+}/.test(replacedTemplates)) {
+        throw new PipelineExecutionError('Parameter is not opened');
+    }
+    return replacedTemplates;
+}
+
+/**
+ * Number of characters per standard line with 11pt Arial font size.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+const CHARACTERS_PER_STANDARD_LINE = 63;
+/**
+ * Number of lines per standard A4 page with 11pt Arial font size and standard margins and spacing.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+const LINES_PER_STANDARD_PAGE = 44;
+/**
+ * TODO: [🧠] Should be this `constants.ts` or `config.ts`?
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Counts number of characters in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countCharacters(text) {
+    // Remove null characters
+    text = text.replace(/\0/g, '');
+    // Replace emojis (and also ZWJ sequence) with hyphens
+    text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
+    text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
+    text = text.replace(/\p{Extended_Pictographic}(\u{200D}\p{Extended_Pictographic})*/gu, '-');
+    return text.length;
+}
+/**
+ * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+ * TODO: [🧠][✌️] Make some Promptbook-native token system
+ */
+
+/**
+ * Counts number of lines in the text
+ *
+ * Note: This does not check only for the presence of newlines, but also for the length of the standard line.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countLines(text) {
+    if (text === '') {
+        return 0;
+    }
+    text = text.replace('\r\n', '\n');
+    text = text.replace('\r', '\n');
+    const lines = text.split('\n');
+    return lines.reduce((count, line) => count + Math.max(Math.ceil(line.length / CHARACTERS_PER_STANDARD_LINE), 1), 0);
+}
+/**
+ * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+ * TODO: [🧠][✌️] Make some Promptbook-native token system
+ */
+
+/**
+ * Counts number of pages in the text
+ *
+ * Note: This does not check only for the count of newlines, but also for the length of the standard line and length of the standard page.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countPages(text) {
+    return Math.ceil(countLines(text) / LINES_PER_STANDARD_PAGE);
+}
+/**
+ * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+ * TODO: [🧠][✌️] Make some Promptbook-native token system
+ */
+
+/**
+ * Counts number of paragraphs in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countParagraphs(text) {
+    return text.split(/\n\s*\n/).filter((paragraph) => paragraph.trim() !== '').length;
+}
+/**
+ * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+ * TODO: [🧠][✌️] Make some Promptbook-native token system
+ */
+
+/**
+ * Split text into sentences
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function splitIntoSentences(text) {
+    return text.split(/[.!?]+/).filter((sentence) => sentence.trim() !== '');
+}
+/**
+ * Counts number of sentences in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countSentences(text) {
+    return splitIntoSentences(text).length;
+}
+/**
+ * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+ * TODO: [🧠][✌️] Make some Promptbook-native token system
+ */
+
+/**
+ * Counts number of words in the text
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function countWords(text) {
+    text = text.replace(/[\p{Extended_Pictographic}]/gu, 'a');
+    text = removeDiacritics(text);
+    // Add spaces before uppercase letters preceded by lowercase letters (for camelCase)
+    text = text.replace(/([a-z])([A-Z])/g, '$1 $2');
+    return text.split(/[^a-zа-я0-9]+/i).filter((word) => word.length > 0).length;
+}
+/**
+ * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+ * TODO: [🧠][✌️] Make some Promptbook-native token system
+ * TODO: [✌️] `countWords` should be just `splitWords(...).length`, and all other counters should use this pattern as well
+ */
+
+/**
+ * Index of all counter functions
+ *
+ * @public exported from `@promptbook/utils`
+ */
+const CountUtils = {
+    CHARACTERS: countCharacters,
+    WORDS: countWords,
+    SENTENCES: countSentences,
+    PARAGRAPHS: countParagraphs,
+    LINES: countLines,
+    PAGES: countPages,
+};
+/**
+ * TODO: [🧠][🤠] This should be probably as part of `TextFormatParser`
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Simple wrapper `new Date().toISOString()`
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic because it depends on the current time
+ *
+ * @returns string_date branded type
+ * @public exported from `@promptbook/utils`
+ */
+function $getCurrentDate() {
+    return new Date().toISOString();
+}
+
+/**
+ * Computes SHA-256 hash of the given object
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function computeHash(value) {
+    return SHA256(hexEncoder.parse(spaceTrim$2(valueToString(value)))).toString( /* hex */);
+}
+/**
+ * TODO: [🥬][🥬] Use this ACRY
+ */
+
+/**
+ * Function parseNumber will parse number from string
+ *
+ * Note: [🔂] This function is idempotent.
+ * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
+ * Note: it also works only with decimal numbers
+ *
+ * @returns parsed number
+ * @throws {ParseError} if the value is not a number
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function parseNumber(value) {
+    const originalValue = value;
+    if (typeof value === 'number') {
+        value = value.toString(); // <- TODO: Maybe more efficient way to do this
+    }
+    if (typeof value !== 'string') {
+        return 0;
+    }
+    value = value.trim();
+    if (value.startsWith('+')) {
+        return parseNumber(value.substring(1));
+    }
+    if (value.startsWith('-')) {
+        const number = parseNumber(value.substring(1));
+        if (number === 0) {
+            return 0; // <- Note: To prevent -0
+        }
+        return -number;
+    }
+    value = value.replace(/,/g, '.');
+    value = value.toUpperCase();
+    if (value === '') {
+        return 0;
+    }
+    if (value === '♾' || value.startsWith('INF')) {
+        return Infinity;
+    }
+    if (value.includes('/')) {
+        const [numerator_, denominator_] = value.split('/');
+        const numerator = parseNumber(numerator_);
+        const denominator = parseNumber(denominator_);
+        if (denominator === 0) {
+            throw new ParseError(`Unable to parse number from "${originalValue}" because denominator is zero`);
+        }
+        return numerator / denominator;
+    }
+    if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
+        return 0;
+    }
+    if (value.includes('E')) {
+        const [significand, exponent] = value.split('E');
+        return parseNumber(significand) * 10 ** parseNumber(exponent);
+    }
+    if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
+        throw new ParseError(`Unable to parse number from "${originalValue}"`);
+    }
+    const num = parseFloat(value);
+    if (isNaN(num)) {
+        throw new ParseError(`Unexpected NaN when parsing number from "${originalValue}"`);
+    }
+    return num;
+}
+/**
+ * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
+ * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`
+ */
+
+/**
+ * Makes first letter of a string uppercase
+ *
+ * Note: [🔂] This function is idempotent.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function capitalize(word) {
+    return word.substring(0, 1).toUpperCase() + word.substring(1);
+}
+
+/**
+ * Makes first letter of a string lowercase
+ *
+ * Note: [🔂] This function is idempotent.
+ *
+ * @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);
+}
+
+/**
+ * Converts a name string into a URI-compatible format.
+ *
+ * @param name The string to be converted to a URI-compatible format.
+ * @returns A URI-compatible string derived from the input name.
+ * @example 'Hello World' -> 'hello-world'
+ * @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;
+}
+
+/**
+ * Converts a given name into URI-compatible parts.
+ *
+ * @param name The name to be converted into URI parts.
+ * @returns An array of URI-compatible parts derived from the name.
+ * @example 'Example Name' -> ['example', 'name']
+ * @public exported from `@promptbook/utils`
+ */
+function nameToUriParts(name) {
+    return nameToUriPart(name)
+        .split('-')
+        .filter((value) => value !== '');
+}
+
+/**
+ * Normalizes a given text to PascalCase format.
+ *
+ * Note: [🔂] This function is idempotent.
+ *
+ * @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
+ *
+ * Note: [🔂] This function is idempotent.
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function normalizeWhitespaces(sentence) {
+    return sentence.replace(/\s+/gs, ' ').trim();
+}
+
+/**
+ * Removes quotes from a string
+ *
+ * Note: [🔂] This function is idempotent.
+ * Tip: This is very useful 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 similar 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 (jsonBlocks.length > 1) {
-        throw new Error('There are multiple JSON code blocks in the markdown');
+    if (text.startsWith("'") && text.endsWith("'")) {
+        return text.slice(1, -1);
     }
-    return jsonBlocks[0].content;
+    return text;
 }
+
 /**
- * TODO: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
- * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
+ * Adds suffix to the URL
+ *
+ * @public exported from `@promptbook/utils`
  */
+function suffixUrl(value, suffix) {
+    const baseUrl = value.href.endsWith('/') ? value.href.slice(0, -1) : value.href;
+    const normalizedSuffix = suffix.replace(/\/+/g, '/');
+    return (baseUrl + normalizedSuffix);
+}
 
 /**
- * Counts number of characters in the text
+ * Removes quotes and optional introduce text from a string
+ *
+ * Tip: This is very useful 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 similar 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 countCharacters(text) {
-    // Remove null characters
-    text = text.replace(/\0/g, '');
-    // Replace emojis (and also ZWJ sequence) with hyphens
-    text = text.replace(/(\p{Extended_Pictographic})\p{Modifier_Symbol}/gu, '$1');
-    text = text.replace(/(\p{Extended_Pictographic})[\u{FE00}-\u{FE0F}]/gu, '$1');
-    text = text.replace(/\p{Extended_Pictographic}(\u{200D}\p{Extended_Pictographic})*/gu, '-');
-    return text.length;
+function unwrapResult(text, options) {
+    const { isTrimmed = true, isIntroduceSentenceRemoved = true } = options || {};
+    let trimmedText = text;
+    // Remove leading and trailing spaces and newlines
+    if (isTrimmed) {
+        trimmedText = spaceTrim$1(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$1(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: [🥴] Implement counting in formats - like JSON, CSV, XML,...
- * TODO: [🧠][✌️] Make some Promptbook-native token system
+ * TODO: [🧠] Should this also unwrap the (parenthesis)
  */
 
 /**
- * Number of characters per standard line with 11pt Arial font size.
+ * Parses the task and returns the list of all parameter names
  *
+ * @param template the string template with parameters in {curly} braces
+ * @returns the list of parameter names
  * @public exported from `@promptbook/utils`
  */
-const CHARACTERS_PER_STANDARD_LINE = 63;
+function extractParameterNames(template) {
+    const matches = template.matchAll(/{\w+}/g);
+    const parameterNames = new Set();
+    for (const match of matches) {
+        const parameterName = match[0].slice(1, -1);
+        parameterNames.add(parameterName);
+    }
+    return parameterNames;
+}
+
 /**
- * Number of lines per standard A4 page with 11pt Arial font size and standard margins and spacing.
- *
+ * Recursively converts JSON strings to JSON objects
+
  * @public exported from `@promptbook/utils`
  */
-const LINES_PER_STANDARD_PAGE = 44;
+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] = jsonParse(value);
+        }
+        else {
+            newObject[key] = jsonStringsToJsons(value);
+        }
+    }
+    return newObject;
+}
 /**
- * TODO: [🧠] Should be this `constants.ts` or `config.ts`?
- * Note: [💞] Ignore a discrepancy between file name and entity name
+ * TODO: Type the return type correctly
  */
 
 /**
- * Counts number of lines in the text
- *
- * Note: This does not check only for the presence of newlines, but also for the length of the standard line.
+ * Create difference set of two sets.
  *
+ * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
  * @public exported from `@promptbook/utils`
  */
-function countLines(text) {
-    if (text === '') {
-        return 0;
+function difference(a, b, isEqual = (a, b) => a === b) {
+    const diff = new Set();
+    for (const itemA of Array.from(a)) {
+        if (!Array.from(b).some((itemB) => isEqual(itemA, itemB))) {
+            diff.add(itemA);
+        }
     }
-    text = text.replace('\r\n', '\n');
-    text = text.replace('\r', '\n');
-    const lines = text.split('\n');
-    return lines.reduce((count, line) => count + Math.max(Math.ceil(line.length / CHARACTERS_PER_STANDARD_LINE), 1), 0);
+    return diff;
 }
 /**
- * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
- * TODO: [🧠][✌️] Make some Promptbook-native token system
+ * TODO: [🧠][💯] Maybe also implement symmetricDifference
  */
 
 /**
- * Counts number of pages in the text
- *
- * Note: This does not check only for the count of newlines, but also for the length of the standard line and length of the standard page.
+ * Creates a new set with all elements that are present in either set
  *
+ * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
  * @public exported from `@promptbook/utils`
  */
-function countPages(text) {
-    return Math.ceil(countLines(text) / LINES_PER_STANDARD_PAGE);
+function union(...sets) {
+    const union = new Set();
+    for (const set of sets) {
+        for (const item of Array.from(set)) {
+            union.add(item);
+        }
+    }
+    return union;
 }
+
 /**
- * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
- * TODO: [🧠][✌️] Make some Promptbook-native token system
+ * Checks if value is valid email
+ *
+ * @public exported from `@promptbook/utils`
  */
+function isValidEmail(email) {
+    if (typeof email !== 'string') {
+        return false;
+    }
+    if (email.split('\n').length > 1) {
+        return false;
+    }
+    return /^.+@.+\..+$/.test(email);
+}
 
 /**
- * Counts number of paragraphs in the text
+ * Checks if the given value is a valid JavaScript identifier name.
  *
+ * @param javascriptName The value to check for JavaScript identifier validity.
+ * @returns `true` if the value is a valid JavaScript name, false otherwise.
  * @public exported from `@promptbook/utils`
  */
-function countParagraphs(text) {
-    return text.split(/\n\s*\n/).filter((paragraph) => paragraph.trim() !== '').length;
+function isValidJavascriptName(javascriptName) {
+    if (typeof javascriptName !== 'string') {
+        return false;
+    }
+    return /^[a-zA-Z_$][0-9a-zA-Z_$]*$/i.test(javascriptName);
 }
+
 /**
- * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
- * TODO: [🧠][✌️] Make some Promptbook-native token system
+ * Tests if given string is valid semantic version
+ *
+ * Note: There are two similar functions:
+ * - `isValidSemanticVersion` which tests any semantic version
+ * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
+ *
+ * @public exported from `@promptbook/utils`
  */
+function isValidSemanticVersion(version) {
+    if (typeof version !== 'string') {
+        return false;
+    }
+    if (version.startsWith('0.0.0')) {
+        return false;
+    }
+    return /^\d+\.\d+\.\d+(-\d+)?$/i.test(version);
+}
 
 /**
- * Split text into sentences
+ * Tests if given string is valid promptbook version
+ * It looks into list of known promptbook versions.
+ *
+ * @see https://www.npmjs.com/package/promptbook?activeTab=versions
+ * Note: When you are using for example promptbook 2.0.0 and there already is promptbook 3.0.0 it don`t know about it.
+ * Note: There are two similar functions:
+ * - `isValidSemanticVersion` which tests any semantic version
+ * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
  *
  * @public exported from `@promptbook/utils`
  */
-function splitIntoSentences(text) {
-    return text.split(/[.!?]+/).filter((sentence) => sentence.trim() !== '');
+function isValidPromptbookVersion(version) {
+    if (!isValidSemanticVersion(version)) {
+        return false;
+    }
+    if ( /* version === '1.0.0' || */version === '2.0.0' || version === '3.0.0') {
+        return false;
+    }
+    // <- TODO: [main] !!3 Check isValidPromptbookVersion against PROMPTBOOK_ENGINE_VERSIONS
+    return true;
 }
+
 /**
- * Counts number of sentences in the text
+ * Tests if given string is valid pipeline URL URL.
+ *
+ * Note: There are two similar functions:
+ * - `isValidUrl` which tests any URL
+ * - `isValidPipelineUrl` *(this one)* which tests just pipeline URL
  *
  * @public exported from `@promptbook/utils`
  */
-function countSentences(text) {
-    return splitIntoSentences(text).length;
+function isValidPipelineUrl(url) {
+    if (!isValidUrl(url)) {
+        return false;
+    }
+    if (!url.startsWith('https://') && !url.startsWith('http://') /* <- Note: [👣] */) {
+        return false;
+    }
+    if (url.includes('#')) {
+        // TODO: [🐠]
+        return false;
+    }
+    /*
+    Note: [👣][🧠] Is it secure to allow pipeline URLs on private and unsecured networks?
+    if (isUrlOnPrivateNetwork(url)) {
+        return false;
+    }
+    */
+    return true;
 }
 /**
- * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
- * TODO: [🧠][✌️] Make some Promptbook-native token system
+ * TODO: [🐠] Maybe more info why the URL is invalid
  */
 
 /**
- * Counts number of words in the text
+ * Extracts all code blocks from markdown.
  *
- * @public exported from `@promptbook/utils`
+ * Note: There are multiple similar functions:
+ * - `extractBlock` just extracts the content of the code block which is also used as built-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 blocks with language and content
+ * @throws {ParseError} if block is not closed properly
+ * @public exported from `@promptbook/markdown-utils`
  */
-function countWords(text) {
-    text = text.replace(/[\p{Extended_Pictographic}]/gu, 'a');
-    text = removeDiacritics(text);
-    // Add spaces before uppercase letters preceded by lowercase letters (for camelCase)
-    text = text.replace(/([a-z])([A-Z])/g, '$1 $2');
-    return text.split(/[^a-zа-я0-9]+/i).filter((word) => word.length > 0).length;
+function extractAllBlocksFromMarkdown(markdown) {
+    const codeBlocks = [];
+    const lines = markdown.split('\n');
+    // Note: [0] Ensure that the last block notated by gt > will be closed
+    lines.push('');
+    let currentCodeBlock = null;
+    for (const line of lines) {
+        if (line.startsWith('> ') || line === '>') {
+            if (currentCodeBlock === null) {
+                currentCodeBlock = { blockNotation: '>', language: null, content: '' };
+            } /* not else */
+            if (currentCodeBlock.blockNotation === '>') {
+                if (currentCodeBlock.content !== '') {
+                    currentCodeBlock.content += '\n';
+                }
+                currentCodeBlock.content += line.slice(2);
+            }
+        }
+        else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '>' /* <- Note: [0] */) {
+            codeBlocks.push(currentCodeBlock);
+            currentCodeBlock = null;
+        }
+        /* not else */
+        if (line.startsWith('```')) {
+            const language = line.slice(3).trim() || null;
+            if (currentCodeBlock === null) {
+                currentCodeBlock = { blockNotation: '```', language, content: '' };
+            }
+            else {
+                if (language !== null) {
+                    throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed and already opening new ${language} code block`);
+                }
+                codeBlocks.push(currentCodeBlock);
+                currentCodeBlock = null;
+            }
+        }
+        else if (currentCodeBlock !== null && currentCodeBlock.blockNotation === '```') {
+            if (currentCodeBlock.content !== '') {
+                currentCodeBlock.content += '\n';
+            }
+            currentCodeBlock.content += line.split('\\`\\`\\`').join('```') /* <- TODO: Maybe make proper unescape */;
+        }
+    }
+    if (currentCodeBlock !== null) {
+        throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
+    }
+    return codeBlocks;
 }
 /**
- * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
- * TODO: [🧠][✌️] Make some Promptbook-native token system
- * TODO: [✌️] `countWords` should be just `splitWords(...).length`, and all other counters should use this pattern as well
+ * TODO: Maybe name for `blockNotation` instead of  '```' and '>'
  */
 
 /**
- * Index of all counter functions
+ * Extracts  extracts exactly one valid JSON code block
  *
- * @public exported from `@promptbook/utils`
+ * - When given string is a valid JSON as it is, it just returns it
+ * - When there is no JSON code block the function throws a `ParseError`
+ * - When there are multiple JSON code blocks the function throws a `ParseError`
+ *
+ * Note: It is not important if marked as ```json BUT if it is VALID JSON
+ * Note: There are multiple similar 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 no valid JSON block in the markdown
  */
-const CountUtils = {
-    CHARACTERS: countCharacters,
-    WORDS: countWords,
-    SENTENCES: countSentences,
-    PARAGRAPHS: countParagraphs,
-    LINES: countLines,
-    PAGES: countPages,
-};
+function extractJsonBlock(markdown) {
+    if (isValidJsonString(markdown)) {
+        return markdown;
+    }
+    const codeBlocks = extractAllBlocksFromMarkdown(markdown);
+    const jsonBlocks = codeBlocks.filter(({ content }) => isValidJsonString(content));
+    if (jsonBlocks.length === 0) {
+        throw new Error('There is no valid JSON block in the markdown');
+    }
+    if (jsonBlocks.length > 1) {
+        throw new Error('There are multiple JSON code blocks in the markdown');
+    }
+    return jsonBlocks[0].content;
+}
 /**
- * TODO: [🧠][🤠] This should be probably as part of `TextFormatParser`
- * Note: [💞] Ignore a discrepancy between file name and entity name
+ * TODO: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
+ * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
  */
 
 /**
@@ -4141,35 +5034,6 @@ class MemoryStorage {
     }
 }
 
-/**
- * Simple wrapper `new Date().toISOString()`
- *
- * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic because it depends on the current time
- *
- * @returns string_date branded type
- * @public exported from `@promptbook/utils`
- */
-function $getCurrentDate() {
-    return new Date().toISOString();
-}
-
-/**
- * Parses the task and returns the list of all parameter names
- *
- * @param template the string template with parameters in {curly} braces
- * @returns the list of parameter names
- * @public exported from `@promptbook/utils`
- */
-function extractParameterNames(template) {
-    const matches = template.matchAll(/{\w+}/g);
-    const parameterNames = new Set();
-    for (const match of matches) {
-        const parameterName = match[0].slice(1, -1);
-        parameterNames.add(parameterName);
-    }
-    return parameterNames;
-}
-
 /**
  * Intercepts LLM tools and counts total usage of the tools
  *
@@ -4245,6 +5109,9 @@ function cacheLlmTools(llmTools, options = {}) {
             case 'EMBEDDING':
                 promptResult = await llmTools.callEmbeddingModel(prompt);
                 break variant;
+            case 'IMAGE_GENERATION':
+                promptResult = await llmTools.callImageGenerationModel(prompt);
+                break variant;
             // <- case [🤖]:
             default:
                 throw new PipelineExecutionError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
@@ -4281,12 +5148,13 @@ function cacheLlmTools(llmTools, options = {}) {
                 }
             }
             catch (error) {
+                assertsError(error);
                 // If validation throws an unexpected error, don't cache
                 shouldCache = false;
                 if (isVerbose) {
                     console.info('Not caching result due to validation error for key:', key, {
                         content: promptResult.content,
-                        validationError: error instanceof Error ? error.message : String(error),
+                        validationError: serializeError(error),
                     });
                 }
             }
@@ -4332,6 +5200,11 @@ function cacheLlmTools(llmTools, options = {}) {
             return /* not await */ callCommonModel(prompt);
         };
     }
+    if (llmTools.callImageGenerationModel !== undefined) {
+        proxyTools.callImageGenerationModel = async (prompt) => {
+            return /* not await */ callCommonModel(prompt);
+        };
+    }
     // <- Note: [🤖]
     return proxyTools;
 }
@@ -4520,6 +5393,15 @@ function countUsage(llmTools) {
             return promptResult;
         };
     }
+    if (llmTools.callImageGenerationModel !== undefined) {
+        proxyTools.callImageGenerationModel = async (prompt) => {
+            // console.info('[🚕] callImageGenerationModel through countTotalUsage');
+            const promptResult = await llmTools.callImageGenerationModel(prompt);
+            totalUsage = addUsage(totalUsage, promptResult.usage);
+            spending.next(promptResult.usage);
+            return promptResult;
+        };
+    }
     // <- Note: [🤖]
     return proxyTools;
 }
@@ -4528,7 +5410,7 @@ function countUsage(llmTools) {
  * TODO: [🧠] Is there some meaningfull way how to test this util
  * TODO: [🧠][🌯] Maybe a way how to hide ability to `get totalUsage`
  *     > const [llmToolsWithUsage,getUsage] = countTotalUsage(llmTools);
- * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+ * TODO: [👷‍♂️] Write a comprehensive manual explaining the construction and usage of LLM tools in the Promptbook ecosystem
  */
 
 /**
@@ -4642,6 +5524,12 @@ class MultipleLlmExecutionTools {
     callEmbeddingModel(prompt) {
         return this.callCommonModel(prompt);
     }
+    /**
+     * Calls the best available embedding model
+     */
+    callImageGenerationModel(prompt) {
+        return this.callCommonModel(prompt);
+    }
     // <- Note: [🤖]
     /**
      * Calls the best available model
@@ -4668,6 +5556,11 @@ class MultipleLlmExecutionTools {
                             continue llm;
                         }
                         return await llmExecutionTools.callEmbeddingModel(prompt);
+                    case 'IMAGE_GENERATION':
+                        if (llmExecutionTools.callImageGenerationModel === undefined) {
+                            continue llm;
+                        }
+                        return await llmExecutionTools.callImageGenerationModel(prompt);
                     // <- case [🤖]:
                     default:
                         throw new UnexpectedError(`Unknown model variant "${prompt.modelRequirements.modelVariant}" in ${llmExecutionTools.title}`);
@@ -4992,21 +5885,6 @@ const promptbookFetch = async (urlOrRequest, init) => {
  * TODO: [🧠] Maybe rename because it is not used only for scrapers but also in `$getCompiledBook`
  */
 
-/**
- * Checks if value is valid email
- *
- * @public exported from `@promptbook/utils`
- */
-function isValidEmail(email) {
-    if (typeof email !== 'string') {
-        return false;
-    }
-    if (email.split('\n').length > 1) {
-        return false;
-    }
-    return /^.+@.+\..+$/.test(email);
-}
-
 /**
  * @private utility of CLI
  */
@@ -5685,113 +6563,39 @@ function $initializeListScrapersCommand(program) {
     }));
 }
 /**
- * Note: [💞] Ignore a discrepancy between file name and entity name
- * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
- */
-
-/**
- * Initializes `login` command for Promptbook CLI utilities
- *
- * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI
- *
- * @private internal function of `promptbookCli`
- */
-function $initializeLoginCommand(program) {
-    const loginCommand = program.command('login');
-    loginCommand.description(spaceTrim$2(`
-            Login to the remote Promptbook server
-        `));
-    loginCommand.action(handleActionErrors(async (cliOptions) => {
-        // Note: Not interested in return value of this function but the side effect of logging in
-        await $provideLlmToolsForCli({
-            isLoginloaded: true,
-            cliOptions: {
-                ...cliOptions,
-                strategy: 'REMOTE_SERVER', // <- Note: Overriding strategy to `REMOTE_SERVER`
-                //                               TODO: Do not allow flag `--strategy` in `login` command at all
-            },
-        });
-        return process.exit(0);
-    }));
-}
-/**
- * TODO: Implement non-interactive login
- * Note: [💞] Ignore a discrepancy between file name and entity name
- * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
- */
-
-/**
- * Tests if given string is valid semantic version
- *
- * Note: There are two similar functions:
- * - `isValidSemanticVersion` which tests any semantic version
- * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
- *
- * @public exported from `@promptbook/utils`
- */
-function isValidSemanticVersion(version) {
-    if (typeof version !== 'string') {
-        return false;
-    }
-    if (version.startsWith('0.0.0')) {
-        return false;
-    }
-    return /^\d+\.\d+\.\d+(-\d+)?$/i.test(version);
-}
-
-/**
- * Tests if given string is valid promptbook version
- * It looks into list of known promptbook versions.
- *
- * @see https://www.npmjs.com/package/promptbook?activeTab=versions
- * Note: When you are using for example promptbook 2.0.0 and there already is promptbook 3.0.0 it don`t know about it.
- * Note: There are two similar functions:
- * - `isValidSemanticVersion` which tests any semantic version
- * - `isValidPromptbookVersion` *(this one)* which tests just Promptbook versions
- *
- * @public exported from `@promptbook/utils`
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
  */
-function isValidPromptbookVersion(version) {
-    if (!isValidSemanticVersion(version)) {
-        return false;
-    }
-    if ( /* version === '1.0.0' || */version === '2.0.0' || version === '3.0.0') {
-        return false;
-    }
-    // <- TODO: [main] !!3 Check isValidPromptbookVersion against PROMPTBOOK_ENGINE_VERSIONS
-    return true;
-}
 
 /**
- * Tests if given string is valid pipeline URL URL.
+ * Initializes `login` command for Promptbook CLI utilities
  *
- * Note: There are two similar functions:
- * - `isValidUrl` which tests any URL
- * - `isValidPipelineUrl` *(this one)* which tests just pipeline URL
+ * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI
  *
- * @public exported from `@promptbook/utils`
+ * @private internal function of `promptbookCli`
  */
-function isValidPipelineUrl(url) {
-    if (!isValidUrl(url)) {
-        return false;
-    }
-    if (!url.startsWith('https://') && !url.startsWith('http://') /* <- Note: [👣] */) {
-        return false;
-    }
-    if (url.includes('#')) {
-        // TODO: [🐠]
-        return false;
-    }
-    /*
-    Note: [👣][🧠] Is it secure to allow pipeline URLs on private and unsecured networks?
-    if (isUrlOnPrivateNetwork(url)) {
-        return false;
-    }
-    */
-    return true;
+function $initializeLoginCommand(program) {
+    const loginCommand = program.command('login');
+    loginCommand.description(spaceTrim$2(`
+            Login to the remote Promptbook server
+        `));
+    loginCommand.action(handleActionErrors(async (cliOptions) => {
+        // Note: Not interested in return value of this function but the side effect of logging in
+        await $provideLlmToolsForCli({
+            isLoginloaded: true,
+            cliOptions: {
+                ...cliOptions,
+                strategy: 'REMOTE_SERVER', // <- Note: Overriding strategy to `REMOTE_SERVER`
+                //                               TODO: Do not allow flag `--strategy` in `login` command at all
+            },
+        });
+        return process.exit(0);
+    }));
 }
 /**
- * TODO: [🐠] Maybe more info why the URL is invalid
+ * TODO: Implement non-interactive login
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ * Note: [🟡] Code in this file should never be published outside of `@promptbook/cli`
  */
 
 /**
@@ -6494,65 +7298,6 @@ function isPipelinePrepared(pipeline) {
  *     - [♨] Are tasks prepared
  */
 
-/**
- * Serializes an error into a [🚉] JSON-serializable object
- *
- * @public exported from `@promptbook/utils`
- */
-function serializeError(error) {
-    const { name, message, stack } = error;
-    const { id } = error;
-    if (!Object.keys(ALL_ERRORS).includes(name)) {
-        console.error(spaceTrim$2((block) => `
-
-                    Cannot serialize error with name "${name}"
-
-                    Authors of Promptbook probably forgot to add this error into the list of errors:
-                    https://github.com/webgptorg/promptbook/blob/main/src/errors/0-index.ts
-
-
-                    ${block(stack || message)}
-
-                `));
-    }
-    return {
-        name: name,
-        message,
-        stack,
-        id, // Include id in the serialized object
-    };
-}
-
-/**
- * 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] = jsonParse(value);
-        }
-        else {
-            newObject[key] = jsonStringsToJsons(value);
-        }
-    }
-    return newObject;
-}
-/**
- * TODO: Type the return type correctly
- */
-
 /**
  * Asserts that the execution of a Promptbook is successful
  *
@@ -6730,144 +7475,63 @@ function createTask(options) {
                         message = `Working on ${current.title}`;
                     }
                 }
-                if (!message) {
-                    if (errors.length) {
-                        message = errors[errors.length - 1].message || 'Error';
-                    }
-                    else if (warnings.length) {
-                        message = warnings[warnings.length - 1].message || 'Warning';
-                    }
-                    else if (status === 'FINISHED') {
-                        message = 'Finished';
-                    }
-                    else if (status === 'ERROR') {
-                        message = 'Error';
-                    }
-                    else {
-                        message = 'Running';
-                    }
-                }
-            }
-            return {
-                percent: percent,
-                message: message + ' (!!!fallback)',
-            };
-        },
-        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 llmCalls() {
-            return [...llmCalls, { foo: '!!! bar' }];
-            // <- Note: [1] --||--
-        },
-        get currentValue() {
-            return currentValue;
-            // <- Note: [1] --||--
-        },
-    };
-}
-/**
- * TODO: Maybe allow to terminate the task and add getter `isFinished` or `status`
- * TODO: [🐚] Split into more files and make `PrepareTask` & `RemoteTask` + split the function
- */
-
-/**
- * Format either small or big number
- *
- * @public exported from `@promptbook/utils`
- */
-function numberToString(value) {
-    if (value === 0) {
-        return '0';
-    }
-    else if (Number.isNaN(value)) {
-        return VALUE_STRINGS.nan;
-    }
-    else if (value === Infinity) {
-        return VALUE_STRINGS.infinity;
-    }
-    else if (value === -Infinity) {
-        return VALUE_STRINGS.negativeInfinity;
-    }
-    for (let exponent = 0; exponent < 15; exponent++) {
-        const factor = 10 ** exponent;
-        const valueRounded = Math.round(value * factor) / factor;
-        if (Math.abs(value - valueRounded) / value < SMALL_NUMBER) {
-            return valueRounded.toFixed(exponent);
-        }
-    }
-    return value.toString();
-}
-
-/**
- * Function `valueToString` will convert the given value to string
- * This is useful and used in the `templateParameters` function
- *
- * Note: This function is not just calling `toString` method
- *       It's more complex and can handle this conversion specifically for LLM models
- *       See `VALUE_STRINGS`
- *
- * Note: There are 2 similar functions
- * - `valueToString` converts value to string for LLM models as human-readable string
- * - `asSerializable` converts value to string to preserve full information to be able to convert it back
- *
- * @public exported from `@promptbook/utils`
- */
-function valueToString(value) {
-    try {
-        if (value === '') {
-            return VALUE_STRINGS.empty;
-        }
-        else if (value === null) {
-            return VALUE_STRINGS.null;
-        }
-        else if (value === undefined) {
-            return VALUE_STRINGS.undefined;
-        }
-        else if (typeof value === 'string') {
-            return value;
-        }
-        else if (typeof value === 'number') {
-            return numberToString(value);
-        }
-        else if (value instanceof Date) {
-            return value.toISOString();
-        }
-        else {
-            try {
-                return JSON.stringify(value);
-            }
-            catch (error) {
-                if (error instanceof TypeError && error.message.includes('circular structure')) {
-                    return VALUE_STRINGS.circular;
+                if (!message) {
+                    if (errors.length) {
+                        message = errors[errors.length - 1].message || 'Error';
+                    }
+                    else if (warnings.length) {
+                        message = warnings[warnings.length - 1].message || 'Warning';
+                    }
+                    else if (status === 'FINISHED') {
+                        message = 'Finished';
+                    }
+                    else if (status === 'ERROR') {
+                        message = 'Error';
+                    }
+                    else {
+                        message = 'Running';
+                    }
                 }
-                throw error;
             }
-        }
-    }
-    catch (error) {
-        assertsError(error);
-        console.error(error);
-        return VALUE_STRINGS.unserializable;
-    }
+            return {
+                percent: percent,
+                message: message + ' (!!!fallback)',
+            };
+        },
+        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 llmCalls() {
+            return [...llmCalls, { foo: '!!! bar' }];
+            // <- Note: [1] --||--
+        },
+        get currentValue() {
+            return currentValue;
+            // <- Note: [1] --||--
+        },
+    };
 }
+/**
+ * TODO: Maybe allow to terminate the task and add getter `isFinished` or `status`
+ * TODO: [🐚] Split into more files and make `PrepareTask` & `RemoteTask` + split the function
+ */
 
 /**
  * Parses the given script and returns the list of all used variables that are not defined in the script
@@ -6994,41 +7658,6 @@ function extractParameterNamesFromTask(task) {
  * TODO: [🔣] If script require contentLanguage
  */
 
-/**
- * Create difference set of two sets.
- *
- * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
- * @public exported from `@promptbook/utils`
- */
-function difference(a, b, isEqual = (a, b) => a === b) {
-    const diff = new Set();
-    for (const itemA of Array.from(a)) {
-        if (!Array.from(b).some((itemB) => isEqual(itemA, itemB))) {
-            diff.add(itemA);
-        }
-    }
-    return diff;
-}
-/**
- * TODO: [🧠][💯] Maybe also implement symmetricDifference
- */
-
-/**
- * Creates a new set with all elements that are present in either set
- *
- * @deprecated use new javascript set methods instead @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
- * @public exported from `@promptbook/utils`
- */
-function union(...sets) {
-    const union = new Set();
-    for (const set of sets) {
-        for (const item of Array.from(set)) {
-            union.add(item);
-        }
-    }
-    return union;
-}
-
 /**
  * Contains configuration options for parsing and generating CSV files, such as delimiters and quoting rules.
  *
@@ -7057,28 +7686,6 @@ function csvParse(value /* <- TODO: string_csv */, settings, schema /* <- TODO:
     return csv;
 }
 
-/**
- * Function to check if a string is valid CSV
- *
- * @param value The string to check
- * @returns `true` if the string is a valid CSV string, false otherwise
- *
- * @public exported from `@promptbook/utils`
- */
-function isValidCsvString(value) {
-    try {
-        // A simple check for CSV format: at least one comma and no invalid characters
-        if (value.includes(',') && /^[\w\s,"']+$/.test(value)) {
-            return true;
-        }
-        return false;
-    }
-    catch (error) {
-        assertsError(error);
-        return false;
-    }
-}
-
 /**
  * Definition for CSV spreadsheet
  *
@@ -7258,30 +7865,6 @@ const TextFormatParser = {
  * TODO: [🏢] Allow to expect something inside each item of list and other formats
  */
 
-/**
- * Function to check if a string is valid XML
- *
- * @param value
- * @returns `true` if the string is a valid XML string, false otherwise
- *
- * @public exported from `@promptbook/utils`
- */
-function isValidXmlString(value) {
-    try {
-        const parser = new DOMParser();
-        const parsedDocument = parser.parseFromString(value, 'application/xml');
-        const parserError = parsedDocument.getElementsByTagName('parsererror');
-        if (parserError.length > 0) {
-            return false;
-        }
-        return true;
-    }
-    catch (error) {
-        assertsError(error);
-        return false;
-    }
-}
-
 /**
  * Definition for XML format
  *
@@ -7371,130 +7954,59 @@ function mapAvailableToExpectedParameters(options) {
                     ${block(Array.from(expectedParameterNames)
             .map((parameterName) => `- {${parameterName}}`)
             .join('\n'))}
-
-                    Remaining available parameters:
-                    ${block(Array.from(availableParametersNames)
-            .map((parameterName) => `- {${parameterName}}`)
-            .join('\n'))}
-
-                `));
-    }
-    const expectedParameterNamesArray = Array.from(expectedParameterNames);
-    const availableParametersNamesArray = Array.from(availableParametersNames);
-    for (let i = 0; i < expectedParameterNames.size; i++) {
-        mappedParameters[expectedParameterNamesArray[i]] = availableParameters[availableParametersNamesArray[i]];
-    }
-    // Note: [👨‍👨‍👧] Now we can freeze `mappedParameters` to prevent accidental modifications after mapping
-    Object.freeze(mappedParameters);
-    return mappedParameters;
-}
-
-/**
- * Takes an item or an array of items and returns an array of items
- *
- * 1) Any item except array and undefined returns array with that one item (also null)
- * 2) Undefined returns empty array
- * 3) Array returns itself
- *
- * @private internal utility
- */
-function arrayableToArray(input) {
-    if (input === undefined) {
-        return [];
-    }
-    if (input instanceof Array) {
-        return input;
-    }
-    return [input];
-}
-
-/**
- * Just returns the given `LlmExecutionTools` or joins multiple into one
- *
- * @public exported from `@promptbook/core`
- */
-function getSingleLlmExecutionTools(oneOrMoreLlmExecutionTools) {
-    const _llms = arrayableToArray(oneOrMoreLlmExecutionTools);
-    const llmTools = _llms.length === 1
-        ? _llms[0]
-        : joinLlmExecutionTools('Multiple LLM Providers joined by `getSingleLlmExecutionTools`', ..._llms);
-    return llmTools;
-}
-/**
- * TODO: [🙆] `getSingleLlmExecutionTools` vs `joinLlmExecutionTools` - explain difference or pick one
- * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
- */
-
-/**
- * Replaces parameters in template with values from parameters object
- *
- * Note: This function is not places strings into string,
- *       It's more complex and can handle this operation specifically for LLM models
- *
- * @param template the template with parameters in {curly} braces
- * @param parameters the object with parameters
- * @returns the template with replaced parameters
- * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
- * @public exported from `@promptbook/utils`
- */
-function templateParameters(template, parameters) {
-    for (const [parameterName, parameterValue] of Object.entries(parameters)) {
-        if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
-            throw new UnexpectedError(`Parameter \`{${parameterName}}\` has missing value`);
-        }
-        else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
-            // TODO: [🍵]
-            throw new UnexpectedError(`Parameter \`{${parameterName}}\` is restricted to use`);
-        }
-    }
-    let replacedTemplates = template;
-    let match;
-    let loopLimit = LOOP_LIMIT;
-    while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
-        .exec(replacedTemplates))) {
-        if (loopLimit-- < 0) {
-            throw new LimitReachedError('Loop limit reached during parameters replacement in `templateParameters`');
-        }
-        const precol = match.groups.precol;
-        const parameterName = match.groups.parameterName;
-        if (parameterName === '') {
-            // Note: Skip empty placeholders. It's used to avoid confusion with JSON-like strings
-            continue;
-        }
-        if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
-            throw new PipelineExecutionError('Parameter is already opened or not closed');
-        }
-        if (parameters[parameterName] === undefined) {
-            throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
-        }
-        let parameterValue = parameters[parameterName];
-        if (parameterValue === undefined) {
-            throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
-        }
-        parameterValue = valueToString(parameterValue);
-        // Escape curly braces in parameter values to prevent prompt-injection
-        parameterValue = parameterValue.replace(/[{}]/g, '\\$&');
-        if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
-            parameterValue = parameterValue
-                .split('\n')
-                .map((line, index) => (index === 0 ? line : `${precol}${line}`))
-                .join('\n');
-        }
-        replacedTemplates =
-            replacedTemplates.substring(0, match.index + precol.length) +
-                parameterValue +
-                replacedTemplates.substring(match.index + precol.length + parameterName.length + 2);
+
+                    Remaining available parameters:
+                    ${block(Array.from(availableParametersNames)
+            .map((parameterName) => `- {${parameterName}}`)
+            .join('\n'))}
+
+                `));
     }
-    // [💫] Check if there are parameters that are not closed properly
-    if (/{\w+$/.test(replacedTemplates)) {
-        throw new PipelineExecutionError('Parameter is not closed');
+    const expectedParameterNamesArray = Array.from(expectedParameterNames);
+    const availableParametersNamesArray = Array.from(availableParametersNames);
+    for (let i = 0; i < expectedParameterNames.size; i++) {
+        mappedParameters[expectedParameterNamesArray[i]] = availableParameters[availableParametersNamesArray[i]];
     }
-    // [💫] Check if there are parameters that are not opened properly
-    if (/^\w+}/.test(replacedTemplates)) {
-        throw new PipelineExecutionError('Parameter is not opened');
+    // Note: [👨‍👨‍👧] Now we can freeze `mappedParameters` to prevent accidental modifications after mapping
+    Object.freeze(mappedParameters);
+    return mappedParameters;
+}
+
+/**
+ * Takes an item or an array of items and returns an array of items
+ *
+ * 1) Any item except array and undefined returns array with that one item (also null)
+ * 2) Undefined returns empty array
+ * 3) Array returns itself
+ *
+ * @private internal utility
+ */
+function arrayableToArray(input) {
+    if (input === undefined) {
+        return [];
     }
-    return replacedTemplates;
+    if (input instanceof Array) {
+        return input;
+    }
+    return [input];
+}
+
+/**
+ * Just returns the given `LlmExecutionTools` or joins multiple into one
+ *
+ * @public exported from `@promptbook/core`
+ */
+function getSingleLlmExecutionTools(oneOrMoreLlmExecutionTools) {
+    const _llms = arrayableToArray(oneOrMoreLlmExecutionTools);
+    const llmTools = _llms.length === 1
+        ? _llms[0]
+        : joinLlmExecutionTools('Multiple LLM Providers joined by `getSingleLlmExecutionTools`', ..._llms);
+    return llmTools;
 }
+/**
+ * TODO: [🙆] `getSingleLlmExecutionTools` vs `joinLlmExecutionTools` - explain difference or pick one
+ * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+ */
 
 /**
  * Executes a pipeline task with multiple attempts, including joker and retry logic. Handles different task types
@@ -7590,8 +8102,9 @@ async function executeAttempts(options) {
                                     $ongoingTaskResult.$resultString = $ongoingTaskResult.$completionResult.content;
                                     break variant;
                                 case 'EMBEDDING':
+                                case 'IMAGE_GENERATION':
                                     throw new PipelineExecutionError(spaceTrim$1((block) => `
-                                                Embedding model can not be used in pipeline
+                                                ${modelRequirements.modelVariant} model can not be used in pipeline
 
                                                 This should be catched during parsing
 
@@ -8725,35 +9238,6 @@ function createPipelineExecutor(options) {
     return pipelineExecutor;
 }
 
-/**
- * Async version of Array.forEach
- *
- * @param array - Array to iterate over
- * @param options - Options for the function
- * @param callbackfunction - Function to call for each item
- * @public exported from `@promptbook/utils`
- * @deprecated [🪂] Use queues instead
- */
-async function forEachAsync(array, options, callbackfunction) {
-    const { maxParallelCount = Infinity } = options;
-    let index = 0;
-    let runningTasks = [];
-    const tasks = [];
-    for (const item of array) {
-        const currentIndex = index++;
-        const task = callbackfunction(item, currentIndex, array);
-        tasks.push(task);
-        runningTasks.push(task);
-        /* not await */ Promise.resolve(task).then(() => {
-            runningTasks = runningTasks.filter((t) => t !== task);
-        });
-        if (maxParallelCount < runningTasks.length) {
-            await Promise.race(runningTasks);
-        }
-    }
-    await Promise.all(tasks);
-}
-
 /**
  * Prepares the persona for the pipeline
  *
@@ -9889,75 +10373,6 @@ const EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'LINES', 'PARAGRA
  * TODO: [💝] Unite object for expecting amount and format - remove format
  */
 
-/**
- * Function parseNumber will parse number from string
- *
- * Note: [🔂] This function is idempotent.
- * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
- * Note: it also works only with decimal numbers
- *
- * @returns parsed number
- * @throws {ParseError} if the value is not a number
- *
- * @public exported from `@promptbook/utils`
- */
-function parseNumber(value) {
-    const originalValue = value;
-    if (typeof value === 'number') {
-        value = value.toString(); // <- TODO: Maybe more efficient way to do this
-    }
-    if (typeof value !== 'string') {
-        return 0;
-    }
-    value = value.trim();
-    if (value.startsWith('+')) {
-        return parseNumber(value.substring(1));
-    }
-    if (value.startsWith('-')) {
-        const number = parseNumber(value.substring(1));
-        if (number === 0) {
-            return 0; // <- Note: To prevent -0
-        }
-        return -number;
-    }
-    value = value.replace(/,/g, '.');
-    value = value.toUpperCase();
-    if (value === '') {
-        return 0;
-    }
-    if (value === '♾' || value.startsWith('INF')) {
-        return Infinity;
-    }
-    if (value.includes('/')) {
-        const [numerator_, denominator_] = value.split('/');
-        const numerator = parseNumber(numerator_);
-        const denominator = parseNumber(denominator_);
-        if (denominator === 0) {
-            throw new ParseError(`Unable to parse number from "${originalValue}" because denominator is zero`);
-        }
-        return numerator / denominator;
-    }
-    if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
-        return 0;
-    }
-    if (value.includes('E')) {
-        const [significand, exponent] = value.split('E');
-        return parseNumber(significand) * 10 ** parseNumber(exponent);
-    }
-    if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
-        throw new ParseError(`Unable to parse number from "${originalValue}"`);
-    }
-    const num = parseFloat(value);
-    if (isNaN(num)) {
-        throw new ParseError(`Unexpected NaN when parsing number from "${originalValue}"`);
-    }
-    return num;
-}
-/**
- * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
- * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`
- */
-
 /**
 import { WrappedError } from '../../errors/WrappedError';
 import { assertsError } from '../../errors/assertsError';
@@ -10100,84 +10515,6 @@ const expectCommandParser = {
     },
 };
 
-/**
- * Normalizes a given text to camelCase format.
- *
- * Note: [🔂] This function is idempotent.
- *
- * @param text The text to be normalized.
- * @param _isFirstLetterCapital Whether the first letter should be capitalized.
- * @returns The camelCase formatted string.
- * @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
- */
-
-/**
- * Removes quotes from a string
- *
- * Note: [🔂] This function is idempotent.
- * Tip: This is very useful 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 similar 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 `validateParameterName` will normalize and validate a parameter name for use in pipelines.
  * It removes diacritics, emojis, and quotes, normalizes to camelCase, and checks for reserved names and invalid characters.
@@ -11067,11 +11404,7 @@ const modelCommandParser = {
         // TODO: [🚜] DRY
         if ($taskJson.modelRequirements[command.key] !== undefined) {
             if ($taskJson.modelRequirements[command.key] === command.value) {
-                console.warn(`Multiple commands \`MODEL ${{
-                    modelName: 'NAME',
-                    modelVariant: 'VARIANT',
-                    maxTokens: '???',
-                }[command.key]} ${command.value}\` in the task "${$taskJson.title || $taskJson.name}"`);
+                console.warn(`Multiple commands \`MODEL ${command.key} ${command.value}\` in the task "${$taskJson.title || $taskJson.name}"`);
                 // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
             }
             else {
@@ -11352,30 +11685,16 @@ function $applyToTaskJson(command, $taskJson, $pipelineJson) {
     }
     console.warn(spaceTrim$2(`
 
-            Persona "${personaName}" is defined multiple times with different description:
-
-            First definition:
-            ${persona.description}
-
-            Second definition:
-            ${personaDescription}
-
-        `));
-    persona.description += spaceTrim$2('\n\n' + personaDescription);
-}
-
-/**
- * Checks if the given value is a valid JavaScript identifier name.
- *
- * @param javascriptName The value to check for JavaScript identifier validity.
- * @returns `true` if the value is a valid JavaScript name, false otherwise.
- * @public exported from `@promptbook/utils`
- */
-function isValidJavascriptName(javascriptName) {
-    if (typeof javascriptName !== 'string') {
-        return false;
-    }
-    return /^[a-zA-Z_$][0-9a-zA-Z_$]*$/i.test(javascriptName);
+            Persona "${personaName}" is defined multiple times with different description:
+
+            First definition:
+            ${persona.description}
+
+            Second definition:
+            ${personaDescription}
+
+        `));
+    persona.description += spaceTrim$2('\n\n' + personaDescription);
 }
 
 /**
@@ -12891,345 +13210,59 @@ function parsePipeline(pipelineString) {
     if ($pipelineJson.formfactorName === undefined) {
         $pipelineJson.formfactorName = 'GENERIC';
     }
-    // =============================================================
-    return exportJson({
-        name: 'pipelineJson',
-        message: `Result of \`parsePipeline\``,
-        order: ORDER_OF_PIPELINE_JSON,
-        value: {
-            formfactorName: 'GENERIC',
-            // <- Note: [🔆] Setting `formfactorName` is redundant to satisfy the typescript
-            ...$pipelineJson,
-        },
-    });
-}
-/**
- * TODO: [🧠] Maybe more things here can be refactored as high-level abstractions
- * TODO: [main] !!4 Warn if used only sync version
- * TODO: [🚞] Report here line/column of error
- * TODO: Use spaceTrim more effectively
- * TODO: [🧠] Parameter flags - isInput, isOutput, isInternal
- * TODO: [🥞] Not optimal parsing because `splitMarkdownIntoSections` is executed twice with same string, once through `flattenMarkdown` and second directly here
- * TODO: [♈] Probably move expectations from tasks to parameters
- * TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
- * TODO: [🍙] Make some standard order of json properties
- */
-
-/**
- * Compile pipeline from string (markdown) format to JSON format
- *
- * @see https://github.com/webgptorg/promptbook/discussions/196
- *
- * Note: This function does not validate logic of the pipeline only the parsing
- * Note: This function acts as compilation process
- *
- * @param pipelineString {Promptbook} in string markdown format (.book.md)
- * @param tools - Tools for the preparation and scraping - if not provided together with `llm`, the preparation will be skipped
- * @param options - Options and tools for the compilation
- * @returns {Promptbook} compiled in JSON format (.bookc)
- * @throws {ParseError} if the promptbook string is not valid
- * @public exported from `@promptbook/core`
- */
-async function compilePipeline(pipelineString, tools, options) {
-    let pipelineJson = parsePipeline(pipelineString);
-    if (tools !== undefined && tools.llm !== undefined) {
-        pipelineJson = await preparePipeline(pipelineJson, tools, options || {
-            rootDirname: null,
-        });
-    }
-    // Note: No need to use `$exportJson` because `parsePipeline` and `preparePipeline` already do that
-    return pipelineJson;
-}
-/**
- * TODO: [🏏] Leverage the batch API and build queues @see https://platform.openai.com/docs/guides/batch
- * TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
- * TODO: [🧠] Should be in generated JSON file GENERATOR_WARNING
- */
-
-/**
- * Creates a Mermaid graph based on the promptbook
- *
- * Note: The result is not wrapped in a Markdown code block
- *
- * @public exported from `@promptbook/utils`
- */
-function renderPromptbookMermaid(pipelineJson, options) {
-    const { linkTask = () => null } = options || {};
-    const MERMAID_PREFIX = 'pipeline_';
-    const MERMAID_KNOWLEDGE_NAME = MERMAID_PREFIX + 'knowledge';
-    const MERMAID_RESERVED_NAME = MERMAID_PREFIX + 'reserved';
-    const MERMAID_INPUT_NAME = MERMAID_PREFIX + 'input';
-    const MERMAID_OUTPUT_NAME = MERMAID_PREFIX + 'output';
-    const parameterNameToTaskName = (parameterName) => {
-        if (parameterName === 'knowledge') {
-            return MERMAID_KNOWLEDGE_NAME;
-        }
-        else if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
-            return MERMAID_RESERVED_NAME;
-        }
-        const parameter = pipelineJson.parameters.find((parameter) => parameter.name === parameterName);
-        if (!parameter) {
-            throw new UnexpectedError(`Could not find {${parameterName}}`);
-            // <- TODO: This causes problems when {knowledge} and other reserved parameters are used
-        }
-        if (parameter.isInput) {
-            return MERMAID_INPUT_NAME;
-        }
-        const task = pipelineJson.tasks.find((task) => task.resultingParameterName === parameterName);
-        if (!task) {
-            throw new Error(`Could not find task for {${parameterName}}`);
-        }
-        return MERMAID_PREFIX + (task.name || normalizeTo_camelCase('task-' + titleToName(task.title)));
-    };
-    const inputAndIntermediateParametersMermaid = pipelineJson.tasks
-        .flatMap(({ title, dependentParameterNames, resultingParameterName }) => [
-        `${parameterNameToTaskName(resultingParameterName)}("${title}")`,
-        ...dependentParameterNames.map((dependentParameterName) => `${parameterNameToTaskName(dependentParameterName)}--"{${dependentParameterName}}"-->${parameterNameToTaskName(resultingParameterName)}`),
-    ])
-        .join('\n');
-    const outputParametersMermaid = pipelineJson.parameters
-        .filter(({ isOutput }) => isOutput)
-        .map(({ name }) => `${parameterNameToTaskName(name)}--"{${name}}"-->${MERMAID_OUTPUT_NAME}`)
-        .join('\n');
-    const linksMermaid = pipelineJson.tasks
-        .map((task) => {
-        const link = linkTask(task);
-        if (link === null) {
-            return '';
-        }
-        const { href, title } = link;
-        const taskName = parameterNameToTaskName(task.resultingParameterName);
-        return `click ${taskName} href "${href}" "${title}";`;
-    })
-        .filter((line) => line !== '')
-        .join('\n');
-    const interactionPointsMermaid = Object.entries({
-        [MERMAID_INPUT_NAME]: 'Input',
-        [MERMAID_OUTPUT_NAME]: 'Output',
-        [MERMAID_RESERVED_NAME]: 'Other',
-        [MERMAID_KNOWLEDGE_NAME]: 'Knowledge',
-    })
-        .filter(([MERMAID_NAME]) => (inputAndIntermediateParametersMermaid + outputParametersMermaid).includes(MERMAID_NAME))
-        .map(([MERMAID_NAME, title]) => `${MERMAID_NAME}((${title})):::${MERMAID_NAME}`)
-        .join('\n');
-    const promptbookMermaid = spaceTrim$1((block) => `
-
-            %% 🔮 Tip: Open this on GitHub or in the VSCode website to see the Mermaid graph visually
-
-            flowchart LR
-              subgraph "${pipelineJson.title}"
-
-                  %% Basic configuration
-                  direction TB
-
-                  %% Interaction points from pipeline to outside
-                  ${block(interactionPointsMermaid)}
-
-                  %% Input and intermediate parameters
-                  ${block(inputAndIntermediateParametersMermaid)}
-
-
-                  %% Output parameters
-                  ${block(outputParametersMermaid)}
-
-                  %% Links
-                  ${block(linksMermaid)}
-
-                  %% Styles
-                  classDef ${MERMAID_INPUT_NAME} color: grey;
-                  classDef ${MERMAID_OUTPUT_NAME} color: grey;
-                  classDef ${MERMAID_RESERVED_NAME} color: grey;
-                  classDef ${MERMAID_KNOWLEDGE_NAME} color: grey;
-
-              end;
-
-        `);
-    return promptbookMermaid;
-}
-/**
- * TODO: [🧠] FOREACH in mermaid graph
- * TODO: [🧠] Knowledge in mermaid graph
- * TODO: [🧠] Personas in mermaid graph
- * TODO: Maybe use some Mermaid package instead of string templating
- * TODO: [🕌] When more than 2 functionalities, split into separate functions
- */
-
-/**
- * Computes SHA-256 hash of the given object
- *
- * @public exported from `@promptbook/utils`
- */
-function computeHash(value) {
-    return SHA256(hexEncoder.parse(spaceTrim$2(valueToString(value)))).toString( /* hex */);
-}
-/**
- * TODO: [🥬][🥬] Use this ACRY
- */
-
-/**
- * Makes first letter of a string lowercase
- *
- * Note: [🔂] This function is idempotent.
- *
- * @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);
-}
-
-/**
- * Converts a name string into a URI-compatible format.
- *
- * @param name The string to be converted to a URI-compatible format.
- * @returns A URI-compatible string derived from the input name.
- * @example 'Hello World' -> 'hello-world'
- * @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;
-}
-
-/**
- * Converts a given name into URI-compatible parts.
- *
- * @param name The name to be converted into URI parts.
- * @returns An array of URI-compatible parts derived from the name.
- * @example 'Example Name' -> ['example', 'name']
- * @public exported from `@promptbook/utils`
- */
-function nameToUriParts(name) {
-    return nameToUriPart(name)
-        .split('-')
-        .filter((value) => value !== '');
-}
-
-/**
- * Normalizes a given text to PascalCase format.
- *
- * Note: [🔂] This function is idempotent.
- *
- * @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);
+    // =============================================================
+    return exportJson({
+        name: 'pipelineJson',
+        message: `Result of \`parsePipeline\``,
+        order: ORDER_OF_PIPELINE_JSON,
+        value: {
+            formfactorName: 'GENERIC',
+            // <- Note: [🔆] Setting `formfactorName` is redundant to satisfy the typescript
+            ...$pipelineJson,
+        },
+    });
 }
-
 /**
- * Take every whitespace (space, new line, tab) and replace it with a single space
- *
- * Note: [🔂] This function is idempotent.
- *
- * @public exported from `@promptbook/utils`
+ * TODO: [🧠] Maybe more things here can be refactored as high-level abstractions
+ * TODO: [main] !!4 Warn if used only sync version
+ * TODO: [🚞] Report here line/column of error
+ * TODO: Use spaceTrim more effectively
+ * TODO: [🧠] Parameter flags - isInput, isOutput, isInternal
+ * TODO: [🥞] Not optimal parsing because `splitMarkdownIntoSections` is executed twice with same string, once through `flattenMarkdown` and second directly here
+ * TODO: [♈] Probably move expectations from tasks to parameters
+ * TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
+ * TODO: [🍙] Make some standard order of json properties
  */
-function normalizeWhitespaces(sentence) {
-    return sentence.replace(/\s+/gs, ' ').trim();
-}
 
 /**
- * Adds suffix to the URL
+ * Compile pipeline from string (markdown) format to JSON format
  *
- * @public exported from `@promptbook/utils`
- */
-function suffixUrl(value, suffix) {
-    const baseUrl = value.href.endsWith('/') ? value.href.slice(0, -1) : value.href;
-    const normalizedSuffix = suffix.replace(/\/+/g, '/');
-    return (baseUrl + normalizedSuffix);
-}
-
-/**
- * Removes quotes and optional introduce text from a string
+ * @see https://github.com/webgptorg/promptbook/discussions/196
  *
- * Tip: This is very useful 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 similar functions:
- * - `removeQuotes` which removes only bounding quotes
- * - `unwrapResult` which removes whole introduce sentence
+ * Note: This function does not validate logic of the pipeline only the parsing
+ * Note: This function acts as compilation process
  *
- * @param text optionally quoted text
- * @returns text without quotes
- * @public exported from `@promptbook/utils`
+ * @param pipelineString {Promptbook} in string markdown format (.book.md)
+ * @param tools - Tools for the preparation and scraping - if not provided together with `llm`, the preparation will be skipped
+ * @param options - Options and tools for the compilation
+ * @returns {Promptbook} compiled in JSON format (.bookc)
+ * @throws {ParseError} if the promptbook string is not valid
+ * @public exported from `@promptbook/core`
  */
-function unwrapResult(text, options) {
-    const { isTrimmed = true, isIntroduceSentenceRemoved = true } = options || {};
-    let trimmedText = text;
-    // Remove leading and trailing spaces and newlines
-    if (isTrimmed) {
-        trimmedText = spaceTrim$1(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$1(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;
+async function compilePipeline(pipelineString, tools, options) {
+    let pipelineJson = parsePipeline(pipelineString);
+    if (tools !== undefined && tools.llm !== undefined) {
+        pipelineJson = await preparePipeline(pipelineJson, tools, options || {
+            rootDirname: null,
+        });
     }
+    // Note: No need to use `$exportJson` because `parsePipeline` and `preparePipeline` already do that
+    return pipelineJson;
 }
 /**
- * TODO: [🧠] Should this also unwrap the (parenthesis)
+ * TODO: [🏏] Leverage the batch API and build queues @see https://platform.openai.com/docs/guides/batch
+ * TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
+ * TODO: [🧠] Should be in generated JSON file GENERATOR_WARNING
  */
 
 /**
@@ -19444,7 +19477,7 @@ class OpenAiCompatibleExecutionTools {
         let threadMessages = [];
         if ('thread' in prompt && Array.isArray(prompt.thread)) {
             threadMessages = prompt.thread.map((msg) => ({
-                role: msg.role === 'assistant' ? 'assistant' : 'user',
+                role: msg.sender === 'assistant' ? 'assistant' : 'user',
                 content: msg.content,
             }));
         }
@@ -19857,13 +19890,14 @@ class OpenAiCompatibleExecutionTools {
         const modelName = currentModelRequirements.modelName || this.getDefaultImageGenerationModel().modelName;
         const modelSettings = {
             model: modelName,
-            // size: currentModelRequirements.size,
-            // quality: currentModelRequirements.quality,
-            // style: currentModelRequirements.style,
+            size: currentModelRequirements.size,
+            quality: currentModelRequirements.quality,
+            style: currentModelRequirements.style,
         };
         const rawPromptContent = templateParameters(content, { ...parameters, modelName });
         const rawRequest = {
             ...modelSettings,
+            size: modelSettings.size || '1024x1024',
             prompt: rawPromptContent,
             user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
             response_format: 'url', // TODO: [🧠] Maybe allow b64_json
@@ -20400,10 +20434,10 @@ class OllamaExecutionTools extends OpenAiCompatibleExecutionTools {
         // <- TODO: [🛄]
     }
     /**
-     * Default model for image generation variant.
+     * Default model for completion variant.
      */
     getDefaultImageGenerationModel() {
-        return this.getDefaultModel('!!!'); // <- TODO: [🧠] Pick the best default model
+        return this.getDefaultModel('dall-e-3');
         // <- TODO: [🛄]
     }
 }
@@ -21218,11 +21252,10 @@ class HardcodedOpenAiCompatibleExecutionTools extends OpenAiCompatibleExecutionT
         throw new PipelineExecutionError(`${this.title} does not support EMBEDDING model variant`);
     }
     /**
-     * Default model for image generation variant.
+     * Default model for completion variant.
      */
     getDefaultImageGenerationModel() {
-        return this.getDefaultModel('!!!'); // <- TODO: [🧠] Pick the best default model
-        // <- TODO: [🛄]
+        throw new PipelineExecutionError(`${this.title} does not support IMAGE_GENERATION model variant`);
     }
 }
 /**
@@ -23098,6 +23131,114 @@ class DeleteCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
+/**
+ * DICTIONARY commitment definition
+ *
+ * The DICTIONARY commitment defines specific terms and their meanings that the agent should use correctly
+ * in its reasoning and responses. This ensures consistent terminology usage.
+ *
+ * Key features:
+ * - Multiple DICTIONARY commitments are automatically merged into one
+ * - Content is placed in a dedicated section of the system message
+ * - Terms and definitions are stored in metadata.DICTIONARY for debugging
+ * - Agent should use the defined terms correctly in responses
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * Legal Assistant
+ *
+ * PERSONA You are a knowledgeable legal assistant
+ * DICTIONARY Misdemeanor is a minor wrongdoing or criminal offense
+ * DICTIONARY Felony is a serious crime usually punishable by imprisonment for more than one year
+ * DICTIONARY Tort is a civil wrong that causes harm or loss to another person, leading to legal liability
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class DictionaryCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('DICTIONARY');
+    }
+    /**
+     * Short one-line description of DICTIONARY.
+     */
+    get description() {
+        return 'Define terms and their meanings for consistent terminology usage.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '📚';
+    }
+    /**
+     * Markdown documentation for DICTIONARY commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # DICTIONARY
+
+            Defines specific terms and their meanings that the agent should use correctly in reasoning and responses.
+
+            ## Key aspects
+
+            - Multiple \`DICTIONARY\` commitments are merged together.
+            - Terms are defined in the format: "Term is definition"
+            - The agent should use these terms consistently in responses.
+            - Definitions help ensure accurate and consistent terminology.
+
+            ## Examples
+
+            \`\`\`book
+            Legal Assistant
+
+            PERSONA You are a knowledgeable legal assistant specializing in criminal law
+            DICTIONARY Misdemeanor is a minor wrongdoing or criminal offense
+            DICTIONARY Felony is a serious crime usually punishable by imprisonment for more than one year
+            DICTIONARY Tort is a civil wrong that causes harm or loss to another person, leading to legal liability
+            \`\`\`
+
+            \`\`\`book
+            Medical Assistant
+
+            PERSONA You are a helpful medical assistant
+            DICTIONARY Hypertension is persistently high blood pressure
+            DICTIONARY Diabetes is a chronic condition that affects how the body processes blood sugar
+            DICTIONARY Vaccine is a biological preparation that provides active immunity to a particular disease
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        var _a;
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Get existing dictionary entries from metadata
+        const existingDictionary = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.DICTIONARY) || '';
+        // Merge the new dictionary entry with existing entries
+        const mergedDictionary = existingDictionary
+            ? `${existingDictionary}\n${trimmedContent}`
+            : trimmedContent;
+        // Store the merged dictionary in metadata for debugging and inspection
+        const updatedMetadata = {
+            ...requirements.metadata,
+            DICTIONARY: mergedDictionary,
+        };
+        // Create the dictionary section for the system message
+        // Format: "# DICTIONARY\nTerm: definition\nTerm: definition..."
+        const dictionarySection = `# DICTIONARY\n${mergedDictionary}`;
+        return {
+            ...this.appendToSystemMessage(requirements, dictionarySection),
+            metadata: updatedMetadata,
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
 /**
  * FORMAT commitment definition
  *
@@ -25918,6 +26059,7 @@ const COMMITMENT_REGISTRY = [
     new DeleteCommitmentDefinition('CANCEL'),
     new DeleteCommitmentDefinition('DISCARD'),
     new DeleteCommitmentDefinition('REMOVE'),
+    new DictionaryCommitmentDefinition(),
     new OpenCommitmentDefinition(),
     new ClosedCommitmentDefinition(),
     new UseBrowserCommitmentDefinition(),
@@ -26002,17 +26144,64 @@ function parseAgentSourceWithCommitments(agentSource) {
         };
     }
     const lines = agentSource.split('\n');
-    const agentName = (((_a = lines[0]) === null || _a === void 0 ? void 0 : _a.trim()) || null);
+    let agentName = null;
+    let agentNameLineIndex = -1;
+    // Find the agent name: first non-empty line that is not a commitment and not a horizontal line
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined) {
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const isHorizontal = HORIZONTAL_LINE_PATTERN.test(line);
+        if (isHorizontal) {
+            continue;
+        }
+        let isCommitment = false;
+        for (const definition of COMMITMENT_REGISTRY) {
+            const typeRegex = definition.createTypeRegex();
+            const match = typeRegex.exec(trimmed);
+            if (match && ((_a = match.groups) === null || _a === void 0 ? void 0 : _a.type)) {
+                isCommitment = true;
+                break;
+            }
+        }
+        if (!isCommitment) {
+            agentName = trimmed;
+            agentNameLineIndex = i;
+            break;
+        }
+    }
     const commitments = [];
     const nonCommitmentLines = [];
-    // Always add the first line (agent name) to non-commitment lines
-    if (lines[0] !== undefined) {
-        nonCommitmentLines.push(lines[0]);
+    // Add lines before agentName that are horizontal lines (they are non-commitment)
+    for (let i = 0; i < agentNameLineIndex; i++) {
+        const line = lines[i];
+        if (line === undefined) {
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const isHorizontal = HORIZONTAL_LINE_PATTERN.test(line);
+        if (isHorizontal) {
+            nonCommitmentLines.push(line);
+        }
+        // Note: Commitments before agentName are not added to nonCommitmentLines
+    }
+    // Add the agent name line to non-commitment lines
+    if (agentNameLineIndex >= 0) {
+        nonCommitmentLines.push(lines[agentNameLineIndex]);
     }
     // Parse commitments with multiline support
     let currentCommitment = null;
-    // Process lines starting from the second line (skip agent name)
-    for (let i = 1; i < lines.length; i++) {
+    // Process lines starting from after the agent name line
+    const startIndex = agentNameLineIndex >= 0 ? agentNameLineIndex + 1 : 0;
+    for (let i = startIndex; i < lines.length; i++) {
         const line = lines[i];
         if (line === undefined) {
             continue;
@@ -26232,7 +26421,12 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
         };
     }
     // Apply each commitment in order using reduce-like pattern
-    for (const commitment of filteredCommitments) {
+    for (let i = 0; i < filteredCommitments.length; i++) {
+        const commitment = filteredCommitments[i];
+        // CLOSED commitment should work only if its the last commitment in the book
+        if (commitment.type === 'CLOSED' && i !== filteredCommitments.length - 1) {
+            continue;
+        }
         const definition = getCommitmentDefinition(commitment.type);
         if (definition) {
             try {
@@ -26273,44 +26467,6 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
     };
 }
 
-/**
- * Generates a gravatar URL based on agent name for fallback avatar
- *
- * @param agentName The agent name to generate avatar for
- * @returns Gravatar URL
- *
- * @private - [🤹] The fact that profile image is Gravatar is just implementation detail which should be hidden for consumer
- */
-function generateGravatarUrl(agentName) {
-    // Use a default name if none provided
-    const safeName = agentName || 'Anonymous Agent';
-    // Create a simple hash from the name for consistent avatar
-    let hash = 0;
-    for (let i = 0; i < safeName.length; i++) {
-        const char = safeName.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    const avatarId = Math.abs(hash).toString();
-    return `https://www.gravatar.com/avatar/${avatarId}?default=robohash&size=200&rating=x`;
-}
-
-/**
- * Generates an image for the agent to use as profile image
- *
- * @param agentName The agent name to generate avatar for
- * @returns The placeholder profile image URL for the agent
- *
- * @public exported from `@promptbook/core`
- */
-function generatePlaceholderAgentProfileImageUrl(agentName) {
-    // Note: [🤹] The fact that profile image is Gravatar is just implementation detail which should be hidden for consumer
-    return generateGravatarUrl(agentName);
-}
-/**
- * TODO: [🤹] Figure out best placeholder image generator https://i.pravatar.cc/1000?u=568
- */
-
 /**
  * Computes SHA-256 hash of the agent source
  *
@@ -26378,7 +26534,57 @@ function parseAgentSource(agentSource) {
     }
     const meta = {};
     const links = [];
+    const capabilities = [];
     for (const commitment of parseResult.commitments) {
+        if (commitment.type === 'USE BROWSER') {
+            capabilities.push({
+                type: 'browser',
+                label: 'Browser',
+                iconName: 'Globe',
+            });
+            continue;
+        }
+        if (commitment.type === 'USE SEARCH ENGINE') {
+            capabilities.push({
+                type: 'search-engine',
+                label: 'Search Internet',
+                iconName: 'Search',
+            });
+            continue;
+        }
+        if (commitment.type === 'KNOWLEDGE') {
+            const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
+            let label = content;
+            let iconName = 'Book';
+            if (content.startsWith('http://') || content.startsWith('https://')) {
+                try {
+                    const url = new URL(content);
+                    if (url.pathname.endsWith('.pdf')) {
+                        label = url.pathname.split('/').pop() || 'Document.pdf';
+                        iconName = 'FileText';
+                    }
+                    else {
+                        label = url.hostname.replace(/^www\./, '');
+                    }
+                }
+                catch (e) {
+                    // Invalid URL, treat as text
+                }
+            }
+            else {
+                // Text content - take first few words
+                const words = content.split(/\s+/);
+                if (words.length > 4) {
+                    label = words.slice(0, 4).join(' ') + '...';
+                }
+            }
+            capabilities.push({
+                type: 'knowledge',
+                label,
+                iconName,
+            });
+            continue;
+        }
         if (commitment.type === 'META LINK') {
             const linkValue = spaceTrim$2(commitment.content);
             links.push(linkValue);
@@ -26408,10 +26614,6 @@ function parseAgentSource(agentSource) {
         const metaType = normalizeTo_camelCase(metaTypeRaw);
         meta[metaType] = spaceTrim$2(commitment.content.substring(metaTypeRaw.length));
     }
-    // Generate gravatar fallback if no meta image specified
-    if (!meta.image) {
-        meta.image = generatePlaceholderAgentProfileImageUrl(parseResult.agentName || '!!');
-    }
     // Generate fullname fallback if no meta fullname specified
     if (!meta.fullname) {
         meta.fullname = parseResult.agentName || createDefaultAgentName(agentSource);
@@ -26423,11 +26625,13 @@ function parseAgentSource(agentSource) {
     return {
         agentName: normalizeAgentName(parseResult.agentName || createDefaultAgentName(agentSource)),
         agentHash,
+        permanentId: meta.id,
         personaDescription,
         initialMessage,
         meta,
         links,
         parameters,
+        capabilities,
     };
 }
 /**