@promptbook/cli 0.94.0-3 → 0.94.0-4

package/umd/index.umd.js

@@ -57,7 +57,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
@@ -11832,7 +11832,7 @@
     function preserve(func) {
         // Note: NOT calling the function
         (async () => {
-            // TODO: [💩] Change to `await forEver` or something better
+            // TODO: [💩] Change to `await forEver` or `forTime(Infinity)`
             await waitasecond.forTime(100000000);
             // [1]
             try {
@@ -12447,7 +12447,10 @@
     function usageToHuman(usage) {
         const reportItems = [];
         const uncertainNumberToHuman = ({ value, isUncertain }) => `${isUncertain ? 'approximately ' : ''}${Math.round(value * 100) / 100}`;
-        if (usage.price.value > 0.01
+        if (usage.price.value === 0) {
+            reportItems.push(`Zero cost`);
+        }
+        else if (usage.price.value > 0.01
         // <- TODO: [🍓][🧞‍♂️][👩🏽‍🤝‍🧑🏻] Configure negligible value - default value to config + value to `UsageToHumanSettings`
         ) {
             reportItems.push(`Cost ${uncertainNumberToHuman(usage.price)} USD`);
@@ -15077,11 +15080,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;
     }
@@ -15103,8 +15106,8 @@
                 modelName: 'claude-3-5-sonnet-20240620',
                 modelDescription: 'Latest Claude model with great reasoning, coding, and language understanding capabilities. 200K context window. Optimized balance of intelligence and speed.',
                 pricing: {
-                    prompt: computeUsage(`$2.50 / 1M tokens`),
-                    output: computeUsage(`$12.50 / 1M tokens`),
+                    prompt: pricing(`$2.50 / 1M tokens`),
+                    output: pricing(`$12.50 / 1M tokens`),
                 },
             },
             {
@@ -15113,8 +15116,8 @@
                 modelName: 'claude-3-opus-20240229',
                 modelDescription: 'Most capable Claude model excelling at complex reasoning, coding, and detailed instruction following. 200K context window. Best for sophisticated tasks requiring nuanced understanding.',
                 pricing: {
-                    prompt: computeUsage(`$12.00 / 1M tokens`),
-                    output: computeUsage(`$60.00 / 1M tokens`),
+                    prompt: pricing(`$12.00 / 1M tokens`),
+                    output: pricing(`$60.00 / 1M tokens`),
                 },
             },
             {
@@ -15123,8 +15126,8 @@
                 modelName: 'claude-3-sonnet-20240229',
                 modelDescription: 'Strong general-purpose model with excellent performance across reasoning, conversation, and coding tasks. 200K context window. Good balance of intelligence and cost-efficiency.',
                 pricing: {
-                    prompt: computeUsage(`$3.00 / 1M tokens`),
-                    output: computeUsage(`$15.00 / 1M tokens`),
+                    prompt: pricing(`$3.00 / 1M tokens`),
+                    output: pricing(`$15.00 / 1M tokens`),
                 },
             },
             {
@@ -15133,8 +15136,8 @@
                 modelName: '	claude-3-haiku-20240307',
                 modelDescription: 'Fastest and most compact Claude model optimized for responsiveness in interactive applications. 200K context window. Excellent for quick responses and lightweight applications.',
                 pricing: {
-                    prompt: computeUsage(`$0.25 / 1M tokens`),
-                    output: computeUsage(`$1.25 / 1M tokens`),
+                    prompt: pricing(`$0.25 / 1M tokens`),
+                    output: pricing(`$1.25 / 1M tokens`),
                 },
             },
             {
@@ -15143,8 +15146,8 @@
                 modelName: 'claude-2.1',
                 modelDescription: 'Improved version of Claude 2 with better performance across reasoning and truthfulness. 100K context window. Legacy model with strong reliability.',
                 pricing: {
-                    prompt: computeUsage(`$8.00 / 1M tokens`),
-                    output: computeUsage(`$24.00 / 1M tokens`),
+                    prompt: pricing(`$8.00 / 1M tokens`),
+                    output: pricing(`$24.00 / 1M tokens`),
                 },
             },
             {
@@ -15153,8 +15156,8 @@
                 modelName: 'claude-2.0',
                 modelDescription: 'Legacy model with strong general reasoning and language capabilities. 100K context window. Superseded by newer Claude 3 models.',
                 pricing: {
-                    prompt: computeUsage(`$8.00 / 1M tokens`),
-                    output: computeUsage(`$24.00 / 1M tokens`),
+                    prompt: pricing(`$8.00 / 1M tokens`),
+                    output: pricing(`$24.00 / 1M tokens`),
                 },
             },
             {
@@ -15163,8 +15166,8 @@
                 modelName: 'claude-instant-1.2',
                 modelDescription: 'Older, faster Claude model optimized for high throughput applications. Lower cost but less capable than newer models. 100K context window.',
                 pricing: {
-                    prompt: computeUsage(`$0.80 / 1M tokens`),
-                    output: computeUsage(`$2.40 / 1M tokens`),
+                    prompt: pricing(`$0.80 / 1M tokens`),
+                    output: pricing(`$2.40 / 1M tokens`),
                 },
             },
             {
@@ -15173,8 +15176,8 @@
                 modelName: 'claude-3-7-sonnet-20250219',
                 modelDescription: 'Latest generation Claude model with advanced reasoning and language understanding. Enhanced capabilities over 3.5 with improved domain knowledge. 200K context window.',
                 pricing: {
-                    prompt: computeUsage(`$2.50 / 1M tokens`),
-                    output: computeUsage(`$12.50 / 1M tokens`),
+                    prompt: pricing(`$2.50 / 1M tokens`),
+                    output: pricing(`$12.50 / 1M tokens`),
                 },
             },
             {
@@ -15183,11 +15186,31 @@
                 modelName: 'claude-3-5-haiku-20241022',
                 modelDescription: 'Fast and efficient Claude 3.5 variant optimized for speed and cost-effectiveness. Great for interactive applications requiring quick responses. 200K context window.',
                 pricing: {
-                    prompt: computeUsage(`$0.25 / 1M tokens`),
-                    output: computeUsage(`$1.25 / 1M tokens`),
+                    prompt: pricing(`$0.25 / 1M tokens`),
+                    output: pricing(`$1.25 / 1M tokens`),
                 },
             },
-            // <- [🕕]
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'Claude 3.7 Haiku',
+                modelName: 'claude-3-7-haiku-20250115',
+                modelDescription: 'Ultra-fast Claude variant for lightweight applications',
+                pricing: {
+                    prompt: pricing(`$0.20 / 1M tokens`),
+                    output: pricing(`$1.00 / 1M tokens`),
+                },
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'Claude Embedding',
+                modelName: 'claude-embedding-1',
+                modelDescription: 'Model optimized for text embeddings',
+                pricing: {
+                    prompt: pricing(`$0.05 / 1M tokens`),
+                    output: 0,
+                },
+            },
+            // …add any additional models from https://docs.anthropic.com/en/docs/models-overview…
         ],
     });
     /**
@@ -15652,8 +15675,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`),
                 },
             },
             /**/
@@ -15670,8 +15693,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`),
                 },
             },
             /**/
@@ -15694,8 +15717,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`),
                 },
             },
             /**/
@@ -15706,8 +15729,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`),
                 },
             },
             /**/
@@ -15729,8 +15752,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`),
                 },
             },
             /**/
@@ -15741,8 +15764,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`),
                 },
             },
             /**/
@@ -15753,8 +15776,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`),
                 },
             },
             /**/
@@ -15765,8 +15788,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
                 },
             },
             /**/
@@ -15777,8 +15800,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`),
                 },
             },
             /**/
@@ -15795,8 +15818,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`),
                 },
             },
             /**/
@@ -15807,8 +15830,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`),
                 },
             },
             /**/
@@ -15819,8 +15842,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`),
                 },
             },
             /**/
@@ -15831,8 +15854,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`),
                 },
             },
             /**/
@@ -15843,8 +15866,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`),
                 },
             },
             /**/
@@ -15861,8 +15884,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`),
                 },
             },
             /**/
@@ -15873,8 +15896,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`),
                 },
             },
             /**/
@@ -15885,7 +15908,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
                 },
@@ -15898,7 +15921,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
                 },
@@ -15911,8 +15934,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`),
                 },
             },
             /**/
@@ -15923,7 +15946,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
                 },
@@ -15954,8 +15977,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`),
                 },
             },
             /**/
@@ -15966,8 +15989,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`),
                 },
             },
             /**/
@@ -15978,8 +16001,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`),
                 },
             },
             /**/
@@ -15990,8 +16013,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`),
                 },
             },
             /**/
@@ -16003,8 +16026,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`),
                 },
             },
             /**/
@@ -16015,8 +16038,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`),
                 },
             },
             /**/
@@ -16027,8 +16050,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`),
                 },
             },
             /**/
@@ -16039,8 +16062,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
                 },
             },
@@ -16052,8 +16075,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`),
                 },
             },
             /**/
@@ -16064,8 +16087,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`),
                 },
             },
             /**/
@@ -16645,8 +16668,8 @@
                 modelName: 'deepseek-chat',
                 modelDescription: 'General-purpose language model with strong performance across conversation, reasoning, and content generation. 128K context window with excellent instruction following capabilities.',
                 pricing: {
-                    prompt: computeUsage(`$0.80 / 1M tokens`),
-                    output: computeUsage(`$1.60 / 1M tokens`),
+                    prompt: pricing(`$0.80 / 1M tokens`),
+                    output: pricing(`$1.60 / 1M tokens`),
                 },
             },
             {
@@ -16655,8 +16678,8 @@
                 modelName: 'deepseek-reasoner',
                 modelDescription: 'Specialized model focused on complex reasoning tasks like mathematical problem-solving and logical analysis. Enhanced step-by-step reasoning with explicit chain-of-thought processes. 128K context window.',
                 pricing: {
-                    prompt: computeUsage(`$3.50 / 1M tokens`),
-                    output: computeUsage(`$7.00 / 1M tokens`),
+                    prompt: pricing(`$3.50 / 1M tokens`),
+                    output: pricing(`$7.00 / 1M tokens`),
                 },
             },
             {
@@ -16665,8 +16688,8 @@
                 modelName: 'deepseek-v3-0324',
                 modelDescription: 'Advanced general-purpose model with improved reasoning, coding abilities, and multimodal understanding. Built on the latest DeepSeek architecture with enhanced knowledge representation.',
                 pricing: {
-                    prompt: computeUsage(`$1.50 / 1M tokens`),
-                    output: computeUsage(`$3.00 / 1M tokens`),
+                    prompt: pricing(`$1.50 / 1M tokens`),
+                    output: pricing(`$3.00 / 1M tokens`),
                 },
             },
             {
@@ -16675,11 +16698,31 @@
                 modelName: 'deepseek-r1',
                 modelDescription: 'Research-focused model optimized for scientific problem-solving and analytical tasks. Excellent performance on tasks requiring domain-specific expertise and critical thinking.',
                 pricing: {
-                    prompt: computeUsage(`$5.00 / 1M tokens`),
-                    output: computeUsage(`$10.00 / 1M tokens`),
+                    prompt: pricing(`$5.00 / 1M tokens`),
+                    output: pricing(`$10.00 / 1M tokens`),
                 },
             },
-            // <- [🕕]
+            {
+                modelVariant: 'EMBEDDING',
+                modelTitle: 'DeepSeek Embedder',
+                modelName: 'deepseek-embedder-v1',
+                modelDescription: 'High-quality text embedding model',
+                pricing: {
+                    prompt: pricing(`$0.10 / 1M tokens`),
+                    output: 0,
+                },
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'DeepSeek Vision',
+                modelName: 'deepseek-vision-v2',
+                modelDescription: 'Multimodal model for image + text tasks',
+                pricing: {
+                    prompt: pricing(`$1.20 / 1M tokens`),
+                    output: pricing(`$2.40 / 1M tokens`),
+                },
+            },
+            // …add any additional at https://www.deepseek.com/models…
         ],
     });
     /**
@@ -16804,8 +16847,8 @@
                 modelName: 'gemini-2.5-pro-preview-03-25',
                 modelDescription: 'Latest advanced multimodal model with exceptional reasoning, tool use, and instruction following. 1M token context window with improved vision capabilities for complex visual tasks.',
                 pricing: {
-                    prompt: computeUsage(`$8.00 / 1M tokens`),
-                    output: computeUsage(`$24.00 / 1M tokens`),
+                    prompt: pricing(`$8.00 / 1M tokens`),
+                    output: pricing(`$24.00 / 1M tokens`),
                 },
             },
             {
@@ -16814,8 +16857,8 @@
                 modelName: 'gemini-2.0-flash',
                 modelDescription: 'Fast, efficient model optimized for rapid response times. Good balance between performance and cost, with strong capabilities across text, code, and reasoning tasks. 128K context window.',
                 pricing: {
-                    prompt: computeUsage(`$0.35 / 1M tokens`),
-                    output: computeUsage(`$1.05 / 1M tokens`),
+                    prompt: pricing(`$0.35 / 1M tokens`),
+                    output: pricing(`$1.05 / 1M tokens`),
                 },
             },
             {
@@ -16824,8 +16867,8 @@
                 modelName: 'gemini-2.0-flash-lite',
                 modelDescription: 'Streamlined version of Gemini 2.0 Flash, designed for extremely low-latency applications and edge deployments. Optimized for efficiency while maintaining core capabilities.',
                 pricing: {
-                    prompt: computeUsage(`$0.20 / 1M tokens`),
-                    output: computeUsage(`$0.60 / 1M tokens`),
+                    prompt: pricing(`$0.20 / 1M tokens`),
+                    output: pricing(`$0.60 / 1M tokens`),
                 },
             },
             {
@@ -16834,8 +16877,8 @@
                 modelName: 'gemini-2.0-flash-thinking-exp-01-21',
                 modelDescription: 'Experimental model focused on enhanced reasoning with explicit chain-of-thought processes. Designed for tasks requiring structured thinking and problem-solving approaches.',
                 pricing: {
-                    prompt: computeUsage(`$0.35 / 1M tokens`),
-                    output: computeUsage(`$1.05 / 1M tokens`),
+                    prompt: pricing(`$0.35 / 1M tokens`),
+                    output: pricing(`$1.05 / 1M tokens`),
                 },
             },
             {
@@ -16844,8 +16887,8 @@
                 modelName: 'gemini-1.5-flash',
                 modelDescription: 'Efficient model balancing speed and quality for general-purpose applications. 1M token context window with good multimodal capabilities and quick response times.',
                 pricing: {
-                    prompt: computeUsage(`$0.25 / 1M tokens`),
-                    output: computeUsage(`$0.75 / 1M tokens`),
+                    prompt: pricing(`$0.25 / 1M tokens`),
+                    output: pricing(`$0.75 / 1M tokens`),
                 },
             },
             {
@@ -16902,8 +16945,8 @@
                 modelName: 'gemini-1.5-pro-latest',
                 modelDescription: 'Points to the most recent version of the flagship Gemini 1.5 Pro model, ensuring access to the latest capabilities and improvements.',
                 pricing: {
-                    prompt: computeUsage(`$7.00 / 1M tokens`),
-                    output: computeUsage(`$21.00 / 1M tokens`),
+                    prompt: pricing(`$7.00 / 1M tokens`),
+                    output: pricing(`$21.00 / 1M tokens`),
                 },
             },
             {
@@ -16912,8 +16955,8 @@
                 modelName: 'gemini-1.5-pro',
                 modelDescription: 'Flagship multimodal model with strong performance across text, code, vision, and audio tasks. 1M token context window with excellent reasoning capabilities.',
                 pricing: {
-                    prompt: computeUsage(`$6.00 / 1M tokens`),
-                    output: computeUsage(`$18.00 / 1M tokens`),
+                    prompt: pricing(`$6.00 / 1M tokens`),
+                    output: pricing(`$18.00 / 1M tokens`),
                 },
             },
             {
@@ -16940,11 +16983,31 @@
                 modelName: 'gemini-1.0-pro',
                 modelDescription: 'Original Gemini series foundation model with solid multimodal capabilities. 32K context window with good performance on text, code, and basic vision tasks.',
                 pricing: {
-                    prompt: computeUsage(`$0.35 / 1M tokens`),
-                    output: computeUsage(`$1.05 / 1M tokens`),
+                    prompt: pricing(`$0.35 / 1M tokens`),
+                    output: pricing(`$1.05 / 1M tokens`),
                 },
             },
-            // <- [🕕]
+            {
+                modelVariant: 'EMBEDDING',
+                modelTitle: 'Gemini Embedder',
+                modelName: 'gemini-embedder-v1',
+                modelDescription: 'High-quality embeddings for retrieval',
+                pricing: {
+                    prompt: pricing(`$0.08 / 1M tokens`),
+                    output: 0,
+                },
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'Gemini Pro Vision',
+                modelName: 'gemini-pro-vision-v1',
+                modelDescription: 'Advanced vision + language model',
+                pricing: {
+                    prompt: pricing(`$9.00 / 1M tokens`),
+                    output: pricing(`$27.00 / 1M tokens`),
+                },
+            },
+            // …add any additional from https://ai.google.dev/models/gemini…
         ],
     });
     /**
@@ -17102,15 +17165,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;
@@ -17123,12 +17186,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
@@ -17139,18 +17196,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`
          */
@@ -17159,23 +17204,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) {
@@ -17191,12 +17228,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();
@@ -17257,20 +17294,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,
@@ -17293,7 +17330,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();
@@ -17334,17 +17371,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,
@@ -17362,11 +17399,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();
@@ -17401,12 +17438,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,
@@ -17429,65 +17466,171 @@
          */
         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;
         }
-        /**
-         * Default model for chat variant.
-         */
-        getDefaultChatModel() {
-            return this.getDefaultModel('gpt-4o');
-        }
-        /**
-         * Default model for completion variant.
-         */
-        getDefaultCompletionModel() {
-            return this.getDefaultModel('gpt-3.5-turbo-instruct');
-        }
-        /**
-         * Default model for completion variant.
-         */
-        getDefaultEmbeddingModel() {
-            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: [🛄] 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
+     * List of available models in Ollama library
      *
-     * Note: This can be also used for other OpenAI compatible APIs, like Ollama
+     * Note: Done at 2025-05-19
      *
-     * @public exported from `@promptbook/openai`
+     * @see https://ollama.com/library
+     * @public exported from `@promptbook/ollama`
      */
-    const createOpenAiExecutionTools = Object.assign((options) => {
-        // TODO: [🧠][main] !!4 If browser, auto add `dangerouslyAllowBrowser`
-        if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
-            options = { ...options, dangerouslyAllowBrowser: true };
-        }
-        return new OpenAiExecutionTools(options);
-    }, {
-        packageName: '@promptbook/openai',
-        className: 'OpenAiExecutionTools',
+    const OLLAMA_MODELS = exportJson({
+        name: 'OLLAMA_MODELS',
+        value: [
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'llama2',
+                modelName: 'llama2',
+                modelDescription: 'Meta Llama 2, a general-purpose large language model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'llama2-chat',
+                modelName: 'llama2-chat',
+                modelDescription: 'Meta Llama 2 Chat, optimized for conversational tasks.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'alpaca-7b',
+                modelName: 'alpaca-7b',
+                modelDescription: 'Stanford Alpaca 7B, instruction-tuned LLaMA model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'alpaca-30b',
+                modelName: 'alpaca-30b',
+                modelDescription: 'Stanford Alpaca 30B, larger instruction-tuned LLaMA model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'vicuna-13b',
+                modelName: 'vicuna-13b',
+                modelDescription: 'Vicuna 13B, fine-tuned LLaMA for chat and instruction.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'falcon-7b',
+                modelName: 'falcon-7b',
+                modelDescription: 'Falcon 7B, a performant open large language model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'falcon-40b',
+                modelName: 'falcon-40b',
+                modelDescription: 'Falcon 40B, a larger open large language model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'bloom-7b',
+                modelName: 'bloom-7b',
+                modelDescription: 'BLOOM 7B, multilingual large language model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'mistral-7b',
+                modelName: 'mistral-7b',
+                modelDescription: 'Mistral 7B, efficient and fast open LLM.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'gorilla',
+                modelName: 'gorilla',
+                modelDescription: 'Gorilla, open-source LLM for tool use and APIs.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'cerebras-13b',
+                modelName: 'cerebras-13b',
+                modelDescription: 'Cerebras-GPT 13B, open large language model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'openchat-7b',
+                modelName: 'openchat-7b',
+                modelDescription: 'OpenChat 7B, fine-tuned for conversational tasks.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'openchat-13b',
+                modelName: 'openchat-13b',
+                modelDescription: 'OpenChat 13B, larger conversational LLM.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'mpt-7b-chat',
+                modelName: 'mpt-7b-chat',
+                modelDescription: 'MPT-7B Chat, optimized for dialogue and chat.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'mpt-7b-instruct',
+                modelName: 'mpt-7b-instruct',
+                modelDescription: 'MPT-7B Instruct, instruction-tuned variant.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'command-7b',
+                modelName: 'command-7b',
+                modelDescription: 'Command 7B, instruction-following LLM.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'starcoder',
+                modelName: 'starcoder',
+                modelDescription: 'StarCoder, code generation large language model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'starcoder2',
+                modelName: 'starcoder2',
+                modelDescription: 'StarCoder2, improved code generation model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'mixtral-7b-chat',
+                modelName: 'mixtral-7b-chat',
+                modelDescription: 'Mixtral 7B Chat, Mixture-of-Experts conversational model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'mixtral-8x7b',
+                modelName: 'mixtral-8x7b',
+                modelDescription: 'Mixtral 8x7B, Mixture-of-Experts large language model.',
+            },
+            {
+                modelVariant: 'CHAT',
+                modelTitle: 'mixtral-8x7b-instruct',
+                modelName: 'mixtral-8x7b-instruct',
+                modelDescription: 'Mixtral 8x7B Instruct, instruction-tuned Mixture-of-Experts model.',
+            },
+            // <- [🕕]
+        ],
     });
     /**
-     * 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"
+     * TODO: [🚸] Not all models are compatible with JSON mode, add this information here and use it
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
     /**
@@ -17495,22 +17638,79 @@
      *
      * @public exported from `@promptbook/ollama`
      */
-    const DEFAULT_OLLAMA_BASE_URL = 'http://localhost:11434'; // <- TODO: !!!! What is the correct base URL? /v1?
+    const DEFAULT_OLLAMA_BASE_URL = 'http://localhost:11434/v1';
 
     /**
      * Execution Tools for calling Ollama API
      *
      * @public exported from `@promptbook/ollama`
      */
-    const createOllamaExecutionTools = Object.assign((ollamaOptions) => {
-        const openAiCompatibleOptions = {
-            baseURL: DEFAULT_OLLAMA_BASE_URL,
-            ...ollamaOptions,
-            userId: 'ollama',
-        };
-        // TODO: !!!! Listing the models - do it dynamically in OpenAiExecutionTools
-        // TODO: !!!! Do not allow to create Assistant from OpenAi compatible tools
-        return createOpenAiExecutionTools(openAiCompatibleOptions);
+    class OllamaExecutionTools extends OpenAiCompatibleExecutionTools {
+        /* <- TODO: [🍚] `, Destroyable` */
+        constructor(ollamaOptions) {
+            const openAiCompatibleOptions = {
+                baseURL: DEFAULT_OLLAMA_BASE_URL,
+                ...ollamaOptions,
+                userId: 'ollama',
+            };
+            super(openAiCompatibleOptions);
+        }
+        get title() {
+            return 'Ollama';
+        }
+        get description() {
+            return 'Use all models provided by Ollama';
+        }
+        /**
+         * 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 OLLAMA_MODELS;
+        }
+        /**
+         * Computes the usage of the Ollama API based on the response from Ollama
+         */
+        computeUsage(...args) {
+            return {
+                ...computeOpenAiUsage(...args),
+                price: ZERO_VALUE, // <- Note: Running on local model, so no price, maybe in the future we can add a way to calculate price based on electricity usage
+            };
+        }
+        /**
+         * Default model for chat variant.
+         */
+        getDefaultChatModel() {
+            return this.getDefaultModel('llama2'); // <- TODO: [🧠] Pick the best default model
+            // <- TODO: [🛄] When 'llama2' not installed, maybe better error message
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultCompletionModel() {
+            return this.getDefaultModel('llama2'); // <- TODO: [🧠] Pick the best default model
+            // <- TODO: [🛄] When 'llama2' not installed, maybe better error message
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultEmbeddingModel() {
+            return this.getDefaultModel('text-embedding-3-large'); // <- TODO: [🧠] Pick the best default model
+            // <- TODO: [🛄]
+        }
+    }
+    /**
+     * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`
+     */
+
+    /**
+     * Execution Tools for calling Ollama API
+     *
+     * @public exported from `@promptbook/ollama`
+     */
+    const createOllamaExecutionTools = Object.assign((options) => {
+        return new OllamaExecutionTools(options);
     }, {
         packageName: '@promptbook/ollama',
         className: 'OllamaExecutionTools',
@@ -17625,6 +17825,67 @@
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
+    /**
+     * 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.
+         */
+        getDefaultChatModel() {
+            return this.getDefaultModel('gpt-4o');
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultCompletionModel() {
+            return this.getDefaultModel('gpt-3.5-turbo-instruct');
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultEmbeddingModel() {
+            return this.getDefaultModel('text-embedding-3-large');
+        }
+    }
+
     /**
      * Execution Tools for calling OpenAI API Assistants
      *
@@ -17812,6 +18073,27 @@
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      */
 
+    /**
+     * 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) => {
+        if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
+            options = { ...options, dangerouslyAllowBrowser: true };
+        }
+        return new OpenAiExecutionTools(options);
+    }, {
+        packageName: '@promptbook/openai',
+        className: 'OpenAiExecutionTools',
+    });
+    /**
+     * 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"
+     */
+
     /**
      * Registration of LLM provider
      *