@promptbook/cli 0.41.109

package/esm/typings/execution/translation/automatic-translate/automatic-translators/FakeAutomaticTranslator.d.ts

@@ -0,0 +1,5 @@
+import { AutomaticTranslator } from './AutomaticTranslator';
+export declare class FakeAutomaticTranslator implements AutomaticTranslator {
+    constructor();
+    translate(message: string): string;
+}

package/esm/typings/execution/translation/automatic-translate/automatic-translators/LindatAutomaticTranslator.d.ts

@@ -0,0 +1,11 @@
+import { AutomaticTranslator } from './AutomaticTranslator';
+import { TranslatorOptions } from './TranslatorOptions';
+interface LindatAutomaticTranslatorOptions extends TranslatorOptions {
+    apiUrl: URL;
+}
+export declare class LindatAutomaticTranslator implements AutomaticTranslator {
+    private readonly options;
+    constructor(options: LindatAutomaticTranslatorOptions);
+    translate(message: string): Promise<string>;
+}
+export {};

package/esm/typings/execution/translation/automatic-translate/automatic-translators/TranslatorOptions.d.ts

@@ -0,0 +1,4 @@
+export type TranslatorOptions = {
+    from: string;
+    to: string;
+};

package/esm/typings/execution/translation/automatic-translate/automatic-translators/utils/extractMultiplicatedOccurrence.d.ts

@@ -0,0 +1 @@
+export declare function extractMultiplicatedOccurrence(message: string): string;

package/esm/typings/execution/translation/automatic-translate/automatic-translators/utils/extractMultiplicatedOccurrence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/typings/execution/translation/automatic-translate/translateMessages.d.ts

@@ -0,0 +1,5 @@
+import { AutomaticTranslator } from './automatic-translators/AutomaticTranslator';
+import { TranslatorOptions } from './automatic-translators/TranslatorOptions';
+export declare function translateMessages({ automaticTranslator, from, to, }: {
+    automaticTranslator: AutomaticTranslator;
+} & TranslatorOptions): Promise<void>;

package/esm/typings/execution/utils/replaceParameters.d.ts

@@ -0,0 +1,12 @@
+import { Parameters } from '../../types/Parameters';
+import { string_template } from '../../types/typeAliases';
+/**
+ * Replaces parameters in template with values from parameters object
+ *
+ * @param template the template with parameters in {curly} braces
+ * @param parameters the object with parameters
+ * @returns the template with replaced parameters
+ *
+ * @private within the createPromptbookExecutor
+ */
+export declare function replaceParameters(template: string_template, parameters: Parameters): string;

package/esm/typings/execution/utils/replaceParameters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/typings/library/PromptbookLibrary.d.ts

@@ -0,0 +1,25 @@
+import { Promisable } from 'type-fest';
+import type { Prompt } from '../types/Prompt';
+import type { PromptbookJson } from '../types/PromptbookJson/PromptbookJson';
+import type { string_promptbook_url } from '../types/typeAliases';
+/**
+ * Library of promptbooks that groups together promptbooks for an application.
+ *
+ * @see https://github.com/webgptorg/promptbook#promptbook-library
+ */
+export type PromptbookLibrary = {
+    /**
+     * Gets all promptbooks in the library
+     */
+    listPromptbooks(): Promisable<Array<string_promptbook_url>>;
+    /**
+     * Gets promptbook by its URL
+     *
+     * Note: This is not a direct fetching from the URL, but a lookup in the library
+     */
+    getPromptbookByUrl(url: string_promptbook_url): Promisable<PromptbookJson>;
+    /**
+     * Checks whether given prompt was defined in any promptbook in the library
+     */
+    isResponsibleForPrompt(prompt: Prompt): Promisable<boolean>;
+};

package/esm/typings/library/SimplePromptbookLibrary.d.ts

@@ -0,0 +1,35 @@
+import type { Prompt } from '../types/Prompt';
+import type { PromptbookJson } from '../types/PromptbookJson/PromptbookJson';
+import type { string_promptbook_url } from '../types/typeAliases';
+import { PromptbookLibrary } from './PromptbookLibrary';
+/**
+ * Library of promptbooks that groups together promptbooks for an application.
+ * This implementation is a very thin wrapper around the Array / Map of promptbooks.
+ *
+ * @see https://github.com/webgptorg/promptbook#promptbook-library
+ */
+export declare class SimplePromptbookLibrary implements PromptbookLibrary {
+    private library;
+    /**!!!
+     *
+     * @param promptbooks !!!
+     *
+     * Note: During the construction logic of all promptbooks are validated
+     * Note: It is not recommended to use this constructor directly, use `createPromptbookLibraryFromSources` *(or other variant)* instead
+     */
+    constructor(...promptbooks: Array<PromptbookJson>);
+    /**
+     * Gets all promptbooks in the library
+     */
+    listPromptbooks(): Array<string_promptbook_url>;
+    /**
+     * Gets promptbook by its URL
+     *
+     * Note: This is not a direct fetching from the URL, but a lookup in the library
+     */
+    getPromptbookByUrl(url: string_promptbook_url): PromptbookJson;
+    /**
+     * Checks whether given prompt was defined in any promptbook in the library
+     */
+    isResponsibleForPrompt(prompt: Prompt): boolean;
+}

package/esm/typings/library/constructors/createPromptbookLibraryFromDirectory.d.ts

@@ -0,0 +1,5 @@
+import { PromptbookLibrary } from '../PromptbookLibrary';
+export declare function createPromptbookLibraryFromDirectory(): PromptbookLibrary;
+/***
+ * TODO: !!! Annotate all + all to README and samples
+ */

package/esm/typings/library/constructors/createPromptbookLibraryFromList.d.ts

@@ -0,0 +1,5 @@
+import { PromptbookLibrary } from '../PromptbookLibrary';
+export declare function createPromptbookLibraryFromList(): PromptbookLibrary;
+/***
+ * TODO: !!! Annotate all + all to README and samples
+ */

package/esm/typings/library/constructors/createPromptbookLibraryFromPromise.d.ts

@@ -0,0 +1,7 @@
+import type { PromptbookJson } from '../../types/PromptbookJson/PromptbookJson';
+import { PromptbookString } from '../../types/PromptbookString';
+import { PromptbookLibrary } from '../PromptbookLibrary';
+export declare function createPromptbookLibraryFromPromise(promptbookSourcesPromiseOrFactory: Promise<Array<PromptbookJson | PromptbookString>> | (() => Promise<Array<PromptbookJson | PromptbookString>>)): PromptbookLibrary;
+/***
+ * TODO: !!! Annotate all + all to README and samples
+ */

package/esm/typings/library/constructors/createPromptbookLibraryFromSources.d.ts

@@ -0,0 +1,16 @@
+import { PromptbookJson, PromptbookString } from '../../_packages/types.index';
+import { SimplePromptbookLibrary } from '../SimplePromptbookLibrary';
+export declare function createPromptbookLibraryFromSources(...promptbookSources: Array<PromptbookJson | PromptbookString>): SimplePromptbookLibrary;
+/**
+ * Constructs Promptbook from any sources
+ *
+ * Note: During the construction syntax and logic of all sources are validated
+ * Note: You can combine .ptbk.md and .ptbk.json files BUT it is not recommended
+ *
+ * @param promptbookSources contents of .ptbk.md or .ptbk.json files
+ * @param settings settings for creating executor functions
+ * @returns PromptbookLibrary
+ */
+/***
+ * TODO: !!! Annotate all + all to README and samples
+ */

package/esm/typings/library/constructors/createPromptbookSublibrary.d.ts

@@ -0,0 +1,6 @@
+import type { string_promptbook_url } from '../../types/typeAliases';
+import { PromptbookLibrary } from '../PromptbookLibrary';
+export declare function createPromptbookSublibrary(library: PromptbookLibrary, predicate: (url: string_promptbook_url) => boolean): PromptbookLibrary;
+/***
+ * TODO: !!! Annotate all + all to README and samples
+ */

package/esm/typings/types/Command.d.ts

@@ -0,0 +1,98 @@
+import type { string_markdown_text, string_name, string_version } from '.././types/typeAliases';
+import type { ExecutionType } from './ExecutionTypes';
+import type { ModelRequirements } from './ModelRequirements';
+import type { ExpectationAmount, ExpectationUnit } from './PromptbookJson/PromptTemplateJson';
+/**
+ * Command is one piece of the prompt template which adds some logic to the prompt template or the whole pipeline.
+ * It is parsed from the markdown from ul/ol items - one command per one item.
+ */
+export type Command = PromptbookUrlCommand | PromptbookVersionCommand | ExecuteCommand | ModelCommand | JokerCommand | ParameterCommand | PostprocessCommand | ExpectCommand;
+/**
+ * PromptbookVersion command tells which version is .promptbook file using
+ *
+ * - It is used for backward compatibility
+ * - It is defined per whole .promptbook file in the header
+ */
+export type PromptbookUrlCommand = {
+    readonly type: 'PROMPTBOOK_URL';
+    readonly promptbookUrl: URL;
+};
+/**
+ * PromptbookVersion command tells which version is .promptbook file using
+ *
+ * - It is used for backward compatibility
+ * - It is defined per whole .promptbook file in the header
+ */
+export type PromptbookVersionCommand = {
+    readonly type: 'PROMPTBOOK_VERSION';
+    readonly promptbookVersion: string_version;
+};
+/**
+ * Execute command tells how to execute the section
+ * It can be either prompt template, script or SIMPLE TEMPLATE etc.
+ */
+export type ExecuteCommand = {
+    readonly type: 'EXECUTE';
+    readonly executionType: ExecutionType;
+};
+/**
+ * Model command tells which model and modelRequirements to use for the prompt template. execution
+ */
+export type ModelCommand = {
+    readonly type: 'MODEL';
+    readonly key: keyof ModelRequirements;
+    readonly value: any;
+};
+/**
+ * Joker parameter is used instead of executing the prompt template if it meet the expectations requirements
+ */
+export type JokerCommand = {
+    readonly type: 'JOKER';
+    readonly parameterName: string_name;
+};
+/**
+ * Parameter command describes one parameter of the prompt template
+ *
+ * - It can tell if it is input or OUTPUT PARAMETER
+ * - It can have description
+ * - In description it can have simple formatting BUT not markdown structure or reference to other parameters
+ */
+export type ParameterCommand = {
+    readonly type: 'PARAMETER';
+    readonly isInput: boolean;
+    readonly isOutput: boolean;
+    readonly parameterName: string_name;
+    readonly parameterDescription: string_markdown_text | null;
+};
+/**
+ * Postprocess command describes which function to use for postprocessing
+ * This will be created as separate EXECUTE SCRIPT block bellow
+ */
+export type PostprocessCommand = {
+    readonly type: 'POSTPROCESS';
+    readonly functionName: string_name;
+};
+/**
+ * Expect command describes the desired output of the prompt template (after post-processing)
+ * It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.
+ */
+export type ExpectCommand = ExpectAmountCommand | ExpectFormatCommand;
+/**
+ * Expect amount command describes the desired output of the prompt template (after post-processing)
+ * It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs,...
+ *
+ * Note: LLMs work with tokens, not characters, but in Promptbooks we want to use some human-recognisable and cross-model interoperable units.
+ */
+export type ExpectAmountCommand = {
+    readonly type: 'EXPECT_AMOUNT';
+    readonly sign: 'EXACTLY' | 'MINIMUM' | 'MAXIMUM';
+    readonly unit: ExpectationUnit;
+    readonly amount: ExpectationAmount;
+};
+/**
+ * Represents a command that expects a specific format.
+ */
+export type ExpectFormatCommand = {
+    readonly type: 'EXPECT_FORMAT';
+    readonly format: 'JSON';
+};

package/esm/typings/types/ExecutionTypes.d.ts

@@ -0,0 +1,13 @@
+import { TupleToUnion } from 'type-fest';
+/**
+ * Execution type describes the way how the block is executed
+ *
+ * @see https://github.com/webgptorg/promptbook#execution-type
+ */
+export type ExecutionType = TupleToUnion<typeof ExecutionTypes>;
+/**
+ * Execution type describes the way how the block is executed
+ *
+ * @see https://github.com/webgptorg/promptbook#execution-type
+ */
+export declare const ExecutionTypes: readonly ["PROMPT_TEMPLATE", "SIMPLE_TEMPLATE", "SCRIPT", "PROMPT_DIALOG"];

package/esm/typings/types/ModelRequirements.d.ts

@@ -0,0 +1,41 @@
+import { string_model_name } from './typeAliases';
+export declare const MODEL_VARIANTS: readonly ["COMPLETION", "CHAT"];
+/**
+ * Model variant describes the very general type of the model
+ *
+ * There are two variants:
+ * - **COMPLETION** - model that takes prompt and writes the rest of the text
+ * - **CHAT** - model that takes prompt and previous messages and returns response
+ */
+export type ModelVariant = typeof MODEL_VARIANTS[number];
+/**
+ * Abstract way to specify the LLM. It does not specify the LLM with concrete version itself, only the requirements for the LLM.
+ *
+ * @see https://github.com/webgptorg/promptbook#model-requirements
+ */
+export type ModelRequirements = {
+    /**
+     * Model variant describes the very general type of the model
+     *
+     * There are two variants:
+     * - **COMPLETION** - model that takes prompt and writes the rest of the text
+     * - **CHAT** - model that takes prompt and previous messages and returns response
+     */
+    readonly modelVariant: ModelVariant;
+    /**
+     * The model for text prompt
+     *
+     * Note: Model must be compatible with the model variant
+     *
+     * @example 'gpt-4', 'gpt-4-32k-0314', 'gpt-3.5-turbo-instruct',...
+     */
+    readonly modelName: string_model_name;
+    /**
+     * Maximum number of tokens that can be generated by the model
+     */
+    readonly maxTokens?: number;
+};
+/**
+ * TODO: Maybe figure out better word than "variant"
+ * TODO: Add here more requirement options like max context size, max tokens, etc.
+ */

package/esm/typings/types/Parameters.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parameters of the prompt template (pipeline)
+ *
+ * There are three types of parameters:
+ * - **INPUT PARAMETERs** are required to execute the pipeline.
+ * - **Intermediate parameters** are used internally in the pipeline.
+ * - **OUTPUT PARAMETERs** are not used internally in the pipeline, but are returned as the result of the pipeline execution.
+ *
+ * @see https://github.com/webgptorg/promptbook#parameters
+ */
+export type Parameters = object;
+/**
+ * TODO: Constrain type to Simple key-value object, only string keys and string values and no index signature + only camelCase keys and spaceTrimmed values
+ */

package/esm/typings/types/Prompt.d.ts

@@ -0,0 +1,41 @@
+import type { string_name, string_prompt, string_promptbook_url_with_hashtemplate, string_title } from '.././types/typeAliases';
+import type { ModelRequirements } from './ModelRequirements';
+/**
+ * Prompt in a text along with model requirements, but without any execution or templating logic.
+ *
+ * @see https://github.com/webgptorg/promptbook#prompt
+ */
+export type Prompt = {
+    /**
+     * The title of the prompt
+     *
+     * Note: This has no effect on the model, it is just for the reporting
+     */
+    readonly title: string_title;
+    /**
+     * The text of the prompt
+     *
+     * Note: This is not a template, this is exactly the text that will be sent to the model
+     * @example "What is the capital of France?"
+     */
+    readonly content: string_prompt;
+    /**
+     * Requirements for the model
+     */
+    readonly modelRequirements: ModelRequirements;
+    /**
+     * Unique identifier of the promptbook with specific template name as hash
+     *
+     * @example https://promptbook.webgpt.com/cs/write-website-content.ptbk.md@v2.4.15#keywords
+     */
+    readonly promptbookUrl: string_promptbook_url_with_hashtemplate;
+    /**
+     * Parameters used in the prompt
+     *
+     * Note: This is redundant (same information is in promptbookUrl+content) but useful for logging and debugging
+     */
+    readonly parameters: Record<string_name, string>;
+};
+/**
+ * TODO: [✔] Check ModelRequirements in runtime
+ */

package/esm/typings/types/PromptbookJson/PromptTemplateJson.d.ts

@@ -0,0 +1,126 @@
+import { ExpectFormatCommand } from '../Command';
+import { ExecutionType } from '../ExecutionTypes';
+import { ModelRequirements } from '../ModelRequirements';
+import { ScriptLanguage } from '../ScriptLanguage';
+import { number_integer, number_positive_or_zero, string_javascript, string_javascript_name, string_markdown, string_name, string_prompt, string_template } from '../typeAliases';
+/**
+ * Describes one prompt template in the promptbook
+ */
+export type PromptTemplateJson = NaturalTemplateJson | SimpleTemplateJson | ScriptTemplateJson | PromptDialogJson;
+/**
+ * Template for prompt to LLM
+ */
+export type NaturalTemplateJson = PromptTemplateJsonCommon & {
+    readonly executionType: 'PROMPT_TEMPLATE';
+    /**
+     * Requirements for the model
+     * - This is required only for executionType PROMPT_TEMPLATE
+     */
+    readonly modelRequirements: ModelRequirements;
+};
+/**
+ * Units of text measurement
+ */
+export declare const EXPECTATION_UNITS: readonly ["CHARACTERS", "WORDS", "SENTENCES", "PARAGRAPHS", "LINES", "PAGES"];
+/**
+ * Unit of text measurement
+ */
+export type ExpectationUnit = typeof EXPECTATION_UNITS[number];
+/**
+ * Amount of text measurement
+ */
+export type ExpectationAmount = number_integer & number_positive_or_zero;
+/**
+ * Template for simple concatenation of strings
+ */
+interface SimpleTemplateJson extends PromptTemplateJsonCommon {
+    readonly executionType: 'SIMPLE_TEMPLATE';
+}
+/**
+ * Template for script execution
+ */
+interface ScriptTemplateJson extends PromptTemplateJsonCommon {
+    readonly executionType: 'SCRIPT';
+    /**
+     * Language of the script
+     * - This is required only for executionType SCRIPT
+     *
+     */
+    readonly contentLanguage?: ScriptLanguage;
+}
+/**
+ * Template for prompt to user
+ */
+interface PromptDialogJson extends PromptTemplateJsonCommon {
+    readonly executionType: 'PROMPT_DIALOG';
+}
+/**
+ * Common properties of all prompt templates
+ */
+interface PromptTemplateJsonCommon {
+    /**
+     * Name of the template
+     * - It must be unique across the pipeline
+     * - It should start uppercase and contain letters and numbers
+     * - The promptbookUrl together with hash and name are used to identify the prompt template in the pipeline
+     */
+    readonly name: string_name;
+    /**
+     * Title of the prompt template
+     * It can use simple markdown formatting like **bold**, *italic*, [link](https://example.com), ... BUT not code blocks and structure
+     */
+    readonly title: string;
+    /**
+     * Description of the prompt template
+     * It can use multiple paragraphs of simple markdown formatting like **bold**, *italic*, [link](https://example.com), ... BUT not code blocks and structure
+     */
+    readonly description?: string;
+    /**
+     * List of parameter names that are used in the prompt template and must be defined before the prompt template is executed
+     *
+     * Note: Joker is one of the dependent parameters
+     */
+    readonly dependentParameterNames: Array<string_name>;
+    /**
+     * If theese parameters meet the expectations requirements, they are used instead of executing this prompt template
+     */
+    readonly jokers?: Array<string>;
+    /**
+     * Type of the execution
+     * This determines if the prompt template is send to LLM, user or some scripting evaluation
+     */
+    readonly executionType: ExecutionType;
+    /**
+     * Content of the template with {placeholders} for parameters
+     */
+    readonly content: (string_prompt | string_javascript | string_markdown) & string_template;
+    /**
+     * List of postprocessing steps that are executed after the prompt template
+     */
+    readonly postprocessing?: Array<string_javascript_name>;
+    /**
+     * Expect this amount of each unit in the answer
+     *
+     * For example 5 words, 3 sentences, 2 paragraphs, ...
+     *
+     * Note: Expectations are performed after all postprocessing steps
+     */
+    readonly expectAmount?: Partial<Record<Lowercase<ExpectationUnit>, {
+        min?: ExpectationAmount;
+        max?: ExpectationAmount;
+    }>>;
+    /**
+     * Expect this format of the answer
+     *
+     * Note: Expectations are performed after all postprocessing steps
+     */
+    readonly expectFormat?: ExpectFormatCommand['format'];
+    /**
+     * Name of the parameter that is the result of the prompt template
+     */
+    readonly resultingParameterName: string_name;
+}
+export {};
+/**
+ * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
+ */

package/esm/typings/types/PromptbookJson/PromptTemplateParameterJson.d.ts

@@ -0,0 +1,25 @@
+import { string_name } from '../typeAliases';
+/**
+ * Describes one parameter of the promptbook
+ */
+export type PromptTemplateParameterJson = {
+    /**
+     * Name of the parameter
+     * - It must be unique across the pipeline
+     * - It should start lowercase and contain letters and numbers
+     */
+    readonly name: string_name;
+    /**
+     * The parameter is input of the pipeline
+     */
+    readonly isInput: boolean;
+    /**
+     * The parameter is output of the pipeline
+     */
+    readonly isOutput: boolean;
+    /**
+     * Description of the parameter
+     * - It can use simple markdown formatting like **bold**, *italic*, [link](https://example.com), ... BUT not code blocks and structure
+     */
+    readonly description?: string;
+};

package/esm/typings/types/PromptbookJson/PromptbookJson.d.ts

@@ -0,0 +1,51 @@
+import { string_promptbook_url, string_version } from '../typeAliases';
+import { PromptTemplateJson } from './PromptTemplateJson';
+import { PromptTemplateParameterJson } from './PromptTemplateParameterJson';
+/**
+ * Promptbook is the **core concept of this library**.
+ * It represents a series of prompt templates chained together to form a pipeline / one big prompt template with input and result parameters.
+ *
+ * @see https://github.com/webgptorg/promptbook#promptbook
+ */
+export type PromptbookJson = {
+    /**
+     * Unique identifier of the promptbook
+     *
+     * Note: It must be unique across all promptbooks libraries
+     * Note: It must use HTTPs URL
+     * Tip: You can do versioning in the URL
+     *      For example: https://promptbook.webgpt.com/cs/write-website-content.ptbk.md@1.0.0
+     * Warning: Do not hash part of the URL, hash part is used for identification of the prompt template in the pipeline
+     */
+    readonly promptbookUrl?: string_promptbook_url;
+    /**
+     * Title of the promptbook
+     * -It can use simple markdown formatting like **bold**, *italic*, [link](https://example.com), ... BUT not code blocks and structure
+     */
+    readonly title: string;
+    /**
+     * Version of the .ptbk.json file
+     */
+    readonly promptbookVersion: string_version;
+    /**
+     * Description of the promptbook
+     * It can use multiple paragraphs of simple markdown formatting like **bold**, *italic*, [link](https://example.com), ... BUT not code blocks and structure
+     */
+    readonly description?: string;
+    /**
+     * Set of variables that are used across the pipeline
+     */
+    readonly parameters: Array<PromptTemplateParameterJson>;
+    /**
+     * Sequence of prompt templates that are chained together to form a pipeline
+     */
+    readonly promptTemplates: Array<PromptTemplateJson>;
+};
+/**
+ * TODO: [🧠] Best format of this code?
+ *             There must be possible to make
+ *             - Branching
+ *             - Loops
+ *             - Paralelization
+ *             - ...and more
+ */

package/esm/typings/types/PromptbookString.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Promptbook is the **core concept of this library**.
+ * It represents a series of prompt templates chained together to form a pipeline / one big prompt template with input and result parameters.
+ *
+ * @see https://github.com/webgptorg/promptbook#promptbook
+ */
+export type PromptbookString = string & {
+    readonly _type: 'Promptbook';
+};
+/**
+ * TODO: !! Better validation (validatePromptbookString) or remove branded type and make it just string
+ */

package/esm/typings/types/ScriptLanguage.d.ts

@@ -0,0 +1,9 @@
+import { TupleToUnion } from 'type-fest';
+/**
+ * Supported script languages
+ */
+export declare const SUPPORTED_SCRIPT_LANGUAGES: readonly ["javascript", "typescript", "python"];
+/**
+ * Script language
+ */
+export type ScriptLanguage = TupleToUnion<typeof SUPPORTED_SCRIPT_LANGUAGES>;

package/esm/typings/types/TaskProgress.d.ts

@@ -0,0 +1,42 @@
+import { ExecutionType } from './ExecutionTypes';
+import { string_markdown_text, string_name } from './typeAliases';
+/**
+ * TaskProgress represents the progress of a Promptbook execution.
+ */
+export type TaskProgress = {
+    /**
+     * The unique name of the task.
+     *
+     * Note: This is not supposed to be displayed to the user.
+     *       It is used to identify the task in the code, for example as react key
+     */
+    readonly name: string_name;
+    /**
+     * Title of the task.
+     *
+     * Note: This is supposed to be displayed to the user.
+     * Note: This is trimmed and stripped of HTML tags and emojis
+     */
+    readonly title: string_markdown_text;
+    /**
+     * Does the task started?
+     */
+    readonly isStarted: boolean;
+    /**
+     * Is task done?
+     */
+    readonly isDone: boolean;
+    /**
+     * The type of the execution.
+     * Note: The Promptbook library reports everything, in the app level you can filter out the execution types that you don't want to show to the user.
+     */
+    readonly executionType: ExecutionType;
+    /**
+     * The parameter name that is being processed.
+     */
+    readonly parameterName: string_name;
+    /**
+     * The parameter value or null if the parameter is not yet processed.
+     */
+    readonly parameterValue: string | null;
+};