@promptbook/color 0.100.0-48

package/esm/typings/src/execution/LlmExecutionToolsConstructor.d.ts

@@ -0,0 +1,11 @@
+import type { Registered } from '../utils/$Register';
+import type { TODO_any } from '../utils/organization/TODO_any';
+import type { LlmExecutionTools } from './LlmExecutionTools';
+/**
+ * Type representing a constructor for LLM execution tools, which are used to interact with language models.
+ * Combines registration metadata with a factory function for creating LLM tool instances.
+ */
+export type LlmExecutionToolsConstructor = Registered & ((options: TODO_any) => LlmExecutionTools);
+/**
+ * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
+ */

package/esm/typings/src/execution/PipelineExecutor.d.ts

@@ -0,0 +1,16 @@
+import type { InputParameters } from '../types/typeAliases';
+import type { ExecutionTask } from './ExecutionTask';
+/**
+ * Executor is a simple async function that takes INPUT  PARAMETERs and returns result parameters _(along with all intermediate parameters and INPUT  PARAMETERs = it extends input object)_.
+ * Executor is made by combining execution tools and pipeline collection.
+ *
+ * It can be created with `createPipelineExecutor` function.
+ *
+ * @see https://github.com/webgptorg/promptbook#executor
+ */
+export type PipelineExecutor = {
+    (inputParameters: InputParameters): ExecutionTask;
+};
+/**
+ * TODO: [🧠] Should this file be in /execution or /types folder?
+ */

package/esm/typings/src/execution/PipelineExecutorResult.d.ts

@@ -0,0 +1,39 @@
+import { ReadonlyDeep } from 'type-fest';
+import type { PipelineJson } from '../pipeline/PipelineJson/PipelineJson';
+import type { Parameters } from '../types/typeAliases';
+import type { AbstractTaskResult } from './AbstractTaskResult';
+import type { ExecutionReportJson } from './execution-report/ExecutionReportJson';
+import type { Usage } from './Usage';
+/**
+ * The result of executing a pipeline
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ */
+export type PipelineExecutorResult = AbstractTaskResult & {
+    /**
+     * Result parameters of the execution
+     *
+     * Note: If the execution was not successful, there are only some of the result parameters
+     */
+    readonly outputParameters: Readonly<Parameters>;
+    /**
+     * Added usage of whole execution, detailed usage is available in `executionReport`
+     */
+    readonly usage: ReadonlyDeep<Usage>;
+    /**
+     * The report of the execution with all details
+     *
+     * Note: If the execution fails unexpectedly, this will be `null`
+     */
+    readonly executionReport: ReadonlyDeep<ExecutionReportJson> | null;
+    /**
+     * The prepared pipeline that was used for the execution
+     *
+     * Note: If you called `createPipelineExecutor` with fully prepared pipeline, this is the same object as this pipeline
+     *       If you passed not fully prepared pipeline, this is same pipeline but fully prepared
+     */
+    readonly preparedPipeline: ReadonlyDeep<PipelineJson>;
+};
+/**
+ * TODO: [🧠] Should this file be in /execution or /types folder?
+ */

package/esm/typings/src/execution/PromptResult.d.ts

@@ -0,0 +1,101 @@
+import type { string_date_iso8601 } from '../types/typeAliases';
+import type { string_model_name } from '../types/typeAliases';
+import type { string_prompt } from '../types/typeAliases';
+import type { TODO_object } from '../utils/organization/TODO_object';
+import type { EmbeddingVector } from './EmbeddingVector';
+import type { Usage } from './Usage';
+/**
+ * Prompt result is the simplest concept of execution.
+ * It is the result of executing one prompt _(NOT a template)_.
+ *
+ * @see https://github.com/webgptorg/promptbook#prompt-result
+ */
+export type PromptResult = CompletionPromptResult | ChatPromptResult | EmbeddingPromptResult;
+/**
+ * Completion prompt result
+ *
+ * Note:It contains only the newly generated text NOT the whole completion
+ * Note: [🚉] This is fully serializable as JSON
+ */
+export type CompletionPromptResult = CommonPromptResult;
+/**
+ *Chat prompt result
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ */
+export type ChatPromptResult = CommonPromptResult & {};
+/**
+ * Embedding prompt  result
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ */
+export type EmbeddingPromptResult = Omit<CommonPromptResult, 'content'> & {
+    /**
+     * The response from the model
+     */
+    content: EmbeddingVector;
+};
+/**
+ * Common properties for all prompt results
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ *
+ * @private just abstract the common properties of the prompt results
+ */
+export type CommonPromptResult = {
+    /**
+     * Exact text response from the model
+     */
+    readonly content: string;
+    /**
+     * Name of the model used to generate the response
+     */
+    readonly modelName: string_model_name;
+    /**
+     * Timing
+     */
+    readonly timing: {
+        /**
+         * Start of the execution
+         */
+        readonly start: string_date_iso8601;
+        /**
+         * First token generated
+         */
+        readonly firstToken?: string_date_iso8601;
+        /**
+         * End of the execution
+         */
+        readonly complete: string_date_iso8601;
+    };
+    /**
+     * Usage of the prompt execution
+     */
+    readonly usage: Usage;
+    /**
+     * Exact text of the prompt (with all replacements)
+     *
+     * Note: This contains redundant information
+     */
+    readonly rawPromptContent: string_prompt;
+    /**
+     * Raw request to the model
+     *
+     * Note: This contains redundant information
+     */
+    readonly rawRequest: TODO_object | null;
+    /**
+     * Raw response from the model
+     *
+     * Note: This contains redundant information
+     */
+    readonly rawResponse: TODO_object;
+};
+/**
+ * TODO: [🧠] Maybe timing more accurate then seconds?
+ * TODO: [🧠] Should here be link to the prompt?
+ * TODO: [🧠] Maybe type `rawResponse` properly - not onject but OpenAI.result.whatever
+ * TODO: [🧠] Maybe remove redundant raw.choices.text
+ * TODO: Log raw even if prompt failed - log the raw error
+ * TODO: [🏳] Add `TranslationPromptResult`
+ */

package/esm/typings/src/execution/PromptbookFetch.d.ts

@@ -0,0 +1,12 @@
+import type { string_url } from '../types/typeAliases';
+/**
+ * Fetch function used in Promptbook engine
+ *
+ * In most cases it is just native `fetch` function with a lightweight error handling wrapper
+ * But it can be replaced with any other fetch function, polyfill, custom implementation, security layer, etc.
+ *
+ * It is used in these places:
+ * - Fetching knowledge sources
+ * - Callbacks from remote server
+ */
+export type PromptbookFetch = (url: string_url, init?: RequestInit) => Promise<Response>;

package/esm/typings/src/execution/PromptbookFetch.test-type.d.ts

@@ -0,0 +1,5 @@
+export {};
+/**
+ * Note: [⚪] This should never be in any released package
+ * TODO: Is this a good pattern to do type testing?
+ */

package/esm/typings/src/execution/ScriptExecutionTools.d.ts

@@ -0,0 +1,39 @@
+import type { ScriptLanguage } from '../types/ScriptLanguage';
+import type { Parameters } from '../types/typeAliases';
+import type { string_script } from '../types/typeAliases';
+/**
+ * Represents all the tools needed to execute `SCRIPT` tasks
+ *
+ * @see https://github.com/webgptorg/promptbook#script-execution-tools
+ */
+export type ScriptExecutionTools = {
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+};
+/**
+ * Input for the script execution
+ */
+export type ScriptExecutionToolsExecuteOptions = {
+    /**
+     * Language of the script
+     */
+    readonly scriptLanguage: ScriptLanguage;
+    /**
+     * Parameters for the script
+     * These parameters are passed to the script as variables
+     * For example: { "name": "John" } => const name = "John";
+     */
+    readonly parameters: Parameters;
+    /**
+     * The content of the script to execute
+     * - It can be a single statement
+     * - It can be multiple statements separated by semicolon and return
+     * - It can be a function (but you need to call it)
+     * - It can be IIFE (immediately invoked function expression)
+     * - It can use the parameters as variables and functions from global scope
+     */
+    readonly script: string_script;
+};
+/**
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ * TODO: [🧠][🪐] Should be common things like types, utils in folder containing A,B,C,.. or else outside this listing folder?
+ */

package/esm/typings/src/execution/UncertainNumber.d.ts

@@ -0,0 +1,19 @@
+import type { number_positive } from '../types/typeAliases';
+import type { number_usd } from '../types/typeAliases';
+/**
+ * Number which can be uncertain
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ * Note: If the value is completelly unknown, the value 0 and isUncertain is true
+ * Note: Not using NaN or null because it looses the value which is better to be uncertain then not to be at all
+ */
+export type UncertainNumber = {
+    /**
+     * The numeric value
+     */
+    readonly value: number_usd & (number_positive | 0);
+    /**
+     * Is the value uncertain
+     */
+    readonly isUncertain?: true;
+};

package/esm/typings/src/execution/Usage.d.ts

@@ -0,0 +1,33 @@
+import type { KebabCase } from 'type-fest';
+import type { ExpectationUnit } from '../pipeline/PipelineJson/Expectations';
+import type { UncertainNumber } from './UncertainNumber';
+/**
+ * Usage statistics for one or more prompt results
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ */
+export type Usage = {
+    /**
+     * Cost of the execution in USD
+     *
+     * Note: If the cost is unknown, the value 0 and isUncertain is true
+     */
+    readonly price: UncertainNumber;
+    /**
+     * Number of whatever used in the input aka. `prompt_tokens`
+     */
+    readonly input: UsageCounts;
+    /**
+     * Number of tokens used in the output aka. `completion_tokens`
+     */
+    readonly output: UsageCounts;
+};
+/**
+ * Record of all possible measurable units
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ */
+export type UsageCounts = Record<`${KebabCase<'TOKENS' | ExpectationUnit>}Count`, UncertainNumber>;
+/**
+ * TODO: [🍙] Make some standard order of json properties
+ */

package/esm/typings/src/execution/UserInterfaceTools.d.ts

@@ -0,0 +1,46 @@
+import type { number_integer } from '../types/typeAliases';
+import type { number_positive } from '../types/typeAliases';
+/**
+ * Represents all the tools needed to interact with the user.
+ *
+ * @see https://github.com/webgptorg/promptbook#user-interface-tools
+ */
+export type UserInterfaceTools = {
+    /**
+     * Asks the user to answer a free-text (multi-line) question
+     *
+     * @param options the question to ask
+     * @returns the answer from the user
+     */
+    promptDialog(options: UserInterfaceToolsPromptDialogOptions): Promise<string>;
+};
+export type UserInterfaceToolsPromptDialogOptions = {
+    /**
+     * Prompt title
+     *
+     * Note: This is not a prompt to language model but a prompt to the user
+     * @example "Your name"
+     */
+    readonly promptTitle: string;
+    /**
+     * Prompt message
+     *
+     * Note: This is not a prompt to language model but a prompt to the user
+     * @example "Please enter your name, including your last name, title, etc."
+     */
+    readonly promptMessage: string;
+    /**
+     * Default value for the input/textarea
+     */
+    readonly defaultValue: string | null;
+    /**
+     * Placeholder for the input/textarea
+     */
+    readonly placeholder?: string;
+    /**
+     * Priority of the prompt
+     *
+     * Note: This would be reflected for example into the UI z-index of the prompt modal
+     */
+    readonly priority: number_integer & number_positive;
+};

package/esm/typings/src/execution/assertsTaskSuccessful.d.ts

@@ -0,0 +1,14 @@
+import type { PipelineExecutorResult } from './PipelineExecutorResult';
+/**
+ * Asserts that the execution of a Promptbook is successful
+ *
+ * Note: If there are only warnings, the execution is still successful but the warnings are logged in the console
+ *
+ * @param executionResult - The partial result of the Promptbook execution
+ * @throws {PipelineExecutionError} If the execution is not successful or if multiple errors occurred
+ * @private internal helper function of `asPromise` method of `ExecutionTask`
+ */
+export declare function assertsTaskSuccessful(executionResult: Pick<PipelineExecutorResult, 'isSuccessful' | 'errors' | 'warnings'>): void;
+/**
+ * TODO: [🧠] Can this return type be better typed than void
+ */

package/esm/typings/src/execution/createPipelineExecutor/$OngoingTaskResult.d.ts

@@ -0,0 +1,56 @@
+import { ExpectError } from '../../errors/ExpectError';
+import type { Prompt } from '../../types/Prompt';
+import type { ChatPromptResult } from '../PromptResult';
+import type { CompletionPromptResult } from '../PromptResult';
+import type { EmbeddingPromptResult } from '../PromptResult';
+import type { PromptResult } from '../PromptResult';
+/**
+ * Represents the ongoing result of a pipeline task execution
+ *
+ * Used internally by the pipeline executor to track state during execution attempts
+ *
+ * @private internal utility of `createPipelineExecutor`
+ */
+export type $OngoingTaskResult = {
+    /**
+     * The prompt object used for the current execution attempt, if applicable.
+     */
+    $prompt?: Prompt;
+    /**
+     * The result of a chat model execution, if applicable.
+     */
+    $chatResult?: ChatPromptResult;
+    /**
+     * The result of a completion model execution, if applicable.
+     */
+    $completionResult?: CompletionPromptResult;
+    /**
+     * The result of an embedding model execution, if applicable.
+     * Note: [🤖] Embedding results are less common in standard pipelines.
+     */
+    $embeddingResult?: EmbeddingPromptResult;
+    /**
+     * The final result object for the task, or null if not yet available.
+     */
+    $result: PromptResult | null;
+    /**
+     * The result string produced by the task, or null if not yet available.
+     */
+    $resultString: string | null;
+    /**
+     * The last expectation error encountered, or null if none.
+     */
+    $expectError: ExpectError | null;
+    /**
+     * List of errors encountered during script postprocessing or execution.
+     */
+    $scriptPipelineExecutionErrors: Array<Error>;
+    /**
+     * Array of all failed attempts, storing both the result string and the error for each failure
+     */
+    $failedResults: Array<{
+        attemptIndex: number;
+        result: string | null;
+        error: ExpectError;
+    }>;
+};

package/esm/typings/src/execution/createPipelineExecutor/00-CreatePipelineExecutorOptions.d.ts

@@ -0,0 +1,46 @@
+import type { CsvSettings } from '../../formats/csv/CsvSettings';
+import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
+import type { PrepareAndScrapeOptions } from '../../prepare/PrepareAndScrapeOptions';
+import type { ExecutionTools } from '../ExecutionTools';
+/**
+ * Options for `createPipelineExecutor`
+ */
+export type CreatePipelineExecutorOptions = PrepareAndScrapeOptions & {
+    /**
+     * The pipeline to be executed
+     */
+    readonly pipeline: PipelineJson;
+    /**
+     * The execution tools to be used during the execution of the pipeline
+     */
+    readonly tools: ExecutionTools;
+    /**
+     * When executor does not satisfy expectations it will be retried this amount of times
+     *
+     * @default MAX_EXECUTION_ATTEMPTS
+     */
+    readonly maxExecutionAttempts?: number;
+    /**
+     * Settings for CSV format
+     *
+     * @default DEFAULT_CSV_SETTINGS
+     */
+    readonly csvSettings?: CsvSettings;
+    /**
+     * If you pass fully prepared pipeline, this does not matter
+     *
+     * Otherwise:
+     * If false or not set, warning is shown when pipeline is not prepared
+     * If true, warning is suppressed
+     *
+     * @default false
+     */
+    readonly isNotPreparedWarningSuppressed?: boolean;
+};
+/**
+ * TODO: [🧎][🧠] Move `csvSettings` to some better place
+ *       1) either to some dependency in `ExecutionTools`
+ *       2) or make here container for multiple formats
+ *       3) or make the setting more universal and which just sets things like `delimiter` and `quote` without specifying the format
+ * TODO: [🤹‍♂️] More granular setting for limits of execution + better waiting for queue
+ */

package/esm/typings/src/execution/createPipelineExecutor/00-createPipelineExecutor.d.ts

@@ -0,0 +1,10 @@
+import type { PipelineExecutor } from '../PipelineExecutor';
+import type { CreatePipelineExecutorOptions } from './00-CreatePipelineExecutorOptions';
+/**
+ * Creates executor function from pipeline and execution tools.
+ *
+ * @returns The executor function
+ * @throws {PipelineLogicError} on logical error in the pipeline
+ * @public exported from `@promptbook/core`
+ */
+export declare function createPipelineExecutor(options: CreatePipelineExecutorOptions): PipelineExecutor;

package/esm/typings/src/execution/createPipelineExecutor/10-executePipeline.d.ts

@@ -0,0 +1,48 @@
+import type { PartialDeep, Promisable, ReadonlyDeep } from 'type-fest';
+import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
+import type { InputParameters } from '../../types/typeAliases';
+import type { PipelineExecutorResult } from '../PipelineExecutorResult';
+import type { CreatePipelineExecutorOptions } from './00-CreatePipelineExecutorOptions';
+/**
+ * Options for executing an entire pipeline, including input parameters, pipeline context, and progress callbacks.
+ *
+ * @private internal type of `executePipeline`
+ */
+type ExecutePipelineOptions = Required<CreatePipelineExecutorOptions> & {
+    /**
+     * The input parameters provided by the user for pipeline execution.
+     */
+    readonly inputParameters: Readonly<InputParameters>;
+    /**
+     * Optional callback invoked with partial results as the pipeline execution progresses.
+     */
+    onProgress?(newOngoingResult: PartialDeep<PipelineExecutorResult>): Promisable<void>;
+    /**
+     * The pipeline definition to execute.
+     */
+    readonly pipeline: PipelineJson;
+    /**
+     * The prepared and validated pipeline, ready for execution.
+     */
+    readonly preparedPipeline: ReadonlyDeep<PipelineJson>;
+    /**
+     * Callback to update the prepared pipeline reference after preparation.
+     */
+    setPreparedPipeline(preparedPipeline: ReadonlyDeep<PipelineJson>): void;
+    /**
+     * String identifier for the pipeline, used in error messages and reporting.
+     */
+    readonly pipelineIdentification: string;
+};
+/**
+ * Executes an entire pipeline, resolving tasks in dependency order, handling errors, and reporting progress.
+ *
+ * Note: This is not a `PipelineExecutor` (which is bound to a single pipeline), but a utility function used by `createPipelineExecutor` to create a `PipelineExecutor`.
+ *
+ * @param options - Options for execution, including input parameters, pipeline, and callbacks.
+ * @returns The result of the pipeline execution, including output parameters, errors, and usage statistics.
+ *
+ * @private internal utility of `createPipelineExecutor`
+ */
+export declare function executePipeline(options: ExecutePipelineOptions): Promise<PipelineExecutorResult>;
+export {};

package/esm/typings/src/execution/createPipelineExecutor/20-executeTask.d.ts

@@ -0,0 +1,51 @@
+import type { PartialDeep, Promisable, ReadonlyDeep, WritableDeep } from 'type-fest';
+import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
+import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
+import type { Parameters } from '../../types/typeAliases';
+import type { ExecutionReportJson } from '../execution-report/ExecutionReportJson';
+import type { PipelineExecutorResult } from '../PipelineExecutorResult';
+import type { CreatePipelineExecutorOptions } from './00-CreatePipelineExecutorOptions';
+/**
+ * Options for executing a single pipeline task, including task details, pipeline context, parameters, and callbacks.
+ *
+ * @private internal type of `executeTask`
+ */
+type executeSingleTaskOptions = Required<CreatePipelineExecutorOptions> & {
+    /**
+     * The task to be executed.
+     */
+    readonly currentTask: ReadonlyDeep<TaskJson>;
+    /**
+     * The pipeline in which the task resides, fully prepared and validated.
+     */
+    readonly preparedPipeline: ReadonlyDeep<PipelineJson>;
+    /**
+     * The parameters to pass to the task execution.
+     */
+    readonly parametersToPass: Readonly<Parameters>;
+    /**
+     * Callback invoked with partial results as the execution progresses.
+     */
+    onProgress(newOngoingResult: PartialDeep<PipelineExecutorResult>): Promisable<void>;
+    /**
+     * Mutable execution report object for tracking execution details.
+     */
+    readonly $executionReport: WritableDeep<ExecutionReportJson>;
+    /**
+     * String identifier for the pipeline, used in error messages and reporting.
+     */
+    readonly pipelineIdentification: string;
+};
+/**
+ * Executes a single task within a pipeline, handling parameter validation, error checking, and progress reporting.
+ *
+ * @param options - Options for execution, including the task, pipeline, parameters, and callbacks.
+ * @returns The output parameters produced by the task.
+ *
+ * @private internal utility of `createPipelineExecutor`
+ */
+export declare function executeTask(options: executeSingleTaskOptions): Promise<Readonly<Parameters>>;
+export {};
+/**
+ * TODO: [🤹‍♂️]
+ */

package/esm/typings/src/execution/createPipelineExecutor/30-executeFormatSubvalues.d.ts

@@ -0,0 +1,27 @@
+import type { PartialDeep, Promisable } from 'type-fest';
+import type { TODO_any } from '../../utils/organization/TODO_any';
+import type { PipelineExecutorResult } from '../PipelineExecutorResult';
+import type { ExecuteAttemptsOptions } from './40-executeAttempts';
+/**
+ * Options for executing a pipeline task that involves formatting subvalues (e.g., iterating over CSV rows).
+ * Extends ExecuteAttemptsOptions with a progress callback.
+ *
+ * @private internal type of `executeFormatSubvalues`
+ */
+type ExecuteFormatCellsOptions = ExecuteAttemptsOptions & {
+    /**
+     * Callback invoked with partial results as the execution progresses.
+     */
+    onProgress(newOngoingResult: PartialDeep<PipelineExecutorResult>): Promisable<void>;
+};
+/**
+ * Executes a pipeline task that requires mapping or iterating over subvalues of a parameter (such as rows in a CSV).
+ * Handles format and subformat resolution, error handling, and progress reporting.
+ *
+ * @param options - Options for execution, including task details and progress callback.
+ * @returns The result of the subvalue mapping or execution attempts.
+ *
+ * @private internal utility of `createPipelineExecutor`
+ */
+export declare function executeFormatSubvalues(options: ExecuteFormatCellsOptions): Promise<TODO_any>;
+export {};

package/esm/typings/src/execution/createPipelineExecutor/40-executeAttempts.d.ts

@@ -0,0 +1,75 @@
+import type { PartialDeep, Promisable, ReadonlyDeep, WritableDeep } from 'type-fest';
+import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
+import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
+import type { Parameters } from '../../types/typeAliases';
+import type { string_parameter_name } from '../../types/typeAliases';
+import type { TODO_string } from '../../utils/organization/TODO_string';
+import type { ExecutionReportJson } from '../execution-report/ExecutionReportJson';
+import type { PipelineExecutorResult } from '../PipelineExecutorResult';
+import type { CreatePipelineExecutorOptions } from './00-CreatePipelineExecutorOptions';
+/**
+ * Options for executing attempts of a pipeline task, including configuration for jokers, priority,
+ * maximum attempts, prepared content, parameters, the task itself, the prepared pipeline, execution report,
+ * and pipeline identification. Used internally by the pipeline executor.
+ *
+ * @private internal type of `executeAttempts`
+ */
+export type ExecuteAttemptsOptions = Required<Omit<CreatePipelineExecutorOptions, 'pipeline'>> & {
+    /**
+     * Names of parameters that act as jokers, which can be used to bypass normal execution if their value meets requirements.
+     */
+    readonly jokerParameterNames: Readonly<ReadonlyArray<string_parameter_name>>;
+    /**
+     * Priority of the current execution attempt, used to influence UI or execution order.
+     */
+    readonly priority: number;
+    /**
+     * Maximum number of attempts allowed for this task, including retries and joker attempts.
+     * Note: [💂] There are two distinct variables
+     * 1) `maxExecutionAttempts` - attempts for LLM model
+     * 2) `maxAttempts` - attempts for any task (LLM, SCRIPT, DIALOG, etc.)
+     */
+    readonly maxAttempts: number;
+    /**
+     * The content prepared for execution, with parameters already substituted.
+     */
+    readonly preparedContent: TODO_string;
+    /**
+     * The parameters provided for this execution attempt.
+     */
+    readonly parameters: Readonly<Parameters>;
+    /**
+     * The task being executed, as a deeply immutable TaskJson object.
+     * Note: Naming should be unified between `task` and `currentTask`.
+     */
+    readonly task: ReadonlyDeep<TaskJson>;
+    /**
+     * The pipeline structure prepared for execution, as a deeply immutable PipelineJson object.
+     */
+    readonly preparedPipeline: ReadonlyDeep<PipelineJson>;
+    /**
+     * Callback invoked with partial results as the execution progresses.
+     */
+    onProgress(newOngoingResult: PartialDeep<PipelineExecutorResult>): Promisable<void>;
+    /**
+     * The execution report object, which is updated during execution.
+     */
+    readonly $executionReport: WritableDeep<ExecutionReportJson>;
+    /**
+     * String identifier for the pipeline, used for logging and error reporting.
+     */
+    readonly pipelineIdentification: string;
+};
+/**
+ * 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.
+ * Throws errors if execution fails after all attempts.
+ *
+ * @param options - The options for execution, including task, parameters, pipeline, and configuration.
+ * @returns The result string of the executed task.
+ * @private internal utility of `createPipelineExecutor`
+ */
+export declare function executeAttempts(options: ExecuteAttemptsOptions): Promise<TODO_string>;
+/**
+ * TODO: Break into smaller functions
+ */