@promptbook/markdown-utils 0.61.0-10

package/esm/typings/src/llm-providers/remote/RemoteLlmExecutionTools.d.ts

@@ -0,0 +1,52 @@
+import type { AvailableModel } from '../../execution/LlmExecutionTools';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { PromptChatResult } from '../../execution/PromptResult';
+import type { PromptCompletionResult } from '../../execution/PromptResult';
+import type { PromptEmbeddingResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_markdown } from '../../types/typeAliases';
+import type { string_markdown_text } from '../../types/typeAliases';
+import type { string_title } from '../../types/typeAliases';
+import type { RemoteLlmExecutionToolsOptions } from './RemoteLlmExecutionToolsOptions';
+/**
+ * Remote server is a proxy server that uses its execution tools internally and exposes the executor interface externally.
+ *
+ * You can simply use `RemoteExecutionTools` on client-side javascript and connect to your remote server.
+ * This is useful to make all logic on browser side but not expose your API keys or no need to use customer's GPU.
+ *
+ * @see https://github.com/webgptorg/promptbook#remote-server
+ */
+export declare class RemoteLlmExecutionTools implements LlmExecutionTools {
+    private readonly options;
+    constructor(options: RemoteLlmExecutionToolsOptions);
+    get title(): string_title & string_markdown_text;
+    get description(): string_markdown;
+    /**
+     * Creates a connection to the remote proxy server.
+     */
+    private makeConnection;
+    /**
+     * Calls remote proxy server to use a chat model
+     */
+    callChatModel(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Calls remote proxy server to use a completion model
+     */
+    callCompletionModel(prompt: Prompt): Promise<PromptCompletionResult>;
+    /**
+     * Calls remote proxy server to use a embedding model
+     */
+    callEmbeddingModel(prompt: Prompt): Promise<PromptEmbeddingResult>;
+    /**
+     * Calls remote proxy server to use both completion or chat model
+     */
+    private callModelCommon;
+    /**
+     * List all available models that can be used
+     */
+    listModels(): Promise<Array<AvailableModel>>;
+}
+/**
+ * TODO: [🍓] Allow to list compatible models with each variant
+ * TODO: [🤹‍♂️] RemoteLlmExecutionTools should extend Destroyable and implement IDestroyable
+ */

package/esm/typings/src/llm-providers/remote/RemoteLlmExecutionToolsOptions.d.ts

@@ -0,0 +1,24 @@
+import type { CommonExecutionToolsOptions } from '../../execution/CommonExecutionToolsOptions';
+import type { client_id } from '../../types/typeAliases';
+import type { string_uri } from '../../types/typeAliases';
+/**
+ * Options for `RemoteLlmExecutionTools`
+ */
+export type RemoteLlmExecutionToolsOptions = CommonExecutionToolsOptions & {
+    /**
+     * URL of the remote PROMPTBOOK server
+     * On this server will be connected to the socket.io server
+     */
+    readonly remoteUrl: URL;
+    /**
+     * Path for the Socket.io server to listen
+     *
+     * @default '/socket.io'
+     * @example '/promptbook/socket.io'
+     */
+    readonly path: string_uri;
+    /**
+     * Your client ID
+     */
+    readonly clientId: client_id;
+};

package/esm/typings/src/llm-providers/remote/interfaces/Promptbook_Server_Error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Socket.io error for remote text generation
+ *
+ * This is sent from server to client when error occurs and stops the process
+ */
+export interface Promptbook_Server_Error {
+    /**
+     * The error message which caused the error
+     */
+    readonly errorMessage: string;
+}

package/esm/typings/src/llm-providers/remote/interfaces/Promptbook_Server_Progress.d.ts

@@ -0,0 +1,12 @@
+import type { TaskProgress } from '../../../types/TaskProgress';
+/**
+ * Socket.io progress for remote text generation
+ *
+ * This is sent from server to client arbitrarily and may be sent multiple times
+ */
+export interface Promptbook_Server_Progress {
+    /**
+     * The progress of text generation
+     */
+    readonly taskProgress: TaskProgress;
+}

package/esm/typings/src/llm-providers/remote/interfaces/Promptbook_Server_Request.d.ts

@@ -0,0 +1,17 @@
+import type { Prompt } from '../../../types/Prompt';
+import type { client_id } from '../../../types/typeAliases';
+/**
+ * Socket.io progress for remote text generation
+ *
+ * This is a request from client to server
+ */
+export interface Promptbook_Server_Request {
+    /**
+     * Client responsible for the requests
+     */
+    readonly clientId: client_id;
+    /**
+     * The Prompt to execute
+     */
+    readonly prompt: Prompt;
+}

package/esm/typings/src/llm-providers/remote/interfaces/Promptbook_Server_Response.d.ts

@@ -0,0 +1,12 @@
+import type { PromptResult } from '../../../execution/PromptResult';
+/**
+ * Socket.io error for remote text generation
+ *
+ * This is sent from server to client when the generated text is completed
+ */
+export interface Promptbook_Server_Response {
+    /**
+     * The result of the prompt
+     */
+    promptResult: PromptResult;
+}

package/esm/typings/src/llm-providers/remote/interfaces/RemoteServerOptions.d.ts

@@ -0,0 +1,28 @@
+import type { PipelineCollection } from '../../../collection/PipelineCollection';
+import type { CommonExecutionToolsOptions } from '../../../execution/CommonExecutionToolsOptions';
+import type { LlmExecutionTools } from '../../../execution/LlmExecutionTools';
+import type { client_id } from '../../../types/typeAliases';
+import type { string_uri } from '../../../types/typeAliases';
+export type RemoteServerOptions = CommonExecutionToolsOptions & {
+    /**
+     * Port on which the server will listen
+     */
+    readonly port: number;
+    /**
+     * Path for the Socket.io server to listen
+     *
+     * @default '/socket.io'
+     * @example '/promptbook/socket.io'
+     */
+    readonly path: string_uri;
+    /**
+     * Promptbook collection to use
+     *
+     * This is used to check validity of the prompt to prevent DDoS
+     */
+    readonly collection: PipelineCollection;
+    /**
+     * Creates llm execution tools for each client
+     */
+    createLlmExecutionTools(clientId: client_id): LlmExecutionTools;
+};

package/esm/typings/src/llm-providers/remote/startRemoteServer.d.ts

@@ -0,0 +1,19 @@
+import type { IDestroyable } from 'destroyable';
+import type { RemoteServerOptions } from './interfaces/RemoteServerOptions';
+/**
+ * Remote server is a proxy server that uses its execution tools internally and exposes the executor interface externally.
+ *
+ * You can simply use `RemoteExecutionTools` on client-side javascript and connect to your remote server.
+ * This is useful to make all logic on browser side but not expose your API keys or no need to use customer's GPU.
+ *
+ * @see https://github.com/webgptorg/promptbook#remote-server
+ */
+export declare function startRemoteServer(options: RemoteServerOptions): IDestroyable;
+/**
+ * TODO: [⚖] Expose the collection to be able to connect to same collection via createCollectionFromUrl
+ * TODO: Handle progress - support streaming
+ * TODO: [🤹‍♂️] Do not hang up immediately but wait until client closes OR timeout
+ * TODO: [🤹‍♂️] Timeout on chat to free up resources
+ * TODO: [🃏] Pass here some security token to prevent malitious usage and/or DDoS
+ * TODO: [0] Set unavailable models as undefined in `RemoteLlmExecutionTools` NOT throw error here
+ */

package/esm/typings/src/personas/preparePersona.d.ts

@@ -0,0 +1,13 @@
+import type { PrepareOptions } from '../prepare/PrepareOptions';
+import type { PersonaPreparedJson } from '../types/PipelineJson/PersonaJson';
+import type { string_persona_description } from '../types/typeAliases';
+/**
+ * Prepares the persona for the pipeline
+ *
+ * @see https://github.com/webgptorg/promptbook/discussions/22
+ * @private within the package
+ */
+export declare function preparePersona(personaDescription: string_persona_description, options: PrepareOptions): Promise<PersonaPreparedJson['modelRequirements']>;
+/**
+ * TODO: [🪂] Do it in parallel
+ */

package/esm/typings/src/personas/preparePersona.test.d.ts

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

package/esm/typings/src/prepare/PrepareOptions.d.ts

@@ -0,0 +1,22 @@
+import type { LlmExecutionTools } from '../execution/LlmExecutionTools';
+/**
+ * Options for preparation of the pipeline
+ */
+export type PrepareOptions = {
+    /**
+     * LLM tools
+     */
+    readonly llmTools: LlmExecutionTools;
+    /**
+     * Maximum number of tasks running in parallel
+     *
+     * @default MAX_PARALLEL_COUNT
+     */
+    readonly maxParallelCount?: number;
+    /**
+     * If true, the preparation logs additional information
+     *
+     * @default false
+     */
+    readonly isVerbose?: boolean;
+};

package/esm/typings/src/prepare/preparePipeline.d.ts

@@ -0,0 +1,15 @@
+import type { PipelineJson } from '../types/PipelineJson/PipelineJson';
+import type { PrepareOptions } from './PrepareOptions';
+/**
+ * Prepare pipeline from string (markdown) format to JSON format
+ *
+ * Note: This function does not validate logic of the pipeline
+ * Note: This function acts as part of compilation process
+ */
+export declare function preparePipeline(pipeline: PipelineJson, options: PrepareOptions): Promise<PipelineJson>;
+/**
+ * TODO: Write tests for `preparePipeline`
+ * TODO: [🏏] Leverage the batch API and build queues @see https://platform.openai.com/docs/guides/batch
+ * TODO: [🧊] In future one preparation can take data from previous preparation and save tokens and time
+ * TODO: [💸] Make utilities `interceptLlmTools` and `costLlmTools` to compute cost and DO put this counting logic in `prepareKnowledge` or `preparePersona`
+ */

package/esm/typings/src/prepare/unpreparePipeline.d.ts

@@ -0,0 +1,8 @@
+import type { PipelineJson } from '../types/PipelineJson/PipelineJson';
+/**
+ * Unprepare just strips the preparation data of the pipeline
+ */
+export declare function unpreparePipeline(pipeline: PipelineJson): PipelineJson;
+/**
+ * TODO: Write tests for `preparePipeline`
+ */

package/esm/typings/src/scripting/_test/custom-function-async.test.ts.test.d.ts

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

package/esm/typings/src/scripting/_test/custom-function-missing.test.d.ts

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

package/esm/typings/src/scripting/_test/custom-function-with-dependencies.test.d.ts

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

package/esm/typings/src/scripting/_test/custom-function.test.d.ts

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

package/esm/typings/src/scripting/_test/postprocessing.test.d.ts

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

package/esm/typings/src/scripting/_test/script-execution-errors.test.d.ts

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

package/esm/typings/src/scripting/_test/script-execution-tools.test.d.ts

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

package/esm/typings/src/scripting/javascript/JavascriptEvalExecutionTools.d.ts

@@ -0,0 +1,20 @@
+import type { ScriptExecutionTools, ScriptExecutionToolsExecuteOptions } from '../../execution/ScriptExecutionTools';
+import type { JavascriptExecutionToolsOptions } from './JavascriptExecutionToolsOptions';
+/**
+ * ScriptExecutionTools for JavaScript implemented via eval
+ *
+ * Warning: It is used for testing and mocking
+ *          **NOT intended to use in the production** due to its unsafe nature, use `JavascriptExecutionTools` instead.
+ */
+export declare class JavascriptEvalExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options?: JavascriptExecutionToolsOptions);
+    /**
+     * Executes a JavaScript
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}
+/**
+ * TODO: Put predefined functions (like removeQuotes, spaceTrim, etc.) into annotation OR pass into constructor
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */

package/esm/typings/src/scripting/javascript/JavascriptEvalExecutionTools.test.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * TODO: !! Make shared test between JavascriptEvalExecutionTools and JavascriptExecutionTools to test the same functionality when implemented via vm2
+ */

package/esm/typings/src/scripting/javascript/JavascriptExecutionTools.d.ts

@@ -0,0 +1,7 @@
+import { JavascriptEvalExecutionTools } from './JavascriptEvalExecutionTools';
+/**
+ * Placeholder for better implementation of JavascriptExecutionTools - some propper sandboxing
+ *
+ * @alias JavascriptExecutionTools
+ */
+export declare const JavascriptExecutionTools: typeof JavascriptEvalExecutionTools;

package/esm/typings/src/scripting/javascript/JavascriptExecutionToolsOptions.d.ts

@@ -0,0 +1,26 @@
+import type { Promisable } from 'type-fest';
+import type { CommonExecutionToolsOptions } from '../../execution/CommonExecutionToolsOptions';
+import type { string_javascript_name } from '../../types/typeAliases';
+/**
+ * Options for `JavascriptExecutionTools`
+ */
+export type JavascriptExecutionToolsOptions = CommonExecutionToolsOptions & {
+    /**
+     * Functions to be executed in the JavaScript evaluation.
+     *
+     * This can be used in two ways:
+     * 1. To provide custom postprocessing functions. For this case function must receive one string and return a (promise of) string.
+     * 2. As environment for the ECECUTE SCRIPT, For this case function can be any function. [0]
+     *
+     * Note: There are also some built-in functions available:
+     *      @see ./JavascriptEvalExecutionTools.ts
+     */
+    functions?: Record<string_javascript_name, PostprocessingFunction>;
+};
+/**
+ * Function that can be used to postprocess the output of the LLM
+ */
+export type PostprocessingFunction = ((value: string) => Promisable<string>) | Function;
+/**
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */

package/esm/typings/src/scripting/javascript/utils/preserve.d.ts

@@ -0,0 +1,12 @@
+import type { really_any } from '../../../utils/organization/really_any';
+/**
+ * Does nothing, but preserves the function in the bundle
+ * Compiler is tricked into thinking the function is used
+ *
+ * @param value any function to preserve
+ * @returns nothing
+ */
+export declare function preserve(func: (...params: Array<really_any>) => unknown): void;
+/**
+ * TODO: !! [1] This maybe does memory leak
+ */

package/esm/typings/src/scripting/javascript/utils/unknownToString.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts anything to string that can be used for debugging and logging
+ *
+ * @param value String value for logging
+ * @private Internal util
+ */
+export declare function unknownToString(value: unknown): string;

package/esm/typings/src/scripting/python/PythonExecutionTools.d.ts

@@ -0,0 +1,16 @@
+import type { CommonExecutionToolsOptions } from '../../execution/CommonExecutionToolsOptions';
+import type { ScriptExecutionTools } from '../../execution/ScriptExecutionTools';
+import type { ScriptExecutionToolsExecuteOptions } from '../../execution/ScriptExecutionTools';
+/**
+ * ScriptExecutionTools for Python
+ *
+ * Warning: This is not implemented yet
+ */
+export declare class PythonExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options?: CommonExecutionToolsOptions);
+    /**
+     * Executes a Python
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}

package/esm/typings/src/scripting/typescript/TypescriptExecutionTools.d.ts

@@ -0,0 +1,16 @@
+import type { CommonExecutionToolsOptions } from '../../execution/CommonExecutionToolsOptions';
+import type { ScriptExecutionTools } from '../../execution/ScriptExecutionTools';
+import type { ScriptExecutionToolsExecuteOptions } from '../../execution/ScriptExecutionTools';
+/**
+ * ScriptExecutionTools for TypeScript
+ *
+ * Warning: This is not implemented yet
+ */
+export declare class TypescriptExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options?: CommonExecutionToolsOptions);
+    /**
+     * Executes a TypeScript
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}

package/esm/typings/src/types/Arrayable.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Item or array of items
+ *
+ * 1) Any item except array and undefined represents array with that one item (also null)
+ * 2) Undefined represents empty array
+ * 3) Array represents itself
+ *
+ * @private Internal utility type
+ */
+export type Arrayable<TItem> = TItem | Array<TItem> | undefined;

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

@@ -0,0 +1,44 @@
+import type { string_model_name } from './typeAliases';
+export declare const MODEL_VARIANTS: readonly ["COMPLETION", "CHAT", "EMBEDDING"];
+/**
+ * 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: !!!!! Add and use systemMessage, temprerature, top_k, top_p, presencePenalty, frequencyPenalty, bestOf, n, logitBias, logitBiasType, stop, ... to ModelRequirements
+ * 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/esm/typings/src/types/Parameters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parameters of the 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: !!!!! Implement samples into parameters
+ * 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/src/types/PipelineJson/Expectations.d.ts

@@ -0,0 +1,32 @@
+import type { number_integer } from '../typeAliases';
+import type { number_positive } from '../typeAliases';
+/**
+ * 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
+ * @see https://github.com/webgptorg/promptbook/discussions/30
+ */
+export type Expectations = Partial<Record<Lowercase<ExpectationUnit>, {
+    readonly min?: ExpectationAmount;
+    readonly max?: ExpectationAmount;
+}>>;
+/**
+ * Units of text measurement
+ * @see https://github.com/webgptorg/promptbook/discussions/30
+ */
+export declare const EXPECTATION_UNITS: readonly ["CHARACTERS", "WORDS", "SENTENCES", "LINES", "PARAGRAPHS", "PAGES"];
+/**
+ * Unit of text measurement
+ * @see https://github.com/webgptorg/promptbook/discussions/30
+ */
+export type ExpectationUnit = typeof EXPECTATION_UNITS[number];
+/**
+ * Amount of text measurement
+ * @see https://github.com/webgptorg/promptbook/discussions/30
+ */
+export type ExpectationAmount = number_integer & (number_positive | 0);
+/**
+ * TODO: [💝] Unite object for expecting amount and format - remove expectFormat
+ */

package/esm/typings/src/types/PipelineJson/KnowledgePieceJson.d.ts

@@ -0,0 +1,67 @@
+import type { EmbeddingVector } from '../../execution/EmbeddingVector';
+import type { string_keyword } from '../../utils/normalization/IKeywords';
+import type { number_id } from '../typeAliases';
+import type { number_linecol_number } from '../typeAliases';
+import type { string_markdown } from '../typeAliases';
+import type { string_markdown_text } from '../typeAliases';
+import type { string_model_name } from '../typeAliases';
+import type { string_name } from '../typeAliases';
+/**
+ * Defines one piece of knowledge in the pipeline
+ *
+ * Note: Knowledge piece is by definition prepared
+ *
+ * @see https://github.com/webgptorg/promptbook/discussions/41
+ */
+export type KnowledgePiecePreparedJson = {
+    /**
+     * Unique name of the knowledge piece based on the title
+     */
+    readonly name?: string_name;
+    /**
+     * Short title for the information
+     */
+    readonly title?: string_markdown_text;
+    /**
+     * The information in markdown format
+     */
+    readonly content?: string_markdown;
+    /**
+     * List of sources where the information comes from
+     */
+    readonly sources: Array<{
+        /**
+         * Identifier of the source
+         */
+        readonly name: string_name;
+        /**
+         * Line number
+         */
+        readonly line?: number_linecol_number;
+        /**
+         * Column number
+         */
+        readonly column?: number_linecol_number;
+    }>;
+    /**
+     * List of keywords that are associated with the knowledge piece
+     */
+    readonly keywords: Array<string_keyword>;
+    /**
+     * List of models embeddings that are associated with the knowledge piece
+     */
+    readonly index: Array<{
+        /**
+         * Model name which generated the embedding
+         */
+        readonly modelName: string_model_name;
+        /**
+         * Embedding vector of the knowledge piece
+         */
+        readonly position: EmbeddingVector;
+    }>;
+    /**
+     * List of preparation ids that were used to prepare this knowledge piece
+     */
+    readonly preparationIds: Array<number_id>;
+};

package/esm/typings/src/types/PipelineJson/KnowledgeSourceJson.d.ts

@@ -0,0 +1,24 @@
+import type { number_id } from '../typeAliases';
+import type { string_knowledge_source } from '../typeAliases';
+import type { string_name } from '../typeAliases';
+/**
+ * Defines one source of knowledge in the pipeline
+ * For example, a source of information, a fact, a quote, a definition, website, etc.
+ *
+ * @see https://github.com/webgptorg/promptbook/discussions/41
+ */
+export type KnowledgeSourceJson = {
+    readonly name: string_name;
+    readonly source: string_knowledge_source;
+};
+/**
+ * Defines one source of knowledge in the pipeline after it has been prepared
+ *
+ * @see https://github.com/webgptorg/promptbook/discussions/41
+ */
+export type KnowledgeSourcePreparedJson = KnowledgeSourceJson & {
+    /**
+     * List of preparation ids that were used to prepare this knowledge source to knowledge pieces
+     */
+    readonly preparationIds: Array<number_id>;
+};

package/esm/typings/src/types/PipelineJson/LlmTemplateJson.d.ts

@@ -0,0 +1,23 @@
+import type { ModelRequirements } from '../ModelRequirements';
+import type { string_name } from '../typeAliases';
+import type { PromptTemplateJsonCommon } from './PromptTemplateJsonCommon';
+/**
+ * Template for prompt to LLM
+ */
+export type LlmTemplateJson = PromptTemplateJsonCommon & {
+    readonly blockType: 'PROMPT_TEMPLATE';
+    /**
+     * Name of the persona who will be responding to this prompt
+     */
+    readonly personaName: string_name | null;
+    /**
+     * Requirements for the model
+     * - This is required only for blockType PROMPT_TEMPLATE
+     */
+    readonly modelRequirements: ModelRequirements;
+};
+/**
+ * TODO: [👙][🧠] Maybe add `knowledge`, `actions` and `instruments` to be available granularly for each template
+ *       @see https://github.com/webgptorg/promptbook/discussions/79
+ * TODO: [💕][🧠] Just selecting gpt3 or gpt4 level of model
+ */