@promptbook/azure-openai 0.52.0-1

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

@@ -0,0 +1,36 @@
+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;
+    /**
+     * Constructs a promptbook library from promptbooks
+     *
+     * @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/umd/typings/library/constructors/createPromptbookLibraryFromDirectory.d.ts

@@ -0,0 +1,14 @@
+import { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Constructs Promptbook from given directory
+ *
+ * Note: Works only in Node.js environment because it reads the file system
+ * Note: The function does NOT return promise it returns the library directly which dynamically loads promptbooks when needed
+ *       SO during the construction syntax and logic sources IS NOT validated
+ *
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookLibraryFromDirectory(): PromptbookLibrary;
+/***
+ * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
+ */

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

@@ -0,0 +1,26 @@
+import type { PromptbookJson } from '../../types/PromptbookJson/PromptbookJson';
+import { PromptbookString } from '../../types/PromptbookString';
+import { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Constructs Promptbook from async sources
+ * It can be one of the following:
+ * - Promise of array of PromptbookJson or PromptbookString
+ * - Factory function that returns Promise of array of PromptbookJson or PromptbookString
+ *
+ * Note: This is useful as internal tool for other constructor functions like
+ *       `createPromptbookLibraryFromUrl` or `createPromptbookLibraryFromDirectory`
+ *       Consider using those functions instead of this one
+ *
+ * Note: The function does NOT return promise it returns the library directly which waits for the sources to be resolved
+ *       when error occurs in given promise or factory function, it is thrown during `listPromptbooks` or `getPromptbookByUrl` call
+ *
+ *
+ * @param promptbookSourcesPromiseOrFactory
+ * @returns PromptbookLibrary
+ *
+ * @deprecated Consider using `createPromptbookLibraryFromUrl` or `createPromptbookLibraryFromDirectory`
+ */
+export declare function createPromptbookLibraryFromPromise(promptbookSourcesPromiseOrFactory: Promise<Array<PromptbookJson | PromptbookString>> | (() => Promise<Array<PromptbookJson | PromptbookString>>)): PromptbookLibrary;
+/***
+ * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
+ */

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

@@ -0,0 +1,15 @@
+import { PromptbookJson, PromptbookString } from '../../_packages/types.index';
+import { SimplePromptbookLibrary } from '../SimplePromptbookLibrary';
+/**
+ * Creates PromptbookLibrary from array of PromptbookJson or PromptbookString
+ *
+ * Note: You can combine `PromptbookString` (`.ptbk.md`) with `PromptbookJson` BUT it is not recommended
+ * Note: During the construction syntax and logic of all sources are validated
+ *
+ * @param promptbookSources
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookLibraryFromSources(...promptbookSources: Array<PromptbookJson | PromptbookString>): SimplePromptbookLibrary;
+/***
+ * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
+ */

package/umd/typings/library/constructors/createPromptbookLibraryFromUrl.d.ts

@@ -0,0 +1,13 @@
+import { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Constructs Promptbook from remote Promptbase URL
+ *
+ * Note: The function does NOT return promise it returns the library directly which dynamically loads promptbooks when needed
+ *       SO during the construction syntax and logic sources IS NOT validated
+ *
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookLibraryFromUrl(): PromptbookLibrary;
+/***
+ * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
+ */

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

@@ -0,0 +1,15 @@
+import type { string_promptbook_url } from '../../types/typeAliases';
+import { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Creates PromptbookLibrary as a subset of another PromptbookLibrary
+ *
+ * Note: You can use any type of library as a parent library - local, remote, etc.
+ * Note: This is just a thin wrapper / proxy around the parent library
+ *
+ * @param promptbookSources
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookSublibrary(library: PromptbookLibrary, predicate: (url: string_promptbook_url) => boolean): PromptbookLibrary;
+/***
+ * TODO: [🍓][🚯] !!! Add to README and samples + maybe make `@promptbook/library` package
+ */

package/umd/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/umd/typings/types/ExecutionTypes.d.ts

@@ -0,0 +1,13 @@
+import type { 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/umd/typings/types/ModelRequirements.d.ts

@@ -0,0 +1,43 @@
+import type { 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
+     * Note: If not specified, the best model for the variant will be used
+     *
+     * @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.
+ * TODO: [👙][🧠] Just selecting gpt3 or gpt4 level of model
+ */

package/umd/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/umd/typings/types/Prompt.d.ts

@@ -0,0 +1,54 @@
+import type { string_name, string_prompt, string_promptbook_url_with_hashtemplate, string_title } from '.././types/typeAliases';
+import type { PostprocessingFunction } from '../execution/plugins/script-execution-tools/javascript/JavascriptExecutionToolsOptions';
+import type { ModelRequirements } from './ModelRequirements';
+import type { Expectations } from './PromptbookJson/PromptTemplateJson';
+/**
+ * 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;
+    /**
+     * List of postprocessing steps that are executed after the prompt
+     */
+    readonly postprocessing?: Array<PostprocessingFunction>;
+    /**
+     * Expectations for the answer
+     *
+     * For example 5 words, 3 sentences, 2 paragraphs, ...
+     * If not set, nothing is expected from the answer
+     */
+    readonly expectations?: Expectations;
+    /**
+     * 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/umd/typings/types/PromptbookJson/PromptTemplateJson.d.ts

@@ -0,0 +1,137 @@
+import type { ExpectFormatCommand } from '../Command';
+import type { ExecutionType } from '../ExecutionTypes';
+import type { ModelRequirements } from '../ModelRequirements';
+import type { ScriptLanguage } from '../ScriptLanguage';
+import type { 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 = LlmTemplateJson | SimpleTemplateJson | ScriptJson | PromptDialogJson;
+/**
+ * Template for prompt to LLM
+ */
+export type LlmTemplateJson = PromptTemplateJsonCommon & {
+    readonly executionType: 'PROMPT_TEMPLATE';
+    /**
+     * Requirements for the model
+     * - This is required only for executionType PROMPT_TEMPLATE
+     */
+    readonly modelRequirements: ModelRequirements;
+};
+/**
+ * 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
+ */
+export type Expectations = Partial<Record<Lowercase<ExpectationUnit>, {
+    min?: ExpectationAmount;
+    max?: ExpectationAmount;
+}>>;
+/**
+ * Units of text measurement
+ */
+export declare const EXPECTATION_UNITS: readonly ["CHARACTERS", "WORDS", "SENTENCES", "LINES", "PARAGRAPHS", "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
+ */
+export interface SimpleTemplateJson extends PromptTemplateJsonCommon {
+    readonly executionType: 'SIMPLE_TEMPLATE';
+}
+/**
+ * Template for script execution
+ */
+export interface ScriptJson extends PromptTemplateJsonCommon {
+    readonly executionType: 'SCRIPT';
+    /**
+     * Language of the script
+     * - This is required only for executionType SCRIPT
+     *
+     */
+    readonly contentLanguage?: ScriptLanguage;
+}
+/**
+ * Template for prompt to user
+ */
+export 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 expectations?: Expectations;
+    /**
+     * Expect this format of the answer
+     *
+     * Note: Expectations are performed after all postprocessing steps
+     * @deprecated [💝]
+     */
+    readonly expectFormat?: ExpectFormatCommand['format'];
+    /**
+     * Name of the parameter that is the result of the prompt template
+     */
+    readonly resultingParameterName: string_name;
+}
+export {};
+/**
+ * TODO: [💝] Unite object for expecting amount and format - remove expectFormat
+ * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
+ * TODO: [👙][🧠] Just selecting gpt3 or gpt4 level of model
+ */

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

@@ -0,0 +1,25 @@
+import type { 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/umd/typings/types/PromptbookJson/PromptbookJson.d.ts

@@ -0,0 +1,51 @@
+import type { string_promptbook_url, string_version } from '../typeAliases';
+import type { PromptTemplateJson } from './PromptTemplateJson';
+import type { 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/umd/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/umd/typings/types/ScriptLanguage.d.ts

@@ -0,0 +1,9 @@
+import type { 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/umd/typings/types/TaskProgress.d.ts

@@ -0,0 +1,42 @@
+import type { ExecutionType } from './ExecutionTypes';
+import type { 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;
+};