@promptbook/browser 0.63.0-0

package/umd/typings/src/llm-providers/multiple/joinLlmExecutionTools.d.ts

@@ -0,0 +1,21 @@
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import { MultipleLlmExecutionTools } from './MultipleLlmExecutionTools';
+/**
+ * Joins multiple LLM Execution Tools into one
+ *
+ * @returns {LlmExecutionTools} Single wrapper for multiple LlmExecutionTools
+ *
+ * 0) If there is no LlmExecutionTools, it warns and returns valid but empty LlmExecutionTools
+ * 1) If there is only one LlmExecutionTools, it returns it wrapped in a proxy object
+ * 2) If there are multiple LlmExecutionTools, first will be used first, second will be used if the first hasn`t defined model variant or fails, etc.
+ * 3) When all LlmExecutionTools fail, it throws an error with a list of all errors merged into one
+ *
+ *
+ * Tip: You don't have to use this function directly, just pass an array of LlmExecutionTools to the `ExecutionTools`
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function joinLlmExecutionTools(...llmExecutionTools: Array<LlmExecutionTools>): MultipleLlmExecutionTools;
+/**
+ * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+ */ 

package/umd/typings/src/llm-providers/multiple/playground/playground.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/umd/typings/src/llm-providers/openai/OpenAiExecutionTools.d.ts

@@ -0,0 +1,68 @@
+import type { AvailableModel } from '../../execution/LlmExecutionTools';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { CompletionPromptResult } from '../../execution/PromptResult';
+import type { EmbeddingPromptResult } 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 { OpenAiExecutionToolsOptions } from './OpenAiExecutionToolsOptions';
+/**
+ * Execution Tools for calling OpenAI API.
+ *
+ * @public exported from `@promptbook/openai`
+ */
+export declare class OpenAiExecutionTools implements LlmExecutionTools {
+    private readonly options;
+    /**
+     * OpenAI API client.
+     */
+    private readonly client;
+    /**
+     * Creates OpenAI Execution Tools.
+     *
+     * @param options which are relevant are directly passed to the OpenAI client
+     */
+    constructor(options?: OpenAiExecutionToolsOptions);
+    get title(): string_title & string_markdown_text;
+    get description(): string_markdown;
+    /**
+     * Calls OpenAI API to use a chat model.
+     */
+    callChatModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements' | 'expectFormat'>): Promise<ChatPromptResult>;
+    /**
+     * Calls OpenAI API to use a complete model.
+     */
+    callCompletionModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<CompletionPromptResult>;
+    /**
+     * Calls OpenAI API to use a embedding model
+     */
+    callEmbeddingModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<EmbeddingPromptResult>;
+    /**
+     * Get the model that should be used as default
+     */
+    private getDefaultModel;
+    /**
+     * Default model for chat variant.
+     */
+    private getDefaultChatModel;
+    /**
+     * Default model for completion variant.
+     */
+    private getDefaultCompletionModel;
+    /**
+     * Default model for completion variant.
+     */
+    private getDefaultEmbeddingModel;
+    /**
+     * List all available OpenAI models that can be used
+     */
+    listModels(): Array<AvailableModel>;
+}
+/**
+ * TODO: [🧠][🧙‍♂️] Maybe there can be some wizzard for thoose who want to use just OpenAI
+ * TODO: Maybe Create some common util for callChatModel and callCompletionModel
+ * TODO: Maybe make custom OpenaiError
+ * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
+ */

package/umd/typings/src/llm-providers/openai/OpenAiExecutionToolsOptions.d.ts

@@ -0,0 +1,20 @@
+import type { ClientOptions } from 'openai';
+import type { CommonExecutionToolsOptions } from '../../execution/CommonExecutionToolsOptions';
+import type { string_token } from '../../types/typeAliases';
+/**
+ * Options for `OpenAiExecutionTools`
+ *
+ * This extends OpenAI's `ClientOptions` with are directly passed to the OpenAI client.
+ * Rest is used by the `OpenAiExecutionTools`.
+ *
+ * @public exported from `@promptbook/openai`
+ */
+export type OpenAiExecutionToolsOptions = CommonExecutionToolsOptions & ClientOptions & {
+    /**
+     * A unique identifier representing your end-user, which can help OpenAI to monitor
+     * and detect abuse.
+     *
+     * @see https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids
+     */
+    user?: string_token;
+};

package/umd/typings/src/llm-providers/openai/computeOpenaiUsage.d.ts

@@ -0,0 +1,14 @@
+import type OpenAI from 'openai';
+import type { PromptResultUsage } from '../../execution/PromptResultUsage';
+import type { Prompt } from '../../types/Prompt';
+/**
+ * Computes the usage of the OpenAI API based on the response from OpenAI
+ *
+ * @param promptContent The content of the prompt
+ * @param resultContent The content of the result (for embedding prompts or failed prompts pass empty string)
+ * @param rawResponse The raw response from OpenAI API
+ * @throws {PipelineExecutionError} If the usage is not defined in the response from OpenAI
+ * @private internal util of `OpenAiExecutionTools`
+ */
+export declare function computeOpenaiUsage(promptContent: Prompt['content'], // <- Note: Intentionally using [] to access type properties to bring jsdoc from Prompt/PromptResult to consumer
+resultContent: string, rawResponse: Pick<OpenAI.Chat.Completions.ChatCompletion | OpenAI.Completions.Completion | OpenAI.Embeddings.CreateEmbeddingResponse, 'model' | 'usage'>): PromptResultUsage;

package/umd/typings/src/llm-providers/openai/computeOpenaiUsage.test.d.ts

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

package/umd/typings/src/llm-providers/openai/computeUsage.d.ts

@@ -0,0 +1,16 @@
+/**
+ * String value found on OpenAI and Anthropic Claude page
+ *
+ * @see https://openai.com/api/pricing/
+ * @see https://docs.anthropic.com/en/docs/models-overview
+ *
+ * @private within the repository, used only as internal helper for `OPENAI_MODELS` and `computeUsage`
+ */
+type string_model_price = `$${number}.${number} / ${number}M tokens`;
+/**
+ * Function computeUsage will create price per one token based on the string value found on openai page
+ *
+ * @private within the repository, used only as internal helper for `OPENAI_MODELS`
+ */
+export declare function computeUsage(value: string_model_price): number;
+export {};

package/umd/typings/src/llm-providers/openai/computeUsage.test.d.ts

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

package/umd/typings/src/llm-providers/openai/openai-models.d.ts

@@ -0,0 +1,29 @@
+import type { AvailableModel } from '../../execution/LlmExecutionTools';
+import type { number_usd } from '../../types/typeAliases';
+/**
+ * List of available OpenAI models with pricing
+ *
+ * Note: Done at 2024-05-20
+ *
+ * @see https://platform.openai.com/docs/models/
+ * @see https://openai.com/api/pricing/
+ * @public exported from `@promptbook/openai`
+ */
+export declare const OPENAI_MODELS: Array<AvailableModel & {
+    pricing?: {
+        readonly prompt: number_usd;
+        readonly output: number_usd;
+    };
+}>;
+/**
+ * Note: [🤖] Add models of new variant
+ * TODO: [🧠] Some mechanism to propagate unsureness
+ * TODO: [🕚][👮‍♀️] Make this list dynamic - dynamically can be listed modelNames but not modelVariant, legacy status, context length and pricing
+ * TODO: [🧠][👮‍♀️] Put here more info like description, isVision, trainingDateCutoff, languages, strengths (	Top-level performance, intelligence, fluency, and understanding), contextWindow,...
+ * @see https://platform.openai.com/docs/models/gpt-4-turbo-and-gpt-4
+ * @see https://openai.com/api/pricing/
+ * @see /other/playground/playground.ts
+ * TODO: [🍓] Make better
+ * TODO: Change model titles to human eg: "gpt-4-turbo-2024-04-09" -> "GPT-4 Turbo (2024-04-09)"
+ * TODO: [🚸] Not all models are compatible with JSON mode, add this information here and use it
+ */

package/umd/typings/src/llm-providers/openai/playground/playground.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+export {};
+/**
+ * TODO: !!! Test here that `systemMessage`, `temperature` and `seed` are working correctly
+ */

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

@@ -0,0 +1,56 @@
+import type { AvailableModel } from '../../execution/LlmExecutionTools';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { CompletionPromptResult } from '../../execution/PromptResult';
+import type { EmbeddingPromptResult } from '../../execution/PromptResult';
+import type { ChatPrompt } from '../../types/Prompt';
+import type { CompletionPrompt } from '../../types/Prompt';
+import type { EmbeddingPrompt } 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
+ * @public exported from `@promptbook/remote-client`
+ */
+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: ChatPrompt): Promise<ChatPromptResult>;
+    /**
+     * Calls remote proxy server to use a completion model
+     */
+    callCompletionModel(prompt: CompletionPrompt): Promise<CompletionPromptResult>;
+    /**
+     * Calls remote proxy server to use a embedding model
+     */
+    callEmbeddingModel(prompt: EmbeddingPrompt): Promise<EmbeddingPromptResult>;
+    /**
+     * 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
+ * TODO: [🍜] Add anonymous option
+ */ 

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

@@ -0,0 +1,26 @@
+import type { CommonExecutionToolsOptions } from '../../execution/CommonExecutionToolsOptions';
+import type { client_id } from '../../types/typeAliases';
+import type { string_uri } from '../../types/typeAliases';
+/**
+ * Options for `RemoteLlmExecutionTools`
+ *
+ * @public exported from `@promptbook/remote-client`
+ */
+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/umd/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/umd/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/umd/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/umd/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/umd/typings/src/llm-providers/remote/interfaces/RemoteServerOptions.d.ts

@@ -0,0 +1,37 @@
+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';
+/**
+ * @@@
+ *
+ * @public exported from `@promptbook/remote-client`
+ * @public exported from `@promptbook/remote-server`
+ */
+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;
+};
+/**
+ * TODO: [🍜] Add anonymous option
+ */

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

@@ -0,0 +1,21 @@
+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
+ * @public exported from `@promptbook/remote-server`
+ */
+export declare function startRemoteServer(options: RemoteServerOptions): IDestroyable;
+/**
+ * TODO: [🍜] Add anonymous option
+ * 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/umd/typings/src/personas/preparePersona.d.ts

@@ -0,0 +1,15 @@
+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
+ * @public exported from `@promptbook/core`
+ */
+export declare function preparePersona(personaDescription: string_persona_description, options: PrepareOptions): Promise<PersonaPreparedJson['modelRequirements']>;
+/**
+ * TODO: [🏢] !! Check validity of `modelName` in pipeline
+ * TODO: [🏢] !! Check validity of `systemMessage` in pipeline
+ * TODO: [🏢] !! Check validity of `temperature` in pipeline
+ */

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

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

package/umd/typings/src/postprocessing/utils/extractBlock.d.ts

@@ -0,0 +1,17 @@
+import type { string_markdown } from '../../types/typeAliases';
+/**
+ * Extracts code block from markdown.
+ *
+ * Note: If there are multiple or no code blocks the function throws an error
+ *
+ * Note: There are 3 simmilar function:
+ * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
+ * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+ * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+ *
+ * @public exported from `@promptbook/utils`
+ */
+export declare function extractBlock(markdown: string_markdown): string;
+/**
+ * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`
+ */

package/umd/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/umd/typings/src/prepare/isPipelinePrepared.d.ts

@@ -0,0 +1,15 @@
+import type { PipelineJson } from '../types/PipelineJson/PipelineJson';
+/**
+ * Determine if the pipeline is fully prepared
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function isPipelinePrepared(pipeline: PipelineJson): boolean;
+/**
+ * TODO: [🐠] Maybe base this on `makeValidator`
+ * TODO: [🧊] Pipeline can be partially prepared, this should return true ONLY if fully prepared
+ * TODO: [🧿] Maybe do same process with same granularity and subfinctions as `preparePipeline`
+ *     - [🏍] ? Is context in each template
+ *     - [♨] Are samples prepared
+ *     - [♨] Are templates prepared
+ */

package/umd/typings/src/prepare/isPipelinePrepared.test.d.ts

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

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

@@ -0,0 +1,16 @@
+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
+ * @public exported from `@promptbook/core`
+ */
+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: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
+ */

package/umd/typings/src/prepare/prepareTemplates.d.ts

@@ -0,0 +1,32 @@
+import type { PipelineJson } from '../types/PipelineJson/PipelineJson';
+import type { PromptTemplateJson } from '../types/PipelineJson/PromptTemplateJson';
+import type { PrepareOptions } from './PrepareOptions';
+type PrepareTemplateInput = Pick<PipelineJson, 'promptTemplates' | 'parameters'> & {
+    /**
+     * @@@
+     */
+    readonly knowledgePiecesCount: number;
+};
+type PreparedTemplates = {
+    /**
+     * @@@ Sequence of prompt templates that are chained together to form a pipeline
+     */
+    readonly promptTemplatesPrepared: Array<PromptTemplateJson>;
+};
+/**
+ * @@@
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function prepareTemplates(pipeline: PrepareTemplateInput, options: PrepareOptions): Promise<PreparedTemplates>;
+export {};
+/**
+ * TODO: [🧠] Add context to each template (if missing)
+ * TODO: [🧠] What is better name `prepareTemplate` or `prepareTemplateAndParameters`
+ * TODO: [♨] !!! Prepare index the samples and maybe templates
+ * 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: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
+ * TODO: [🧠][🥜]
+ */

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

@@ -0,0 +1,12 @@
+import type { PipelineJson } from '../types/PipelineJson/PipelineJson';
+/**
+ * Unprepare just strips the preparation data of the pipeline
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function unpreparePipeline(pipeline: PipelineJson): PipelineJson;
+/**
+ * TODO: [🧿] Maybe do same process with same granularity and subfinctions as `preparePipeline`
+ * TODO: Write tests for `preparePipeline`
+ * TODO: [🍙] Make some standart order of json properties
+ */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+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.
+ *
+ * @public exported from `@promptbook/execute-javascript`
+ */
+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/umd/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/umd/typings/src/scripting/javascript/JavascriptExecutionTools.d.ts

@@ -0,0 +1,8 @@
+import { JavascriptEvalExecutionTools } from './JavascriptEvalExecutionTools';
+/**
+ * Placeholder for better implementation of JavascriptExecutionTools - some propper sandboxing
+ *
+ * @alias JavascriptExecutionTools
+ * @public exported from `@promptbook/execute-javascript`
+ */
+export declare const JavascriptExecutionTools: typeof JavascriptEvalExecutionTools;

package/umd/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
+ */