@promptbook/cli 0.94.0-2 → 0.94.0-4

package/esm/index.es.js

@@ -47,7 +47,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.94.0-2';
+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
@@ -11822,7 +11822,7 @@ function extractBlock(markdown) {
 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 forTime(100000000);
         // [1]
         try {
@@ -12437,7 +12437,10 @@ function usageToWorktime(usage) {
 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`);
@@ -15067,11 +15070,11 @@ const _AnthropicClaudeMetadataRegistration = $llmToolsMetadataRegister.register(
  */
 
 /**
- * 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;
 }
@@ -15093,8 +15096,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15103,8 +15106,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15113,8 +15116,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15123,8 +15126,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15133,8 +15136,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15143,8 +15146,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15153,8 +15156,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15163,8 +15166,8 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -15173,11 +15176,31 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
             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…
     ],
 });
 /**
@@ -15642,8 +15665,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`),
             },
         },
         /**/
@@ -15660,8 +15683,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`),
             },
         },
         /**/
@@ -15684,8 +15707,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`),
             },
         },
         /**/
@@ -15696,8 +15719,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`),
             },
         },
         /**/
@@ -15719,8 +15742,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`),
             },
         },
         /**/
@@ -15731,8 +15754,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`),
             },
         },
         /**/
@@ -15743,8 +15766,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`),
             },
         },
         /**/
@@ -15755,8 +15778,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
             },
         },
         /**/
@@ -15767,8 +15790,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`),
             },
         },
         /**/
@@ -15785,8 +15808,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`),
             },
         },
         /**/
@@ -15797,8 +15820,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`),
             },
         },
         /**/
@@ -15809,8 +15832,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`),
             },
         },
         /**/
@@ -15821,8 +15844,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`),
             },
         },
         /**/
@@ -15833,8 +15856,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`),
             },
         },
         /**/
@@ -15851,8 +15874,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`),
             },
         },
         /**/
@@ -15863,8 +15886,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`),
             },
         },
         /**/
@@ -15875,7 +15898,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
             },
@@ -15888,7 +15911,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
             },
@@ -15901,8 +15924,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`),
             },
         },
         /**/
@@ -15913,7 +15936,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
             },
@@ -15944,8 +15967,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`),
             },
         },
         /**/
@@ -15956,8 +15979,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`),
             },
         },
         /**/
@@ -15968,8 +15991,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`),
             },
         },
         /**/
@@ -15980,8 +16003,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`),
             },
         },
         /**/
@@ -15993,8 +16016,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`),
             },
         },
         /**/
@@ -16005,8 +16028,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`),
             },
         },
         /**/
@@ -16017,8 +16040,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`),
             },
         },
         /**/
@@ -16029,8 +16052,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
             },
         },
@@ -16042,8 +16065,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`),
             },
         },
         /**/
@@ -16054,8 +16077,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`),
             },
         },
         /**/
@@ -16635,8 +16658,8 @@ const DEEPSEEK_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16645,8 +16668,8 @@ const DEEPSEEK_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16655,8 +16678,8 @@ const DEEPSEEK_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16665,11 +16688,31 @@ const DEEPSEEK_MODELS = exportJson({
             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…
     ],
 });
 /**
@@ -16794,8 +16837,8 @@ const GOOGLE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16804,8 +16847,8 @@ const GOOGLE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16814,8 +16857,8 @@ const GOOGLE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16824,8 +16867,8 @@ const GOOGLE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16834,8 +16877,8 @@ const GOOGLE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16892,8 +16935,8 @@ const GOOGLE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16902,8 +16945,8 @@ const GOOGLE_MODELS = exportJson({
             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`),
             },
         },
         {
@@ -16930,11 +16973,31 @@ const GOOGLE_MODELS = exportJson({
             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…
     ],
 });
 /**
@@ -17092,15 +17155,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;
@@ -17113,12 +17176,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
@@ -17129,18 +17186,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`
      */
@@ -17149,23 +17194,15 @@ 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
      */
     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) {
@@ -17181,12 +17218,12 @@ class OpenAiExecutionTools {
         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();
@@ -17247,20 +17284,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,
@@ -17283,7 +17320,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();
@@ -17324,17 +17361,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,
@@ -17352,11 +17389,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();
@@ -17391,12 +17428,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,
@@ -17419,65 +17456,171 @@ 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((block) => `
-                            Cannot find model in OpenAI models with name "${defaultModelName}" which should be used as default.
+            throw new PipelineExecutionError(spaceTrim((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
  */
 
 /**
@@ -17485,22 +17628,79 @@ const createOpenAiExecutionTools = Object.assign((options) => {
  *
  * @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',
@@ -17615,6 +17815,67 @@ const _OpenAiAssistantMetadataRegistration = $llmToolsMetadataRegister.register(
  * 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
  *
@@ -17802,6 +18063,27 @@ const createOpenAiAssistantExecutionTools = Object.assign((options) => {
  * 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
  *