@promptbook/legacy-documents 0.98.0-6 → 0.98.0-9

package/esm/index.es.js

@@ -28,7 +28,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.98.0-6';
+const PROMPTBOOK_ENGINE_VERSION = '0.98.0-9';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -177,7 +177,7 @@ const DEFAULT_MAX_PARALLEL_COUNT = 5; // <- TODO: [🤹‍♂️]
  *
  * @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`
 /**
@@ -2562,7 +2562,7 @@ function jsonParse(value) {
         throw new Error(spaceTrim$1((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
     }
@@ -4639,6 +4639,77 @@ function mapAvailableToExpectedParameters(options) {
     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.
  *
@@ -4741,77 +4812,6 @@ function extractJsonBlock(markdown) {
  * 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
  *
@@ -4972,6 +4972,68 @@ function checkExpectations(expectations, value) {
  * 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((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.
@@ -4994,13 +5056,13 @@ async function executeAttempts(options) {
     // 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((block) => `
-                        Joker not found in attempt ${attempt}
+                        Joker not found in attempt ${attemptIndex}
 
                         ${block(pipelineIdentification)}
                     `));
@@ -5198,35 +5260,18 @@ async function executeAttempts(options) {
                 }
             }
             // 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((block) => `
-                                        Expected valid JSON string
-
-                                        ${block(
-                            /*<- Note: No need for `pipelineIdentification`, it will be catched and added later */ '')}
-                                    `));
-                        }
-                    }
-                }
-                else {
-                    throw new UnexpectedError(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;
         }
@@ -5240,6 +5285,7 @@ async function executeAttempts(options) {
                 $ongoingTaskResult.$failedResults = [];
             }
             $ongoingTaskResult.$failedResults.push({
+                attemptIndex,
                 result: $ongoingTaskResult.$resultString,
                 error: error,
             });
@@ -5264,19 +5310,13 @@ async function executeAttempts(options) {
                 });
             }
         }
-        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((block) => {
+                .map((failure) => 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'))}