@promptbook/node 0.98.0-5 → 0.98.0-8

package/umd/index.umd.js

@@ -46,7 +46,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.98.0-5';
+    const PROMPTBOOK_ENGINE_VERSION = '0.98.0-8';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -190,7 +190,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const DEFAULT_MAX_EXECUTION_ATTEMPTS = 3; // <- TODO: [🤹‍♂️]
+    const DEFAULT_MAX_EXECUTION_ATTEMPTS = 7; // <- TODO: [🤹‍♂️]
     // <- TODO: [🕝] Make also `BOOKS_DIRNAME_ALTERNATIVES`
     // TODO: Just `.promptbook` in config, hardcode subfolders like `download-cache` or `execution-cache`
     /**
@@ -360,7 +360,7 @@
             throw new Error(spaceTrim__default["default"]((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
         }
@@ -3121,108 +3121,6 @@
      * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
      */
 
-    /**
-     * 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 (currentCodeBlock !== null) {
-            throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
-        }
-        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;
-        }
-        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: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
-     * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
-     */
-
     /**
      * Takes an item or an array of items and returns an array of items
      *
@@ -3330,6 +3228,108 @@
         return replacedTemplates;
     }
 
+    /**
+     * 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 (currentCodeBlock !== null) {
+            throw new ParseError(`${capitalize(currentCodeBlock.language || 'the')} code block was not closed at the end of the markdown`);
+        }
+        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;
+        }
+        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: Add some auto-healing logic + extract YAML, JSON5, TOML, etc.
+     * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
+     */
+
     /**
      * Counts number of characters in the text
      *
@@ -3751,6 +3751,68 @@
      * 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}"`);
+                }
+            }
+            // 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,
+            };
+        }
+    }
+
     /**
      * Executes a pipeline task with multiple attempts, including joker and retry logic. Handles different task types
      * (prompt, script, dialog, etc.), applies postprocessing, checks expectations, and updates the execution report.
@@ -3773,13 +3835,13 @@
         // 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)}
                     `));
@@ -3977,35 +4039,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;
             }
@@ -4019,6 +4064,7 @@
                     $ongoingTaskResult.$failedResults = [];
                 }
                 $ongoingTaskResult.$failedResults.push({
+                    attemptIndex,
                     result: $ongoingTaskResult.$resultString,
                     error: error,
                 });
@@ -4043,19 +4089,13 @@
                     });
                 }
             }
-            if ($ongoingTaskResult.$expectError !== null && attempt === maxAttempts - 1) {
-                // Store the current failure before throwing
-                $ongoingTaskResult.$failedResults = $ongoingTaskResult.$failedResults || [];
-                $ongoingTaskResult.$failedResults.push({
-                    result: $ongoingTaskResult.$resultString,
-                    error: $ongoingTaskResult.$expectError,
-                });
-                // Create a summary of all failures
+            if ($ongoingTaskResult.$expectError !== null && attemptIndex === maxAttempts - 1) {
+                // Note: Create a summary of all failures
                 const failuresSummary = $ongoingTaskResult.$failedResults
-                    .map((failure, index) => spaceTrim.spaceTrim((block) => {
+                    .map((failure) => spaceTrim.spaceTrim((block) => {
                     var _a, _b;
                     return `
-                            Attempt ${index + 1}:
+                            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'))}