@promptbook/openai 0.95.0 → 0.98.0-10

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('spacetrim'), require('crypto'), require('bottleneck'), require('openai')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'spacetrim', 'crypto', 'bottleneck', 'openai'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-openai"] = {}, global.colors, global.spaceTrim, global.crypto, global.Bottleneck, global.OpenAI));
-})(this, (function (exports, colors, spaceTrim, crypto, Bottleneck, OpenAI) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('spacetrim'), require('crypto'), require('bottleneck'), require('openai'), require('socket.io-client')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'spacetrim', 'crypto', 'bottleneck', 'openai', 'socket.io-client'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-openai"] = {}, global.colors, global.spaceTrim, global.crypto, global.Bottleneck, global.OpenAI, global.socket_ioClient));
+})(this, (function (exports, colors, spaceTrim, crypto, Bottleneck, OpenAI, socket_ioClient) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.95.0';
+    const PROMPTBOOK_ENGINE_VERSION = '0.98.0-10';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -283,6 +283,19 @@
      * @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.
@@ -1787,7 +1800,7 @@
      */
 
     /**
-     * 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`
      */
@@ -2155,7 +2168,7 @@
          * Default model for chat variant.
          */
         getDefaultChatModel() {
-            return this.getDefaultModel('gpt-4o');
+            return this.getDefaultModel('gpt-4-turbo');
         }
         /**
          * Default model for completion variant.
@@ -2185,6 +2198,9 @@
          * @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`
@@ -2358,6 +2374,569 @@
      * 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.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__default["default"]((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__default["default"]((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 = socket_ioClient.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
+     *
+     * Note: This can be used for any OpenAI compatible APIs
+     *
+     * @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 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"
+     */
+
     /**
      * Execution Tools for calling OpenAI API
      *
@@ -2369,6 +2948,9 @@
         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',
@@ -2519,6 +3101,7 @@
      * TODO: [®] DRY Register logic
      */
 
+    // Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be instantiated directly
     /**
      * Registration of LLM provider
      *
@@ -2539,6 +3122,20 @@
      * @public exported from `@promptbook/cli`
      */
     const _OpenAiAssistantRegistration = $llmToolsRegister.register(createOpenAiAssistantExecutionTools);
+    /**
+     * Registration of the OpenAI Compatible provider
+     *
+     * Note: [🏐] Configurations registrations are done in register-constructor.ts BUT constructor register-constructor.ts
+     *
+     * @public exported from `@promptbook/openai`
+     * @public exported from `@promptbook/wizard`
+     * @public exported from `@promptbook/cli`
+     */
+    const _OpenAiCompatibleRegistration = $llmToolsRegister.register(createOpenAiCompatibleExecutionTools);
+    /**
+     * Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be registered directly.
+     * It serves as a base class for OpenAiExecutionTools and other compatible implementations.
+     */
     /**
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2551,8 +3148,10 @@
     exports.OpenAiExecutionTools = OpenAiExecutionTools;
     exports.PROMPTBOOK_ENGINE_VERSION = PROMPTBOOK_ENGINE_VERSION;
     exports._OpenAiAssistantRegistration = _OpenAiAssistantRegistration;
+    exports._OpenAiCompatibleRegistration = _OpenAiCompatibleRegistration;
     exports._OpenAiRegistration = _OpenAiRegistration;
     exports.createOpenAiAssistantExecutionTools = createOpenAiAssistantExecutionTools;
+    exports.createOpenAiCompatibleExecutionTools = createOpenAiCompatibleExecutionTools;
     exports.createOpenAiExecutionTools = createOpenAiExecutionTools;
 
     Object.defineProperty(exports, '__esModule', { value: true });