@promptbook/remote-server 0.8.0

package/umd/typings/execution/NaturalExecutionTools.d.ts

@@ -0,0 +1,22 @@
+import { Prompt } from '../types/Prompt';
+import { PromptChatResult, PromptCompletionResult } from './PromptResult';
+/**
+ * Vontainer for all the tools needed to execute prompts to large language models like GPT-4
+ * On its interface it exposes common methods for prompt execution.
+ * Inside (in constructor) it calls OpenAI, Azure, GPU, proxy, cache, logging,...
+ *
+ * @see https://github.com/webgptorg/promptbook#natural-execution-tools
+ */
+export interface NaturalExecutionTools {
+    /**
+     * Use a chat model
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Use a completion model
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+}
+/**
+ * TODO: [🧠] Should or should not there be a word "GPT" in both gptComplete and gptChat
+ */

package/umd/typings/execution/PromptResult.d.ts

@@ -0,0 +1,38 @@
+import { string_model_name } from '.././types/typeAliases';
+/**
+ * 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 = PromptCompletionResult | PromptChatResult;
+/**
+ * Prompt completion result
+ * It contains only the following text NOT the whole completion
+ */
+export type PromptCompletionResult = PromptCommonResult;
+/**
+ * Prompt chat result
+ */
+export interface PromptChatResult extends PromptCommonResult {
+}
+export interface PromptCommonResult {
+    /**
+     * Exact text response from the model
+     */
+    readonly content: string;
+    /**
+     * Name of the model used to generate the response
+     */
+    readonly model: string_model_name;
+    /**
+     * Raw response from the model
+     */
+    readonly rawResponse: object;
+}
+/**
+ * TODO: [🧠] Should here be link to the prompt?
+ * TODO: [🧠] Maybe type raw 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
+ */

package/umd/typings/execution/PtpExecutor.d.ts

@@ -0,0 +1,19 @@
+import { Promisable } from 'type-fest';
+import { string_name } from '.././types/typeAliases';
+import { TaskProgress } from '../types/TaskProgress';
+/**
+ * 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 prompt template pipeline library.
+ *
+ * It can be done in two ways:
+ * -   From `PromptTemplatePipelineLibrary.getExecutor` method
+ * -   `createPtpExecutor` utility function
+ *
+ * @see https://github.com/webgptorg/promptbook#executor
+ */
+export interface PtpExecutor {
+    (inputParameters: Record<string_name, string>, onProgress: (taskProgress: TaskProgress) => Promisable<void>): Promise<Record<string_name, string>>;
+}
+/**
+ * TODO: [🧠] Should this file be in /execution or /types folder?
+ */

package/umd/typings/execution/ScriptExecutionTools.d.ts

@@ -0,0 +1,34 @@
+import { string_name, string_script } from '.././types/typeAliases';
+import { ScriptLanguage } from '../types/ScriptLanguage';
+/**
+ * Represents all the tools needed to execute scripts
+ *
+ * @see https://github.com/webgptorg/promptbook#script-execution-tools
+ */
+export interface ScriptExecutionTools {
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}
+/**
+ * Input for the script execution
+ */
+export interface ScriptExecutionToolsExecuteOptions {
+    /**
+     * Language of the script
+     */
+    scriptLanguage: ScriptLanguage;
+    /**
+     * Parameters for the script
+     * Theese parameters are passed to the script as variables
+     * For example: { "name": "John" } => const name = "John";
+     */
+    parameters: Record<string_name, string>;
+    /**
+     * 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
+     */
+    script: string_script;
+}

package/umd/typings/execution/UserInterfaceTools.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents all the tools needed to interact with the user.
+ *
+ * @see https://github.com/webgptorg/promptbook#user-interface-tools
+ */
+export interface UserInterfaceTools {
+    /**
+     * Asks the user to answer a free-text (multiline) question
+     *
+     * @param options the question to ask
+     * @returns the answer from the user
+     */
+    promptDialog(options: UserInterfaceToolsPromptDialogOptions): Promise<string>;
+}
+export interface UserInterfaceToolsPromptDialogOptions {
+    /**
+     * Prompt message
+     *
+     * Note: This is not a prompt to language model but a prompt to the user
+     */
+    prompt: string;
+    /**
+     * Default value for the input/textarea
+     */
+    defaultValue: string | null;
+    /**
+     * Placeholder for the input/textarea
+     */
+    placeholder?: string;
+}

package/umd/typings/execution/createPtpExecutor.d.ts

@@ -0,0 +1,18 @@
+import { PromptTemplatePipeline } from '../classes/PromptTemplatePipeline';
+import { ExecutionTools } from './ExecutionTools';
+import { PtpExecutor } from './PtpExecutor';
+interface CreatePtpExecutorOptions {
+    readonly ptp: PromptTemplatePipeline;
+    readonly tools: ExecutionTools;
+}
+/**
+ * Creates executor function from prompt template pipeline and execution tools.
+ *
+ * Note: Consider using getExecutor method of the library instead of using this function
+ */
+export declare function createPtpExecutor(options: CreatePtpExecutorOptions): PtpExecutor;
+export {};
+/**
+ * TODO: [👧] Strongly type the executors to avoid need of remove nullables whtn noUncheckedIndexedAccess in tsconfig.json
+ * Note: CreatePtpExecutorOptions are just connected to PtpExecutor so do not extract to types folder
+ */

package/umd/typings/execution/plugins/natural-execution-tools/mocked/MockedEchoNaturalExecutionTools.d.ts

@@ -0,0 +1,22 @@
+import { Prompt } from '../../../../types/Prompt';
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { NaturalExecutionTools } from '../../../NaturalExecutionTools';
+import { PromptChatResult, PromptCompletionResult } from '../../../PromptResult';
+/**
+ * Mocked execution Tools for just echoing the requests for testing purposes.
+ */
+export declare class MockedEchoNaturalExecutionTools implements NaturalExecutionTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Mocks chat model
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Mocks completion model
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+}
+/**
+ * TODO: Allow in spaceTrim: nesting with > ${block(prompt.request)}
+ */

package/umd/typings/execution/plugins/natural-execution-tools/mocked/mocked-chat.test.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * TODO: [🧠] What should be name of this test "MockedEchoExecutionTools.test.ts" or "createPtpExecutor.test.ts"
+ */

package/umd/typings/execution/plugins/natural-execution-tools/mocked/mocked-completion.test.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * TODO: [🧠] What should be name of this test "MockedEchoExecutionTools.test.ts" or "createPtpExecutor.test.ts"
+ */

package/umd/typings/execution/plugins/natural-execution-tools/openai/OpenAiExecutionTools.d.ts

@@ -0,0 +1,27 @@
+import { Prompt } from '../../../../types/Prompt';
+import { NaturalExecutionTools } from '../../../NaturalExecutionTools';
+import { PromptChatResult, PromptCompletionResult } from '../../../PromptResult';
+import { OpenAiExecutionToolsOptions } from './OpenAiExecutionToolsOptions';
+/**
+ * Execution Tools for calling OpenAI API.
+ */
+export declare class OpenAiExecutionTools implements NaturalExecutionTools {
+    private readonly options;
+    /**
+     * OpenAI API client.
+     */
+    private readonly openai;
+    constructor(options: OpenAiExecutionToolsOptions);
+    /**
+     * Calls OpenAI API to use a chat model.
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Calls OpenAI API to use a complete model.
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+}
+/**
+ * TODO: Maybe Create some common util for gptChat and gptComplete
+ * TODO: Maybe make custom OpenaiError
+ */

package/umd/typings/execution/plugins/natural-execution-tools/openai/OpenAiExecutionToolsOptions.d.ts

@@ -0,0 +1,11 @@
+import { string_token } from '../../../.././types/typeAliases';
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+/**
+ * Options for OpenAiExecutionTools
+ */
+export interface OpenAiExecutionToolsOptions extends CommonExecutionToolsOptions {
+    /**
+     * OpenAI API key
+     */
+    openAiApiKey: string_token;
+}

package/umd/typings/execution/plugins/natural-execution-tools/remote/RemoteNaturalExecutionTools.d.ts

@@ -0,0 +1,35 @@
+import { Prompt } from '../../../../types/Prompt';
+import { NaturalExecutionTools } from '../../../NaturalExecutionTools';
+import { PromptChatResult, PromptCompletionResult } from '../../../PromptResult';
+import { RemoteNaturalExecutionToolsOptions } from './RemoteNaturalExecutionToolsOptions';
+/**
+ * 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 RemoteNaturalExecutionTools implements NaturalExecutionTools {
+    private readonly options;
+    constructor(options: RemoteNaturalExecutionToolsOptions);
+    /**
+     * Creates a connection to the remote proxy server.
+     */
+    private makeConnection;
+    /**
+     * Calls remote proxy server to use a chat model.
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Calls remote proxy server to use a completion model.
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+    /**
+     * Calls remote proxy server to use both completion or chat model.
+     */
+    private gptCommon;
+}
+/**
+ * TODO: [🤹‍♂️] RemoteNaturalExecutionTools should extend Destroyable and implement IDestroyable
+ */

package/umd/typings/execution/plugins/natural-execution-tools/remote/RemoteNaturalExecutionToolsOptions.d.ts

@@ -0,0 +1,16 @@
+import { uuid } from '../../../.././types/typeAliases';
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+/**
+ * Options for RemoteNaturalExecutionTools
+ */
+export interface RemoteNaturalExecutionToolsOptions extends CommonExecutionToolsOptions {
+    /**
+     * URL of the remote PTP server
+     * On this server will be connected to the socket.io server
+     */
+    readonly remoteUrl: URL;
+    /**
+     * Your client ID
+     */
+    readonly clientId: uuid;
+}

package/umd/typings/execution/plugins/natural-execution-tools/remote/createRemoteServer.d.ts

@@ -0,0 +1,16 @@
+import { 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 createRemoteServer(options: RemoteServerOptions): void;
+/**
+ * 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 DDoS
+ */

package/umd/typings/execution/plugins/natural-execution-tools/remote/interfaces/Ptps_Error.d.ts

@@ -0,0 +1,3 @@
+export interface Ptps_Error {
+    readonly errorMessage: string;
+}

package/umd/typings/execution/plugins/natural-execution-tools/remote/interfaces/Ptps_Progress.d.ts

@@ -0,0 +1,4 @@
+import { TaskProgress } from '../../../../../types/TaskProgress';
+export interface Ptps_Progress {
+    readonly taskProgress: TaskProgress;
+}

package/umd/typings/execution/plugins/natural-execution-tools/remote/interfaces/Ptps_Request.d.ts

@@ -0,0 +1,6 @@
+import { uuid } from '../../../../.././types/typeAliases';
+import { Prompt } from '../../../../../types/Prompt';
+export interface Ptps_Request {
+    readonly clientId: uuid;
+    readonly prompt: Prompt;
+}

package/umd/typings/execution/plugins/natural-execution-tools/remote/interfaces/Ptps_Response.d.ts

@@ -0,0 +1,4 @@
+import { PromptResult } from '../../../../../execution/PromptResult';
+export interface Ptps_Response {
+    promptResult: PromptResult;
+}

package/umd/typings/execution/plugins/natural-execution-tools/remote/interfaces/RemoteServerOptions.d.ts

@@ -0,0 +1,20 @@
+import { PromptTemplatePipelineLibrary } from '../../../../../classes/PromptTemplatePipelineLibrary';
+import { uuid } from '../../../../../types/typeAliases';
+import { CommonExecutionToolsOptions } from '../../../../CommonExecutionToolsOptions';
+import { NaturalExecutionTools } from '../../../../NaturalExecutionTools';
+export interface RemoteServerOptions extends CommonExecutionToolsOptions {
+    /**
+     * Port on which the server will listen
+     */
+    readonly port: number;
+    /**
+     * Prompt template pipeline library to use
+     *
+     * This is used to checkl validity of the prompt to prevent DDoS
+     */
+    readonly ptpLibrary: PromptTemplatePipelineLibrary;
+    /**
+     * Creates natural execution tools for each client
+     */
+    createNaturalExecutionTools(clientId: uuid): NaturalExecutionTools;
+}

package/umd/typings/execution/plugins/script-execution-tools/javascript/JavascriptEvalExecutionTools.d.ts

@@ -0,0 +1,19 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { ScriptExecutionTools, ScriptExecutionToolsExecuteOptions } from '../../../ScriptExecutionTools';
+/**
+ * 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: CommonExecutionToolsOptions);
+    /**
+     * Executes a JavaScript
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}
+/**
+ * TODO: Put predefined functions (like removeQuotes, spaceTrim, etc.) into annotation OR pass into constructor
+ */

package/umd/typings/execution/plugins/script-execution-tools/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/umd/typings/execution/plugins/script-execution-tools/javascript/JavascriptExecutionTools.d.ts

@@ -0,0 +1,20 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { ScriptExecutionTools, ScriptExecutionToolsExecuteOptions } from '../../../ScriptExecutionTools';
+/**
+ * ScriptExecutionTools for JavaScript implemented via vm2
+ *
+ * Warning: This is not implemented yet
+ */
+export declare class JavascriptExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Executes a JavaScript
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}
+/**
+ * TODO: !! Pass isVerbose to constructor and use it
+ * TODO: !! Probbably make some common util createStatementToEvaluate
+ * TODO: !! Implement via vm2
+ */

package/umd/typings/execution/plugins/script-execution-tools/javascript/utils/preserve.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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<any>) => unknown): void;
+/**
+ * TODO: !! [1] This maybe does memory leak
+ */

package/umd/typings/execution/plugins/script-execution-tools/postprocessing.test.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * TODO: What is the ideal folder for this test?
+ */

package/umd/typings/execution/plugins/script-execution-tools/python/PythonExecutionTools.d.ts

@@ -0,0 +1,15 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { ScriptExecutionTools, ScriptExecutionToolsExecuteOptions } from '../../../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/umd/typings/execution/plugins/script-execution-tools/script-execution-errors.test.d.ts

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

package/umd/typings/execution/plugins/script-execution-tools/script-execution-tools.test.d.ts

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

package/umd/typings/execution/plugins/script-execution-tools/typescript/TypescriptExecutionTools.d.ts

@@ -0,0 +1,15 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { ScriptExecutionTools, ScriptExecutionToolsExecuteOptions } from '../../../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/umd/typings/execution/plugins/user-interface-execution-tools/callback/CallbackInterfaceTools.d.ts

@@ -0,0 +1,14 @@
+import { UserInterfaceTools, UserInterfaceToolsPromptDialogOptions } from '../../../UserInterfaceTools';
+import { CallbackInterfaceToolsOptions } from './CallbackInterfaceToolsOptions';
+/**
+ * Delagates the user interaction to a async callback function
+ * You need to provide your own implementation of this callback function and its bind to UI.
+ */
+export declare class CallbackInterfaceTools implements UserInterfaceTools {
+    private readonly options;
+    constructor(options: CallbackInterfaceToolsOptions);
+    /**
+     * Trigger the custom callback function
+     */
+    promptDialog(options: UserInterfaceToolsPromptDialogOptions): Promise<string>;
+}

package/umd/typings/execution/plugins/user-interface-execution-tools/callback/CallbackInterfaceToolsOptions.d.ts

@@ -0,0 +1,12 @@
+import { Promisable } from 'type-fest';
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { UserInterfaceToolsPromptDialogOptions } from '../../../UserInterfaceTools';
+/**
+ * Options for CallbackInterfaceTools
+ */
+export interface CallbackInterfaceToolsOptions extends CommonExecutionToolsOptions {
+    /**
+     * The callback function to be called when promptDialog is called
+     */
+    callback(prompt: UserInterfaceToolsPromptDialogOptions): Promisable<string>;
+}

package/umd/typings/execution/plugins/user-interface-execution-tools/simple-prompt/SimplePromptInterfaceTools.d.ts

@@ -0,0 +1,16 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { UserInterfaceTools, UserInterfaceToolsPromptDialogOptions } from '../../../UserInterfaceTools';
+/**
+ * Wrapper around `window.prompt` synchronous function that interacts with the user via browser prompt
+ *
+ * Warning: It is used for testing and mocking
+ *          **NOT intended to use in the production** due to its synchronous nature.
+ */
+export declare class SimplePromptInterfaceTools implements UserInterfaceTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Trigger window.prompt dialog
+     */
+    promptDialog(options: UserInterfaceToolsPromptDialogOptions): Promise<string>;
+}

package/umd/typings/execution/plugins/user-interface-execution-tools/user-interface-execution-tools.test.d.ts

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

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

@@ -0,0 +1,65 @@
+import { string_markdown_text, string_name, string_version } from '.././types/typeAliases';
+import { ExecutionType } from './ExecutionTypes';
+import { ModelRequirements } from './ModelRequirements';
+/**
+ * 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 = PtpUrlCommand | PtpVersionCommand | ExecuteCommand | UseCommand | ParameterCommand | PostprocessCommand;
+/**
+ * PtpVersion command tells which version is .ptp file using
+ *
+ * - It is used for backward compatibility
+ * - It is defined per whole .ptp file in the header
+ */
+export interface PtpUrlCommand {
+    readonly type: 'PTP_URL';
+    readonly ptpUrl: URL;
+}
+/**
+ * PtpVersion command tells which version is .ptp file using
+ *
+ * - It is used for backward compatibility
+ * - It is defined per whole .ptp file in the header
+ */
+export interface PtpVersionCommand {
+    readonly type: 'PTP_VERSION';
+    readonly ptpVersion: string_version;
+}
+/**
+ * Execute command tells how to execute the section
+ * It can be either prompt template, script or simple template etc.
+ */
+export interface ExecuteCommand {
+    readonly type: 'EXECUTE';
+    readonly executionType: ExecutionType;
+}
+/**
+ * Use command tells which model and modelRequirements to use for the prompt template. execution
+ */
+export interface UseCommand {
+    readonly type: 'USE';
+    readonly key: keyof ModelRequirements;
+    readonly value: any;
+}
+/**
+ * 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 interface ParameterCommand {
+    readonly type: 'PARAMETER';
+    readonly isInputParameter: 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 interface PostprocessCommand {
+    readonly type: 'POSTPROCESS';
+    readonly functionName: string_name;
+}

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

@@ -0,0 +1,28 @@
+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 interface 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 variant: ModelVariant;
+}
+/**
+ * TODO: Maybe figure out better word than "variant"
+ * TODO: Add here more requirement options like max context size, max tokens, etc.
+ */

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 prompt template pipeline.
+ * - **Intermediate parameters** are used internally in the prompt template pipeline.
+ * - **Output parameters** are not used internally in the prompt template pipeline, but are returned as the result of the prompt template 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
+ */