@promptbook/markitdown 0.112.0-39 → 0.112.0-41

package/esm/index.es.js

@@ -24,7 +24,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -6115,317 +6115,511 @@ function validatePromptResult(options) {
  * @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$1((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$1((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$1((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$1((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$1((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$1((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$1((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$1((block) => `
-                                                Unknown model variant "${task.modelRequirements.modelVariant}"
-
-                                                ${block(pipelineIdentification)}
-
-                                            `));
-                            }
-                        }
-                        break;
-                    case 'SCRIPT_TASK':
-                        if (arrayableToArray(tools.script).length === 0) {
-                            throw new PipelineExecutionError(spaceTrim$1((block) => `
-                                        No script execution tools are available
+                        This should be catched during parsing
 
-                                        ${block(pipelineIdentification)}
-                                    `));
-                        }
-                        if (!task.contentLanguage) {
-                            throw new PipelineExecutionError(spaceTrim$1((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$1((block) => `
-                                        Script execution failed ${$ongoingTaskResult.$scriptPipelineExecutionErrors.length}x
+                    `));
+        // <- case [🤖]:
+        default:
+            throw new PipelineExecutionError(spaceTrim$1((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$1((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$1((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$1((block) => `
-                                    Unknown execution type "${task.taskType}"
+                    ${block(pipelineIdentification)}
+                `));
+    }
+    if (!task.contentLanguage) {
+        throw new PipelineExecutionError(spaceTrim$1((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$1((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$1((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$1((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$1(failure.result)
-                        .split(/\r?\n/)
-                        .map((line) => `> ${line}`)
-                        .join('\n'))}
-                        `;
-            }))
-                .join('\n\n---\n\n');
-            throw new PipelineExecutionError(spaceTrim$1((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$1((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$1((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$1(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$1((block) => `
                     Something went wrong and prompt result is null
@@ -6435,7 +6629,6 @@ async function executeAttempts(options) {
     }
     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).