@promptbook/legacy-documents 0.98.0-5 → 0.98.0-8

package/umd/index.umd.js

@@ -26,7 +26,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
@@ -175,7 +175,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`
     /**
@@ -2560,7 +2560,7 @@
             throw new Error(spaceTrim__default["default"]((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
         }
@@ -4637,6 +4637,77 @@
         return mappedParameters;
     }
 
+    /**
+     * Replaces parameters in template with values from parameters object
+     *
+     * Note: This function is not places strings into string,
+     *       It's more complex and can handle this operation specifically for LLM models
+     *
+     * @param template the template with parameters in {curly} braces
+     * @param parameters the object with parameters
+     * @returns the template with replaced parameters
+     * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
+     * @public exported from `@promptbook/utils`
+     */
+    function templateParameters(template, parameters) {
+        for (const [parameterName, parameterValue] of Object.entries(parameters)) {
+            if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
+                throw new UnexpectedError(`Parameter \`{${parameterName}}\` has missing value`);
+            }
+            else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
+                // TODO: [🍵]
+                throw new UnexpectedError(`Parameter \`{${parameterName}}\` is restricted to use`);
+            }
+        }
+        let replacedTemplates = template;
+        let match;
+        let loopLimit = LOOP_LIMIT;
+        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
+            .exec(replacedTemplates))) {
+            if (loopLimit-- < 0) {
+                throw new LimitReachedError('Loop limit reached during parameters replacement in `templateParameters`');
+            }
+            const precol = match.groups.precol;
+            const parameterName = match.groups.parameterName;
+            if (parameterName === '') {
+                // Note: Skip empty placeholders. It's used to avoid confusion with JSON-like strings
+                continue;
+            }
+            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
+                throw new PipelineExecutionError('Parameter is already opened or not closed');
+            }
+            if (parameters[parameterName] === undefined) {
+                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
+            }
+            let parameterValue = parameters[parameterName];
+            if (parameterValue === undefined) {
+                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
+            }
+            parameterValue = valueToString(parameterValue);
+            // Escape curly braces in parameter values to prevent prompt-injection
+            parameterValue = parameterValue.replace(/[{}]/g, '\\$&');
+            if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
+                parameterValue = parameterValue
+                    .split('\n')
+                    .map((line, index) => (index === 0 ? line : `${precol}${line}`))
+                    .join('\n');
+            }
+            replacedTemplates =
+                replacedTemplates.substring(0, match.index + precol.length) +
+                    parameterValue +
+                    replacedTemplates.substring(match.index + precol.length + parameterName.length + 2);
+        }
+        // [💫] Check if there are parameters that are not closed properly
+        if (/{\w+$/.test(replacedTemplates)) {
+            throw new PipelineExecutionError('Parameter is not closed');
+        }
+        // [💫] Check if there are parameters that are not opened properly
+        if (/^\w+}/.test(replacedTemplates)) {
+            throw new PipelineExecutionError('Parameter is not opened');
+        }
+        return replacedTemplates;
+    }
+
     /**
      * Extracts all code blocks from markdown.
      *
@@ -4739,77 +4810,6 @@
      * TODO: [🏢] Make this logic part of `JsonFormatParser` or `isValidJsonString`
      */
 
-    /**
-     * Replaces parameters in template with values from parameters object
-     *
-     * Note: This function is not places strings into string,
-     *       It's more complex and can handle this operation specifically for LLM models
-     *
-     * @param template the template with parameters in {curly} braces
-     * @param parameters the object with parameters
-     * @returns the template with replaced parameters
-     * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
-     * @public exported from `@promptbook/utils`
-     */
-    function templateParameters(template, parameters) {
-        for (const [parameterName, parameterValue] of Object.entries(parameters)) {
-            if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
-                throw new UnexpectedError(`Parameter \`{${parameterName}}\` has missing value`);
-            }
-            else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
-                // TODO: [🍵]
-                throw new UnexpectedError(`Parameter \`{${parameterName}}\` is restricted to use`);
-            }
-        }
-        let replacedTemplates = template;
-        let match;
-        let loopLimit = LOOP_LIMIT;
-        while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
-            .exec(replacedTemplates))) {
-            if (loopLimit-- < 0) {
-                throw new LimitReachedError('Loop limit reached during parameters replacement in `templateParameters`');
-            }
-            const precol = match.groups.precol;
-            const parameterName = match.groups.parameterName;
-            if (parameterName === '') {
-                // Note: Skip empty placeholders. It's used to avoid confusion with JSON-like strings
-                continue;
-            }
-            if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
-                throw new PipelineExecutionError('Parameter is already opened or not closed');
-            }
-            if (parameters[parameterName] === undefined) {
-                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
-            }
-            let parameterValue = parameters[parameterName];
-            if (parameterValue === undefined) {
-                throw new PipelineExecutionError(`Parameter \`{${parameterName}}\` is not defined`);
-            }
-            parameterValue = valueToString(parameterValue);
-            // Escape curly braces in parameter values to prevent prompt-injection
-            parameterValue = parameterValue.replace(/[{}]/g, '\\$&');
-            if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
-                parameterValue = parameterValue
-                    .split('\n')
-                    .map((line, index) => (index === 0 ? line : `${precol}${line}`))
-                    .join('\n');
-            }
-            replacedTemplates =
-                replacedTemplates.substring(0, match.index + precol.length) +
-                    parameterValue +
-                    replacedTemplates.substring(match.index + precol.length + parameterName.length + 2);
-        }
-        // [💫] Check if there are parameters that are not closed properly
-        if (/{\w+$/.test(replacedTemplates)) {
-            throw new PipelineExecutionError('Parameter is not closed');
-        }
-        // [💫] Check if there are parameters that are not opened properly
-        if (/^\w+}/.test(replacedTemplates)) {
-            throw new PipelineExecutionError('Parameter is not opened');
-        }
-        return replacedTemplates;
-    }
-
     /**
      * Counts number of characters in the text
      *
@@ -4970,6 +4970,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.
@@ -4992,13 +5054,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)}
                     `));
@@ -5196,35 +5258,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;
             }
@@ -5238,6 +5283,7 @@
                     $ongoingTaskResult.$failedResults = [];
                 }
                 $ongoingTaskResult.$failedResults.push({
+                    attemptIndex,
                     result: $ongoingTaskResult.$resultString,
                     error: error,
                 });
@@ -5262,19 +5308,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'))}