@promptbook/openai 0.94.0-3 → 0.94.0-4

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.94.0-3';
+    const PROMPTBOOK_ENGINE_VERSION = '0.94.0-4';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1264,11 +1264,11 @@
     }
 
     /**
-     * Function computeUsage will create price per one token based on the string value found on openai page
+     * 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`
      */
-    function computeUsage(value) {
+    function pricing(value) {
         const [price, tokens] = value.split(' / ');
         return parseFloat(price.replace('$', '')) / parseFloat(tokens.replace('M tokens', '')) / 1000000;
     }
@@ -1304,8 +1304,8 @@
                 modelName: 'davinci-002',
                 modelDescription: 'Legacy completion model with strong performance on text generation tasks. Optimized for complex instructions and longer outputs.',
                 pricing: {
-                    prompt: computeUsage(`$2.00 / 1M tokens`),
-                    output: computeUsage(`$2.00 / 1M tokens`),
+                    prompt: pricing(`$2.00 / 1M tokens`),
+                    output: pricing(`$2.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1322,8 +1322,8 @@
                 modelName: 'gpt-3.5-turbo-16k',
                 modelDescription: 'GPT-3.5 Turbo with extended 16k token context length for handling longer conversations and documents.',
                 pricing: {
-                    prompt: computeUsage(`$3.00 / 1M tokens`),
-                    output: computeUsage(`$4.00 / 1M tokens`),
+                    prompt: pricing(`$3.00 / 1M tokens`),
+                    output: pricing(`$4.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1346,8 +1346,8 @@
                 modelName: 'gpt-4',
                 modelDescription: 'GPT-4 is a powerful language model with enhanced reasoning, instruction-following capabilities, and 8K context window. Optimized for complex tasks requiring deep understanding.',
                 pricing: {
-                    prompt: computeUsage(`$30.00 / 1M tokens`),
-                    output: computeUsage(`$60.00 / 1M tokens`),
+                    prompt: pricing(`$30.00 / 1M tokens`),
+                    output: pricing(`$60.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1358,8 +1358,8 @@
                 modelName: 'gpt-4-32k',
                 modelDescription: 'Extended context version of GPT-4 with a 32K token window for processing very long inputs and generating comprehensive responses for complex tasks.',
                 pricing: {
-                    prompt: computeUsage(`$60.00 / 1M tokens`),
-                    output: computeUsage(`$120.00 / 1M tokens`),
+                    prompt: pricing(`$60.00 / 1M tokens`),
+                    output: pricing(`$120.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1381,8 +1381,8 @@
                 modelName: 'gpt-4-turbo-2024-04-09',
                 modelDescription: 'Latest stable GPT-4 Turbo model from April 2024 with enhanced reasoning and context handling capabilities. Offers 128K context window and improved performance.',
                 pricing: {
-                    prompt: computeUsage(`$10.00 / 1M tokens`),
-                    output: computeUsage(`$30.00 / 1M tokens`),
+                    prompt: pricing(`$10.00 / 1M tokens`),
+                    output: pricing(`$30.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1393,8 +1393,8 @@
                 modelName: 'gpt-3.5-turbo-1106',
                 modelDescription: 'November 2023 version of GPT-3.5 Turbo with improved instruction following and a 16K token context window.',
                 pricing: {
-                    prompt: computeUsage(`$1.00 / 1M tokens`),
-                    output: computeUsage(`$2.00 / 1M tokens`),
+                    prompt: pricing(`$1.00 / 1M tokens`),
+                    output: pricing(`$2.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1405,8 +1405,8 @@
                 modelName: 'gpt-4-turbo',
                 modelDescription: 'More capable model than GPT-4 with improved instruction following, function calling and a 128K token context window for handling very large documents.',
                 pricing: {
-                    prompt: computeUsage(`$10.00 / 1M tokens`),
-                    output: computeUsage(`$30.00 / 1M tokens`),
+                    prompt: pricing(`$10.00 / 1M tokens`),
+                    output: pricing(`$30.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1417,8 +1417,8 @@
                 modelName: 'gpt-3.5-turbo-instruct-0914',
                 modelDescription: 'September 2023 version of GPT-3.5 Turbo optimized for completion-style instruction following with a 4K context window.',
                 pricing: {
-                    prompt: computeUsage(`$1.50  / 1M tokens`),
-                    output: computeUsage(`$2.00 / 1M tokens`), // <- For gpt-3.5-turbo-instruct
+                    prompt: pricing(`$1.50  / 1M tokens`),
+                    output: pricing(`$2.00 / 1M tokens`), // <- For gpt-3.5-turbo-instruct
                 },
             },
             /**/
@@ -1429,8 +1429,8 @@
                 modelName: 'gpt-3.5-turbo-instruct',
                 modelDescription: 'Optimized version of GPT-3.5 for completion-style API with good instruction following and a 4K token context window.',
                 pricing: {
-                    prompt: computeUsage(`$1.50  / 1M tokens`),
-                    output: computeUsage(`$2.00 / 1M tokens`),
+                    prompt: pricing(`$1.50  / 1M tokens`),
+                    output: pricing(`$2.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1447,8 +1447,8 @@
                 modelName: 'gpt-3.5-turbo',
                 modelDescription: 'Latest version of GPT-3.5 Turbo with improved performance and instruction following capabilities. Default 4K context window with options for 16K.',
                 pricing: {
-                    prompt: computeUsage(`$0.50 / 1M tokens`),
-                    output: computeUsage(`$1.50 / 1M tokens`),
+                    prompt: pricing(`$0.50 / 1M tokens`),
+                    output: pricing(`$1.50 / 1M tokens`),
                 },
             },
             /**/
@@ -1459,8 +1459,8 @@
                 modelName: 'gpt-3.5-turbo-0301',
                 modelDescription: 'March 2023 version of GPT-3.5 Turbo with a 4K token context window. Legacy model maintained for backward compatibility.',
                 pricing: {
-                    prompt: computeUsage(`$1.50 / 1M tokens`),
-                    output: computeUsage(`$2.00 / 1M tokens`),
+                    prompt: pricing(`$1.50 / 1M tokens`),
+                    output: pricing(`$2.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1471,8 +1471,8 @@
                 modelName: 'babbage-002',
                 modelDescription: 'Efficient legacy completion model with a good balance of performance and speed. Suitable for straightforward text generation tasks.',
                 pricing: {
-                    prompt: computeUsage(`$0.40 / 1M tokens`),
-                    output: computeUsage(`$0.40 / 1M tokens`),
+                    prompt: pricing(`$0.40 / 1M tokens`),
+                    output: pricing(`$0.40 / 1M tokens`),
                 },
             },
             /**/
@@ -1483,8 +1483,8 @@
                 modelName: 'gpt-4-1106-preview',
                 modelDescription: 'November 2023 preview version of GPT-4 Turbo with improved instruction following and a 128K token context window.',
                 pricing: {
-                    prompt: computeUsage(`$10.00 / 1M tokens`),
-                    output: computeUsage(`$30.00 / 1M tokens`),
+                    prompt: pricing(`$10.00 / 1M tokens`),
+                    output: pricing(`$30.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1495,8 +1495,8 @@
                 modelName: 'gpt-4-0125-preview',
                 modelDescription: 'January 2024 preview version of GPT-4 Turbo with improved reasoning capabilities and a 128K token context window.',
                 pricing: {
-                    prompt: computeUsage(`$10.00 / 1M tokens`),
-                    output: computeUsage(`$30.00 / 1M tokens`),
+                    prompt: pricing(`$10.00 / 1M tokens`),
+                    output: pricing(`$30.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1513,8 +1513,8 @@
                 modelName: 'gpt-3.5-turbo-0125',
                 modelDescription: 'January 2024 version of GPT-3.5 Turbo with improved reasoning capabilities and a 16K token context window.',
                 pricing: {
-                    prompt: computeUsage(`$0.50 / 1M tokens`),
-                    output: computeUsage(`$1.50  / 1M tokens`),
+                    prompt: pricing(`$0.50 / 1M tokens`),
+                    output: pricing(`$1.50  / 1M tokens`),
                 },
             },
             /**/
@@ -1525,8 +1525,8 @@
                 modelName: 'gpt-4-turbo-preview',
                 modelDescription: 'Preview version of GPT-4 Turbo that points to the latest model version. Features improved instruction following, 128K token context window and lower latency.',
                 pricing: {
-                    prompt: computeUsage(`$10.00 / 1M tokens`),
-                    output: computeUsage(`$30.00 / 1M tokens`),
+                    prompt: pricing(`$10.00 / 1M tokens`),
+                    output: pricing(`$30.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1537,7 +1537,7 @@
                 modelName: 'text-embedding-3-large',
                 modelDescription: "OpenAI's most capable text embedding model designed for high-quality embeddings for complex similarity tasks and information retrieval.",
                 pricing: {
-                    prompt: computeUsage(`$0.13 / 1M tokens`),
+                    prompt: pricing(`$0.13 / 1M tokens`),
                     // TODO: [🏏] Leverage the batch API @see https://platform.openai.com/docs/guides/batch
                     output: 0, // <- Note: [🆖] In Embedding models you dont pay for output
                 },
@@ -1550,7 +1550,7 @@
                 modelName: 'text-embedding-3-small',
                 modelDescription: 'Cost-effective embedding model with good performance for simpler tasks like text similarity and retrieval. Good balance of quality and efficiency.',
                 pricing: {
-                    prompt: computeUsage(`$0.02 / 1M tokens`),
+                    prompt: pricing(`$0.02 / 1M tokens`),
                     // TODO: [🏏] Leverage the batch API @see https://platform.openai.com/docs/guides/batch
                     output: 0, // <- Note: [🆖] In Embedding models you dont pay for output
                 },
@@ -1563,8 +1563,8 @@
                 modelName: 'gpt-3.5-turbo-0613',
                 modelDescription: 'June 2023 version of GPT-3.5 Turbo with function calling capabilities and a 4K token context window.',
                 pricing: {
-                    prompt: computeUsage(`$1.50 / 1M tokens`),
-                    output: computeUsage(`$2.00 / 1M tokens`),
+                    prompt: pricing(`$1.50 / 1M tokens`),
+                    output: pricing(`$2.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1575,7 +1575,7 @@
                 modelName: 'text-embedding-ada-002',
                 modelDescription: 'Legacy text embedding model suitable for text similarity and retrieval augmented generation use cases. Replaced by newer embedding-3 models.',
                 pricing: {
-                    prompt: computeUsage(`$0.1 / 1M tokens`),
+                    prompt: pricing(`$0.1 / 1M tokens`),
                     // TODO: [🏏] Leverage the batch API @see https://platform.openai.com/docs/guides/batch
                     output: 0, // <- Note: [🆖] In Embedding models you dont pay for output
                 },
@@ -1606,8 +1606,8 @@
                 modelName: 'gpt-4o-2024-05-13',
                 modelDescription: 'May 2024 version of GPT-4o with enhanced multimodal capabilities, improved reasoning, and optimized for vision, audio and chat at lower latencies.',
                 pricing: {
-                    prompt: computeUsage(`$5.00 / 1M tokens`),
-                    output: computeUsage(`$15.00 / 1M tokens`),
+                    prompt: pricing(`$5.00 / 1M tokens`),
+                    output: pricing(`$15.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1618,8 +1618,8 @@
                 modelName: 'gpt-4o',
                 modelDescription: "OpenAI's most advanced multimodal model optimized for performance, speed, and cost. Capable of vision, reasoning, and high quality text generation.",
                 pricing: {
-                    prompt: computeUsage(`$5.00 / 1M tokens`),
-                    output: computeUsage(`$15.00 / 1M tokens`),
+                    prompt: pricing(`$5.00 / 1M tokens`),
+                    output: pricing(`$15.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1630,8 +1630,8 @@
                 modelName: 'gpt-4o-mini',
                 modelDescription: 'Smaller, more cost-effective version of GPT-4o with good performance across text, vision, and audio tasks at reduced complexity.',
                 pricing: {
-                    prompt: computeUsage(`$0.15 / 1M tokens`),
-                    output: computeUsage(`$0.60 / 1M tokens`),
+                    prompt: pricing(`$0.15 / 1M tokens`),
+                    output: pricing(`$0.60 / 1M tokens`),
                 },
             },
             /**/
@@ -1642,8 +1642,8 @@
                 modelName: 'o1-preview',
                 modelDescription: 'Advanced reasoning model with exceptional performance on complex logical, mathematical, and analytical tasks. Built for deep reasoning and specialized professional tasks.',
                 pricing: {
-                    prompt: computeUsage(`$15.00 / 1M tokens`),
-                    output: computeUsage(`$60.00 / 1M tokens`),
+                    prompt: pricing(`$15.00 / 1M tokens`),
+                    output: pricing(`$60.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1655,8 +1655,8 @@
                 modelDescription: 'September 2024 version of O1 preview with specialized reasoning capabilities for complex tasks requiring precise analytical thinking.',
                 //             <- TODO: [💩] Some better system to organize these date suffixes and versions
                 pricing: {
-                    prompt: computeUsage(`$15.00 / 1M tokens`),
-                    output: computeUsage(`$60.00 / 1M tokens`),
+                    prompt: pricing(`$15.00 / 1M tokens`),
+                    output: pricing(`$60.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1667,8 +1667,8 @@
                 modelName: 'o1-mini',
                 modelDescription: 'Smaller, cost-effective version of the O1 model with good performance on reasoning tasks while maintaining efficiency for everyday analytical use.',
                 pricing: {
-                    prompt: computeUsage(`$3.00 / 1M tokens`),
-                    output: computeUsage(`$12.00 / 1M tokens`),
+                    prompt: pricing(`$3.00 / 1M tokens`),
+                    output: pricing(`$12.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1679,8 +1679,8 @@
                 modelName: 'o1',
                 modelDescription: "OpenAI's advanced reasoning model focused on logic and problem-solving. Designed for complex analytical tasks with rigorous step-by-step reasoning. 128K context window.",
                 pricing: {
-                    prompt: computeUsage(`$15.00 / 1M tokens`),
-                    output: computeUsage(`$60.00 / 1M tokens`),
+                    prompt: pricing(`$15.00 / 1M tokens`),
+                    output: pricing(`$60.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1691,8 +1691,8 @@
                 modelName: 'o3-mini',
                 modelDescription: 'Cost-effective reasoning model optimized for academic and scientific problem-solving. Efficient performance on STEM tasks with deep mathematical and scientific knowledge. 128K context window.',
                 pricing: {
-                    prompt: computeUsage(`$3.00 / 1M tokens`),
-                    output: computeUsage(`$12.00 / 1M tokens`),
+                    prompt: pricing(`$3.00 / 1M tokens`),
+                    output: pricing(`$12.00 / 1M tokens`),
                     // <- TODO: !! Unsure, check the pricing
                 },
             },
@@ -1704,8 +1704,8 @@
                 modelName: 'o1-mini-2024-09-12',
                 modelDescription: "September 2024 version of O1-mini with balanced reasoning capabilities and cost-efficiency. Good for analytical tasks that don't require the full O1 model.",
                 pricing: {
-                    prompt: computeUsage(`$3.00 / 1M tokens`),
-                    output: computeUsage(`$12.00 / 1M tokens`),
+                    prompt: pricing(`$3.00 / 1M tokens`),
+                    output: pricing(`$12.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1716,8 +1716,8 @@
                 modelName: 'gpt-3.5-turbo-16k-0613',
                 modelDescription: 'June 2023 version of GPT-3.5 Turbo with extended 16k token context window for processing longer conversations and documents.',
                 pricing: {
-                    prompt: computeUsage(`$3.00 / 1M tokens`),
-                    output: computeUsage(`$4.00 / 1M tokens`),
+                    prompt: pricing(`$3.00 / 1M tokens`),
+                    output: pricing(`$4.00 / 1M tokens`),
                 },
             },
             /**/
@@ -1792,15 +1792,15 @@
      */
 
     /**
-     * Execution Tools for calling OpenAI API
+     * Execution Tools for calling OpenAI API or other OpeenAI compatible provider
      *
      * @public exported from `@promptbook/openai`
      */
-    class OpenAiExecutionTools {
+    class OpenAiCompatibleExecutionTools {
         /**
-         * Creates OpenAI Execution Tools.
+         * Creates OpenAI compatible Execution Tools.
          *
-         * @param options which are relevant are directly passed to the OpenAI client
+         * @param options which are relevant are directly passed to the OpenAI compatible client
          */
         constructor(options) {
             this.options = options;
@@ -1813,12 +1813,6 @@
                 minTime: 60000 / (this.options.maxRequestsPerMinute || DEFAULT_MAX_REQUESTS_PER_MINUTE),
             });
         }
-        get title() {
-            return 'OpenAI';
-        }
-        get description() {
-            return 'Use all models provided by OpenAI';
-        }
         async getClient() {
             if (this.client === null) {
                 // Note: Passing only OpenAI relevant options to OpenAI constructor
@@ -1829,18 +1823,6 @@
             }
             return this.client;
         }
-        /*
-        Note: Commenting this out to avoid circular dependency
-        /**
-         * Create (sub)tools for calling OpenAI API Assistants
-         *
-         * @param assistantId Which assistant to use
-         * @returns Tools for calling OpenAI API Assistants with same token
-         * /
-        public createAssistantSubtools(assistantId: string_token): OpenAiAssistantExecutionTools {
-            return new OpenAiAssistantExecutionTools({ ...this.options, assistantId });
-        }
-        */
         /**
          * Check the `options` passed to `constructor`
          */
@@ -1849,23 +1831,15 @@
             // TODO: [🎍] Do here a real check that API is online, working and API key is correct
         }
         /**
-         * List all available OpenAI models that can be used
+         * List all available OpenAI compatible models that can be used
          */
         async listModels() {
-            /*
-            Note: Dynamic lising of the models
-            const models = await this.openai.models.list({});
-
-            console.log({ models });
-            console.log(models.data);
-            */
             const client = await this.getClient();
             const rawModelsList = await client.models.list();
             const availableModels = rawModelsList.data
                 .sort((a, b) => (a.created > b.created ? 1 : -1))
                 .map((modelFromApi) => {
-                // TODO: !!!! What about other model compatibilities?
-                const modelFromList = OPENAI_MODELS.find(({ modelName }) => modelName === modelFromApi.id ||
+                const modelFromList = this.HARDCODED_MODELS.find(({ modelName }) => modelName === modelFromApi.id ||
                     modelName.startsWith(modelFromApi.id) ||
                     modelFromApi.id.startsWith(modelName));
                 if (modelFromList !== undefined) {
@@ -1881,12 +1855,12 @@
             return availableModels;
         }
         /**
-         * Calls OpenAI API to use a chat model.
+         * Calls OpenAI compatible API to use a chat model.
          */
         async callChatModel(prompt) {
             var _a;
             if (this.options.isVerbose) {
-                console.info('💬 OpenAI callChatModel call', { prompt });
+                console.info(`💬 ${this.title} callChatModel call`, { prompt });
             }
             const { content, parameters, modelRequirements, format } = prompt;
             const client = await this.getClient();
@@ -1947,20 +1921,20 @@
             }
             const complete = $getCurrentDate();
             if (!rawResponse.choices[0]) {
-                throw new PipelineExecutionError('No choises from OpenAI');
+                throw new PipelineExecutionError(`No choises from ${this.title}`);
             }
             if (rawResponse.choices.length > 1) {
                 // TODO: This should be maybe only warning
-                throw new PipelineExecutionError('More than one choise from OpenAI');
+                throw new PipelineExecutionError(`More than one choise from ${this.title}`);
             }
             const resultContent = rawResponse.choices[0].message.content;
-            const usage = computeOpenAiUsage(content || '', resultContent || '', rawResponse);
+            const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
             if (resultContent === null) {
-                throw new PipelineExecutionError('No response message from OpenAI');
+                throw new PipelineExecutionError(`No response message from ${this.title}`);
             }
             return exportJson({
                 name: 'promptResult',
-                message: `Result of \`OpenAiExecutionTools.callChatModel\``,
+                message: `Result of \`OpenAiCompatibleExecutionTools.callChatModel\``,
                 order: [],
                 value: {
                     content: resultContent,
@@ -1983,7 +1957,7 @@
         async callCompletionModel(prompt) {
             var _a;
             if (this.options.isVerbose) {
-                console.info('🖋 OpenAI callCompletionModel call', { prompt });
+                console.info(`🖋 ${this.title} callCompletionModel call`, { prompt });
             }
             const { content, parameters, modelRequirements } = prompt;
             const client = await this.getClient();
@@ -2024,17 +1998,17 @@
             }
             const complete = $getCurrentDate();
             if (!rawResponse.choices[0]) {
-                throw new PipelineExecutionError('No choises from OpenAI');
+                throw new PipelineExecutionError(`No choises from ${this.title}`);
             }
             if (rawResponse.choices.length > 1) {
                 // TODO: This should be maybe only warning
-                throw new PipelineExecutionError('More than one choise from OpenAI');
+                throw new PipelineExecutionError(`More than one choise from ${this.title}`);
             }
             const resultContent = rawResponse.choices[0].text;
-            const usage = computeOpenAiUsage(content || '', resultContent || '', rawResponse);
+            const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
             return exportJson({
                 name: 'promptResult',
-                message: `Result of \`OpenAiExecutionTools.callCompletionModel\``,
+                message: `Result of \`OpenAiCompatibleExecutionTools.callCompletionModel\``,
                 order: [],
                 value: {
                     content: resultContent,
@@ -2052,11 +2026,11 @@
             });
         }
         /**
-         * Calls OpenAI API to use a embedding model
+         * Calls OpenAI compatible API to use a embedding model
          */
         async callEmbeddingModel(prompt) {
             if (this.options.isVerbose) {
-                console.info('🖋 OpenAI embedding call', { prompt });
+                console.info(`🖋 ${this.title} embedding call`, { prompt });
             }
             const { content, parameters, modelRequirements } = prompt;
             const client = await this.getClient();
@@ -2091,12 +2065,12 @@
                 throw new PipelineExecutionError(`Expected exactly 1 data item in response, got ${rawResponse.data.length}`);
             }
             const resultContent = rawResponse.data[0].embedding;
-            const usage = computeOpenAiUsage(content || '', '', 
+            const usage = this.computeUsage(content || '', '', 
             // <- Note: Embedding does not have result content
             rawResponse);
             return exportJson({
                 name: 'promptResult',
-                message: `Result of \`OpenAiExecutionTools.callEmbeddingModel\``,
+                message: `Result of \`OpenAiCompatibleExecutionTools.callEmbeddingModel\``,
                 order: [],
                 value: {
                     content: resultContent,
@@ -2119,18 +2093,69 @@
          */
         getDefaultModel(defaultModelName) {
             // Note: Match exact or prefix for model families
-            const model = OPENAI_MODELS.find(({ modelName }) => modelName === defaultModelName || modelName.startsWith(defaultModelName));
+            const model = this.HARDCODED_MODELS.find(({ modelName }) => modelName === defaultModelName || modelName.startsWith(defaultModelName));
             if (model === undefined) {
-                throw new UnexpectedError(spaceTrim__default["default"]((block) => `
-                            Cannot find model in OpenAI models with name "${defaultModelName}" which should be used as default.
+                throw new PipelineExecutionError(spaceTrim__default["default"]((block) => `
+                            Cannot find model in ${this.title} models with name "${defaultModelName}" which should be used as default.
 
                             Available models:
-                            ${block(OPENAI_MODELS.map(({ modelName }) => `- "${modelName}"`).join('\n'))}
+                            ${block(this.HARDCODED_MODELS.map(({ modelName }) => `- "${modelName}"`).join('\n'))}
+
+                            Model "${defaultModelName}" is probably not available anymore, not installed, inaccessible or misconfigured.
 
                         `));
             }
             return model;
         }
+    }
+    /**
+     * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`
+     * TODO: [🛄] Maybe make custom `OpenAiCompatibleError`
+     * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
+     * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
+     */
+
+    /**
+     * Execution Tools for calling OpenAI API
+     *
+     * @public exported from `@promptbook/openai`
+     */
+    class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
+        constructor() {
+            super(...arguments);
+            /**
+             * Computes the usage of the OpenAI API based on the response from OpenAI
+             */
+            this.computeUsage = computeOpenAiUsage;
+            // <- Note: [🤖] getDefaultXxxModel
+        }
+        /* <- TODO: [🍚] `, Destroyable` */
+        get title() {
+            return 'OpenAI';
+        }
+        get description() {
+            return 'Use all models provided by OpenAI';
+        }
+        /*
+        Note: Commenting this out to avoid circular dependency
+        /**
+         * Create (sub)tools for calling OpenAI API Assistants
+         *
+         * @param assistantId Which assistant to use
+         * @returns Tools for calling OpenAI API Assistants with same token
+         * /
+        public createAssistantSubtools(assistantId: string_token): OpenAiAssistantExecutionTools {
+            return new OpenAiAssistantExecutionTools({ ...this.options, assistantId });
+        }
+        */
+        /**
+         * 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 OPENAI_MODELS;
+        }
         /**
          * Default model for chat variant.
          */
@@ -2150,13 +2175,6 @@
             return this.getDefaultModel('text-embedding-3-large');
         }
     }
-    /**
-     * 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
-     * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
-     */
 
     /**
      * Execution Tools for calling OpenAI API Assistants
@@ -2353,7 +2371,6 @@
      * @public exported from `@promptbook/openai`
      */
     const createOpenAiExecutionTools = Object.assign((options) => {
-        // TODO: [🧠][main] !!4 If browser, auto add `dangerouslyAllowBrowser`
         if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
             options = { ...options, dangerouslyAllowBrowser: true };
         }
@@ -2535,6 +2552,7 @@
     exports.BOOK_LANGUAGE_VERSION = BOOK_LANGUAGE_VERSION;
     exports.OPENAI_MODELS = OPENAI_MODELS;
     exports.OpenAiAssistantExecutionTools = OpenAiAssistantExecutionTools;
+    exports.OpenAiCompatibleExecutionTools = OpenAiCompatibleExecutionTools;
     exports.OpenAiExecutionTools = OpenAiExecutionTools;
     exports.PROMPTBOOK_ENGINE_VERSION = PROMPTBOOK_ENGINE_VERSION;
     exports._OpenAiAssistantRegistration = _OpenAiAssistantRegistration;