@promptbook/website-crawler 0.112.0-39 → 0.112.0-41

package/umd/index.umd.js

@@ -23,7 +23,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-39';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-41';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -6124,317 +6124,511 @@
      * @private internal utility of `createPipelineExecutor`
      */
     async function executeAttempts(options) {
-        const { jokerParameterNames, priority, maxAttempts, // <- Note: [💂]
-        preparedContent, parameters, task, preparedPipeline, tools, $executionReport, pipelineIdentification, maxExecutionAttempts, onProgress, logLlmCall, } = options;
-        const $ongoingTaskResult = {
+        const $ongoingTaskResult = createOngoingTaskResult();
+        const llmTools = getSingleLlmExecutionTools(options.tools.llm);
+        attempts: for (let attemptIndex = -options.jokerParameterNames.length; attemptIndex < options.maxAttempts; attemptIndex++) {
+            const attempt = createAttemptDescriptor({
+                attemptIndex,
+                jokerParameterNames: options.jokerParameterNames,
+                pipelineIdentification: options.pipelineIdentification,
+            });
+            resetAttemptExecutionState($ongoingTaskResult);
+            try {
+                await executeSingleAttempt({
+                    attempt,
+                    options,
+                    llmTools,
+                    $ongoingTaskResult,
+                });
+                break attempts;
+            }
+            catch (error) {
+                if (!(error instanceof ExpectError)) {
+                    throw error;
+                }
+                recordFailedAttempt({
+                    error,
+                    attemptIndex,
+                    onProgress: options.onProgress,
+                    $ongoingTaskResult,
+                });
+            }
+            finally {
+                reportPromptExecution({
+                    attempt,
+                    task: options.task,
+                    $executionReport: options.$executionReport,
+                    logLlmCall: options.logLlmCall,
+                    $ongoingTaskResult,
+                });
+            }
+            throwIfFinalAttemptFailed({
+                attemptIndex,
+                maxAttempts: options.maxAttempts,
+                maxExecutionAttempts: options.maxExecutionAttempts,
+                pipelineIdentification: options.pipelineIdentification,
+                $ongoingTaskResult,
+            });
+        }
+        return getSuccessfulResultString({
+            pipelineIdentification: options.pipelineIdentification,
+            $ongoingTaskResult,
+        });
+    }
+    /**
+     * Creates mutable attempt state for one task execution lifecycle.
+     */
+    function createOngoingTaskResult() {
+        return {
             $result: null,
             $resultString: null,
             $expectError: null,
             $scriptPipelineExecutionErrors: [],
-            $failedResults: [], // Track all failed attempts
+            $failedResults: [],
         };
-        const llmTools = getSingleLlmExecutionTools(tools.llm);
-        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 ${attemptIndex}
+    }
+    /**
+     * Resolves the bookkeeping for one loop iteration, including joker lookup.
+     */
+    function createAttemptDescriptor(options) {
+        const { attemptIndex, jokerParameterNames, pipelineIdentification } = options;
+        const isJokerAttempt = attemptIndex < 0;
+        const jokerParameterName = isJokerAttempt
+            ? jokerParameterNames[jokerParameterNames.length + attemptIndex]
+            : undefined;
+        if (isJokerAttempt && !jokerParameterName) {
+            throw new UnexpectedError(spacetrim.spaceTrim((block) => `
+                    Joker not found in attempt ${attemptIndex}
 
-                        ${block(pipelineIdentification)}
+                    ${block(pipelineIdentification)}
+                `));
+        }
+        return {
+            attemptIndex,
+            isJokerAttempt,
+            jokerParameterName,
+        };
+    }
+    /**
+     * Clears the per-attempt result slots while preserving cumulative failure history.
+     */
+    function resetAttemptExecutionState($ongoingTaskResult) {
+        $ongoingTaskResult.$result = null;
+        $ongoingTaskResult.$resultString = null;
+        $ongoingTaskResult.$expectError = null;
+    }
+    /**
+     * Executes one loop iteration, from joker resolution or task execution through validation.
+     */
+    async function executeSingleAttempt(options) {
+        const { attempt, options: executeAttemptsOptions, llmTools, $ongoingTaskResult } = options;
+        if (attempt.isJokerAttempt) {
+            resolveJokerAttemptResult({
+                jokerParameterName: attempt.jokerParameterName,
+                parameters: executeAttemptsOptions.parameters,
+                pipelineIdentification: executeAttemptsOptions.pipelineIdentification,
+                $ongoingTaskResult,
+            });
+        }
+        else {
+            await executeTaskAttempt({
+                options: executeAttemptsOptions,
+                llmTools,
+                $ongoingTaskResult,
+            });
+            await applyPostprocessingFunctions({
+                task: executeAttemptsOptions.task,
+                tools: executeAttemptsOptions.tools,
+                $ongoingTaskResult,
+            });
+        }
+        validateAttemptResult({
+            task: executeAttemptsOptions.task,
+            $ongoingTaskResult,
+        });
+    }
+    /**
+     * Resolves the shortcut value used by a joker attempt.
+     */
+    function resolveJokerAttemptResult(options) {
+        const { jokerParameterName, parameters, pipelineIdentification, $ongoingTaskResult } = options;
+        if (parameters[jokerParameterName] === undefined) {
+            throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                    Joker parameter {${jokerParameterName}} not defined
+
+                    ${block(pipelineIdentification)}
+                `));
+            // <- TODO: This is maybe `PipelineLogicError` which should be detected in `validatePipeline` and here just thrown as `UnexpectedError`
+        }
+        $ongoingTaskResult.$resultString = parameters[jokerParameterName];
+    }
+    /**
+     * Dispatches non-joker execution to the handler for the current task type.
+     */
+    async function executeTaskAttempt(options) {
+        const { options: executeAttemptsOptions, llmTools, $ongoingTaskResult } = options;
+        const { task } = executeAttemptsOptions;
+        switch (task.taskType) {
+            case 'SIMPLE_TASK':
+                executeSimpleTaskAttempt({
+                    preparedContent: executeAttemptsOptions.preparedContent,
+                    parameters: executeAttemptsOptions.parameters,
+                    $ongoingTaskResult,
+                });
+                return;
+            case 'PROMPT_TASK':
+                await executePromptTaskAttempt({
+                    preparedPipeline: executeAttemptsOptions.preparedPipeline,
+                    task,
+                    parameters: executeAttemptsOptions.parameters,
+                    preparedContent: executeAttemptsOptions.preparedContent,
+                    pipelineIdentification: executeAttemptsOptions.pipelineIdentification,
+                    llmTools,
+                    $ongoingTaskResult,
+                });
+                return;
+            case 'SCRIPT_TASK':
+                await executeScriptTaskAttempt({
+                    tools: executeAttemptsOptions.tools,
+                    task,
+                    preparedContent: executeAttemptsOptions.preparedContent,
+                    parameters: executeAttemptsOptions.parameters,
+                    pipelineIdentification: executeAttemptsOptions.pipelineIdentification,
+                    $ongoingTaskResult,
+                });
+                return;
+            case 'DIALOG_TASK':
+                await executeDialogTaskAttempt({
+                    tools: executeAttemptsOptions.tools,
+                    task,
+                    parameters: executeAttemptsOptions.parameters,
+                    preparedContent: executeAttemptsOptions.preparedContent,
+                    priority: executeAttemptsOptions.priority,
+                    pipelineIdentification: executeAttemptsOptions.pipelineIdentification,
+                    $ongoingTaskResult,
+                });
+                return;
+            default:
+                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                        Unknown execution type "${task.taskType}"
+
+                        ${block(executeAttemptsOptions.pipelineIdentification)}
                     `));
-            }
-            $ongoingTaskResult.$result = null;
-            $ongoingTaskResult.$resultString = null;
-            $ongoingTaskResult.$expectError = null;
-            if (isJokerAttempt) {
-                if (parameters[jokerParameterName] === undefined) {
-                    throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                            Joker parameter {${jokerParameterName}} not defined
+        }
+    }
+    /**
+     * Executes a simple templated task with no external tools.
+     */
+    function executeSimpleTaskAttempt(options) {
+        const { preparedContent, parameters, $ongoingTaskResult } = options;
+        $ongoingTaskResult.$resultString = templateParameters(preparedContent, parameters);
+    }
+    /**
+     * Builds the prompt for a prompt task and calls the appropriate LLM variant.
+     */
+    async function executePromptTaskAttempt(options) {
+        const { preparedPipeline, task, parameters, preparedContent, pipelineIdentification, llmTools, $ongoingTaskResult, } = options;
+        const modelRequirements = {
+            modelVariant: 'CHAT',
+            ...(preparedPipeline.defaultModelRequirements || {}),
+            ...(task.modelRequirements || {}),
+        }; /* <- Note: [🤛] */
+        $ongoingTaskResult.$prompt = {
+            title: task.title,
+            pipelineUrl: `${preparedPipeline.pipelineUrl ? preparedPipeline.pipelineUrl : 'anonymous'}#${task.name
+        // <- TODO: Here should be maybe also subformat index to distinguish between same task with different subformat values
+        }`,
+            parameters,
+            content: preparedContent,
+            modelRequirements,
+            expectations: {
+                ...(preparedPipeline.personas.find(({ name }) => name === task.personaName) || {}),
+                ...task.expectations,
+            },
+            format: task.format,
+            postprocessingFunctionNames: task.postprocessingFunctionNames,
+        }; // <- TODO: Not very good type guard
+        switch (modelRequirements.modelVariant) {
+            case 'CHAT':
+                $ongoingTaskResult.$chatResult = await llmTools.callChatModel(
+                // <- TODO: [🧁] Check that `callChatModel` is defined
+                $deepFreeze($ongoingTaskResult.$prompt));
+                // TODO: [🍬] Destroy chatThread
+                $ongoingTaskResult.$result = $ongoingTaskResult.$chatResult;
+                $ongoingTaskResult.$resultString = $ongoingTaskResult.$chatResult.content;
+                return;
+            case 'COMPLETION':
+                $ongoingTaskResult.$completionResult = await llmTools.callCompletionModel(
+                // <- TODO: [🧁] Check that `callCompletionModel` is defined
+                $deepFreeze($ongoingTaskResult.$prompt));
+                $ongoingTaskResult.$result = $ongoingTaskResult.$completionResult;
+                $ongoingTaskResult.$resultString = $ongoingTaskResult.$completionResult.content;
+                return;
+            case 'EMBEDDING':
+            case 'IMAGE_GENERATION':
+                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                        ${modelRequirements.modelVariant} model can not be used in pipeline
 
-                            ${block(pipelineIdentification)}
-                        `));
-                    // <- TODO: This is maybe `PipelineLogicError` which should be detected in `validatePipeline` and here just thrown as `UnexpectedError`
-                }
-                else {
-                    $ongoingTaskResult.$resultString = parameters[jokerParameterName];
-                }
-            }
-            try {
-                if (!isJokerAttempt) {
-                    taskType: switch (task.taskType) {
-                        case 'SIMPLE_TASK':
-                            $ongoingTaskResult.$resultString = templateParameters(preparedContent, parameters);
-                            break taskType;
-                        case 'PROMPT_TASK':
-                            {
-                                const modelRequirements = {
-                                    modelVariant: 'CHAT',
-                                    ...(preparedPipeline.defaultModelRequirements || {}),
-                                    ...(task.modelRequirements || {}),
-                                }; /* <- Note: [🤛] */
-                                $ongoingTaskResult.$prompt = {
-                                    title: task.title,
-                                    pipelineUrl: `${preparedPipeline.pipelineUrl
-                                    ? preparedPipeline.pipelineUrl
-                                    : 'anonymous' /* <- TODO: [🧠] How to deal with anonymous pipelines, do here some auto-url like SHA-256 based ad-hoc identifier? */}#${task.name
-                                // <- TODO: Here should be maybe also subformat index to distinguish between same task with different subformat values
-                                }`,
-                                    parameters,
-                                    content: preparedContent,
-                                    modelRequirements,
-                                    expectations: {
-                                        ...(preparedPipeline.personas.find(({ name }) => name === task.personaName) || {}),
-                                        ...task.expectations,
-                                    },
-                                    format: task.format,
-                                    postprocessingFunctionNames: task.postprocessingFunctionNames,
-                                }; // <- TODO: Not very good type guard
-                                variant: switch (modelRequirements.modelVariant) {
-                                    case 'CHAT':
-                                        $ongoingTaskResult.$chatResult = await llmTools.callChatModel(
-                                        // <- TODO: [🧁] Check that `callChatModel` is defined
-                                        $deepFreeze($ongoingTaskResult.$prompt));
-                                        // TODO: [🍬] Destroy chatThread
-                                        $ongoingTaskResult.$result = $ongoingTaskResult.$chatResult;
-                                        $ongoingTaskResult.$resultString = $ongoingTaskResult.$chatResult.content;
-                                        break variant;
-                                    case 'COMPLETION':
-                                        $ongoingTaskResult.$completionResult = await llmTools.callCompletionModel(
-                                        // <- TODO: [🧁] Check that `callCompletionModel` is defined
-                                        $deepFreeze($ongoingTaskResult.$prompt));
-                                        $ongoingTaskResult.$result = $ongoingTaskResult.$completionResult;
-                                        $ongoingTaskResult.$resultString = $ongoingTaskResult.$completionResult.content;
-                                        break variant;
-                                    case 'EMBEDDING':
-                                    case 'IMAGE_GENERATION':
-                                        throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                                                ${modelRequirements.modelVariant} model can not be used in pipeline
-
-                                                This should be catched during parsing
-
-                                                ${block(pipelineIdentification)}
-
-                                            `));
-                                        break variant;
-                                    // <- case [🤖]:
-                                    default:
-                                        throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                                                Unknown model variant "${task.modelRequirements.modelVariant}"
-
-                                                ${block(pipelineIdentification)}
-
-                                            `));
-                                }
-                            }
-                            break;
-                        case 'SCRIPT_TASK':
-                            if (arrayableToArray(tools.script).length === 0) {
-                                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                                        No script execution tools are available
+                        This should be catched during parsing
 
-                                        ${block(pipelineIdentification)}
-                                    `));
-                            }
-                            if (!task.contentLanguage) {
-                                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                                        Script language is not defined for SCRIPT TASK "${task.name}"
+                        ${block(pipelineIdentification)}
 
-                                        ${block(pipelineIdentification)}
-                                    `));
-                            }
-                            // TODO: DRY [☯]
-                            scripts: for (const scriptTools of arrayableToArray(tools.script)) {
-                                try {
-                                    $ongoingTaskResult.$resultString = await scriptTools.execute($deepFreeze({
-                                        scriptLanguage: task.contentLanguage,
-                                        script: preparedContent,
-                                        parameters,
-                                    }));
-                                    break scripts;
-                                }
-                                catch (error) {
-                                    assertsError(error);
-                                    if (error instanceof UnexpectedError) {
-                                        throw error;
-                                    }
-                                    $ongoingTaskResult.$scriptPipelineExecutionErrors.push(error);
-                                }
-                            }
-                            if ($ongoingTaskResult.$resultString !== null) {
-                                break taskType;
-                            }
-                            if ($ongoingTaskResult.$scriptPipelineExecutionErrors.length === 1) {
-                                throw $ongoingTaskResult.$scriptPipelineExecutionErrors[0];
-                            }
-                            else {
-                                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                                        Script execution failed ${$ongoingTaskResult.$scriptPipelineExecutionErrors.length}x
+                    `));
+            // <- case [🤖]:
+            default:
+                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                        Unknown model variant "${task.modelRequirements.modelVariant}"
 
-                                        ${block(pipelineIdentification)}
+                        ${block(pipelineIdentification)}
 
-                                        ${block($ongoingTaskResult.$scriptPipelineExecutionErrors
-                                .map((error) => '- ' + error.message)
-                                .join('\n\n'))}
-                                    `));
-                            }
-                            // Note: This line is unreachable because of the break taskType above
-                            break taskType;
-                        case 'DIALOG_TASK':
-                            if (tools.userInterface === undefined) {
-                                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                                        User interface tools are not available
+                    `));
+        }
+    }
+    /**
+     * Executes a script task with the first script tool that succeeds.
+     */
+    async function executeScriptTaskAttempt(options) {
+        const { tools, task, preparedContent, parameters, pipelineIdentification, $ongoingTaskResult } = options;
+        const scriptExecutionTools = arrayableToArray(tools.script);
+        if (scriptExecutionTools.length === 0) {
+            throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                    No script execution tools are available
 
-                                        ${block(pipelineIdentification)}
-                                    `));
-                            }
-                            // TODO: [🌹] When making next attempt for `DIALOG TASK`, preserve the previous user input
-                            $ongoingTaskResult.$resultString = await tools.userInterface.promptDialog($deepFreeze({
-                                promptTitle: task.title,
-                                promptMessage: templateParameters(task.description || '', parameters),
-                                defaultValue: templateParameters(preparedContent, parameters),
-                                // TODO: [🧠] Figure out how to define placeholder in .book.md file
-                                placeholder: undefined,
-                                priority,
-                            }));
-                            break taskType;
-                        // <- case: [🅱]
-                        default:
-                            throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
-                                    Unknown execution type "${task.taskType}"
+                    ${block(pipelineIdentification)}
+                `));
+        }
+        if (!task.contentLanguage) {
+            throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                    Script language is not defined for SCRIPT TASK "${task.name}"
 
-                                    ${block(pipelineIdentification)}
-                                `));
-                    }
-                }
-                if (!isJokerAttempt && task.postprocessingFunctionNames) {
-                    for (const functionName of task.postprocessingFunctionNames) {
-                        let postprocessingError = null;
-                        scripts: for (const scriptTools of arrayableToArray(tools.script)) {
-                            try {
-                                $ongoingTaskResult.$resultString = await scriptTools.execute({
-                                    scriptLanguage: `javascript` /* <- TODO: Try it in each languages; In future allow postprocessing with arbitrary combination of languages to combine */,
-                                    script: `${functionName}(resultString)`,
-                                    parameters: {
-                                        resultString: $ongoingTaskResult.$resultString || '',
-                                        // Note: No ...parametersForTask, because working with result only
-                                    },
-                                });
-                                postprocessingError = null;
-                                break scripts;
-                            }
-                            catch (error) {
-                                assertsError(error);
-                                if (error instanceof UnexpectedError) {
-                                    throw error;
-                                }
-                                postprocessingError = error;
-                                $ongoingTaskResult.$scriptPipelineExecutionErrors.push(error);
-                            }
-                        }
-                        if (postprocessingError) {
-                            throw postprocessingError;
-                        }
-                    }
-                }
-                // TODO: [💝] Unite object for expecting amount and format
-                // 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;
-                    }
-                    // Update the result string in case format processing modified it (e.g., JSON extraction)
-                    $ongoingTaskResult.$resultString = validationResult.processedResultString;
-                }
-                break attempts;
+                    ${block(pipelineIdentification)}
+                `));
+        }
+        for (const scriptTools of scriptExecutionTools) {
+            try {
+                $ongoingTaskResult.$resultString = await scriptTools.execute($deepFreeze({
+                    scriptLanguage: task.contentLanguage,
+                    script: preparedContent,
+                    parameters,
+                }));
+                return;
             }
             catch (error) {
-                if (!(error instanceof ExpectError)) {
+                assertsError(error);
+                if (error instanceof UnexpectedError) {
                     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,
-                });
-                // Report failed attempt
-                onProgress({
-                    errors: [error],
+                $ongoingTaskResult.$scriptPipelineExecutionErrors.push(error);
+            }
+        }
+        throw createScriptExecutionFailure({
+            pipelineIdentification,
+            $ongoingTaskResult,
+        });
+    }
+    /**
+     * Creates the final script-task error after all script tools have failed.
+     */
+    function createScriptExecutionFailure(options) {
+        const { pipelineIdentification, $ongoingTaskResult } = options;
+        if ($ongoingTaskResult.$scriptPipelineExecutionErrors.length === 1) {
+            return $ongoingTaskResult.$scriptPipelineExecutionErrors[0];
+        }
+        return new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                Script execution failed ${$ongoingTaskResult.$scriptPipelineExecutionErrors.length}x
+
+                ${block(pipelineIdentification)}
+
+                ${block($ongoingTaskResult.$scriptPipelineExecutionErrors.map((error) => '- ' + error.message).join('\n\n'))}
+            `));
+    }
+    /**
+     * Executes a dialog task through the configured user-interface tools.
+     */
+    async function executeDialogTaskAttempt(options) {
+        const { tools, task, parameters, preparedContent, priority, pipelineIdentification, $ongoingTaskResult } = options;
+        if (tools.userInterface === undefined) {
+            throw new PipelineExecutionError(spacetrim.spaceTrim((block) => `
+                    User interface tools are not available
+
+                    ${block(pipelineIdentification)}
+                `));
+        }
+        // TODO: [🌹] When making next attempt for `DIALOG TASK`, preserve the previous user input
+        $ongoingTaskResult.$resultString = await tools.userInterface.promptDialog($deepFreeze({
+            promptTitle: task.title,
+            promptMessage: templateParameters(task.description || '', parameters),
+            defaultValue: templateParameters(preparedContent, parameters),
+            // TODO: [🧠] Figure out how to define placeholder in .book.md file
+            placeholder: undefined,
+            priority,
+        }));
+    }
+    /**
+     * Runs all configured postprocessing functions in order.
+     */
+    async function applyPostprocessingFunctions(options) {
+        const { task } = options;
+        if (!task.postprocessingFunctionNames) {
+            return;
+        }
+        for (const functionName of task.postprocessingFunctionNames) {
+            await executePostprocessingFunction({
+                functionName,
+                tools: options.tools,
+                $ongoingTaskResult: options.$ongoingTaskResult,
+            });
+        }
+    }
+    /**
+     * Executes one postprocessing function against the current result string.
+     */
+    async function executePostprocessingFunction(options) {
+        const { functionName, tools, $ongoingTaskResult } = options;
+        let postprocessingError = null;
+        for (const scriptTools of arrayableToArray(tools.script)) {
+            try {
+                $ongoingTaskResult.$resultString = await scriptTools.execute({
+                    scriptLanguage: `javascript` /* <- TODO: Try it in each languages; In future allow postprocessing with arbitrary combination of languages to combine */,
+                    script: `${functionName}(resultString)`,
+                    parameters: {
+                        resultString: $ongoingTaskResult.$resultString || '',
+                        // Note: No ...parametersForTask, because working with result only
+                    },
                 });
+                postprocessingError = null;
+                return;
             }
-            finally {
-                if (!isJokerAttempt && task.taskType === 'PROMPT_TASK' && $ongoingTaskResult.$prompt) {
-                    // Note:  [2] When some expected parameter is not defined, error will occur in templateParameters
-                    //        In that case we don’t want to make a report about it because it’s not a llm execution error
-                    const executionPromptReport = {
-                        prompt: {
-                            ...$ongoingTaskResult.$prompt,
-                            // <- TODO: [🧠] How to pick everyhing except `pipelineUrl`
-                        },
-                        result: $ongoingTaskResult.$result || undefined,
-                        error: $ongoingTaskResult.$expectError === null
-                            ? undefined
-                            : serializeError($ongoingTaskResult.$expectError),
-                    };
-                    $executionReport.promptExecutions.push(executionPromptReport);
-                    if (logLlmCall) {
-                        logLlmCall({
-                            modelName: 'model' /* <- TODO: How to get model name from the report */,
-                            report: executionPromptReport,
-                        });
-                    }
+            catch (error) {
+                assertsError(error);
+                if (error instanceof UnexpectedError) {
+                    throw error;
                 }
+                postprocessingError = error;
+                $ongoingTaskResult.$scriptPipelineExecutionErrors.push(error);
             }
-            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(/\r?\n/).map((line) => `> ${line}`).join('\n'))}
-
-                            Result:
-                            ${block(failure.result === null
-                    ? 'null'
-                    : spacetrim.spaceTrim(failure.result)
-                        .split(/\r?\n/)
-                        .map((line) => `> ${line}`)
-                        .join('\n'))}
-                        `;
-                }))
-                    .join('\n\n---\n\n');
-                throw new PipelineExecutionError(spacetrim.spaceTrim((block) => {
-                    var _a;
-                    return `
-                        LLM execution failed ${maxExecutionAttempts}x
+        }
+        if (postprocessingError) {
+            throw postprocessingError;
+        }
+    }
+    /**
+     * Validates the current result string against expectations and format constraints.
+     */
+    function validateAttemptResult(options) {
+        const { task, $ongoingTaskResult } = options;
+        if (!task.format && !task.expectations) {
+            return;
+        }
+        // TODO: [💝] Unite object for expecting amount and format
+        // Use the common validation function for both format and expectations
+        const validationResult = validatePromptResult({
+            resultString: $ongoingTaskResult.$resultString || '',
+            expectations: task.expectations,
+            format: task.format,
+        });
+        if (!validationResult.isValid) {
+            throw validationResult.error;
+        }
+        // Update the result string in case format processing modified it (e.g., JSON extraction)
+        $ongoingTaskResult.$resultString = validationResult.processedResultString;
+    }
+    /**
+     * Stores one failed attempt and reports the expectation error upstream.
+     */
+    function recordFailedAttempt(options) {
+        const { error, attemptIndex, onProgress, $ongoingTaskResult } = options;
+        $ongoingTaskResult.$expectError = error;
+        $ongoingTaskResult.$failedResults.push({
+            attemptIndex,
+            result: $ongoingTaskResult.$resultString,
+            error,
+        });
+        onProgress({
+            errors: [error],
+        });
+    }
+    /**
+     * Appends the prompt execution report for prompt-task attempts.
+     */
+    function reportPromptExecution(options) {
+        const { attempt, task, $executionReport, logLlmCall, $ongoingTaskResult } = options;
+        if (attempt.isJokerAttempt || task.taskType !== 'PROMPT_TASK' || !$ongoingTaskResult.$prompt) {
+            return;
+        }
+        // Note:  [2] When some expected parameter is not defined, error will occur in templateParameters
+        //        In that case we don’t want to make a report about it because it’s not a llm execution error
+        const executionPromptReport = {
+            prompt: {
+                ...$ongoingTaskResult.$prompt,
+                // <- TODO: [🧠] How to pick everyhing except `pipelineUrl`
+            },
+            result: $ongoingTaskResult.$result || undefined,
+            error: $ongoingTaskResult.$expectError === null ? undefined : serializeError($ongoingTaskResult.$expectError),
+        };
+        $executionReport.promptExecutions.push(executionPromptReport);
+        if (logLlmCall) {
+            logLlmCall({
+                modelName: 'model' /* <- TODO: How to get model name from the report */,
+                report: executionPromptReport,
+            });
+        }
+    }
+    /**
+     * Throws the aggregated retry error after the last regular attempt fails expectations.
+     */
+    function throwIfFinalAttemptFailed(options) {
+        const { attemptIndex, maxAttempts, maxExecutionAttempts, pipelineIdentification, $ongoingTaskResult } = options;
+        if ($ongoingTaskResult.$expectError === null || attemptIndex !== maxAttempts - 1) {
+            return;
+        }
+        throw new PipelineExecutionError(spacetrim.spaceTrim((block) => {
+            var _a;
+            return `
+                LLM execution failed ${maxExecutionAttempts}x
 
-                        ${block(pipelineIdentification)}
+                ${block(pipelineIdentification)}
 
-                        The Prompt:
-                        ${block((((_a = $ongoingTaskResult.$prompt) === null || _a === void 0 ? void 0 : _a.content) || '')
-                    .split(/\r?\n/)
-                    .map((line) => `> ${line}`)
-                    .join('\n'))}
+                The Prompt:
+                ${block(quoteMultilineText(((_a = $ongoingTaskResult.$prompt) === null || _a === void 0 ? void 0 : _a.content) || ''))}
 
-                        All Failed Attempts:
-                        ${block(failuresSummary)}
-                    `;
-                }));
-            }
-        }
+                All Failed Attempts:
+                ${block(createFailuresSummary($ongoingTaskResult.$failedResults))}
+            `;
+        }));
+    }
+    /**
+     * Renders the retry history into the aggregated final error body.
+     */
+    function createFailuresSummary($failedResults) {
+        return $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(quoteMultilineText(((_b = failure.error) === null || _b === void 0 ? void 0 : _b.message) || ''))}
+
+                    Result:
+                    ${block(failure.result === null ? 'null' : quoteMultilineText(spacetrim.spaceTrim(failure.result)))}
+                `;
+        }))
+            .join('\n\n---\n\n');
+    }
+    /**
+     * Formats multiline text as a quoted markdown block.
+     */
+    function quoteMultilineText(text) {
+        return text
+            .split(/\r?\n/)
+            .map((line) => `> ${line}`)
+            .join('\n');
+    }
+    /**
+     * Returns the successful result string or raises an unexpected internal-state error.
+     */
+    function getSuccessfulResultString(options) {
+        const { pipelineIdentification, $ongoingTaskResult } = options;
         if ($ongoingTaskResult.$resultString === null) {
             throw new UnexpectedError(spacetrim.spaceTrim((block) => `
                     Something went wrong and prompt result is null
@@ -6444,7 +6638,6 @@
         }
         return $ongoingTaskResult.$resultString;
     }
-    // TODO: Break into smaller functions
 
     /**
      * Executes a pipeline task that requires mapping or iterating over subvalues of a parameter (such as rows in a CSV).