@promptbook/openai 0.94.0-1 → 0.94.0-4

package/esm/index.es.js

@@ -18,7 +18,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.94.0-1';
+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
@@ -1257,11 +1257,11 @@ function uncertainNumber(value, isUncertain) {
 }
 
 /**
- * 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;
 }
@@ -1297,8 +1297,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1315,8 +1315,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1339,8 +1339,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1351,8 +1351,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1374,8 +1374,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1386,8 +1386,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1398,8 +1398,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1410,8 +1410,8 @@ const OPENAI_MODELS = exportJson({
             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
             },
         },
         /**/
@@ -1422,8 +1422,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1440,8 +1440,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1452,8 +1452,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1464,8 +1464,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1476,8 +1476,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1488,8 +1488,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1506,8 +1506,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1518,8 +1518,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1530,7 +1530,7 @@ const OPENAI_MODELS = exportJson({
             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
             },
@@ -1543,7 +1543,7 @@ const OPENAI_MODELS = exportJson({
             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
             },
@@ -1556,8 +1556,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1568,7 +1568,7 @@ const OPENAI_MODELS = exportJson({
             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
             },
@@ -1599,8 +1599,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1611,8 +1611,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1623,8 +1623,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1635,8 +1635,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1648,8 +1648,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1660,8 +1660,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1672,8 +1672,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1684,8 +1684,8 @@ const OPENAI_MODELS = exportJson({
             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
             },
         },
@@ -1697,8 +1697,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1709,8 +1709,8 @@ const OPENAI_MODELS = exportJson({
             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`),
             },
         },
         /**/
@@ -1785,15 +1785,15 @@ resultContent, rawResponse) {
  */
 
 /**
- * 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;
@@ -1806,12 +1806,6 @@ class OpenAiExecutionTools {
             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
@@ -1822,18 +1816,6 @@ class OpenAiExecutionTools {
         }
         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`
      */
@@ -1842,25 +1824,36 @@ class OpenAiExecutionTools {
         // 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
      */
-    listModels() {
-        /*
-        Note: Dynamic lising of the models
-        const models = await this.openai.models.list({});
-
-        console.log({ models });
-        console.log(models.data);
-        */
-        return OPENAI_MODELS;
+    async listModels() {
+        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) => {
+            const modelFromList = this.HARDCODED_MODELS.find(({ modelName }) => modelName === modelFromApi.id ||
+                modelName.startsWith(modelFromApi.id) ||
+                modelFromApi.id.startsWith(modelName));
+            if (modelFromList !== undefined) {
+                return modelFromList;
+            }
+            return {
+                modelVariant: 'CHAT',
+                modelTitle: modelFromApi.id,
+                modelName: modelFromApi.id,
+                modelDescription: '',
+            };
+        });
+        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();
@@ -1921,20 +1914,20 @@ class OpenAiExecutionTools {
         }
         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,
@@ -1957,7 +1950,7 @@ class OpenAiExecutionTools {
     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();
@@ -1998,17 +1991,17 @@ class OpenAiExecutionTools {
         }
         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,
@@ -2026,11 +2019,11 @@ class OpenAiExecutionTools {
         });
     }
     /**
-     * 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();
@@ -2065,12 +2058,12 @@ class OpenAiExecutionTools {
             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,
@@ -2093,18 +2086,69 @@ class OpenAiExecutionTools {
      */
     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$1((block) => `
-                            Cannot find model in OpenAI models with name "${defaultModelName}" which should be used as default.
+            throw new PipelineExecutionError(spaceTrim$1((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.
      */
@@ -2124,13 +2168,6 @@ class OpenAiExecutionTools {
         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
@@ -2322,10 +2359,11 @@ const createOpenAiAssistantExecutionTools = Object.assign((options) => {
 /**
  * Execution Tools for calling OpenAI API
  *
+ * Note: This can be also used for other OpenAI compatible APIs, like Ollama
+ *
  * @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 };
     }
@@ -2504,5 +2542,5 @@ const _OpenAiAssistantRegistration = $llmToolsRegister.register(createOpenAiAssi
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
-export { BOOK_LANGUAGE_VERSION, OPENAI_MODELS, OpenAiAssistantExecutionTools, OpenAiExecutionTools, PROMPTBOOK_ENGINE_VERSION, _OpenAiAssistantRegistration, _OpenAiRegistration, createOpenAiAssistantExecutionTools, createOpenAiExecutionTools };
+export { BOOK_LANGUAGE_VERSION, OPENAI_MODELS, OpenAiAssistantExecutionTools, OpenAiCompatibleExecutionTools, OpenAiExecutionTools, PROMPTBOOK_ENGINE_VERSION, _OpenAiAssistantRegistration, _OpenAiRegistration, createOpenAiAssistantExecutionTools, createOpenAiExecutionTools };
 //# sourceMappingURL=index.es.js.map