@promptbook/azure-openai 0.52.0-1

package/umd/typings/conversion/utils/renameParameter.d.ts

@@ -0,0 +1,25 @@
+import type { PromptbookJson } from '../../types/PromptbookJson/PromptbookJson';
+import type { string_name } from '../../types/typeAliases';
+type RenameParameterOptions = {
+    /**
+     * Promptbook to search and replace for parameters
+     * This promptbook is returned as copy with replaced parameters
+     */
+    promptbook: PromptbookJson;
+    /**
+     * Original parameter name that should be replaced
+     */
+    oldParameterName: string_name;
+    /**
+     * New parameter name that should replace the original parameter name
+     */
+    newParameterName: string_name;
+};
+/**
+ * Function renameParameter will find all usable parameters for given prompt template
+ * In other words, it will find all parameters that are not used in the prompt template itseld and all its dependencies
+ *
+ * @throws {PromptbookLogicError} If the new parameter name is already used in the promptbook
+ */
+export declare function renameParameter(options: RenameParameterOptions): PromptbookJson;
+export {};

package/umd/typings/conversion/utils/renameParameter.test.d.ts

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

package/umd/typings/conversion/utils/titleToName.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Function normalizes title to name which can be used as identifier
+ */
+export declare function titleToName(value: string): string;

package/umd/typings/conversion/utils/titleToName.test.d.ts

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

package/umd/typings/conversion/validation/_importPromptbook.d.ts

@@ -0,0 +1,13 @@
+import { PromptbookJson } from '../../types/PromptbookJson/PromptbookJson';
+import { PromptbookString } from '../../types/PromptbookString';
+/**
+ * Import the text file
+ *
+ * Note: Using here custom import to work in jest tests
+ * Note: Using sync version is 💩 in the production code, but it's ok here in tests
+ *
+ * @param path - The path to the file relative to samples/templates directory
+ * @private
+ */
+export declare function importPromptbook(path: `${string}.ptbk.md`): PromptbookString;
+export declare function importPromptbook(path: `${string}.ptbk.json`): PromptbookJson;

package/umd/typings/conversion/validation/promptbookStringToJson-syntaxErrors.test.d.ts

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

package/umd/typings/conversion/validation/validatePromptbookJson-logicErrors.test.d.ts

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

package/umd/typings/conversion/validation/validatePromptbookJson.d.ts

@@ -0,0 +1,27 @@
+import type { PromptbookJson } from '../../types/PromptbookJson/PromptbookJson';
+/**
+ * Validates PromptbookJson if it is logically valid
+ *
+ * It checks:
+ * -   if it has correct parameters dependency
+ *
+ * It does NOT check:
+ * -   if it is valid json
+ * -   if it is meaningful
+ *
+ * @param promptbook valid or invalid PromptbookJson
+ * @returns the same promptbook if it is logically valid
+ * @throws {PromptbookLogicError} on logical error in the promptbook
+ */
+export declare function validatePromptbookJson(promptbook: PromptbookJson): PromptbookJson;
+/**
+ * TODO: [🧠] Work with promptbookVersion
+ * TODO: Use here some json-schema, Zod or something similar and change it to:
+ *     > /**
+ *     >  * Validates PromptbookJson if it is logically valid.
+ *     >  *
+ *     >  * It checks:
+ *     >  * -   it has a valid structure
+ *     >  * -   ...
+ *     >  ex port function validatePromptbookJson(promptbook: unknown): asserts promptbook is PromptbookJson {
+ */

package/umd/typings/conversion/validation/validatePromptbookJson.test.d.ts

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

package/umd/typings/errors/PromptbookExecutionError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This error indicates errors during the execution of the promptbook
+ */
+export declare class PromptbookExecutionError extends Error {
+    readonly name = "PromptbookExecutionError";
+    constructor(message: string);
+}

package/umd/typings/errors/PromptbookLogicError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This error indicates that the promptbook object has valid syntax but contains logical errors (like circular dependencies)
+ */
+export declare class PromptbookLogicError extends Error {
+    readonly name = "PromptbookLogicError";
+    constructor(message: string);
+}

package/umd/typings/errors/PromptbookNotFoundError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This error indicates that promptbook not found in the library
+ */
+export declare class PromptbookNotFoundError extends Error {
+    readonly name = "PromptbookNotFoundError";
+    constructor(message: string);
+}

package/umd/typings/errors/PromptbookReferenceError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This error indicates errors in referencing promptbooks between each other
+ */
+export declare class PromptbookReferenceError extends Error {
+    readonly name = "PromptbookReferenceError";
+    constructor(message: string);
+}

package/umd/typings/errors/PromptbookSyntaxError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
+ */
+export declare class PromptbookSyntaxError extends Error {
+    readonly name = "PromptbookSyntaxError";
+    constructor(message: string);
+}

package/umd/typings/errors/TemplateError.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This error occurs during the parameter replacement in the template
+ *
+ * Note: This is a kindof subtype of PromptbookExecutionError because it occurs during the execution of the pipeline
+ */
+export declare class TemplateError extends Error {
+    readonly name = "TemplateError";
+    constructor(message: string);
+}

package/umd/typings/errors/UnexpectedError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This error type indicates that the error should not happen and its last check before crashing with some other error
+ */
+export declare class UnexpectedError extends Error {
+    readonly name = "UnexpectedError";
+    constructor(message: string);
+}

package/umd/typings/errors/_ExpectError.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This error occurs when some expectation is not met in the execution of the pipeline
+ *
+ * @private Always catched and rethrown as `PromptbookExecutionError`
+ * Note: This is a kindof subtype of PromptbookExecutionError
+ */
+export declare class ExpectError extends Error {
+    readonly name = "ExpectError";
+    constructor(message: string);
+}

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

@@ -0,0 +1,9 @@
+export type CommonExecutionToolsOptions = {
+    /**
+     * If true, the internal executions will be logged
+     */
+    readonly isVerbose?: boolean;
+};
+/**
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */

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

@@ -0,0 +1,30 @@
+import type { LlmExecutionTools } from './LlmExecutionTools';
+import type { ScriptExecutionTools } from './ScriptExecutionTools';
+import type { UserInterfaceTools } from './UserInterfaceTools';
+/**
+ * All the tools needed to execute prompts (template pipelines).
+ *
+ * @see https://github.com/webgptorg/promptbook#execution-tools
+ */
+export type ExecutionTools = {
+    /**
+     * Tools for executing prompts to large language models like GPT-4
+     */
+    llm: LlmExecutionTools;
+    /**
+     * Tools for executing scripts
+     *
+     * Note: You can pass multiple ScriptExecutionTools, they will be tried one by one until one of them supports the script
+     *       If none of them supports the script, an error is thrown
+     */
+    script: Array<ScriptExecutionTools>;
+    /**
+     * Tools for interacting with the user
+     *
+     * Note: When undefined, the user interface is disabled and promptbook which requires user interaction will fail
+     */
+    userInterface?: UserInterfaceTools;
+};
+/**
+ * TODO: [🍓] !!!! Allow to have more LlmExecutionTools
+ */

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

@@ -0,0 +1,48 @@
+import type { Promisable } from 'type-fest';
+import type { ModelVariant } from '../types/ModelRequirements';
+import type { Prompt } from '../types/Prompt';
+import type { string_model_name, string_title } from '../types/typeAliases';
+import type { PromptChatResult, PromptCompletionResult } from './PromptResult';
+/**
+ * Container 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#llm-execution-tools
+ */
+export type LlmExecutionTools = {
+    /**
+     * Use a chat model
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Use a completion model
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+    /**
+     * List all available models that can be used
+     */
+    listModels(): Promisable<Array<AvailableModel>>;
+};
+/**
+ * Represents a model that can be used for prompt execution
+ */
+export type AvailableModel = {
+    /**
+     * The model title
+     */
+    readonly modelTitle: string_title;
+    /**
+     * The model name aviailable
+     */
+    readonly modelName: string_model_name;
+    /**
+     * Variant of the model
+     */
+    readonly modelVariant: ModelVariant;
+};
+/**
+ * TODO: [🍓][♐] Some heuristic to pick the best model in listed models
+ * TODO: [🏳] gptChat -> chat, gptComplete -> complete, translate
+ * 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,74 @@
+import type { number_positive_or_zero, number_tokens, number_usd, string_date_iso8601, 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 type PromptChatResult = PromptCommonResult & {};
+export type PromptCommonResult = {
+    /**
+     * Exact text response from the model
+     */
+    readonly content: string;
+    /**
+     * Name of the model used to generate the response
+     */
+    readonly model: string_model_name;
+    /**
+     * Timing
+     */
+    readonly timing: {
+        /**
+         * Start of the execution
+         */
+        start: string_date_iso8601;
+        /**
+         * First token generated
+         */
+        firstToken?: string_date_iso8601;
+        /**
+         * End of the execution
+         */
+        complete: string_date_iso8601;
+    };
+    /**
+     * Usage of the prompt execution
+     */
+    readonly usage: {
+        /**
+         * Cost of the execution in USD
+         *
+         * If the cost is unknown, the value is `'UNKNOWN'`
+         */
+        price: (number_positive_or_zero & number_usd) | 'UNKNOWN';
+        /**
+         * Number of tokens used in the input aka. `prompt_tokens`
+         */
+        inputTokens: number_tokens;
+        /**
+         * Number of tokens used in the output aka. `completion_tokens`
+         */
+        outputTokens: number_tokens;
+    };
+    /**
+     * Raw response from the model
+     */
+    readonly rawResponse: object;
+};
+/**
+ * TODO: [🧠] Maybe timing more accurate then seconds?
+ * 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/PromptbookExecutor.d.ts

@@ -0,0 +1,37 @@
+import type { Promisable } from 'type-fest';
+import type { TaskProgress } from '../types/TaskProgress';
+import type { ExecutionReportJson } from '../types/execution-report/ExecutionReportJson';
+import type { string_name } from '../types/typeAliases';
+/**
+ * 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 promptbook library.
+ *
+ * It can be created with `createPromptbookExecutor` function.
+ *
+ * @see https://github.com/webgptorg/promptbook#executor
+ */
+export type PromptbookExecutor = {
+    (inputParameters: Record<string_name, string>, onProgress?: (taskProgress: TaskProgress) => Promisable<void>): Promise<{
+        /**
+         * Whether the execution was successful
+         */
+        isSuccessful: boolean;
+        /**
+         * Errors that occured during the execution
+         */
+        errors: Array<Error>;
+        /**
+         * The report of the execution
+         */
+        executionReport: ExecutionReportJson;
+        /**
+         * Result parameters of the execution
+         *
+         * Note: If the execution was not successful, there are only some of the result parameters
+         */
+        outputParameters: Record<string_name, string>;
+    }>;
+};
+/**
+ * TODO: [🧠] Should this file be in /execution or /types folder?
+ */

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

@@ -0,0 +1,37 @@
+import type { string_name, string_script } from '.././types/typeAliases';
+import type { ScriptLanguage } from '../types/ScriptLanguage';
+/**
+ * Represents all the tools needed to EXECUTE SCRIPTs
+ *
+ * @see https://github.com/webgptorg/promptbook#script-execution-tools
+ */
+export type ScriptExecutionTools = {
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+};
+/**
+ * Input for the script execution
+ */
+export type ScriptExecutionToolsExecuteOptions = {
+    /**
+     * Language of the script
+     */
+    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;
+};
+/**
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */

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

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

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

@@ -0,0 +1,11 @@
+import type { PromptbookExecutor } from './PromptbookExecutor';
+/**
+ * Asserts that the execution of a promptnook is successful
+ *
+ * @param executionResult - The partial result of the promptnook execution
+ * @throws {PromptbookExecutionError} If the execution is not successful or if multiple errors occurred
+ */
+export declare function assertsExecutionSuccessful(executionResult: Pick<Awaited<ReturnType<PromptbookExecutor>>, 'isSuccessful' | 'errors'>): void;
+/**
+ * TODO: [🧠] Can this return type be better typed than void
+ */

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

@@ -0,0 +1,42 @@
+import { PromptbookJson } from '../_packages/types.index';
+import { ExecutionTools } from './ExecutionTools';
+import { PromptbookExecutor } from './PromptbookExecutor';
+type CreatePromptbookExecutorSettings = {
+    /**
+     * When executor does not satisfy expectations it will be retried this amount of times
+     *
+     * @default 3
+     */
+    readonly maxExecutionAttempts: number;
+};
+/**
+ * Options for creating a promptbook executor
+ */
+interface CreatePromptbookExecutorOptions {
+    /**
+     * The promptbook to be executed
+     */
+    readonly promptbook: PromptbookJson;
+    /**
+     * The execution tools to be used during the execution of the PROMPTBOOK
+     */
+    readonly tools: ExecutionTools;
+    /**
+     * Optional settings for the PROMPTBOOK executor
+     */
+    readonly settings?: Partial<CreatePromptbookExecutorSettings>;
+}
+/**
+ * Creates executor function from promptbook and execution tools.
+ *
+ * @returns The executor function
+ * @throws {PromptbookLogicError} on logical error in the promptbook
+ */
+export declare function createPromptbookExecutor(options: CreatePromptbookExecutorOptions): PromptbookExecutor;
+export {};
+/**
+ * TODO: [🧠] When not meet expectations in PROMPT_DIALOG, make some way to tell the user
+ * TODO: [👧] Strongly type the executors to avoid need of remove nullables whtn noUncheckedIndexedAccess in tsconfig.json
+ * Note: CreatePromptbookExecutorOptions are just connected to PromptbookExecutor so do not extract to types folder
+ * TODO: [🧠][3] transparent = (report intermediate parameters) / opaque execution = (report only output parameters) progress reporting mode
+ */

package/umd/typings/execution/plugins/llm-execution-tools/langtail/LangtailExecutionTools.d.ts

@@ -0,0 +1,10 @@
+import type { LlmExecutionTools } from '../../../LlmExecutionTools';
+import { OpenAiExecutionTools } from '../openai/OpenAiExecutionTools';
+/**
+ * Execution Tools for calling OpenAI API.
+ */
+export declare class LangtailExecutionTools extends OpenAiExecutionTools implements LlmExecutionTools {
+}
+/**
+ * TODO: [🍓][♐] Allow to list the available prompts in Langtail
+ */

package/umd/typings/execution/plugins/llm-execution-tools/langtail/LangtailExecutionToolsOptions.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAiExecutionToolsOptions } from '../openai/OpenAiExecutionToolsOptions';
+/**
+ * Options for LangtailExecutionTools
+ *
+ * This extends OpenAI's `ClientOptions` with are directly passed to the OpenAI client.
+ * Rest is used by the `OpenAiExecutionTools`.
+ */
+export type LangtailExecutionToolsOptions = OpenAiExecutionToolsOptions;
+/**
+ * TODO: !!! Use or remove
+ */

package/umd/typings/execution/plugins/llm-execution-tools/mocked/MockedEchoLlmExecutionTools.d.ts

@@ -0,0 +1,26 @@
+import type { Prompt } from '../../../../types/Prompt';
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import type { AvailableModel, LlmExecutionTools } from '../../../LlmExecutionTools';
+import type { PromptChatResult, PromptCompletionResult } from '../../../PromptResult';
+/**
+ * Mocked execution Tools for just echoing the requests for testing purposes.
+ */
+export declare class MockedEchoLlmExecutionTools implements LlmExecutionTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Mocks chat model
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Mocks completion model
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+    /**
+     * List all available mocked-models that can be used
+     */
+    listModels(): Array<AvailableModel>;
+}
+/**
+ * TODO: Allow in spaceTrim: nesting with > ${block(prompt.request)}, same as replace params
+ */

package/umd/typings/execution/plugins/llm-execution-tools/mocked/MockedFackedLlmExecutionTools.d.ts

@@ -0,0 +1,23 @@
+import type { Prompt } from '../../../../types/Prompt';
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import type { AvailableModel, LlmExecutionTools } from '../../../LlmExecutionTools';
+import type { PromptChatResult, PromptCompletionResult } from '../../../PromptResult';
+/**
+ * Mocked execution Tools for just faking expected responses for testing purposes
+ */
+export declare class MockedFackedLlmExecutionTools implements LlmExecutionTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Fakes chat model
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult & PromptCompletionResult>;
+    /**
+     * Fakes completion model
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+    /**
+     * List all available fake-models that can be used
+     */
+    listModels(): Array<AvailableModel>;
+}

package/umd/typings/execution/plugins/llm-execution-tools/mocked/fakeTextToExpectations.d.ts

@@ -0,0 +1,15 @@
+import type { Expectations } from '../../../../types/PromptbookJson/PromptTemplateJson';
+import { PostprocessingFunction } from '../../script-execution-tools/javascript/JavascriptExecutionToolsOptions';
+/**
+ * Gets the expectations and creates a fake text that meets the expectations
+ *
+ * Note: You can provide postprocessing functions to modify the text before checking the expectations
+ *       The result will be the text BEFORE the postprocessing
+ *
+ * @private internal util for MockedFackedLlmExecutionTools
+ */
+export declare function $fakeTextToExpectations(expectations: Expectations, postprocessing?: Array<PostprocessingFunction>): Promise<string>;
+/**
+ * TODO: [🚏] Implement better - create FakeLLM from this
+ * TODO: [💝] Unite object for expecting amount and format - use here also a format
+ */

package/umd/typings/execution/plugins/llm-execution-tools/mocked/fakeTextToExpectations.test.d.ts

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

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

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

package/umd/typings/execution/plugins/llm-execution-tools/mocked/joker.test.d.ts

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

package/umd/typings/execution/plugins/llm-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 "createPromptbookExecutor.test.ts"
+ */

package/umd/typings/execution/plugins/llm-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 "createPromptbookExecutor.test.ts"
+ */