@promptbook/openai 0.98.0-5 → 0.98.0-8

package/esm/index.es.js

@@ -3,6 +3,7 @@ import spaceTrim$1, { spaceTrim } from 'spacetrim';
 import { randomBytes } from 'crypto';
 import Bottleneck from 'bottleneck';
 import OpenAI from 'openai';
+import { io } from 'socket.io-client';
 
 // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
 /**
@@ -18,7 +19,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.98.0-5';
+const PROMPTBOOK_ENGINE_VERSION = '0.98.0-8';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -276,6 +277,19 @@ const VALUE_STRINGS = {
  * @public exported from `@promptbook/utils`
  */
 const SMALL_NUMBER = 0.001;
+/**
+ * Timeout for the connections in milliseconds
+ *
+ * @private within the repository - too low-level in comparison with other `MAX_...`
+ */
+const CONNECTION_TIMEOUT_MS = 7 * 1000;
+// <- TODO: [⏳] Standardize timeouts, Make DEFAULT_TIMEOUT_MS as global constant
+/**
+ * How many times to retry the connections
+ *
+ * @private within the repository - too low-level in comparison with other `MAX_...`
+ */
+const CONNECTION_RETRIES_LIMIT = 5;
 // <- TODO: [🧜‍♂️]
 /**
  * Default settings for parsing and generating CSV files in Promptbook.
@@ -1780,7 +1794,7 @@ resultContent, rawResponse) {
  */
 
 /**
- * Execution Tools for calling OpenAI API or other OpeenAI compatible provider
+ * Execution Tools for calling OpenAI API or other OpenAI compatible provider
  *
  * @public exported from `@promptbook/openai`
  */
@@ -2148,7 +2162,7 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
      * Default model for chat variant.
      */
     getDefaultChatModel() {
-        return this.getDefaultModel('gpt-4o');
+        return this.getDefaultModel('gpt-4-turbo');
     }
     /**
      * Default model for completion variant.
@@ -2178,6 +2192,9 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
      * @param options which are relevant are directly passed to the OpenAI client
      */
     constructor(options) {
+        if (options.isProxied) {
+            throw new NotYetImplementedError(`Proxy mode is not yet implemented for OpenAI assistants`);
+        }
         super(options);
         this.assistantId = options.assistantId;
         // TODO: [👱] Make limiter same as in `OpenAiExecutionTools`
@@ -2351,6 +2368,465 @@ const createOpenAiAssistantExecutionTools = Object.assign((options) => {
  * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
  */
 
+/**
+ * This error indicates problems parsing the format value
+ *
+ * For example, when the format value is not a valid JSON or CSV
+ * This is not thrown directly but in extended classes
+ *
+ * @public exported from `@promptbook/core`
+ */
+class AbstractFormatError extends Error {
+    // Note: To allow instanceof do not put here error `name`
+    // public readonly name = 'AbstractFormatError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, AbstractFormatError.prototype);
+    }
+}
+
+/**
+ * This error indicates problem with parsing of CSV
+ *
+ * @public exported from `@promptbook/core`
+ */
+class CsvFormatError extends AbstractFormatError {
+    constructor(message) {
+        super(message);
+        this.name = 'CsvFormatError';
+        Object.setPrototypeOf(this, CsvFormatError.prototype);
+    }
+}
+
+/**
+ * AuthenticationError is thrown from login function which is dependency of remote server
+ *
+ * @public exported from `@promptbook/core`
+ */
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+
+/**
+ * This error indicates that the pipeline collection cannot be properly loaded
+ *
+ * @public exported from `@promptbook/core`
+ */
+class CollectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CollectionError';
+        Object.setPrototypeOf(this, CollectionError.prototype);
+    }
+}
+
+/**
+ * This error type indicates that you try to use a feature that is not available in the current environment
+ *
+ * @public exported from `@promptbook/core`
+ */
+class EnvironmentMismatchError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EnvironmentMismatchError';
+        Object.setPrototypeOf(this, EnvironmentMismatchError.prototype);
+    }
+}
+
+/**
+ * This error occurs when some expectation is not met in the execution of the pipeline
+ *
+ * @public exported from `@promptbook/core`
+ * Note: Do not throw this error, its reserved for `checkExpectations` and `createPipelineExecutor` and public ONLY to be serializable through remote server
+ * Note: Always thrown in `checkExpectations` and catched in `createPipelineExecutor` and rethrown as `PipelineExecutionError`
+ * Note: This is a kindof subtype of PipelineExecutionError
+ */
+class ExpectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ExpectError';
+        Object.setPrototypeOf(this, ExpectError.prototype);
+    }
+}
+
+/**
+ * This error indicates that the promptbook can not retrieve knowledge from external sources
+ *
+ * @public exported from `@promptbook/core`
+ */
+class KnowledgeScrapeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'KnowledgeScrapeError';
+        Object.setPrototypeOf(this, KnowledgeScrapeError.prototype);
+    }
+}
+
+/**
+ * This error type indicates that some tools are missing for pipeline execution or preparation
+ *
+ * @public exported from `@promptbook/core`
+ */
+class MissingToolsError extends Error {
+    constructor(message) {
+        super(spaceTrim((block) => `
+                    ${block(message)}
+
+                    Note: You have probably forgot to provide some tools for pipeline execution or preparation
+
+                `));
+        this.name = 'MissingToolsError';
+        Object.setPrototypeOf(this, MissingToolsError.prototype);
+    }
+}
+
+/**
+ * This error indicates that promptbook not found in the collection
+ *
+ * @public exported from `@promptbook/core`
+ */
+class NotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotFoundError';
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+}
+
+/**
+ * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
+ *
+ * @public exported from `@promptbook/core`
+ */
+class ParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ParseError';
+        Object.setPrototypeOf(this, ParseError.prototype);
+    }
+}
+/**
+ * TODO: Maybe split `ParseError` and `ApplyError`
+ */
+
+/**
+ * This error indicates that the promptbook object has valid syntax (=can be parsed) but contains logical errors (like circular dependencies)
+ *
+ * @public exported from `@promptbook/core`
+ */
+class PipelineLogicError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PipelineLogicError';
+        Object.setPrototypeOf(this, PipelineLogicError.prototype);
+    }
+}
+
+/**
+ * This error indicates errors in referencing promptbooks between each other
+ *
+ * @public exported from `@promptbook/core`
+ */
+class PipelineUrlError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PipelineUrlError';
+        Object.setPrototypeOf(this, PipelineUrlError.prototype);
+    }
+}
+
+/**
+ * Error thrown when a fetch request fails
+ *
+ * @public exported from `@promptbook/core`
+ */
+class PromptbookFetchError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PromptbookFetchError';
+        Object.setPrototypeOf(this, PromptbookFetchError.prototype);
+    }
+}
+
+/**
+ * Index of all custom errors
+ *
+ * @public exported from `@promptbook/core`
+ */
+const PROMPTBOOK_ERRORS = {
+    AbstractFormatError,
+    CsvFormatError,
+    CollectionError,
+    EnvironmentMismatchError,
+    ExpectError,
+    KnowledgeScrapeError,
+    LimitReachedError,
+    MissingToolsError,
+    NotFoundError,
+    NotYetImplementedError,
+    ParseError,
+    PipelineExecutionError,
+    PipelineLogicError,
+    PipelineUrlError,
+    AuthenticationError,
+    PromptbookFetchError,
+    UnexpectedError,
+    WrappedError,
+    // TODO: [🪑]> VersionMismatchError,
+};
+/**
+ * Index of all javascript errors
+ *
+ * @private for internal usage
+ */
+const COMMON_JAVASCRIPT_ERRORS = {
+    Error,
+    EvalError,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    TypeError,
+    URIError,
+    AggregateError,
+    /*
+  Note: Not widely supported
+  > InternalError,
+  > ModuleError,
+  > HeapError,
+  > WebAssemblyCompileError,
+  > WebAssemblyRuntimeError,
+  */
+};
+/**
+ * Index of all errors
+ *
+ * @private for internal usage
+ */
+const ALL_ERRORS = {
+    ...PROMPTBOOK_ERRORS,
+    ...COMMON_JAVASCRIPT_ERRORS,
+};
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Deserializes the error object
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function deserializeError(error) {
+    const { name, stack, id } = error; // Added id
+    let { message } = error;
+    let ErrorClass = ALL_ERRORS[error.name];
+    if (ErrorClass === undefined) {
+        ErrorClass = Error;
+        message = `${name}: ${message}`;
+    }
+    if (stack !== undefined && stack !== '') {
+        message = spaceTrim$1((block) => `
+                ${block(message)}
+
+                Original stack trace:
+                ${block(stack || '')}
+            `);
+    }
+    const deserializedError = new ErrorClass(message);
+    deserializedError.id = id; // Assign id to the error object
+    return deserializedError;
+}
+
+/**
+ * Tests if given string is valid URL.
+ *
+ * Note: Dataurl are considered perfectly valid.
+ * Note: There are two similar functions:
+ * - `isValidUrl` which tests any URL
+ * - `isValidPipelineUrl` *(this one)* which tests just promptbook URL
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function isValidUrl(url) {
+    if (typeof url !== 'string') {
+        return false;
+    }
+    try {
+        if (url.startsWith('blob:')) {
+            url = url.replace(/^blob:/, '');
+        }
+        const urlObject = new URL(url /* because fail is handled */);
+        if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+
+/**
+ * Creates a connection to the remote proxy server.
+ *
+ * Note: This function creates a connection to the remote server and returns a socket but responsibility of closing the connection is on the caller
+ *
+ * @private internal utility function
+ */
+async function createRemoteClient(options) {
+    const { remoteServerUrl } = options;
+    if (!isValidUrl(remoteServerUrl)) {
+        throw new Error(`Invalid \`remoteServerUrl\`: "${remoteServerUrl}"`);
+    }
+    const remoteServerUrlParsed = new URL(remoteServerUrl);
+    if (remoteServerUrlParsed.pathname !== '/' && remoteServerUrlParsed.pathname !== '') {
+        remoteServerUrlParsed.pathname = '/';
+        throw new Error(spaceTrim$1((block) => `
+                        Remote server requires root url \`/\`
+
+                        You have provided \`remoteServerUrl\`:
+                        ${block(remoteServerUrl)}
+
+                        But something like this is expected:
+                        ${block(remoteServerUrlParsed.href)}
+
+                        Note: If you need to run multiple services on the same server, use 3rd or 4th degree subdomain
+
+                    `));
+    }
+    return new Promise((resolve, reject) => {
+        const socket = io(remoteServerUrl, {
+            retries: CONNECTION_RETRIES_LIMIT,
+            timeout: CONNECTION_TIMEOUT_MS,
+            path: '/socket.io',
+            transports: ['polling', 'websocket' /*, <- TODO: [🌬] Allow to pass `transports`, add 'webtransport' */],
+        });
+        // console.log('Connecting to', this.options.remoteServerUrl.href, { socket });
+        socket.on('connect', () => {
+            resolve(socket);
+        });
+        // TODO: [💩] Better timeout handling
+        setTimeout(() => {
+            reject(new Error(`Timeout while connecting to ${remoteServerUrl}`));
+        }, CONNECTION_TIMEOUT_MS);
+    });
+}
+
+/**
+ * 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`
+ */
+class RemoteLlmExecutionTools {
+    /* <- TODO: [🍚] `, Destroyable` */
+    constructor(options) {
+        this.options = options;
+    }
+    get title() {
+        // TODO: [🧠] Maybe fetch title+description from the remote server (as well as if model methods are defined)
+        return 'Promptbook remote server';
+    }
+    get description() {
+        return `Models from Promptbook remote server ${this.options.remoteServerUrl}`;
+    }
+    /**
+     * Check the configuration of all execution tools
+     */
+    async checkConfiguration() {
+        const socket = await createRemoteClient(this.options);
+        socket.disconnect();
+        // TODO: [main] !!3 Check version of the remote server and compatibility
+        // TODO: [🎍] Send checkConfiguration
+    }
+    /**
+     * List all available models that can be used
+     */
+    async listModels() {
+        // TODO: [👒] Listing models (and checking configuration) probably should go through REST API not Socket.io
+        const socket = await createRemoteClient(this.options);
+        socket.emit('listModels-request', {
+            identification: this.options.identification,
+        } /* <- Note: [🤛] */);
+        const promptResult = await new Promise((resolve, reject) => {
+            socket.on('listModels-response', (response) => {
+                resolve(response.models);
+                socket.disconnect();
+            });
+            socket.on('error', (error) => {
+                reject(deserializeError(error));
+                socket.disconnect();
+            });
+        });
+        socket.disconnect();
+        return promptResult;
+    }
+    /**
+     * Calls remote proxy server to use a chat model
+     */
+    callChatModel(prompt) {
+        if (this.options.isVerbose) {
+            console.info(`🖋 Remote callChatModel call`);
+        }
+        return /* not await */ this.callCommonModel(prompt);
+    }
+    /**
+     * Calls remote proxy server to use a completion model
+     */
+    callCompletionModel(prompt) {
+        if (this.options.isVerbose) {
+            console.info(`💬 Remote callCompletionModel call`);
+        }
+        return /* not await */ this.callCommonModel(prompt);
+    }
+    /**
+     * Calls remote proxy server to use a embedding model
+     */
+    callEmbeddingModel(prompt) {
+        if (this.options.isVerbose) {
+            console.info(`💬 Remote callEmbeddingModel call`);
+        }
+        return /* not await */ this.callCommonModel(prompt);
+    }
+    // <- Note: [🤖] callXxxModel
+    /**
+     * Calls remote proxy server to use both completion or chat model
+     */
+    async callCommonModel(prompt) {
+        const socket = await createRemoteClient(this.options);
+        socket.emit('prompt-request', {
+            identification: this.options.identification,
+            prompt,
+        } /* <- Note: [🤛] */);
+        const promptResult = await new Promise((resolve, reject) => {
+            socket.on('prompt-response', (response) => {
+                resolve(response.promptResult);
+                socket.disconnect();
+            });
+            socket.on('error', (error) => {
+                reject(deserializeError(error));
+                socket.disconnect();
+            });
+        });
+        socket.disconnect();
+        return promptResult;
+    }
+}
+/**
+ * TODO: Maybe use `$exportJson`
+ * TODO: [🧠][🛍] Maybe not `isAnonymous: boolean` BUT `mode: 'ANONYMOUS'|'COLLECTION'`
+ * TODO: [🍓] Allow to list compatible models with each variant
+ * TODO: [🗯] RemoteLlmExecutionTools should extend Destroyable and implement IDestroyable
+ * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
+ * TODO: [🧠] Maybe remove `@promptbook/remote-client` and just use `@promptbook/core`
+ */
+
 /**
  * Execution Tools for calling OpenAI compatible API
  *
@@ -2359,14 +2835,97 @@ const createOpenAiAssistantExecutionTools = Object.assign((options) => {
  * @public exported from `@promptbook/openai`
  */
 const createOpenAiCompatibleExecutionTools = Object.assign((options) => {
+    if (options.isProxied) {
+        return new RemoteLlmExecutionTools({
+            ...options,
+            identification: {
+                isAnonymous: true,
+                llmToolsConfiguration: [
+                    {
+                        title: 'OpenAI Compatible (proxied)',
+                        packageName: '@promptbook/openai',
+                        className: 'OpenAiCompatibleExecutionTools',
+                        options: {
+                            ...options,
+                            isProxied: false,
+                        },
+                    },
+                ],
+            },
+        });
+    }
     if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
         options = { ...options, dangerouslyAllowBrowser: true };
     }
-    return new OpenAiExecutionTools(options);
+    return new HardcodedOpenAiCompatibleExecutionTools(options.defaultModelName, options);
 }, {
     packageName: '@promptbook/openai',
     className: 'OpenAiCompatibleExecutionTools',
 });
+/**
+ * Execution Tools for calling ONE SPECIFIC PRECONFIGURED OpenAI compatible provider
+ *
+ * @private for `createOpenAiCompatibleExecutionTools`
+ */
+class HardcodedOpenAiCompatibleExecutionTools extends OpenAiCompatibleExecutionTools {
+    /**
+     * Creates OpenAI compatible Execution Tools.
+     *
+     * @param options which are relevant are directly passed to the OpenAI compatible client
+     */
+    constructor(defaultModelName, options) {
+        super(options);
+        this.defaultModelName = defaultModelName;
+        this.options = options;
+    }
+    get title() {
+        return `${this.defaultModelName} on ${this.options.baseURL}`;
+    }
+    get description() {
+        return `OpenAI compatible connected to "${this.options.baseURL}" model "${this.defaultModelName}"`;
+    }
+    /**
+     * List all available models (non dynamically)
+     *
+     * Note: Purpose of this is to provide more information about models than standard listing from API
+     */
+    get HARDCODED_MODELS() {
+        return [
+            {
+                modelName: this.defaultModelName,
+                modelVariant: 'CHAT',
+                modelDescription: '', // <- TODO: What is the best value here, maybe `this.description`?
+            },
+        ];
+    }
+    /**
+     * Computes the usage
+     */
+    computeUsage(...args) {
+        return {
+            ...computeOpenAiUsage(...args),
+            price: UNCERTAIN_ZERO_VALUE, // <- TODO: Maybe in future pass this counting mechanism, but for now, we dont know
+        };
+    }
+    /**
+     * Default model for chat variant.
+     */
+    getDefaultChatModel() {
+        return this.getDefaultModel(this.defaultModelName);
+    }
+    /**
+     * Default model for completion variant.
+     */
+    getDefaultCompletionModel() {
+        throw new PipelineExecutionError(`${this.title} does not support COMPLETION model variant`);
+    }
+    /**
+     * Default model for completion variant.
+     */
+    getDefaultEmbeddingModel() {
+        throw new PipelineExecutionError(`${this.title} does not support EMBEDDING model variant`);
+    }
+}
 /**
  * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?
  * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
@@ -2383,6 +2942,9 @@ const createOpenAiExecutionTools = Object.assign((options) => {
     if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
         options = { ...options, dangerouslyAllowBrowser: true };
     }
+    if (options.isProxied) {
+        throw new NotYetImplementedError(`Proxy mode is not yet implemented in createOpenAiExecutionTools`);
+    }
     return new OpenAiExecutionTools(options);
 }, {
     packageName: '@promptbook/openai',