@promptbook/cli 0.95.0 → 0.98.0-10

package/umd/index.umd.js

@@ -57,7 +57,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.95.0';
+    const PROMPTBOOK_ENGINE_VERSION = '0.98.0-10';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -271,7 +271,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const DEFAULT_MAX_EXECUTION_ATTEMPTS = 10; // <- TODO: [🤹‍♂️]
+    const DEFAULT_MAX_EXECUTION_ATTEMPTS = 7; // <- TODO: [🤹‍♂️]
     // <- TODO: [🐝]
     /**
      * Where to store your books
@@ -1070,7 +1070,7 @@
             throw new Error(spaceTrim__default["default"]((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
         }
@@ -2769,303 +2769,520 @@
     }
 
     /**
-     * Intercepts LLM tools and counts total usage of the tools
+     * Function isValidJsonString will tell you if the string is valid JSON or not
      *
-     * Note: It can take extended `LlmExecutionTools` and cache the
+     * @param value The string to check
+     * @returns `true` if the string is a valid JSON string, false otherwise
      *
-     * @param llmTools LLM tools to be intercepted with usage counting, it can contain extra methods like `totalUsage`
-     * @returns LLM tools with same functionality with added total cost counting
-     * @public exported from `@promptbook/core`
+     * @public exported from `@promptbook/utils`
      */
-    function cacheLlmTools(llmTools, options = {}) {
-        const { storage = new MemoryStorage(), isCacheReloaded = false, isVerbose = DEFAULT_IS_VERBOSE } = options;
-        const proxyTools = {
-            ...llmTools,
-            // <- Note: [🥫]
-            get title() {
-                return `${llmTools.title} (cached)`;
-                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
-            },
-            get description() {
-                return `${llmTools.description} (cached)`;
-                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
-            },
-            listModels() {
-                // TODO: [🧠] Should be model listing also cached?
-                return /* not await */ llmTools.listModels();
-            },
-        };
-        const callCommonModel = async (prompt) => {
-            const { parameters, content, modelRequirements } = prompt;
-            // <- Note: These are relevant things from the prompt that the cache key should depend on.
-            // TODO: Maybe some standalone function for normalization of content for cache
-            let normalizedContent = content;
-            normalizedContent = normalizedContent.replace(/\s+/g, ' ');
-            normalizedContent = normalizedContent.split('\r\n').join('\n');
-            normalizedContent = spaceTrim__default["default"](normalizedContent);
-            // Note: Do not need to save everything in the cache, just the relevant parameters
-            const relevantParameterNames = extractParameterNames(content);
-            const relevantParameters = Object.fromEntries(Object.entries(parameters).filter(([key]) => relevantParameterNames.has(key)));
-            const keyHashBase = { relevantParameters, normalizedContent, modelRequirements };
-            const key = titleToName(prompt.title.substring(0, MAX_FILENAME_LENGTH - 10) +
-                '-' +
-                sha256__default["default"](hexEncoder__default["default"].parse(JSON.stringify(keyHashBase)))
-                    .toString( /* hex */)
-                    .substring(0, 10 - 1));
-            const cacheItem = !isCacheReloaded ? await storage.getItem(key) : null;
-            if (cacheItem) {
-                return cacheItem.promptResult;
+    function isValidJsonString(value /* <- [👨‍⚖️] */) {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (error) {
+            assertsError(error);
+            if (error.message.includes('Unexpected token')) {
+                return false;
             }
-            if (isVerbose) {
-                console.info('Cache miss for key:', key, {
-                    prompt,
-                    'prompt.title': prompt.title,
-                    MAX_FILENAME_LENGTH,
-                    keyHashBase,
-                    parameters,
-                    relevantParameters,
-                    content,
-                    normalizedContent,
-                    modelRequirements,
-                });
+            return false;
+        }
+    }
+
+    /**
+     * Makes first letter of a string uppercase
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function capitalize(word) {
+        return word.substring(0, 1).toUpperCase() + word.substring(1);
+    }
+
+    /**
+     * Extracts all code blocks from markdown.
+     *
+     * 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 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);
+                }
             }
-            let promptResult;
-            variant: switch (prompt.modelRequirements.modelVariant) {
-                case 'CHAT':
-                    promptResult = await llmTools.callChatModel(prompt);
-                    break variant;
-                case 'COMPLETION':
-                    promptResult = await llmTools.callCompletionModel(prompt);
-                    break variant;
-                case 'EMBEDDING':
-                    promptResult = await llmTools.callEmbeddingModel(prompt);
-                    break variant;
-                // <- case [🤖]:
-                default:
-                    throw new PipelineExecutionError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
+            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 */;
             }
-            // TODO: [🧠] !!5 How to do timing in mixed cache / non-cache situation
-            // promptResult.timing: FromtoItems
-            await storage.setItem(key, {
-                date: $getCurrentDate(),
-                promptbookVersion: PROMPTBOOK_ENGINE_VERSION,
-                bookVersion: BOOK_LANGUAGE_VERSION,
-                prompt: {
-                    ...prompt,
-                    parameters: Object.entries(parameters).length === Object.entries(relevantParameters).length
-                        ? parameters
-                        : {
-                            ...relevantParameters,
-                            note: `<- Note: Only relevant parameters are stored in the cache`,
-                        },
-                },
-                promptResult,
-            });
-            return promptResult;
-        };
-        if (llmTools.callChatModel !== undefined) {
-            proxyTools.callChatModel = async (prompt) => {
-                return /* not await */ callCommonModel(prompt);
-            };
         }
-        if (llmTools.callCompletionModel !== undefined) {
-            proxyTools.callCompletionModel = async (prompt) => {
-                return /* not await */ callCommonModel(prompt);
-            };
+        if (currentCodeBlock !== null) {
+            throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
         }
-        if (llmTools.callEmbeddingModel !== undefined) {
-            proxyTools.callEmbeddingModel = async (prompt) => {
-                return /* not await */ callCommonModel(prompt);
-            };
+        return codeBlocks;
+    }
+    /**
+     * TODO: Maybe name for `blockNotation` instead of  '```' and '>'
+     */
+
+    /**
+     * 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
+     *
+     * @public exported from `@promptbook/markdown-utils`
+     * @throws {ParseError} if there is no valid JSON block in the markdown
+     */
+    function extractJsonBlock(markdown) {
+        if (isValidJsonString(markdown)) {
+            return markdown;
         }
-        // <- Note: [🤖]
-        return proxyTools;
+        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: [🧠][💸] Maybe make some common abstraction `interceptLlmTools` and use here (or use javascript Proxy?)
-     * TODO: [🧠] Is there some meaningfull way how to test this util
-     * TODO: [👷‍♂️] Comprehensive manual about construction of llmTools
-     *            Detailed explanation about caching strategies and appropriate storage selection for different use cases
-     *            Examples of how to combine multiple interceptors for advanced caching, logging, and usage tracking
+     * TODO: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
+     * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
      */
 
     /**
-     * Represents the uncertain value
+     * Counts number of characters in the text
      *
-     * @public exported from `@promptbook/core`
+     * @public exported from `@promptbook/utils`
      */
-    const ZERO_VALUE = $deepFreeze({ value: 0 });
+    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;
+    }
     /**
-     * Represents the uncertain value
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     */
+
+    /**
+     * Number of characters per standard line with 11pt Arial font size.
      *
-     * @public exported from `@promptbook/core`
+     * @public exported from `@promptbook/utils`
      */
-    const UNCERTAIN_ZERO_VALUE = $deepFreeze({ value: 0, isUncertain: true });
+    const CHARACTERS_PER_STANDARD_LINE = 63;
     /**
-     * Represents the usage with no resources consumed
+     * Number of lines per standard A4 page with 11pt Arial font size and standard margins and spacing.
      *
-     * @public exported from `@promptbook/core`
+     * @public exported from `@promptbook/utils`
      */
-    const ZERO_USAGE = $deepFreeze({
-        price: ZERO_VALUE,
-        input: {
-            tokensCount: ZERO_VALUE,
-            charactersCount: ZERO_VALUE,
-            wordsCount: ZERO_VALUE,
-            sentencesCount: ZERO_VALUE,
-            linesCount: ZERO_VALUE,
-            paragraphsCount: ZERO_VALUE,
-            pagesCount: ZERO_VALUE,
-        },
-        output: {
-            tokensCount: ZERO_VALUE,
-            charactersCount: ZERO_VALUE,
-            wordsCount: ZERO_VALUE,
-            sentencesCount: ZERO_VALUE,
-            linesCount: ZERO_VALUE,
-            paragraphsCount: ZERO_VALUE,
-            pagesCount: ZERO_VALUE,
-        },
-    });
+    const LINES_PER_STANDARD_PAGE = 44;
     /**
-     * Represents the usage with unknown resources consumed
+     * TODO: [🧠] Should be this `constants.ts` or `config.ts`?
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Counts number of lines in the text
      *
-     * @public exported from `@promptbook/core`
+     * 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`
      */
-    const UNCERTAIN_USAGE = $deepFreeze({
-        price: UNCERTAIN_ZERO_VALUE,
-        input: {
-            tokensCount: UNCERTAIN_ZERO_VALUE,
-            charactersCount: UNCERTAIN_ZERO_VALUE,
-            wordsCount: UNCERTAIN_ZERO_VALUE,
-            sentencesCount: UNCERTAIN_ZERO_VALUE,
-            linesCount: UNCERTAIN_ZERO_VALUE,
-            paragraphsCount: UNCERTAIN_ZERO_VALUE,
-            pagesCount: UNCERTAIN_ZERO_VALUE,
-        },
-        output: {
-            tokensCount: UNCERTAIN_ZERO_VALUE,
-            charactersCount: UNCERTAIN_ZERO_VALUE,
-            wordsCount: UNCERTAIN_ZERO_VALUE,
-            sentencesCount: UNCERTAIN_ZERO_VALUE,
-            linesCount: UNCERTAIN_ZERO_VALUE,
-            paragraphsCount: UNCERTAIN_ZERO_VALUE,
-            pagesCount: UNCERTAIN_ZERO_VALUE,
-        },
-    });
+    function countLines(text) {
+        text = text.replace('\r\n', '\n');
+        text = text.replace('\r', '\n');
+        const lines = text.split('\n');
+        return lines.reduce((count, line) => count + Math.ceil(line.length / CHARACTERS_PER_STANDARD_LINE), 0);
+    }
+    /**
+     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     */
+
+    /**
+     * 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,...
+     */
+
+    /**
+     * 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,...
+     */
+
+    /**
+     * 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,...
+     */
+
+    /**
+     * 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,...
+     */
+
+    /**
+     * 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
      */
 
     /**
-     * Function `addUsage` will add multiple usages into one
+     * Function checkExpectations will check if the expectations on given value are met
      *
-     * Note: If you provide 0 values, it returns ZERO_USAGE
+     * Note: There are two similar functions:
+     * - `checkExpectations` which throws an error if the expectations are not met
+     * - `isPassingExpectations` which returns a boolean
      *
-     * @public exported from `@promptbook/core`
+     * @throws {ExpectError} if the expectations are not met
+     * @returns {void} Nothing
+     * @private internal function of `createPipelineExecutor`
      */
-    function addUsage(...usageItems) {
-        return usageItems.reduce((acc, item) => {
-            var _a;
-            acc.price.value += ((_a = item.price) === null || _a === void 0 ? void 0 : _a.value) || 0;
-            for (const key of Object.keys(acc.input)) {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                //@ts-ignore
-                if (item.input[key]) {
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    //@ts-ignore
-                    acc.input[key].value += item.input[key].value || 0;
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    //@ts-ignore
-                    if (item.input[key].isUncertain) {
-                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                        //@ts-ignore
-                        acc.input[key].isUncertain = true;
-                    }
-                }
+    function checkExpectations(expectations, value) {
+        for (const [unit, { max, min }] of Object.entries(expectations)) {
+            const amount = CountUtils[unit.toUpperCase()](value);
+            if (min && amount < min) {
+                throw new ExpectError(`Expected at least ${min} ${unit} but got ${amount}`);
+            } /* not else */
+            if (max && amount > max) {
+                throw new ExpectError(`Expected at most ${max} ${unit} but got ${amount}`);
             }
-            for (const key of Object.keys(acc.output)) {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                //@ts-ignore
-                if (item.output[key]) {
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    //@ts-ignore
-                    acc.output[key].value += item.output[key].value || 0;
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    //@ts-ignore
-                    if (item.output[key].isUncertain) {
-                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                        //@ts-ignore
-                        acc.output[key].isUncertain = true;
+        }
+    }
+    /**
+     * TODO: [💝] Unite object for expecting amount and format
+     * TODO: [🧠][🤠] This should be part of `TextFormatParser`
+     * Note: [💝] and [🤠] are interconnected together
+     */
+
+    /**
+     * Validates a prompt result against expectations and format requirements.
+     * This function provides a common abstraction for result validation that can be used
+     * by both execution logic and caching logic to ensure consistency.
+     *
+     * @param options - The validation options including result string, expectations, and format
+     * @returns Validation result with processed string and validity status
+     * @private internal function of `createPipelineExecutor` and `cacheLlmTools`
+     */
+    function validatePromptResult(options) {
+        const { resultString, expectations, format } = options;
+        let processedResultString = resultString;
+        let validationError;
+        try {
+            // TODO: [💝] Unite object for expecting amount and format
+            if (format) {
+                if (format === 'JSON') {
+                    if (!isValidJsonString(processedResultString)) {
+                        // TODO: [🏢] Do more universally via `FormatParser`
+                        try {
+                            processedResultString = extractJsonBlock(processedResultString);
+                        }
+                        catch (error) {
+                            keepUnused(error);
+                            throw new ExpectError(spaceTrim.spaceTrim((block) => `
+                                    Expected valid JSON string
+
+                                    The expected JSON text:
+                                    ${block(processedResultString)}
+                                `));
+                        }
                     }
                 }
+                else {
+                    throw new UnexpectedError(`Unknown format "${format}"`);
+                }
             }
-            return acc;
-        }, deepClone(ZERO_USAGE));
+            // TODO: [💝] Unite object for expecting amount and format
+            if (expectations) {
+                checkExpectations(expectations, processedResultString);
+            }
+            return {
+                isValid: true,
+                processedResultString,
+            };
+        }
+        catch (error) {
+            if (error instanceof ExpectError) {
+                validationError = error;
+            }
+            else {
+                // Re-throw non-ExpectError errors (like UnexpectedError)
+                throw error;
+            }
+            return {
+                isValid: false,
+                processedResultString,
+                error: validationError,
+            };
+        }
     }
 
     /**
      * Intercepts LLM tools and counts total usage of the tools
      *
-     * @param llmTools LLM tools to be intercepted with usage counting
+     * Note: It can take extended `LlmExecutionTools` and cache the
+     *
+     * @param llmTools LLM tools to be intercepted with usage counting, it can contain extra methods like `totalUsage`
      * @returns LLM tools with same functionality with added total cost counting
      * @public exported from `@promptbook/core`
      */
-    function countUsage(llmTools) {
-        let totalUsage = ZERO_USAGE;
-        const spending = new rxjs.Subject();
+    function cacheLlmTools(llmTools, options = {}) {
+        const { storage = new MemoryStorage(), isCacheReloaded = false, isVerbose = DEFAULT_IS_VERBOSE } = options;
         const proxyTools = {
+            ...llmTools,
+            // <- Note: [🥫]
             get title() {
-                return `${llmTools.title} (+usage)`;
+                return `${llmTools.title} (cached)`;
                 // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
             },
             get description() {
-                return `${llmTools.description} (+usage)`;
+                return `${llmTools.description} (cached)`;
                 // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-            },
-            checkConfiguration() {
-                return /* not await */ llmTools.checkConfiguration();
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
             },
             listModels() {
+                // TODO: [🧠] Should be model listing also cached?
                 return /* not await */ llmTools.listModels();
             },
-            spending() {
-                return spending.asObservable();
-            },
-            getTotalUsage() {
-                // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
-                return totalUsage;
-            },
         };
-        if (llmTools.callChatModel !== undefined) {
-            proxyTools.callChatModel = async (prompt) => {
-                // console.info('[🚕] callChatModel through countTotalUsage');
-                const promptResult = await llmTools.callChatModel(prompt);
-                totalUsage = addUsage(totalUsage, promptResult.usage);
-                spending.next(promptResult.usage);
-                return promptResult;
-            };
-        }
-        if (llmTools.callCompletionModel !== undefined) {
-            proxyTools.callCompletionModel = async (prompt) => {
-                // console.info('[🚕] callCompletionModel through countTotalUsage');
-                const promptResult = await llmTools.callCompletionModel(prompt);
-                totalUsage = addUsage(totalUsage, promptResult.usage);
-                spending.next(promptResult.usage);
-                return promptResult;
+        const callCommonModel = async (prompt) => {
+            var _a;
+            const { parameters, content, modelRequirements } = prompt;
+            // <- Note: These are relevant things from the prompt that the cache key should depend on.
+            // TODO: Maybe some standalone function for normalization of content for cache
+            let normalizedContent = content;
+            normalizedContent = normalizedContent.replace(/\s+/g, ' ');
+            normalizedContent = normalizedContent.split('\r\n').join('\n');
+            normalizedContent = spaceTrim__default["default"](normalizedContent);
+            // Note: Do not need to save everything in the cache, just the relevant parameters
+            const relevantParameterNames = extractParameterNames(content);
+            const relevantParameters = Object.fromEntries(Object.entries(parameters).filter(([key]) => relevantParameterNames.has(key)));
+            const keyHashBase = { relevantParameters, normalizedContent, modelRequirements };
+            const key = titleToName(prompt.title.substring(0, MAX_FILENAME_LENGTH - 10) +
+                '-' +
+                sha256__default["default"](hexEncoder__default["default"].parse(JSON.stringify(keyHashBase)))
+                    .toString( /* hex */)
+                    .substring(0, 10 - 1));
+            const cacheItem = !isCacheReloaded ? await storage.getItem(key) : null;
+            if (cacheItem) {
+                return cacheItem.promptResult;
+            }
+            if (isVerbose) {
+                console.info('Cache miss for key:', key, {
+                    prompt,
+                    'prompt.title': prompt.title,
+                    MAX_FILENAME_LENGTH,
+                    keyHashBase,
+                    parameters,
+                    relevantParameters,
+                    content,
+                    normalizedContent,
+                    modelRequirements,
+                });
+            }
+            let promptResult;
+            variant: switch (prompt.modelRequirements.modelVariant) {
+                case 'CHAT':
+                    promptResult = await llmTools.callChatModel(prompt);
+                    break variant;
+                case 'COMPLETION':
+                    promptResult = await llmTools.callCompletionModel(prompt);
+                    break variant;
+                case 'EMBEDDING':
+                    promptResult = await llmTools.callEmbeddingModel(prompt);
+                    break variant;
+                // <- case [🤖]:
+                default:
+                    throw new PipelineExecutionError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
+            }
+            // TODO: [🧠] !!5 How to do timing in mixed cache / non-cache situation
+            // promptResult.timing: FromtoItems
+            // Check if the result is valid and should be cached
+            // A result is considered failed if:
+            // 1. It has a content property that is null or undefined
+            // 2. It has an error property that is truthy
+            // 3. It has a success property that is explicitly false
+            // 4. It doesn't meet the prompt's expectations or format requirements
+            const isBasicFailedResult = promptResult.content === null ||
+                promptResult.content === undefined ||
+                promptResult.error ||
+                promptResult.success === false;
+            let shouldCache = !isBasicFailedResult;
+            // If the basic result is valid, check against expectations and format
+            if (shouldCache && promptResult.content) {
+                try {
+                    const validationResult = validatePromptResult({
+                        resultString: promptResult.content,
+                        expectations: prompt.expectations,
+                        format: prompt.format,
+                    });
+                    shouldCache = validationResult.isValid;
+                    if (!shouldCache && isVerbose) {
+                        console.info('Not caching result that fails expectations/format validation for key:', key, {
+                            content: promptResult.content,
+                            expectations: prompt.expectations,
+                            format: prompt.format,
+                            validationError: (_a = validationResult.error) === null || _a === void 0 ? void 0 : _a.message,
+                        });
+                    }
+                }
+                catch (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),
+                        });
+                    }
+                }
+            }
+            if (shouldCache) {
+                await storage.setItem(key, {
+                    date: $getCurrentDate(),
+                    promptbookVersion: PROMPTBOOK_ENGINE_VERSION,
+                    bookVersion: BOOK_LANGUAGE_VERSION,
+                    prompt: {
+                        ...prompt,
+                        parameters: Object.entries(parameters).length === Object.entries(relevantParameters).length
+                            ? parameters
+                            : {
+                                ...relevantParameters,
+                                note: `<- Note: Only relevant parameters are stored in the cache`,
+                            },
+                    },
+                    promptResult,
+                });
+            }
+            else if (isVerbose && isBasicFailedResult) {
+                console.info('Not caching failed result for key:', key, {
+                    content: promptResult.content,
+                    error: promptResult.error,
+                    success: promptResult.success,
+                });
+            }
+            return promptResult;
+        };
+        if (llmTools.callChatModel !== undefined) {
+            proxyTools.callChatModel = async (prompt) => {
+                return /* not await */ callCommonModel(prompt);
+            };
+        }
+        if (llmTools.callCompletionModel !== undefined) {
+            proxyTools.callCompletionModel = async (prompt) => {
+                return /* not await */ callCommonModel(prompt);
             };
         }
         if (llmTools.callEmbeddingModel !== undefined) {
             proxyTools.callEmbeddingModel = async (prompt) => {
-                // console.info('[🚕] callEmbeddingModel through countTotalUsage');
-                const promptResult = await llmTools.callEmbeddingModel(prompt);
-                totalUsage = addUsage(totalUsage, promptResult.usage);
-                spending.next(promptResult.usage);
-                return promptResult;
+                return /* not await */ callCommonModel(prompt);
             };
         }
         // <- Note: [🤖]
@@ -3074,84 +3291,272 @@
     /**
      * TODO: [🧠][💸] Maybe make some common abstraction `interceptLlmTools` and use here (or use javascript Proxy?)
      * 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: [👷‍♂️] Comprehensive manual about construction of llmTools
+     *            Detailed explanation about caching strategies and appropriate storage selection for different use cases
+     *            Examples of how to combine multiple interceptors for advanced caching, logging, and usage tracking
      */
 
     /**
-     * Provides LLM tools configuration by reading environment variables.
+     * Represents the uncertain value
      *
-     * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+     * @public exported from `@promptbook/core`
+     */
+    const ZERO_VALUE = $deepFreeze({ value: 0 });
+    /**
+     * Represents the uncertain value
      *
-     * It looks for environment variables:
-     * - `process.env.OPENAI_API_KEY`
-     * - `process.env.ANTHROPIC_CLAUDE_API_KEY`
-     * - ...
+     * @public exported from `@promptbook/core`
+     */
+    const UNCERTAIN_ZERO_VALUE = $deepFreeze({ value: 0, isUncertain: true });
+    /**
+     * Represents the usage with no resources consumed
      *
-     * @see Environment variables documentation or .env file for required variables.
-     * @returns A promise that resolves to the LLM tools configuration, or null if configuration is incomplete or missing.
-     * @public exported from `@promptbook/node`
+     * @public exported from `@promptbook/core`
      */
-    async function $provideLlmToolsConfigurationFromEnv() {
-        if (!$isRunningInNode()) {
-            throw new EnvironmentMismatchError('Function `$provideLlmToolsFromEnv` works only in Node.js environment');
-        }
-        const envFilepath = await $provideEnvFilename();
-        if (envFilepath !== null) {
-            dotenv__namespace.config({ path: envFilepath });
-        }
-        const llmToolsConfiguration = $llmToolsMetadataRegister
-            .list()
-            .map((metadata) => metadata.createConfigurationFromEnv(process.env))
-            .filter((configuration) => configuration !== null);
-        return llmToolsConfiguration;
-    }
+    const ZERO_USAGE = $deepFreeze({
+        price: ZERO_VALUE,
+        input: {
+            tokensCount: ZERO_VALUE,
+            charactersCount: ZERO_VALUE,
+            wordsCount: ZERO_VALUE,
+            sentencesCount: ZERO_VALUE,
+            linesCount: ZERO_VALUE,
+            paragraphsCount: ZERO_VALUE,
+            pagesCount: ZERO_VALUE,
+        },
+        output: {
+            tokensCount: ZERO_VALUE,
+            charactersCount: ZERO_VALUE,
+            wordsCount: ZERO_VALUE,
+            sentencesCount: ZERO_VALUE,
+            linesCount: ZERO_VALUE,
+            paragraphsCount: ZERO_VALUE,
+            pagesCount: ZERO_VALUE,
+        },
+    });
     /**
-     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     * Represents the usage with unknown resources consumed
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const UNCERTAIN_USAGE = $deepFreeze({
+        price: UNCERTAIN_ZERO_VALUE,
+        input: {
+            tokensCount: UNCERTAIN_ZERO_VALUE,
+            charactersCount: UNCERTAIN_ZERO_VALUE,
+            wordsCount: UNCERTAIN_ZERO_VALUE,
+            sentencesCount: UNCERTAIN_ZERO_VALUE,
+            linesCount: UNCERTAIN_ZERO_VALUE,
+            paragraphsCount: UNCERTAIN_ZERO_VALUE,
+            pagesCount: UNCERTAIN_ZERO_VALUE,
+        },
+        output: {
+            tokensCount: UNCERTAIN_ZERO_VALUE,
+            charactersCount: UNCERTAIN_ZERO_VALUE,
+            wordsCount: UNCERTAIN_ZERO_VALUE,
+            sentencesCount: UNCERTAIN_ZERO_VALUE,
+            linesCount: UNCERTAIN_ZERO_VALUE,
+            paragraphsCount: UNCERTAIN_ZERO_VALUE,
+            pagesCount: UNCERTAIN_ZERO_VALUE,
+        },
+    });
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
     /**
-     * Multiple LLM Execution Tools is a proxy server that uses multiple execution tools internally and exposes the executor interface externally.
+     * Function `addUsage` will add multiple usages into one
+     *
+     * Note: If you provide 0 values, it returns ZERO_USAGE
      *
-     * Note: Internal utility of `joinLlmExecutionTools` but exposed type
      * @public exported from `@promptbook/core`
      */
-    class MultipleLlmExecutionTools {
-        /**
-         * Gets array of execution tools in order of priority
-         */
-        constructor(...llmExecutionTools) {
-            this.llmExecutionTools = llmExecutionTools;
-        }
-        get title() {
-            return 'Multiple LLM Providers';
-        }
-        get description() {
-            const innerModelsTitlesAndDescriptions = this.llmExecutionTools
-                .map(({ title, description }, index) => {
-                const headLine = `${index + 1}) \`${title}\``;
-                if (description === undefined) {
-                    return headLine;
+    function addUsage(...usageItems) {
+        return usageItems.reduce((acc, item) => {
+            var _a;
+            acc.price.value += ((_a = item.price) === null || _a === void 0 ? void 0 : _a.value) || 0;
+            for (const key of Object.keys(acc.input)) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                if (item.input[key]) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    //@ts-ignore
+                    acc.input[key].value += item.input[key].value || 0;
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    //@ts-ignore
+                    if (item.input[key].isUncertain) {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        acc.input[key].isUncertain = true;
+                    }
                 }
-                return spaceTrim__default["default"]((block) => `
-                        ${headLine}
-                        
-                          ${ /* <- Note: Indenting the description: */block(description)}
-                    `);
-            })
-                .join('\n\n');
-            return spaceTrim__default["default"]((block) => `
-                Multiple LLM Providers:
+            }
+            for (const key of Object.keys(acc.output)) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                if (item.output[key]) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    //@ts-ignore
+                    acc.output[key].value += item.output[key].value || 0;
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    //@ts-ignore
+                    if (item.output[key].isUncertain) {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        acc.output[key].isUncertain = true;
+                    }
+                }
+            }
+            return acc;
+        }, deepClone(ZERO_USAGE));
+    }
 
-                ${block(innerModelsTitlesAndDescriptions)}
-            `);
-        }
-        /**
-         * Check the configuration of all execution tools
-         */
-        async checkConfiguration() {
-            // Note: Run checks in parallel
+    /**
+     * Intercepts LLM tools and counts total usage of the tools
+     *
+     * @param llmTools LLM tools to be intercepted with usage counting
+     * @returns LLM tools with same functionality with added total cost counting
+     * @public exported from `@promptbook/core`
+     */
+    function countUsage(llmTools) {
+        let totalUsage = ZERO_USAGE;
+        const spending = new rxjs.Subject();
+        const proxyTools = {
+            get title() {
+                return `${llmTools.title} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            },
+            get description() {
+                return `${llmTools.description} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            },
+            checkConfiguration() {
+                return /* not await */ llmTools.checkConfiguration();
+            },
+            listModels() {
+                return /* not await */ llmTools.listModels();
+            },
+            spending() {
+                return spending.asObservable();
+            },
+            getTotalUsage() {
+                // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
+                return totalUsage;
+            },
+        };
+        if (llmTools.callChatModel !== undefined) {
+            proxyTools.callChatModel = async (prompt) => {
+                // console.info('[🚕] callChatModel through countTotalUsage');
+                const promptResult = await llmTools.callChatModel(prompt);
+                totalUsage = addUsage(totalUsage, promptResult.usage);
+                spending.next(promptResult.usage);
+                return promptResult;
+            };
+        }
+        if (llmTools.callCompletionModel !== undefined) {
+            proxyTools.callCompletionModel = async (prompt) => {
+                // console.info('[🚕] callCompletionModel through countTotalUsage');
+                const promptResult = await llmTools.callCompletionModel(prompt);
+                totalUsage = addUsage(totalUsage, promptResult.usage);
+                spending.next(promptResult.usage);
+                return promptResult;
+            };
+        }
+        if (llmTools.callEmbeddingModel !== undefined) {
+            proxyTools.callEmbeddingModel = async (prompt) => {
+                // console.info('[🚕] callEmbeddingModel through countTotalUsage');
+                const promptResult = await llmTools.callEmbeddingModel(prompt);
+                totalUsage = addUsage(totalUsage, promptResult.usage);
+                spending.next(promptResult.usage);
+                return promptResult;
+            };
+        }
+        // <- Note: [🤖]
+        return proxyTools;
+    }
+    /**
+     * TODO: [🧠][💸] Maybe make some common abstraction `interceptLlmTools` and use here (or use javascript Proxy?)
+     * 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
+     */
+
+    /**
+     * Provides LLM tools configuration by reading environment variables.
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+     *
+     * It looks for environment variables:
+     * - `process.env.OPENAI_API_KEY`
+     * - `process.env.ANTHROPIC_CLAUDE_API_KEY`
+     * - ...
+     *
+     * @see Environment variables documentation or .env file for required variables.
+     * @returns A promise that resolves to the LLM tools configuration, or null if configuration is incomplete or missing.
+     * @public exported from `@promptbook/node`
+     */
+    async function $provideLlmToolsConfigurationFromEnv() {
+        if (!$isRunningInNode()) {
+            throw new EnvironmentMismatchError('Function `$provideLlmToolsFromEnv` works only in Node.js environment');
+        }
+        const envFilepath = await $provideEnvFilename();
+        if (envFilepath !== null) {
+            dotenv__namespace.config({ path: envFilepath });
+        }
+        const llmToolsConfiguration = $llmToolsMetadataRegister
+            .list()
+            .map((metadata) => metadata.createConfigurationFromEnv(process.env))
+            .filter((configuration) => configuration !== null);
+        return llmToolsConfiguration;
+    }
+    /**
+     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     */
+
+    /**
+     * Multiple LLM Execution Tools is a proxy server that uses multiple execution tools internally and exposes the executor interface externally.
+     *
+     * Note: Internal utility of `joinLlmExecutionTools` but exposed type
+     * @public exported from `@promptbook/core`
+     */
+    class MultipleLlmExecutionTools {
+        /**
+         * Gets array of execution tools in order of priority
+         */
+        constructor(...llmExecutionTools) {
+            this.llmExecutionTools = llmExecutionTools;
+        }
+        get title() {
+            return 'Multiple LLM Providers';
+        }
+        get description() {
+            const innerModelsTitlesAndDescriptions = this.llmExecutionTools
+                .map(({ title, description }, index) => {
+                const headLine = `${index + 1}) \`${title}\``;
+                if (description === undefined) {
+                    return headLine;
+                }
+                return spaceTrim__default["default"]((block) => `
+                        ${headLine}
+                        
+                          ${ /* <- Note: Indenting the description: */block(description)}
+                    `);
+            })
+                .join('\n\n');
+            return spaceTrim__default["default"]((block) => `
+                Multiple LLM Providers:
+
+                ${block(innerModelsTitlesAndDescriptions)}
+            `);
+        }
+        /**
+         * Check the configuration of all execution tools
+         */
+        async checkConfiguration() {
+            // Note: Run checks in parallel
             await Promise.all(this.llmExecutionTools.map((tools) => tools.checkConfiguration()));
         }
         /**
@@ -3334,8 +3739,10 @@
                 .list()
                 .find(({ packageName, className }) => llmConfiguration.packageName === packageName && llmConfiguration.className === className);
             if (registeredItem === undefined) {
+                console.log('!!! $llmToolsRegister.list()', $llmToolsRegister.list());
                 throw new Error(spaceTrim__default["default"]((block) => `
                         There is no constructor for LLM provider \`${llmConfiguration.className}\` from \`${llmConfiguration.packageName}\`
+                        Running in ${!$isRunningInBrowser() ? '' : 'browser environment'}${!$isRunningInNode() ? '' : 'node environment'}${!$isRunningInWebWorker() ? '' : 'worker environment'}
 
                         You have probably forgotten install and import the provider package.
                         To fix this issue, you can:
@@ -4669,28 +5076,6 @@
 
     var PipelineCollection = [{title:"Prepare Knowledge from Markdown",pipelineUrl:"https://promptbook.studio/promptbook/prepare-knowledge-from-markdown.book",formfactorName:"GENERIC",parameters:[{name:"knowledgeContent",description:"Markdown document content",isInput:true,isOutput:false},{name:"knowledgePieces",description:"The knowledge JSON object",isInput:false,isOutput:true}],tasks:[{taskType:"PROMPT_TASK",name:"knowledge",title:"Knowledge",content:"You are experienced data researcher, extract the important knowledge from the document.\n\n# Rules\n\n-   Make pieces of information concise, clear, and easy to understand\n-   One piece of information should be approximately 1 paragraph\n-   Divide the paragraphs by markdown horizontal lines ---\n-   Omit irrelevant information\n-   Group redundant information\n-   Write just extracted information, nothing else\n\n# The document\n\nTake information from this document:\n\n> {knowledgeContent}",resultingParameterName:"knowledgePieces",dependentParameterNames:["knowledgeContent"]}],personas:[],preparations:[],knowledgeSources:[],knowledgePieces:[],sources:[{type:"BOOK",path:null,content:"# Prepare Knowledge from Markdown\n\n-   PIPELINE URL `https://promptbook.studio/promptbook/prepare-knowledge-from-markdown.book`\n-   INPUT PARAMETER `{knowledgeContent}` Markdown document content\n-   OUTPUT PARAMETER `{knowledgePieces}` The knowledge JSON object\n\n## Knowledge\n\n<!-- TODO: [🍆] -FORMAT JSON -->\n\n```markdown\nYou are experienced data researcher, extract the important knowledge from the document.\n\n# Rules\n\n-   Make pieces of information concise, clear, and easy to understand\n-   One piece of information should be approximately 1 paragraph\n-   Divide the paragraphs by markdown horizontal lines ---\n-   Omit irrelevant information\n-   Group redundant information\n-   Write just extracted information, nothing else\n\n# The document\n\nTake information from this document:\n\n> {knowledgeContent}\n```\n\n`-> {knowledgePieces}`\n"}],sourceFile:"./books/prepare-knowledge-from-markdown.book"},{title:"Prepare Keywords",pipelineUrl:"https://promptbook.studio/promptbook/prepare-knowledge-keywords.book",formfactorName:"GENERIC",parameters:[{name:"knowledgePieceContent",description:"The content",isInput:true,isOutput:false},{name:"keywords",description:"Keywords separated by comma",isInput:false,isOutput:true}],tasks:[{taskType:"PROMPT_TASK",name:"knowledge",title:"Knowledge",content:"You are experienced data researcher, detect the important keywords in the document.\n\n# Rules\n\n-   Write just keywords separated by comma\n\n# The document\n\nTake information from this document:\n\n> {knowledgePieceContent}",resultingParameterName:"keywords",dependentParameterNames:["knowledgePieceContent"]}],personas:[],preparations:[],knowledgeSources:[],knowledgePieces:[],sources:[{type:"BOOK",path:null,content:"# Prepare Keywords\n\n-   PIPELINE URL `https://promptbook.studio/promptbook/prepare-knowledge-keywords.book`\n-   INPUT PARAMETER `{knowledgePieceContent}` The content\n-   OUTPUT PARAMETER `{keywords}` Keywords separated by comma\n\n## Knowledge\n\n<!-- TODO: [🍆] -FORMAT JSON -->\n\n```markdown\nYou are experienced data researcher, detect the important keywords in the document.\n\n# Rules\n\n-   Write just keywords separated by comma\n\n# The document\n\nTake information from this document:\n\n> {knowledgePieceContent}\n```\n\n`-> {keywords}`\n"}],sourceFile:"./books/prepare-knowledge-keywords.book"},{title:"Prepare Knowledge-piece Title",pipelineUrl:"https://promptbook.studio/promptbook/prepare-knowledge-title.book",formfactorName:"GENERIC",parameters:[{name:"knowledgePieceContent",description:"The content",isInput:true,isOutput:false},{name:"title",description:"The title of the document",isInput:false,isOutput:true}],tasks:[{taskType:"PROMPT_TASK",name:"knowledge",title:"Knowledge",content:"You are experienced content creator, write best title for the document.\n\n# Rules\n\n-   Write just title, nothing else\n-   Write maximum 5 words for the title\n\n# The document\n\n> {knowledgePieceContent}",resultingParameterName:"title",expectations:{words:{min:1,max:8}},dependentParameterNames:["knowledgePieceContent"]}],personas:[],preparations:[],knowledgeSources:[],knowledgePieces:[],sources:[{type:"BOOK",path:null,content:"# Prepare Knowledge-piece Title\n\n-   PIPELINE URL `https://promptbook.studio/promptbook/prepare-knowledge-title.book`\n-   INPUT PARAMETER `{knowledgePieceContent}` The content\n-   OUTPUT PARAMETER `{title}` The title of the document\n\n## Knowledge\n\n-   EXPECT MIN 1 WORD\n-   EXPECT MAX 8 WORDS\n\n```markdown\nYou are experienced content creator, write best title for the document.\n\n# Rules\n\n-   Write just title, nothing else\n-   Write maximum 5 words for the title\n\n# The document\n\n> {knowledgePieceContent}\n```\n\n`-> {title}`\n"}],sourceFile:"./books/prepare-knowledge-title.book"},{title:"Prepare Persona",pipelineUrl:"https://promptbook.studio/promptbook/prepare-persona.book",formfactorName:"GENERIC",parameters:[{name:"availableModels",description:"List of available model names together with their descriptions as JSON",isInput:true,isOutput:false},{name:"personaDescription",description:"Description of the persona",isInput:true,isOutput:false},{name:"modelsRequirements",description:"Specific requirements for the model",isInput:false,isOutput:true}],tasks:[{taskType:"PROMPT_TASK",name:"make-model-requirements",title:"Make modelRequirements",content:"You are an experienced AI engineer, you need to find the best models for virtual assistants:\n\n## Example\n\n```json\n[\n  {\n  \"modelName\": \"gpt-4o\",\n  \"systemMessage\": \"You are experienced AI engineer and helpful assistant.\",\n  \"temperature\": 0.7\n  },\n  {\n    \"modelName\": \"claude-3-5-sonnet\",\n    \"systemMessage\": \"You are a friendly and knowledgeable chatbot.\",\n    \"temperature\": 0.5\n  }\n]\n```\n\n## Instructions\n\n-   Your output format is JSON array\n-   Sort best-fitting models first\n-   Omit any models that are not suitable\n-   Write just the JSON, no other text should be present\n-   Array contain items with following keys:\n    -   `modelName`: The name of the model to use\n    -   `systemMessage`: The system message to provide context to the model\n    -   `temperature`: The sampling temperature to use\n\n### Key `modelName`\n\nHere are the available models:\n\n```json\n{availableModels}\n```\n\n### Key `systemMessage`\n\nThe system message is used to communicate instructions or provide context to the model at the beginning of a conversation. It is displayed in a different format compared to user messages, helping the model understand its role in the conversation. The system message typically guides the model's behavior, sets the tone, or specifies desired output from the model. By utilizing the system message effectively, users can steer the model towards generating more accurate and relevant responses.\n\nFor example:\n\n> You are an experienced AI engineer and helpful assistant.\n\n> You are a friendly and knowledgeable chatbot.\n\n### Key `temperature`\n\nThe sampling temperature, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. If set to 0, the model will use log probability to automatically increase the temperature until certain thresholds are hit.\n\nYou can pick a value between 0 and 2. For example:\n\n-   `0.1`: Low temperature, extremely conservative and deterministic\n-   `0.5`: Medium temperature, balanced between conservative and creative\n-   `1.0`: High temperature, creative and bit random\n-   `1.5`: Very high temperature, extremely creative and often chaotic and unpredictable\n-   `2.0`: Maximum temperature, completely random and unpredictable, for some extreme creative use cases\n\n# The assistant\n\nTake this description of the persona:\n\n> {personaDescription}",resultingParameterName:"modelsRequirements",format:"JSON",dependentParameterNames:["availableModels","personaDescription"]}],personas:[],preparations:[],knowledgeSources:[],knowledgePieces:[],sources:[{type:"BOOK",path:null,content:"# Prepare Persona\n\n-   PIPELINE URL `https://promptbook.studio/promptbook/prepare-persona.book`\n-   INPUT PARAMETER `{availableModels}` List of available model names together with their descriptions as JSON\n-   INPUT PARAMETER `{personaDescription}` Description of the persona\n-   OUTPUT PARAMETER `{modelsRequirements}` Specific requirements for the model\n\n## Make modelRequirements\n\n-   FORMAT JSON\n\n```markdown\nYou are an experienced AI engineer, you need to find the best models for virtual assistants:\n\n## Example\n\n\\`\\`\\`json\n[\n  {\n  \"modelName\": \"gpt-4o\",\n  \"systemMessage\": \"You are experienced AI engineer and helpful assistant.\",\n  \"temperature\": 0.7\n  },\n  {\n    \"modelName\": \"claude-3-5-sonnet\",\n    \"systemMessage\": \"You are a friendly and knowledgeable chatbot.\",\n    \"temperature\": 0.5\n  }\n]\n\\`\\`\\`\n\n## Instructions\n\n-   Your output format is JSON array\n-   Sort best-fitting models first\n-   Omit any models that are not suitable\n-   Write just the JSON, no other text should be present\n-   Array contain items with following keys:\n    -   `modelName`: The name of the model to use\n    -   `systemMessage`: The system message to provide context to the model\n    -   `temperature`: The sampling temperature to use\n\n### Key `modelName`\n\nHere are the available models:\n\n\\`\\`\\`json\n{availableModels}\n\\`\\`\\`\n\n### Key `systemMessage`\n\nThe system message is used to communicate instructions or provide context to the model at the beginning of a conversation. It is displayed in a different format compared to user messages, helping the model understand its role in the conversation. The system message typically guides the model's behavior, sets the tone, or specifies desired output from the model. By utilizing the system message effectively, users can steer the model towards generating more accurate and relevant responses.\n\nFor example:\n\n> You are an experienced AI engineer and helpful assistant.\n\n> You are a friendly and knowledgeable chatbot.\n\n### Key `temperature`\n\nThe sampling temperature, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. If set to 0, the model will use log probability to automatically increase the temperature until certain thresholds are hit.\n\nYou can pick a value between 0 and 2. For example:\n\n-   `0.1`: Low temperature, extremely conservative and deterministic\n-   `0.5`: Medium temperature, balanced between conservative and creative\n-   `1.0`: High temperature, creative and bit random\n-   `1.5`: Very high temperature, extremely creative and often chaotic and unpredictable\n-   `2.0`: Maximum temperature, completely random and unpredictable, for some extreme creative use cases\n\n# The assistant\n\nTake this description of the persona:\n\n> {personaDescription}\n```\n\n`-> {modelsRequirements}`\n"}],sourceFile:"./books/prepare-persona.book"},{title:"Prepare Title",pipelineUrl:"https://promptbook.studio/promptbook/prepare-title.book",formfactorName:"GENERIC",parameters:[{name:"book",description:"The book to prepare the title for",isInput:true,isOutput:false},{name:"title",description:"Best title for the book",isInput:false,isOutput:true}],tasks:[{taskType:"PROMPT_TASK",name:"make-title",title:"Make title",content:"Make best title for given text which describes the workflow:\n\n## Rules\n\n-   Write just title, nothing else\n-   Title should be concise and clear - Write maximum ideally 2 words, maximum 5 words\n-   Title starts with emoticon\n-   Title should not mention the input and output of the workflow but the main purpose of the workflow\n    _For example, not \"✍ Convert Knowledge-piece to title\" but \"✍ Title\"_\n\n## The workflow\n\n> {book}",resultingParameterName:"title",expectations:{words:{min:1,max:8},lines:{min:1,max:1}},dependentParameterNames:["book"]}],personas:[],preparations:[],knowledgeSources:[],knowledgePieces:[],sources:[{type:"BOOK",path:null,content:"# Prepare Title\n\n-   PIPELINE URL `https://promptbook.studio/promptbook/prepare-title.book`\n-   INPUT PARAMETER `{book}` The book to prepare the title for\n-   OUTPUT PARAMETER `{title}` Best title for the book\n\n## Make title\n\n-   EXPECT MIN 1 Word\n-   EXPECT MAX 8 Words\n-   EXPECT EXACTLY 1 Line\n\n```markdown\nMake best title for given text which describes the workflow:\n\n## Rules\n\n-   Write just title, nothing else\n-   Title should be concise and clear - Write maximum ideally 2 words, maximum 5 words\n-   Title starts with emoticon\n-   Title should not mention the input and output of the workflow but the main purpose of the workflow\n    _For example, not \"✍ Convert Knowledge-piece to title\" but \"✍ Title\"_\n\n## The workflow\n\n> {book}\n```\n\n`-> {title}`\n"}],sourceFile:"./books/prepare-title.book"}];
 
-    /**
-     * 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 `validatePipelineString` will validate the if the string is a valid pipeline string
      * It does not check if the string is fully logically correct, but if it is a string that can be a pipeline string or the string looks completely different.
@@ -4754,15 +5139,6 @@
         }
     }
 
-    /**
-     * Makes first letter of a string uppercase
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function capitalize(word) {
-        return word.substring(0, 1).toUpperCase() + word.substring(1);
-    }
-
     /**
      * Converts promptbook in JSON format to string format
      *
@@ -5521,743 +5897,481 @@
     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.
-     *
-     * @public exported from `@promptbook/core`
-     */
-    const MANDATORY_CSV_SETTINGS = Object.freeze({
-        header: true,
-        // encoding: 'utf-8',
-    });
-
-    /**
-     * Converts a CSV string into an object
-     *
-     * Note: This is wrapper around `papaparse.parse()` with better autohealing
-     *
-     * @private - for now until `@promptbook/csv` is released
-     */
-    function csvParse(value /* <- TODO: string_csv */, settings, schema /* <- TODO: Make CSV Schemas */) {
-        settings = { ...settings, ...MANDATORY_CSV_SETTINGS };
-        // Note: Autoheal invalid '\n' characters
-        if (settings.newline && !settings.newline.includes('\r') && value.includes('\r')) {
-            console.warn('CSV string contains carriage return characters, but in the CSV settings the `newline` setting does not include them. Autohealing the CSV string.');
-            value = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-        }
-        const csv = papaparse.parse(value, settings);
-        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
-     *
-     * @public exported from `@promptbook/core`
-     *                          <- TODO: [🏢] Export from package `@promptbook/csv`
-     */
-    const CsvFormatParser = {
-        formatName: 'CSV',
-        aliases: ['SPREADSHEET', 'TABLE'],
-        isValid(value, settings, schema) {
-            return isValidCsvString(value);
-        },
-        canBeValid(partialValue, settings, schema) {
-            return true;
-        },
-        heal(value, settings, schema) {
-            throw new Error('Not implemented');
-        },
-        subvalueParsers: [
-            {
-                subvalueName: 'ROW',
-                async mapValues(options) {
-                    const { value, outputParameterName, settings, mapCallback, onProgress } = options;
-                    const csv = csvParse(value, settings);
-                    if (csv.errors.length !== 0) {
-                        throw new CsvFormatError(spaceTrim__default["default"]((block) => `
-                                CSV parsing error
-
-                                Error(s) from CSV parsing:
-                                ${block(csv.errors.map((error) => error.message).join('\n\n'))}
-
-                                The CSV setings:
-                                ${block(JSON.stringify({ ...settings, ...MANDATORY_CSV_SETTINGS }, null, 2))}
-
-                                The CSV data:
-                                ${block(value)}
-                            `));
-                    }
-                    const mappedData = [];
-                    const length = csv.data.length;
-                    for (let index = 0; index < length; index++) {
-                        const row = csv.data[index];
-                        if (row[outputParameterName]) {
-                            throw new CsvFormatError(`Can not overwrite existing column "${outputParameterName}" in CSV row`);
-                        }
-                        const mappedRow = {
-                            ...row,
-                            [outputParameterName]: await mapCallback(row, index, length),
-                        };
-                        mappedData.push(mappedRow);
-                        if (onProgress) {
-                            // Note: Report the CSV with all rows mapped so far
-                            /*
-                            // TODO: [🛕] Report progress with all the rows including the pending ones
-                              const progressData = mappedData.map((row, i) =>
-                                i > index ? { ...row, [outputParameterName]: PENDING_VALUE_PLACEHOLDER } : row,
-                            );
-                            */
-                            await onProgress(papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS }));
-                        }
-                    }
-                    return papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
-                },
-            },
-            {
-                subvalueName: 'CELL',
-                async mapValues(options) {
-                    const { value, settings, mapCallback, onProgress } = options;
-                    const csv = csvParse(value, settings);
-                    if (csv.errors.length !== 0) {
-                        throw new CsvFormatError(spaceTrim__default["default"]((block) => `
-                                CSV parsing error
-
-                                Error(s) from CSV parsing:
-                                ${block(csv.errors.map((error) => error.message).join('\n\n'))}
-
-                                The CSV setings:
-                                ${block(JSON.stringify({ ...settings, ...MANDATORY_CSV_SETTINGS }, null, 2))}
-
-                                The CSV data:
-                                ${block(value)}
-                            `));
-                    }
-                    const mappedData = await Promise.all(csv.data.map(async (row, rowIndex) => {
-                        return /* not await */ Promise.all(Object.entries(row).map(async ([key, value], columnIndex, array) => {
-                            const index = rowIndex * Object.keys(row).length + columnIndex;
-                            return /* not await */ mapCallback({ [key]: value }, index, array.length);
-                        }));
-                    }));
-                    return papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
-                },
-            },
-        ],
-    };
-    /**
-     * TODO: [🍓] In `CsvFormatParser` implement simple `isValid`
-     * TODO: [🍓] In `CsvFormatParser` implement partial `canBeValid`
-     * TODO: [🍓] In `CsvFormatParser` implement `heal
-     * TODO: [🍓] In `CsvFormatParser` implement `subvalueParsers`
-     * TODO: [🏢] Allow to expect something inside CSV objects and other formats
-     */
-
-    /**
-     * Definition for JSON format
-     *
-     * @private still in development [🏢]
-     */
-    const JsonFormatParser = {
-        formatName: 'JSON',
-        mimeType: 'application/json',
-        isValid(value, settings, schema) {
-            return isValidJsonString(value);
-        },
-        canBeValid(partialValue, settings, schema) {
-            return true;
-        },
-        heal(value, settings, schema) {
-            throw new Error('Not implemented');
-        },
-        subvalueParsers: [],
-    };
-    /**
-     * TODO: [🧠] Maybe proper instance of object
-     * TODO: [0] Make string_serialized_json
-     * TODO: [1] Make type for JSON Settings and Schema
-     * TODO: [🧠] What to use for validating JSONs - JSON Schema, ZoD, typescript types/interfaces,...?
-     * TODO: [🍓] In `JsonFormatParser` implement simple `isValid`
-     * TODO: [🍓] In `JsonFormatParser` implement partial `canBeValid`
-     * TODO: [🍓] In `JsonFormatParser` implement `heal
-     * TODO: [🍓] In `JsonFormatParser` implement `subvalueParsers`
-     * TODO: [🏢] Allow to expect something inside JSON objects and other formats
-     */
-
-    /**
-     * Definition for any text - this will be always valid
-     *
-     * Note: This is not useful for validation, but for splitting and mapping with `subvalueParsers`
-     *
-     * @public exported from `@promptbook/core`
-     */
-    const TextFormatParser = {
-        formatName: 'TEXT',
-        isValid(value) {
-            return typeof value === 'string';
-        },
-        canBeValid(partialValue) {
-            return typeof partialValue === 'string';
-        },
-        heal() {
-            throw new UnexpectedError('It does not make sense to call `TextFormatParser.heal`');
-        },
-        subvalueParsers: [
-            {
-                subvalueName: 'LINE',
-                async mapValues(options) {
-                    const { value, mapCallback, onProgress } = options;
-                    const lines = value.split('\n');
-                    const mappedLines = await Promise.all(lines.map((lineContent, lineNumber, array) => 
-                    // TODO: [🧠] Maybe option to skip empty line
-                    /* not await */ mapCallback({
-                        lineContent,
-                        // TODO: [🧠] Maybe also put here `lineNumber`
-                    }, lineNumber, array.length)));
-                    return mappedLines.join('\n');
-                },
-            },
-            // <- TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages available as subvalues
-        ],
-    };
-    /**
-     * TODO: [1] Make type for XML Text and Schema
-     * TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages available as subvalues
-     * TODO: [🍓] In `TextFormatParser` implement simple `isValid`
-     * TODO: [🍓] In `TextFormatParser` implement partial `canBeValid`
-     * TODO: [🍓] In `TextFormatParser` implement `heal
-     * TODO: [🍓] In `TextFormatParser` implement `subvalueParsers`
-     * 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
-     *
-     * @private still in development [🏢]
-     */
-    const XmlFormatParser = {
-        formatName: 'XML',
-        mimeType: 'application/xml',
-        isValid(value, settings, schema) {
-            return isValidXmlString(value);
-        },
-        canBeValid(partialValue, settings, schema) {
-            return true;
-        },
-        heal(value, settings, schema) {
-            throw new Error('Not implemented');
-        },
-        subvalueParsers: [],
-    };
-    /**
-     * TODO: [🧠] Maybe proper instance of object
-     * TODO: [0] Make string_serialized_xml
-     * TODO: [1] Make type for XML Settings and Schema
-     * TODO: [🧠] What to use for validating XMLs - XSD,...
-     * TODO: [🍓] In `XmlFormatParser` implement simple `isValid`
-     * TODO: [🍓] In `XmlFormatParser` implement partial `canBeValid`
-     * TODO: [🍓] In `XmlFormatParser` implement `heal
-     * TODO: [🍓] In `XmlFormatParser` implement `subvalueParsers`
-     * TODO: [🏢] Allow to expect something inside XML and other formats
-     */
-
-    /**
-     * Definitions for all formats supported by Promptbook
-     *
-     * @private internal index of `...` <- TODO [🏢]
-     */
-    const FORMAT_DEFINITIONS = [JsonFormatParser, XmlFormatParser, TextFormatParser, CsvFormatParser];
-    /**
-     * Note: [💞] Ignore a discrepancy between file name and entity name
-     */
-
-    /**
-     * Maps available parameters to expected parameters for a pipeline task.
-     *
-     * The strategy is:
-     * 1) First, match parameters by name where both available and expected.
-     * 2) Then, if there are unmatched expected and available parameters, map them by order.
-     *
-     * @throws {PipelineExecutionError} If the number of unmatched expected and available parameters does not match, or mapping is ambiguous.
-     * @private within the repository used in `createPipelineExecutor`
-     */
-    function mapAvailableToExpectedParameters(options) {
-        const { expectedParameters, availableParameters } = options;
-        const availableParametersNames = new Set(Object.keys(availableParameters));
-        const expectedParameterNames = new Set(Object.keys(expectedParameters));
-        const mappedParameters = {};
-        // Phase 1️⃣: Matching mapping
-        for (const parameterName of Array.from(union(availableParametersNames, expectedParameterNames))) {
-            // Situation: Parameter is available and expected
-            if (availableParametersNames.has(parameterName) && expectedParameterNames.has(parameterName)) {
-                mappedParameters[parameterName] = availableParameters[parameterName];
-                // <- Note: [👩‍👩‍👧] Maybe detect parameter collision here?
-                availableParametersNames.delete(parameterName);
-                expectedParameterNames.delete(parameterName);
-            }
-            // Situation: Parameter is available but NOT expected
-            else if (availableParametersNames.has(parameterName) && !expectedParameterNames.has(parameterName)) ;
-            // Situation: Parameter is NOT available BUT expected
-            else if (!availableParametersNames.has(parameterName) && expectedParameterNames.has(parameterName)) ;
-        }
-        if (expectedParameterNames.size === 0) {
-            // Note: [👨‍👨‍👧] Now we can freeze `mappedParameters` to prevent accidental modifications after mapping
-            Object.freeze(mappedParameters);
-            return mappedParameters;
-        }
-        // Phase 2️⃣: Non-matching mapping
-        if (expectedParameterNames.size !== availableParametersNames.size) {
-            throw new PipelineExecutionError(spaceTrim__default["default"]((block) => `
-                    Can not map available parameters to expected parameters
-
-                    Mapped parameters:
-                    ${block(Object.keys(mappedParameters)
-            .map((parameterName) => `- {${parameterName}}`)
-            .join('\n'))}
-
-                    Expected parameters which can not be mapped:
-                    ${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;
-    }
-
-    /**
-     * Extracts all code blocks from markdown.
-     *
-     * 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 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 (!Array.from(b).some((itemB) => isEqual(itemA, itemB))) {
+                diff.add(itemA);
             }
         }
-        if (currentCodeBlock !== null) {
-            throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
-        }
-        return codeBlocks;
+        return diff;
     }
     /**
-     * TODO: Maybe name for `blockNotation` instead of  '```' and '>'
+     * TODO: [🧠][💯] Maybe also implement symmetricDifference
      */
 
     /**
-     * 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
+     * Creates a new set with all elements that are present in either set
      *
-     * @public exported from `@promptbook/markdown-utils`
-     * @throws {ParseError} if there is no valid JSON block in the markdown
+     * @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 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');
+    function union(...sets) {
+        const union = new Set();
+        for (const set of sets) {
+            for (const item of Array.from(set)) {
+                union.add(item);
+            }
         }
-        return jsonBlocks[0].content;
+        return union;
     }
+
     /**
-     * TODO: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
-     * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
+     * Contains configuration options for parsing and generating CSV files, such as delimiters and quoting rules.
+     *
+     * @public exported from `@promptbook/core`
      */
+    const MANDATORY_CSV_SETTINGS = Object.freeze({
+        header: true,
+        // encoding: 'utf-8',
+    });
 
     /**
-     * Takes an item or an array of items and returns an array of items
+     * Converts a CSV string into an object
      *
-     * 1) Any item except array and undefined returns array with that one item (also null)
-     * 2) Undefined returns empty array
-     * 3) Array returns itself
+     * Note: This is wrapper around `papaparse.parse()` with better autohealing
      *
-     * @private internal utility
+     * @private - for now until `@promptbook/csv` is released
      */
-    function arrayableToArray(input) {
-        if (input === undefined) {
-            return [];
-        }
-        if (input instanceof Array) {
-            return input;
+    function csvParse(value /* <- TODO: string_csv */, settings, schema /* <- TODO: Make CSV Schemas */) {
+        settings = { ...settings, ...MANDATORY_CSV_SETTINGS };
+        // Note: Autoheal invalid '\n' characters
+        if (settings.newline && !settings.newline.includes('\r') && value.includes('\r')) {
+            console.warn('CSV string contains carriage return characters, but in the CSV settings the `newline` setting does not include them. Autohealing the CSV string.');
+            value = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
         }
-        return [input];
+        const csv = papaparse.parse(value, settings);
+        return csv;
     }
 
     /**
-     * Replaces parameters in template with values from parameters object
+     * Function to check if a string is valid CSV
      *
-     * Note: This function is not places strings into string,
-     *       It's more complex and can handle this operation specifically for LLM models
+     * @param value The string to check
+     * @returns `true` if the string is a valid CSV string, false otherwise
      *
-     * @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');
+    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;
             }
-            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');
+            return false;
         }
-        // [💫] Check if there are parameters that are not opened properly
-        if (/^\w+}/.test(replacedTemplates)) {
-            throw new PipelineExecutionError('Parameter is not opened');
+        catch (error) {
+            assertsError(error);
+            return false;
         }
-        return replacedTemplates;
     }
 
     /**
-     * Counts number of characters in the text
+     * Definition for CSV spreadsheet
      *
-     * @public exported from `@promptbook/utils`
+     * @public exported from `@promptbook/core`
+     *                          <- TODO: [🏢] Export from package `@promptbook/csv`
      */
-    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;
-    }
+    const CsvFormatParser = {
+        formatName: 'CSV',
+        aliases: ['SPREADSHEET', 'TABLE'],
+        isValid(value, settings, schema) {
+            return isValidCsvString(value);
+        },
+        canBeValid(partialValue, settings, schema) {
+            return true;
+        },
+        heal(value, settings, schema) {
+            throw new Error('Not implemented');
+        },
+        subvalueParsers: [
+            {
+                subvalueName: 'ROW',
+                async mapValues(options) {
+                    const { value, outputParameterName, settings, mapCallback, onProgress } = options;
+                    const csv = csvParse(value, settings);
+                    if (csv.errors.length !== 0) {
+                        throw new CsvFormatError(spaceTrim__default["default"]((block) => `
+                                CSV parsing error
+
+                                Error(s) from CSV parsing:
+                                ${block(csv.errors.map((error) => error.message).join('\n\n'))}
+
+                                The CSV setings:
+                                ${block(JSON.stringify({ ...settings, ...MANDATORY_CSV_SETTINGS }, null, 2))}
+
+                                The CSV data:
+                                ${block(value)}
+                            `));
+                    }
+                    const mappedData = [];
+                    const length = csv.data.length;
+                    for (let index = 0; index < length; index++) {
+                        const row = csv.data[index];
+                        if (row[outputParameterName]) {
+                            throw new CsvFormatError(`Can not overwrite existing column "${outputParameterName}" in CSV row`);
+                        }
+                        const mappedRow = {
+                            ...row,
+                            [outputParameterName]: await mapCallback(row, index, length),
+                        };
+                        mappedData.push(mappedRow);
+                        if (onProgress) {
+                            // Note: Report the CSV with all rows mapped so far
+                            /*
+                            // TODO: [🛕] Report progress with all the rows including the pending ones
+                              const progressData = mappedData.map((row, i) =>
+                                i > index ? { ...row, [outputParameterName]: PENDING_VALUE_PLACEHOLDER } : row,
+                            );
+                            */
+                            await onProgress(papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS }));
+                        }
+                    }
+                    return papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
+                },
+            },
+            {
+                subvalueName: 'CELL',
+                async mapValues(options) {
+                    const { value, settings, mapCallback, onProgress } = options;
+                    const csv = csvParse(value, settings);
+                    if (csv.errors.length !== 0) {
+                        throw new CsvFormatError(spaceTrim__default["default"]((block) => `
+                                CSV parsing error
+
+                                Error(s) from CSV parsing:
+                                ${block(csv.errors.map((error) => error.message).join('\n\n'))}
+
+                                The CSV setings:
+                                ${block(JSON.stringify({ ...settings, ...MANDATORY_CSV_SETTINGS }, null, 2))}
+
+                                The CSV data:
+                                ${block(value)}
+                            `));
+                    }
+                    const mappedData = await Promise.all(csv.data.map(async (row, rowIndex) => {
+                        return /* not await */ Promise.all(Object.entries(row).map(async ([key, value], columnIndex, array) => {
+                            const index = rowIndex * Object.keys(row).length + columnIndex;
+                            return /* not await */ mapCallback({ [key]: value }, index, array.length);
+                        }));
+                    }));
+                    return papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
+                },
+            },
+        ],
+    };
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🍓] In `CsvFormatParser` implement simple `isValid`
+     * TODO: [🍓] In `CsvFormatParser` implement partial `canBeValid`
+     * TODO: [🍓] In `CsvFormatParser` implement `heal
+     * TODO: [🍓] In `CsvFormatParser` implement `subvalueParsers`
+     * TODO: [🏢] Allow to expect something inside CSV objects and other formats
      */
 
     /**
-     * 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.
+     * Definition for JSON format
      *
-     * @public exported from `@promptbook/utils`
+     * @private still in development [🏢]
      */
-    const LINES_PER_STANDARD_PAGE = 44;
+    const JsonFormatParser = {
+        formatName: 'JSON',
+        mimeType: 'application/json',
+        isValid(value, settings, schema) {
+            return isValidJsonString(value);
+        },
+        canBeValid(partialValue, settings, schema) {
+            return true;
+        },
+        heal(value, settings, schema) {
+            throw new Error('Not implemented');
+        },
+        subvalueParsers: [],
+    };
     /**
-     * TODO: [🧠] Should be this `constants.ts` or `config.ts`?
-     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * TODO: [🧠] Maybe proper instance of object
+     * TODO: [0] Make string_serialized_json
+     * TODO: [1] Make type for JSON Settings and Schema
+     * TODO: [🧠] What to use for validating JSONs - JSON Schema, ZoD, typescript types/interfaces,...?
+     * TODO: [🍓] In `JsonFormatParser` implement simple `isValid`
+     * TODO: [🍓] In `JsonFormatParser` implement partial `canBeValid`
+     * TODO: [🍓] In `JsonFormatParser` implement `heal
+     * TODO: [🍓] In `JsonFormatParser` implement `subvalueParsers`
+     * TODO: [🏢] Allow to expect something inside JSON objects and other formats
      */
 
     /**
-     * Counts number of lines in the text
+     * Definition for any text - this will be always valid
      *
-     * Note: This does not check only for the presence of newlines, but also for the length of the standard line.
+     * Note: This is not useful for validation, but for splitting and mapping with `subvalueParsers`
      *
-     * @public exported from `@promptbook/utils`
+     * @public exported from `@promptbook/core`
      */
-    function countLines(text) {
-        text = text.replace('\r\n', '\n');
-        text = text.replace('\r', '\n');
-        const lines = text.split('\n');
-        return lines.reduce((count, line) => count + Math.ceil(line.length / CHARACTERS_PER_STANDARD_LINE), 0);
-    }
+    const TextFormatParser = {
+        formatName: 'TEXT',
+        isValid(value) {
+            return typeof value === 'string';
+        },
+        canBeValid(partialValue) {
+            return typeof partialValue === 'string';
+        },
+        heal() {
+            throw new UnexpectedError('It does not make sense to call `TextFormatParser.heal`');
+        },
+        subvalueParsers: [
+            {
+                subvalueName: 'LINE',
+                async mapValues(options) {
+                    const { value, mapCallback, onProgress } = options;
+                    const lines = value.split('\n');
+                    const mappedLines = await Promise.all(lines.map((lineContent, lineNumber, array) => 
+                    // TODO: [🧠] Maybe option to skip empty line
+                    /* not await */ mapCallback({
+                        lineContent,
+                        // TODO: [🧠] Maybe also put here `lineNumber`
+                    }, lineNumber, array.length)));
+                    return mappedLines.join('\n');
+                },
+            },
+            // <- TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages available as subvalues
+        ],
+    };
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [1] Make type for XML Text and Schema
+     * TODO: [🧠][🤠] Here should be all words, characters, lines, paragraphs, pages available as subvalues
+     * TODO: [🍓] In `TextFormatParser` implement simple `isValid`
+     * TODO: [🍓] In `TextFormatParser` implement partial `canBeValid`
+     * TODO: [🍓] In `TextFormatParser` implement `heal
+     * TODO: [🍓] In `TextFormatParser` implement `subvalueParsers`
+     * TODO: [🏢] Allow to expect something inside each item of list and other formats
      */
 
     /**
-     * Counts number of pages in the text
+     * Function to check if a string is valid XML
      *
-     * 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.
+     * @param value
+     * @returns `true` if the string is a valid XML string, false otherwise
      *
      * @public exported from `@promptbook/utils`
      */
-    function countPages(text) {
-        return Math.ceil(countLines(text) / LINES_PER_STANDARD_PAGE);
+    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;
+        }
     }
-    /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     */
 
     /**
-     * Counts number of paragraphs in the text
+     * Definition for XML format
      *
-     * @public exported from `@promptbook/utils`
+     * @private still in development [🏢]
      */
-    function countParagraphs(text) {
-        return text.split(/\n\s*\n/).filter((paragraph) => paragraph.trim() !== '').length;
-    }
+    const XmlFormatParser = {
+        formatName: 'XML',
+        mimeType: 'application/xml',
+        isValid(value, settings, schema) {
+            return isValidXmlString(value);
+        },
+        canBeValid(partialValue, settings, schema) {
+            return true;
+        },
+        heal(value, settings, schema) {
+            throw new Error('Not implemented');
+        },
+        subvalueParsers: [],
+    };
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * TODO: [🧠] Maybe proper instance of object
+     * TODO: [0] Make string_serialized_xml
+     * TODO: [1] Make type for XML Settings and Schema
+     * TODO: [🧠] What to use for validating XMLs - XSD,...
+     * TODO: [🍓] In `XmlFormatParser` implement simple `isValid`
+     * TODO: [🍓] In `XmlFormatParser` implement partial `canBeValid`
+     * TODO: [🍓] In `XmlFormatParser` implement `heal
+     * TODO: [🍓] In `XmlFormatParser` implement `subvalueParsers`
+     * TODO: [🏢] Allow to expect something inside XML and other formats
      */
 
     /**
-     * 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
+     * Definitions for all formats supported by Promptbook
      *
-     * @public exported from `@promptbook/utils`
+     * @private internal index of `...` <- TODO [🏢]
      */
-    function countSentences(text) {
-        return splitIntoSentences(text).length;
-    }
+    const FORMAT_DEFINITIONS = [JsonFormatParser, XmlFormatParser, TextFormatParser, CsvFormatParser];
     /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
     /**
-     * Counts number of words in the text
+     * Maps available parameters to expected parameters for a pipeline task.
      *
-     * @public exported from `@promptbook/utils`
+     * The strategy is:
+     * 1) First, match parameters by name where both available and expected.
+     * 2) Then, if there are unmatched expected and available parameters, map them by order.
+     *
+     * @throws {PipelineExecutionError} If the number of unmatched expected and available parameters does not match, or mapping is ambiguous.
+     * @private within the repository used in `createPipelineExecutor`
      */
-    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 mapAvailableToExpectedParameters(options) {
+        const { expectedParameters, availableParameters } = options;
+        const availableParametersNames = new Set(Object.keys(availableParameters));
+        const expectedParameterNames = new Set(Object.keys(expectedParameters));
+        const mappedParameters = {};
+        // Phase 1️⃣: Matching mapping
+        for (const parameterName of Array.from(union(availableParametersNames, expectedParameterNames))) {
+            // Situation: Parameter is available and expected
+            if (availableParametersNames.has(parameterName) && expectedParameterNames.has(parameterName)) {
+                mappedParameters[parameterName] = availableParameters[parameterName];
+                // <- Note: [👩‍👩‍👧] Maybe detect parameter collision here?
+                availableParametersNames.delete(parameterName);
+                expectedParameterNames.delete(parameterName);
+            }
+            // Situation: Parameter is available but NOT expected
+            else if (availableParametersNames.has(parameterName) && !expectedParameterNames.has(parameterName)) ;
+            // Situation: Parameter is NOT available BUT expected
+            else if (!availableParametersNames.has(parameterName) && expectedParameterNames.has(parameterName)) ;
+        }
+        if (expectedParameterNames.size === 0) {
+            // Note: [👨‍👨‍👧] Now we can freeze `mappedParameters` to prevent accidental modifications after mapping
+            Object.freeze(mappedParameters);
+            return mappedParameters;
+        }
+        // Phase 2️⃣: Non-matching mapping
+        if (expectedParameterNames.size !== availableParametersNames.size) {
+            throw new PipelineExecutionError(spaceTrim__default["default"]((block) => `
+                    Can not map available parameters to expected parameters
+
+                    Mapped parameters:
+                    ${block(Object.keys(mappedParameters)
+            .map((parameterName) => `- {${parameterName}}`)
+            .join('\n'))}
+
+                    Expected parameters which can not be mapped:
+                    ${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;
     }
-    /**
-     * TODO: [🥴] Implement counting in formats - like JSON, CSV, XML,...
-     */
 
     /**
-     * Index of all counter functions
+     * Takes an item or an array of items and returns an array of items
      *
-     * @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
+     * 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];
+    }
 
     /**
-     * Function checkExpectations will check if the expectations on given value are met
+     * Replaces parameters in template with values from parameters object
      *
-     * Note: There are two similar functions:
-     * - `checkExpectations` which throws an error if the expectations are not met
-     * - `isPassingExpectations` which returns a boolean
+     * Note: This function is not places strings into string,
+     *       It's more complex and can handle this operation specifically for LLM models
      *
-     * @throws {ExpectError} if the expectations are not met
-     * @returns {void} Nothing
-     * @private internal function of `createPipelineExecutor`
+     * @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 checkExpectations(expectations, value) {
-        for (const [unit, { max, min }] of Object.entries(expectations)) {
-            const amount = CountUtils[unit.toUpperCase()](value);
-            if (min && amount < min) {
-                throw new ExpectError(`Expected at least ${min} ${unit} but got ${amount}`);
-            } /* not else */
-            if (max && amount > max) {
-                throw new ExpectError(`Expected at most ${max} ${unit} but got ${amount}`);
+    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;
     }
-    /**
-     * TODO: [💝] Unite object for expecting amount and format
-     * TODO: [🧠][🤠] This should be part of `TextFormatParser`
-     * Note: [💝] and [🤠] are interconnected together
-     */
 
     /**
      * Executes a pipeline task with multiple attempts, including joker and retry logic. Handles different task types
@@ -6276,17 +6390,18 @@
             $resultString: null,
             $expectError: null,
             $scriptPipelineExecutionErrors: [],
+            $failedResults: [], // Track all failed attempts
         };
         // TODO: [🚐] Make arrayable LLMs -> single LLM DRY
         const _llms = arrayableToArray(tools.llm);
         const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
-        attempts: for (let attempt = -jokerParameterNames.length; attempt < maxAttempts; attempt++) {
-            const isJokerAttempt = attempt < 0;
-            const jokerParameterName = jokerParameterNames[jokerParameterNames.length + attempt];
+        attempts: for (let attemptIndex = -jokerParameterNames.length; attemptIndex < maxAttempts; attemptIndex++) {
+            const isJokerAttempt = attemptIndex < 0;
+            const jokerParameterName = jokerParameterNames[jokerParameterNames.length + attemptIndex];
             // TODO: [🧠][🍭] JOKERS, EXPECTATIONS, POSTPROCESSING and FOREACH
             if (isJokerAttempt && !jokerParameterName) {
                 throw new UnexpectedError(spaceTrim.spaceTrim((block) => `
-                        Joker not found in attempt ${attempt}
+                        Joker not found in attempt ${attemptIndex}
 
                         ${block(pipelineIdentification)}
                     `));
@@ -6484,35 +6599,18 @@
                     }
                 }
                 // TODO: [💝] Unite object for expecting amount and format
-                if (task.format) {
-                    if (task.format === 'JSON') {
-                        if (!isValidJsonString($ongoingTaskResult.$resultString || '')) {
-                            // TODO: [🏢] Do more universally via `FormatParser`
-                            try {
-                                $ongoingTaskResult.$resultString = extractJsonBlock($ongoingTaskResult.$resultString || '');
-                            }
-                            catch (error) {
-                                keepUnused(error);
-                                throw new ExpectError(spaceTrim.spaceTrim((block) => `
-                                        Expected valid JSON string
-
-                                        ${block(
-                            /*<- Note: No need for `pipelineIdentification`, it will be catched and added later */ '')}
-                                    `));
-                            }
-                        }
-                    }
-                    else {
-                        throw new UnexpectedError(spaceTrim.spaceTrim((block) => `
-                                Unknown format "${task.format}"
-
-                                ${block(pipelineIdentification)}
-                            `));
+                // Use the common validation function for both format and expectations
+                if (task.format || task.expectations) {
+                    const validationResult = validatePromptResult({
+                        resultString: $ongoingTaskResult.$resultString || '',
+                        expectations: task.expectations,
+                        format: task.format,
+                    });
+                    if (!validationResult.isValid) {
+                        throw validationResult.error;
                     }
-                }
-                // TODO: [💝] Unite object for expecting amount and format
-                if (task.expectations) {
-                    checkExpectations(task.expectations, $ongoingTaskResult.$resultString || '');
+                    // Update the result string in case format processing modified it (e.g., JSON extraction)
+                    $ongoingTaskResult.$resultString = validationResult.processedResultString;
                 }
                 break attempts;
             }
@@ -6521,6 +6619,15 @@
                     throw error;
                 }
                 $ongoingTaskResult.$expectError = error;
+                // Store each failed attempt
+                if (!Array.isArray($ongoingTaskResult.$failedResults)) {
+                    $ongoingTaskResult.$failedResults = [];
+                }
+                $ongoingTaskResult.$failedResults.push({
+                    attemptIndex,
+                    result: $ongoingTaskResult.$resultString,
+                    error: error,
+                });
             }
             finally {
                 if (!isJokerAttempt &&
@@ -6542,35 +6649,41 @@
                     });
                 }
             }
-            if ($ongoingTaskResult.$expectError !== null && attempt === maxAttempts - 1) {
+            if ($ongoingTaskResult.$expectError !== null && attemptIndex === maxAttempts - 1) {
+                // Note: Create a summary of all failures
+                const failuresSummary = $ongoingTaskResult.$failedResults
+                    .map((failure) => spaceTrim.spaceTrim((block) => {
+                    var _a, _b;
+                    return `
+                            Attempt ${failure.attemptIndex + 1}:
+                            Error ${((_a = failure.error) === null || _a === void 0 ? void 0 : _a.name) || ''}:
+                            ${block((_b = failure.error) === null || _b === void 0 ? void 0 : _b.message.split('\n').map((line) => `> ${line}`).join('\n'))}
+
+                            Result:
+                            ${block(failure.result === null
+                    ? 'null'
+                    : spaceTrim.spaceTrim(failure.result)
+                        .split('\n')
+                        .map((line) => `> ${line}`)
+                        .join('\n'))}
+                        `;
+                }))
+                    .join('\n\n---\n\n');
                 throw new PipelineExecutionError(spaceTrim.spaceTrim((block) => {
-                    var _a, _b, _c;
+                    var _a;
                     return `
                         LLM execution failed ${maxExecutionAttempts}x
 
                         ${block(pipelineIdentification)}
 
-                        ---
                         The Prompt:
                         ${block((((_a = $ongoingTaskResult.$prompt) === null || _a === void 0 ? void 0 : _a.content) || '')
                     .split('\n')
                     .map((line) => `> ${line}`)
                     .join('\n'))}
 
-                        Last error ${((_b = $ongoingTaskResult.$expectError) === null || _b === void 0 ? void 0 : _b.name) || ''}:
-                        ${block((((_c = $ongoingTaskResult.$expectError) === null || _c === void 0 ? void 0 : _c.message) || '')
-                    .split('\n')
-                    .map((line) => `> ${line}`)
-                    .join('\n'))}
-
-                        Last result:
-                        ${block($ongoingTaskResult.$resultString === null
-                    ? 'null'
-                    : spaceTrim.spaceTrim($ongoingTaskResult.$resultString)
-                        .split('\n')
-                        .map((line) => `> ${line}`)
-                        .join('\n'))}
-                        ---
+                        All Failed Attempts:
+                        ${block(failuresSummary)}
                     `;
                 }));
             }
@@ -14349,6 +14462,66 @@
             response.setHeader('X-Powered-By', 'Promptbook engine');
             next();
         });
+        // Note: OpenAI-compatible chat completions endpoint
+        app.post('/v1/chat/completions', async (request, response) => {
+            // TODO: !!!! Make more promptbook-native:
+            try {
+                const params = request.body;
+                const { model, messages } = params;
+                // Convert messages to a single prompt
+                const prompt = messages
+                    .map((message) => `${message.role}: ${message.content}`)
+                    .join('\n');
+                // Get pipeline for the book
+                if (!collection) {
+                    throw new Error('No collection available');
+                }
+                const pipeline = await collection.getPipelineByUrl(model);
+                const pipelineExecutor = createPipelineExecutor({
+                    pipeline,
+                    tools: await getExecutionToolsFromIdentification({
+                        isAnonymous: true,
+                        llmToolsConfiguration: [],
+                    }),
+                });
+                // Execute the pipeline with the prompt content as input
+                const result = await pipelineExecutor({ prompt }).asPromise({ isCrashedOnError: true });
+                if (!result.isSuccessful) {
+                    throw new Error(`Failed to execute book: ${result.errors.join(', ')}`);
+                }
+                // Return the result in OpenAI-compatible format
+                response.json({
+                    id: 'chatcmpl-' + Math.random().toString(36).substring(2),
+                    object: 'chat.completion',
+                    created: Math.floor(Date.now() / 1000),
+                    model,
+                    choices: [
+                        {
+                            index: 0,
+                            message: {
+                                role: 'assistant',
+                                content: result.outputParameters.response,
+                            },
+                            finish_reason: 'stop',
+                        },
+                    ],
+                    usage: {
+                        prompt_tokens: 0,
+                        completion_tokens: 0,
+                        total_tokens: 0,
+                    },
+                });
+            }
+            catch (error) {
+                response.status(500).json({
+                    error: {
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                        type: 'server_error',
+                        code: 'internal_error',
+                    },
+                });
+            }
+        });
         // TODO: [🥺] Expose openapiJson to consumer and also allow to add new routes
         app.use(OpenApiValidator__namespace.middleware({
             apiSpec: openapiJson,
@@ -14709,7 +14882,6 @@
                 catch (error) {
                     assertsError(error);
                     socket.emit('error', serializeError(error));
-                    // <- TODO: [🚋] There is a problem with the remote server handling errors and sending them back to the client
                 }
                 finally {
                     socket.disconnect();
@@ -17234,7 +17406,7 @@
      */
 
     /**
-     * Execution Tools for calling OpenAI API or other OpeenAI compatible provider
+     * Execution Tools for calling OpenAI API or other OpenAI compatible provider
      *
      * @public exported from `@promptbook/openai`
      */
@@ -17804,6 +17976,7 @@
                 baseURL: DEFAULT_OLLAMA_BASE_URL,
                 ...ollamaOptions,
                 apiKey: 'ollama',
+                isProxied: false, // <- Note: Ollama is always local
             };
             super(openAiCompatibleOptions);
         }
@@ -17976,6 +18149,42 @@
             */
         },
     });
+    /**
+     * Registration of the OpenAI Compatible metadata
+     *
+     * Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be instantiated directly.
+     * It serves as a base class for OpenAiExecutionTools and other compatible implementations.
+     *
+     * @public exported from `@promptbook/core`
+     * @public exported from `@promptbook/wizard`
+     * @public exported from `@promptbook/cli`
+     */
+    const _OpenAiCompatibleMetadataRegistration = $llmToolsMetadataRegister.register({
+        title: 'Open AI Compatible',
+        packageName: '@promptbook/openai',
+        className: 'OpenAiCompatibleExecutionTools',
+        envVariables: ['OPENAI_API_KEY', 'OPENAI_BASE_URL'],
+        trustLevel: 'CLOSED',
+        order: MODEL_ORDERS.TOP_TIER,
+        getBoilerplateConfiguration() {
+            return {
+                title: 'Open AI Compatible',
+                packageName: '@promptbook/openai',
+                className: 'OpenAiCompatibleExecutionTools',
+                options: {
+                    apiKey: 'sk-',
+                    baseURL: 'https://api.openai.com/v1',
+                    defaultModelName: 'gpt-4-turbo',
+                    isProxied: false,
+                    remoteServerUrl: DEFAULT_REMOTE_SERVER_URL,
+                    maxRequestsPerMinute: DEFAULT_MAX_REQUESTS_PER_MINUTE,
+                },
+            };
+        },
+        createConfigurationFromEnv(env) {
+            return null;
+        },
+    });
     /**
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
@@ -18025,7 +18234,7 @@
          * Default model for chat variant.
          */
         getDefaultChatModel() {
-            return this.getDefaultModel('gpt-4o');
+            return this.getDefaultModel('gpt-4-turbo');
         }
         /**
          * Default model for completion variant.
@@ -18055,6 +18264,9 @@
          * @param options which are relevant are directly passed to the OpenAI client
          */
         constructor(options) {
+            if (options.isProxied) {
+                throw new NotYetImplementedError(`Proxy mode is not yet implemented for OpenAI assistants`);
+            }
             super(options);
             this.assistantId = options.assistantId;
             // TODO: [👱] Make limiter same as in `OpenAiExecutionTools`
@@ -18228,6 +18440,110 @@
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      */
 
+    /**
+     * Execution Tools for calling OpenAI compatible API
+     *
+     * Note: This can be used for any OpenAI compatible APIs
+     *
+     * @public exported from `@promptbook/openai`
+     */
+    const createOpenAiCompatibleExecutionTools = Object.assign((options) => {
+        if (options.isProxied) {
+            return new RemoteLlmExecutionTools({
+                ...options,
+                identification: {
+                    isAnonymous: true,
+                    llmToolsConfiguration: [
+                        {
+                            title: 'OpenAI Compatible (proxied)',
+                            packageName: '@promptbook/openai',
+                            className: 'OpenAiCompatibleExecutionTools',
+                            options: {
+                                ...options,
+                                isProxied: false,
+                            },
+                        },
+                    ],
+                },
+            });
+        }
+        if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
+            options = { ...options, dangerouslyAllowBrowser: true };
+        }
+        return new HardcodedOpenAiCompatibleExecutionTools(options.defaultModelName, options);
+    }, {
+        packageName: '@promptbook/openai',
+        className: 'OpenAiCompatibleExecutionTools',
+    });
+    /**
+     * Execution Tools for calling ONE SPECIFIC PRECONFIGURED OpenAI compatible provider
+     *
+     * @private for `createOpenAiCompatibleExecutionTools`
+     */
+    class HardcodedOpenAiCompatibleExecutionTools extends OpenAiCompatibleExecutionTools {
+        /**
+         * Creates OpenAI compatible Execution Tools.
+         *
+         * @param options which are relevant are directly passed to the OpenAI compatible client
+         */
+        constructor(defaultModelName, options) {
+            super(options);
+            this.defaultModelName = defaultModelName;
+            this.options = options;
+        }
+        get title() {
+            return `${this.defaultModelName} on ${this.options.baseURL}`;
+        }
+        get description() {
+            return `OpenAI compatible connected to "${this.options.baseURL}" model "${this.defaultModelName}"`;
+        }
+        /**
+         * List all available models (non dynamically)
+         *
+         * Note: Purpose of this is to provide more information about models than standard listing from API
+         */
+        get HARDCODED_MODELS() {
+            return [
+                {
+                    modelName: this.defaultModelName,
+                    modelVariant: 'CHAT',
+                    modelDescription: '', // <- TODO: What is the best value here, maybe `this.description`?
+                },
+            ];
+        }
+        /**
+         * Computes the usage
+         */
+        computeUsage(...args) {
+            return {
+                ...computeOpenAiUsage(...args),
+                price: UNCERTAIN_ZERO_VALUE, // <- TODO: Maybe in future pass this counting mechanism, but for now, we dont know
+            };
+        }
+        /**
+         * Default model for chat variant.
+         */
+        getDefaultChatModel() {
+            return this.getDefaultModel(this.defaultModelName);
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultCompletionModel() {
+            throw new PipelineExecutionError(`${this.title} does not support COMPLETION model variant`);
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultEmbeddingModel() {
+            throw new PipelineExecutionError(`${this.title} does not support EMBEDDING model variant`);
+        }
+    }
+    /**
+     * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?
+     * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
+     */
+
     /**
      * Execution Tools for calling OpenAI API
      *
@@ -18239,6 +18555,9 @@
         if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
             options = { ...options, dangerouslyAllowBrowser: true };
         }
+        if (options.isProxied) {
+            throw new NotYetImplementedError(`Proxy mode is not yet implemented in createOpenAiExecutionTools`);
+        }
         return new OpenAiExecutionTools(options);
     }, {
         packageName: '@promptbook/openai',
@@ -18249,6 +18568,7 @@
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      */
 
+    // Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be instantiated directly
     /**
      * Registration of LLM provider
      *
@@ -18269,6 +18589,20 @@
      * @public exported from `@promptbook/cli`
      */
     const _OpenAiAssistantRegistration = $llmToolsRegister.register(createOpenAiAssistantExecutionTools);
+    /**
+     * Registration of the OpenAI Compatible provider
+     *
+     * Note: [🏐] Configurations registrations are done in register-constructor.ts BUT constructor register-constructor.ts
+     *
+     * @public exported from `@promptbook/openai`
+     * @public exported from `@promptbook/wizard`
+     * @public exported from `@promptbook/cli`
+     */
+    const _OpenAiCompatibleRegistration = $llmToolsRegister.register(createOpenAiCompatibleExecutionTools);
+    /**
+     * Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be registered directly.
+     * It serves as a base class for OpenAiExecutionTools and other compatible implementations.
+     */
     /**
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -19531,6 +19865,8 @@
     exports._OllamaRegistration = _OllamaRegistration;
     exports._OpenAiAssistantMetadataRegistration = _OpenAiAssistantMetadataRegistration;
     exports._OpenAiAssistantRegistration = _OpenAiAssistantRegistration;
+    exports._OpenAiCompatibleMetadataRegistration = _OpenAiCompatibleMetadataRegistration;
+    exports._OpenAiCompatibleRegistration = _OpenAiCompatibleRegistration;
     exports._OpenAiMetadataRegistration = _OpenAiMetadataRegistration;
     exports._OpenAiRegistration = _OpenAiRegistration;
     exports._PdfScraperMetadataRegistration = _PdfScraperMetadataRegistration;