@promptbook/openai 0.94.0-1 → 0.94.0-12

package/esm/index.es.js

@@ -18,7 +18,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.94.0-1';
+const PROMPTBOOK_ENGINE_VERSION = '0.94.0-12';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1257,11 +1257,11 @@ function uncertainNumber(value, isUncertain) {
 }
 
 /**
- * Function computeUsage will create price per one token based on the string value found on openai page
+ * Create price per one token based on the string value found on openai page
  *
  * @private within the repository, used only as internal helper for `OPENAI_MODELS`
  */
-function computeUsage(value) {
+function pricing(value) {
     const [price, tokens] = value.split(' / ');
     return parseFloat(price.replace('$', '')) / parseFloat(tokens.replace('M tokens', '')) / 1000000;
 }
@@ -1295,10 +1295,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'COMPLETION',
             modelTitle: 'davinci-002',
             modelName: 'davinci-002',
-            modelDescription: 'Legacy completion model with strong performance on text generation tasks. Optimized for complex instructions and longer outputs.',
+            modelDescription: 'Legacy completion model with 4K token context window. Excels at complex text generation, creative writing, and detailed content creation with strong contextual understanding. Optimized for instructions requiring nuanced outputs and extended reasoning. Suitable for applications needing high-quality text generation without conversation management.',
             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`),
             },
         },
         /**/
@@ -1313,10 +1313,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-3.5-turbo-16k',
             modelName: 'gpt-3.5-turbo-16k',
-            modelDescription: 'GPT-3.5 Turbo with extended 16k token context length for handling longer conversations and documents.',
+            modelDescription: 'Extended context GPT-3.5 Turbo with 16K token window. Maintains core capabilities of standard 3.5 Turbo while supporting longer conversations and documents. Features good balance of performance and cost for applications requiring more context than standard 4K models. Effective for document analysis, extended conversations, and multi-step reasoning tasks.',
             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`),
             },
         },
         /**/
@@ -1337,10 +1337,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4',
             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.',
+            modelDescription: 'Powerful language model with 8K context window featuring sophisticated reasoning, instruction-following, and knowledge capabilities. Demonstrates strong performance on complex tasks requiring deep understanding and multi-step reasoning. Excels at code generation, logical analysis, and nuanced content creation. Suitable for advanced applications requiring high-quality outputs.',
             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`),
             },
         },
         /**/
@@ -1349,10 +1349,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4-32k',
             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.',
+            modelDescription: 'Extended context version of GPT-4 with 32K token window. Maintains all capabilities of standard GPT-4 while supporting analysis of very lengthy documents, code bases, and conversations. Features enhanced ability to maintain context over long interactions and process detailed information from large inputs. Ideal for document analysis, legal review, and complex problem-solving.',
             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`),
             },
         },
         /**/
@@ -1372,10 +1372,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4-turbo-2024-04-09',
             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.',
+            modelDescription: 'Latest stable GPT-4 Turbo from April 2024 with 128K context window. Features enhanced reasoning chains, improved factual accuracy with 40% reduction in hallucinations, and better instruction following compared to earlier versions. Includes advanced function calling capabilities and knowledge up to April 2024. Provides optimal performance for enterprise applications requiring reliability.',
             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`),
             },
         },
         /**/
@@ -1384,10 +1384,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-3.5-turbo-1106',
             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.',
+            modelDescription: 'November 2023 version of GPT-3.5 Turbo with 16K token context window. Features improved instruction following, more consistent output formatting, and enhanced function calling capabilities. Includes knowledge cutoff from April 2023. Suitable for applications requiring good performance at lower cost than GPT-4 models.',
             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`),
             },
         },
         /**/
@@ -1396,10 +1396,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4-turbo',
             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.',
+            modelDescription: 'More capable and cost-efficient version of GPT-4 with 128K token context window. Features improved instruction following, advanced function calling capabilities, and better performance on coding tasks. Maintains superior reasoning and knowledge while offering substantial cost reduction compared to base GPT-4. Ideal for complex applications requiring extensive context processing.',
             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`),
             },
         },
         /**/
@@ -1408,10 +1408,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'COMPLETION',
             modelTitle: 'gpt-3.5-turbo-instruct-0914',
             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.',
+            modelDescription: 'September 2023 version of GPT-3.5 Turbo Instruct with 4K context window. Optimized for completion-style instruction following with deterministic responses. Better suited than chat models for applications requiring specific formatted outputs without conversation management. Knowledge cutoff from September 2021.',
             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`),
             },
         },
         /**/
@@ -1420,10 +1420,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'COMPLETION',
             modelTitle: 'gpt-3.5-turbo-instruct',
             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.',
+            modelDescription: 'Optimized version of GPT-3.5 for completion-style API with 4K token context window. Features strong instruction following with single-turn design rather than multi-turn conversation. Provides more consistent, deterministic outputs compared to chat models. Well-suited for templated content generation and structured text transformation tasks.',
             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`),
             },
         },
         /**/
@@ -1438,10 +1438,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-3.5-turbo',
             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.',
+            modelDescription: 'Latest version of GPT-3.5 Turbo with 4K token default context window (16K available). Features continually improved performance with enhanced instruction following and reduced hallucinations. Offers excellent balance between capability and cost efficiency. Suitable for most general-purpose applications requiring good AI capabilities at reasonable cost.',
             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`),
             },
         },
         /**/
@@ -1450,10 +1450,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-3.5-turbo-0301',
             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.',
+            modelDescription: 'March 2023 version of GPT-3.5 Turbo with 4K token context window. Legacy model maintained for backward compatibility with specific application behaviors. Features solid conversational abilities and basic instruction following. Knowledge cutoff from September 2021. Suitable for applications explicitly designed for this version.',
             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`),
             },
         },
         /**/
@@ -1462,10 +1462,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'COMPLETION',
             modelTitle: 'babbage-002',
             modelName: 'babbage-002',
-            modelDescription: 'Efficient legacy completion model with a good balance of performance and speed. Suitable for straightforward text generation tasks.',
+            modelDescription: 'Efficient legacy completion model with 4K context window balancing performance and speed. Features moderate reasoning capabilities with focus on straightforward text generation tasks. Significantly more efficient than davinci models while maintaining adequate quality for many applications. Suitable for high-volume, cost-sensitive text generation needs.',
             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`),
             },
         },
         /**/
@@ -1474,10 +1474,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4-1106-preview',
             modelName: 'gpt-4-1106-preview',
-            modelDescription: 'November 2023 preview version of GPT-4 Turbo with improved instruction following and a 128K token context window.',
+            modelDescription: 'November 2023 preview version of GPT-4 Turbo with 128K token context window. Features improved instruction following, better function calling capabilities, and enhanced reasoning. Includes knowledge cutoff from April 2023. Suitable for complex applications requiring extensive document understanding and sophisticated interactions.',
             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`),
             },
         },
         /**/
@@ -1486,10 +1486,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4-0125-preview',
             modelName: 'gpt-4-0125-preview',
-            modelDescription: 'January 2024 preview version of GPT-4 Turbo with improved reasoning capabilities and a 128K token context window.',
+            modelDescription: 'January 2024 preview version of GPT-4 Turbo with 128K token context window. Features improved reasoning capabilities, enhanced tool use, and more reliable function calling. Includes knowledge cutoff from October 2023. Offers better performance on complex logical tasks and more consistent outputs than previous preview versions.',
             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`),
             },
         },
         /**/
@@ -1504,10 +1504,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-3.5-turbo-0125',
             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.',
+            modelDescription: 'January 2024 version of GPT-3.5 Turbo with 16K token context window. Features improved reasoning capabilities, better instruction adherence, and reduced hallucinations compared to previous versions. Includes knowledge cutoff from September 2021. Provides good performance for most general applications at reasonable cost.',
             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`),
             },
         },
         /**/
@@ -1516,10 +1516,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4-turbo-preview',
             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.',
+            modelDescription: 'Preview version of GPT-4 Turbo with 128K token context window that points to the latest development model. Features cutting-edge improvements to instruction following, knowledge representation, and tool use capabilities. Provides access to newest features but may have occasional behavior changes. Best for non-critical applications wanting latest capabilities.',
             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`),
             },
         },
         /**/
@@ -1528,11 +1528,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'EMBEDDING',
             modelTitle: 'text-embedding-3-large',
             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.",
+            modelDescription: "OpenAI's most capable text embedding model generating 3072-dimensional vectors. Designed for high-quality embeddings for complex similarity tasks, clustering, and information retrieval. Features enhanced cross-lingual capabilities and significantly improved performance on retrieval and classification benchmarks. Ideal for sophisticated RAG systems and semantic search applications.",
             pricing: {
-                prompt: computeUsage(`$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
+                prompt: pricing(`$0.13 / 1M tokens`),
+                output: 0,
             },
         },
         /**/
@@ -1541,11 +1540,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'EMBEDDING',
             modelTitle: 'text-embedding-3-small',
             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.',
+            modelDescription: 'Cost-effective embedding model generating 1536-dimensional vectors. Balances quality and efficiency for simpler tasks while maintaining good performance on text similarity and retrieval applications. Offers 20% better quality than ada-002 at significantly lower cost. Ideal for production embedding applications with cost constraints.',
             pricing: {
-                prompt: computeUsage(`$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
+                prompt: pricing(`$0.02 / 1M tokens`),
+                output: 0,
             },
         },
         /**/
@@ -1554,10 +1552,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-3.5-turbo-0613',
             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.',
+            modelDescription: "June 2023 version of GPT-3.5 Turbo with 4K token context window. Features function calling capabilities for structured data extraction and API interaction. Includes knowledge cutoff from September 2021. Maintained for applications specifically designed for this version's behaviors and capabilities.",
             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`),
             },
         },
         /**/
@@ -1566,11 +1564,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'EMBEDDING',
             modelTitle: 'text-embedding-ada-002',
             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.',
+            modelDescription: 'Legacy text embedding model generating 1536-dimensional vectors suitable for text similarity and retrieval applications. Processes up to 8K tokens per request with consistent embedding quality. While superseded by newer embedding-3 models, still maintains adequate performance for many semantic search and classification tasks.',
             pricing: {
-                prompt: computeUsage(`$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
+                prompt: pricing(`$0.1 / 1M tokens`),
+                output: 0,
             },
         },
         /**/
@@ -1597,10 +1594,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4o-2024-05-13',
             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.',
+            modelDescription: 'May 2024 version of GPT-4o with 128K context window. Features enhanced multimodal capabilities including superior image understanding (up to 20MP), audio processing, and improved reasoning. Optimized for 2x lower latency than GPT-4 Turbo while maintaining high performance. Includes knowledge up to October 2023. Ideal for production applications requiring reliable multimodal capabilities.',
             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`),
             },
         },
         /**/
@@ -1609,10 +1606,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4o',
             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.",
+            modelDescription: "OpenAI's most advanced general-purpose multimodal model with 128K context window. Optimized for balanced performance, speed, and cost with 2x faster responses than GPT-4 Turbo. Features excellent vision processing, audio understanding, reasoning, and text generation quality. Represents optimal balance of capability and efficiency for most advanced applications.",
             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`),
             },
         },
         /**/
@@ -1621,10 +1618,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-4o-mini',
             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.',
+            modelDescription: 'Smaller, more cost-effective version of GPT-4o with 128K context window. Maintains impressive capabilities across text, vision, and audio tasks while operating at significantly lower cost. Features 3x faster inference than GPT-4o with good performance on general tasks. Excellent for applications requiring good quality multimodal capabilities at scale.',
             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`),
             },
         },
         /**/
@@ -1633,10 +1630,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'o1-preview',
             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.',
+            modelDescription: 'Advanced reasoning model with 128K context window specializing in complex logical, mathematical, and analytical tasks. Features exceptional step-by-step problem-solving capabilities, advanced mathematical and scientific reasoning, and superior performance on STEM-focused problems. Significantly outperforms GPT-4 on quantitative reasoning benchmarks. Ideal for professional and specialized applications.',
             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`),
             },
         },
         /**/
@@ -1645,11 +1642,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'o1-preview-2024-09-12',
             modelName: 'o1-preview-2024-09-12',
-            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
+            modelDescription: 'September 2024 version of O1 preview with 128K context window. Features specialized reasoning capabilities with 30% improvement on mathematical and scientific accuracy over previous versions. Includes enhanced support for formal logic, statistical analysis, and technical domains. Optimized for professional applications requiring precise analytical thinking and rigorous methodologies.',
             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`),
             },
         },
         /**/
@@ -1658,10 +1654,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'o1-mini',
             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.',
+            modelDescription: 'Smaller, cost-effective version of the O1 model with 128K context window. Maintains strong analytical reasoning abilities while reducing computational requirements by 70%. Features good performance on mathematical, logical, and scientific tasks at significantly lower cost than full O1. Excellent for everyday analytical applications that benefit from reasoning focus.',
             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`),
             },
         },
         /**/
@@ -1670,10 +1666,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'o1',
             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.",
+            modelDescription: "OpenAI's advanced reasoning model with 128K context window focusing on logical problem-solving and analytical thinking. Features exceptional performance on quantitative tasks, step-by-step deduction, and complex technical problems. Maintains 95%+ of o1-preview capabilities with production-ready stability. Ideal for scientific computing, financial analysis, and professional applications.",
             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`),
             },
         },
         /**/
@@ -1682,11 +1678,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'o3-mini',
             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.',
+            modelDescription: 'Cost-effective reasoning model with 128K context window optimized for academic and scientific problem-solving. Features efficient performance on STEM tasks with specialized capabilities in mathematics, physics, chemistry, and computer science. Offers 80% of O1 performance on technical domains at significantly lower cost. Ideal for educational applications and research support.',
             pricing: {
-                prompt: computeUsage(`$3.00 / 1M tokens`),
-                output: computeUsage(`$12.00 / 1M tokens`),
-                // <- TODO: !! Unsure, check the pricing
+                prompt: pricing(`$3.00 / 1M tokens`),
+                output: pricing(`$12.00 / 1M tokens`),
             },
         },
         /**/
@@ -1695,10 +1690,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'o1-mini-2024-09-12',
             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.",
+            modelDescription: "September 2024 version of O1-mini with 128K context window featuring balanced reasoning capabilities and cost-efficiency. Includes 25% improvement in mathematical accuracy and enhanced performance on coding tasks compared to previous versions. Maintains efficient resource utilization while delivering improved results for analytical applications 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`),
             },
         },
         /**/
@@ -1707,10 +1702,10 @@ const OPENAI_MODELS = exportJson({
             modelVariant: 'CHAT',
             modelTitle: 'gpt-3.5-turbo-16k-0613',
             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.',
+            modelDescription: "June 2023 version of GPT-3.5 Turbo with extended 16K token context window. Features good handling of longer conversations and documents with improved memory management across extended contexts. Includes knowledge cutoff from September 2021. Maintained for applications specifically designed for this version's behaviors and capabilities.",
             pricing: {
-                prompt: computeUsage(`$3.00 / 1M tokens`),
-                output: computeUsage(`$4.00 / 1M tokens`),
+                prompt: pricing(`$3.00 / 1M tokens`),
+                output: pricing(`$4.00 / 1M tokens`),
             },
         },
         /**/
@@ -1785,15 +1780,15 @@ resultContent, rawResponse) {
  */
 
 /**
- * Execution Tools for calling OpenAI API
+ * Execution Tools for calling OpenAI API or other OpeenAI compatible provider
  *
  * @public exported from `@promptbook/openai`
  */
-class OpenAiExecutionTools {
+class OpenAiCompatibleExecutionTools {
     /**
-     * Creates OpenAI Execution Tools.
+     * Creates OpenAI compatible Execution Tools.
      *
-     * @param options which are relevant are directly passed to the OpenAI client
+     * @param options which are relevant are directly passed to the OpenAI compatible client
      */
     constructor(options) {
         this.options = options;
@@ -1806,12 +1801,6 @@ class OpenAiExecutionTools {
             minTime: 60000 / (this.options.maxRequestsPerMinute || DEFAULT_MAX_REQUESTS_PER_MINUTE),
         });
     }
-    get title() {
-        return 'OpenAI';
-    }
-    get description() {
-        return 'Use all models provided by OpenAI';
-    }
     async getClient() {
         if (this.client === null) {
             // Note: Passing only OpenAI relevant options to OpenAI constructor
@@ -1822,18 +1811,6 @@ class OpenAiExecutionTools {
         }
         return this.client;
     }
-    /*
-    Note: Commenting this out to avoid circular dependency
-    /**
-     * Create (sub)tools for calling OpenAI API Assistants
-     *
-     * @param assistantId Which assistant to use
-     * @returns Tools for calling OpenAI API Assistants with same token
-     * /
-    public createAssistantSubtools(assistantId: string_token): OpenAiAssistantExecutionTools {
-        return new OpenAiAssistantExecutionTools({ ...this.options, assistantId });
-    }
-    */
     /**
      * Check the `options` passed to `constructor`
      */
@@ -1842,25 +1819,36 @@ class OpenAiExecutionTools {
         // TODO: [🎍] Do here a real check that API is online, working and API key is correct
     }
     /**
-     * List all available OpenAI models that can be used
+     * List all available OpenAI compatible models that can be used
      */
-    listModels() {
-        /*
-        Note: Dynamic lising of the models
-        const models = await this.openai.models.list({});
-
-        console.log({ models });
-        console.log(models.data);
-        */
-        return OPENAI_MODELS;
+    async listModels() {
+        const client = await this.getClient();
+        const rawModelsList = await client.models.list();
+        const availableModels = rawModelsList.data
+            .sort((a, b) => (a.created > b.created ? 1 : -1))
+            .map((modelFromApi) => {
+            const modelFromList = this.HARDCODED_MODELS.find(({ modelName }) => modelName === modelFromApi.id ||
+                modelName.startsWith(modelFromApi.id) ||
+                modelFromApi.id.startsWith(modelName));
+            if (modelFromList !== undefined) {
+                return modelFromList;
+            }
+            return {
+                modelVariant: 'CHAT',
+                modelTitle: modelFromApi.id,
+                modelName: modelFromApi.id,
+                modelDescription: '',
+            };
+        });
+        return availableModels;
     }
     /**
-     * Calls OpenAI API to use a chat model.
+     * Calls OpenAI compatible API to use a chat model.
      */
     async callChatModel(prompt) {
         var _a;
         if (this.options.isVerbose) {
-            console.info('💬 OpenAI callChatModel call', { prompt });
+            console.info(`💬 ${this.title} callChatModel call`, { prompt });
         }
         const { content, parameters, modelRequirements, format } = prompt;
         const client = await this.getClient();
@@ -1921,20 +1909,20 @@ class OpenAiExecutionTools {
         }
         const complete = $getCurrentDate();
         if (!rawResponse.choices[0]) {
-            throw new PipelineExecutionError('No choises from OpenAI');
+            throw new PipelineExecutionError(`No choises from ${this.title}`);
         }
         if (rawResponse.choices.length > 1) {
             // TODO: This should be maybe only warning
-            throw new PipelineExecutionError('More than one choise from OpenAI');
+            throw new PipelineExecutionError(`More than one choise from ${this.title}`);
         }
         const resultContent = rawResponse.choices[0].message.content;
-        const usage = computeOpenAiUsage(content || '', resultContent || '', rawResponse);
+        const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
         if (resultContent === null) {
-            throw new PipelineExecutionError('No response message from OpenAI');
+            throw new PipelineExecutionError(`No response message from ${this.title}`);
         }
         return exportJson({
             name: 'promptResult',
-            message: `Result of \`OpenAiExecutionTools.callChatModel\``,
+            message: `Result of \`OpenAiCompatibleExecutionTools.callChatModel\``,
             order: [],
             value: {
                 content: resultContent,
@@ -1957,7 +1945,7 @@ class OpenAiExecutionTools {
     async callCompletionModel(prompt) {
         var _a;
         if (this.options.isVerbose) {
-            console.info('🖋 OpenAI callCompletionModel call', { prompt });
+            console.info(`🖋 ${this.title} callCompletionModel call`, { prompt });
         }
         const { content, parameters, modelRequirements } = prompt;
         const client = await this.getClient();
@@ -1998,17 +1986,17 @@ class OpenAiExecutionTools {
         }
         const complete = $getCurrentDate();
         if (!rawResponse.choices[0]) {
-            throw new PipelineExecutionError('No choises from OpenAI');
+            throw new PipelineExecutionError(`No choises from ${this.title}`);
         }
         if (rawResponse.choices.length > 1) {
             // TODO: This should be maybe only warning
-            throw new PipelineExecutionError('More than one choise from OpenAI');
+            throw new PipelineExecutionError(`More than one choise from ${this.title}`);
         }
         const resultContent = rawResponse.choices[0].text;
-        const usage = computeOpenAiUsage(content || '', resultContent || '', rawResponse);
+        const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
         return exportJson({
             name: 'promptResult',
-            message: `Result of \`OpenAiExecutionTools.callCompletionModel\``,
+            message: `Result of \`OpenAiCompatibleExecutionTools.callCompletionModel\``,
             order: [],
             value: {
                 content: resultContent,
@@ -2026,11 +2014,11 @@ class OpenAiExecutionTools {
         });
     }
     /**
-     * Calls OpenAI API to use a embedding model
+     * Calls OpenAI compatible API to use a embedding model
      */
     async callEmbeddingModel(prompt) {
         if (this.options.isVerbose) {
-            console.info('🖋 OpenAI embedding call', { prompt });
+            console.info(`🖋 ${this.title} embedding call`, { prompt });
         }
         const { content, parameters, modelRequirements } = prompt;
         const client = await this.getClient();
@@ -2065,12 +2053,12 @@ class OpenAiExecutionTools {
             throw new PipelineExecutionError(`Expected exactly 1 data item in response, got ${rawResponse.data.length}`);
         }
         const resultContent = rawResponse.data[0].embedding;
-        const usage = computeOpenAiUsage(content || '', '', 
+        const usage = this.computeUsage(content || '', '', 
         // <- Note: Embedding does not have result content
         rawResponse);
         return exportJson({
             name: 'promptResult',
-            message: `Result of \`OpenAiExecutionTools.callEmbeddingModel\``,
+            message: `Result of \`OpenAiCompatibleExecutionTools.callEmbeddingModel\``,
             order: [],
             value: {
                 content: resultContent,
@@ -2093,18 +2081,69 @@ class OpenAiExecutionTools {
      */
     getDefaultModel(defaultModelName) {
         // Note: Match exact or prefix for model families
-        const model = OPENAI_MODELS.find(({ modelName }) => modelName === defaultModelName || modelName.startsWith(defaultModelName));
+        const model = this.HARDCODED_MODELS.find(({ modelName }) => modelName === defaultModelName || modelName.startsWith(defaultModelName));
         if (model === undefined) {
-            throw new UnexpectedError(spaceTrim$1((block) => `
-                            Cannot find model in OpenAI models with name "${defaultModelName}" which should be used as default.
+            throw new PipelineExecutionError(spaceTrim$1((block) => `
+                            Cannot find model in ${this.title} models with name "${defaultModelName}" which should be used as default.
 
                             Available models:
-                            ${block(OPENAI_MODELS.map(({ modelName }) => `- "${modelName}"`).join('\n'))}
+                            ${block(this.HARDCODED_MODELS.map(({ modelName }) => `- "${modelName}"`).join('\n'))}
+
+                            Model "${defaultModelName}" is probably not available anymore, not installed, inaccessible or misconfigured.
 
                         `));
         }
         return model;
     }
+}
+/**
+ * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`
+ * TODO: [🛄] Maybe make custom `OpenAiCompatibleError`
+ * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
+ * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
+ */
+
+/**
+ * Execution Tools for calling OpenAI API
+ *
+ * @public exported from `@promptbook/openai`
+ */
+class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
+    constructor() {
+        super(...arguments);
+        /**
+         * Computes the usage of the OpenAI API based on the response from OpenAI
+         */
+        this.computeUsage = computeOpenAiUsage;
+        // <- Note: [🤖] getDefaultXxxModel
+    }
+    /* <- TODO: [🍚] `, Destroyable` */
+    get title() {
+        return 'OpenAI';
+    }
+    get description() {
+        return 'Use all models provided by OpenAI';
+    }
+    /*
+    Note: Commenting this out to avoid circular dependency
+    /**
+     * Create (sub)tools for calling OpenAI API Assistants
+     *
+     * @param assistantId Which assistant to use
+     * @returns Tools for calling OpenAI API Assistants with same token
+     * /
+    public createAssistantSubtools(assistantId: string_token): OpenAiAssistantExecutionTools {
+        return new OpenAiAssistantExecutionTools({ ...this.options, assistantId });
+    }
+    */
+    /**
+     * List all available models (non dynamically)
+     *
+     * Note: Purpose of this is to provide more information about models than standard listing from API
+     */
+    get HARDCODED_MODELS() {
+        return OPENAI_MODELS;
+    }
     /**
      * Default model for chat variant.
      */
@@ -2124,13 +2163,6 @@ class OpenAiExecutionTools {
         return this.getDefaultModel('text-embedding-3-large');
     }
 }
-/**
- * TODO: [🧠][🧙‍♂️] Maybe there can be some wizzard for thoose who want to use just OpenAI
- * TODO: Maybe Create some common util for callChatModel and callCompletionModel
- * TODO: Maybe make custom OpenAiError
- * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
- * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
- */
 
 /**
  * Execution Tools for calling OpenAI API Assistants
@@ -2322,10 +2354,11 @@ const createOpenAiAssistantExecutionTools = Object.assign((options) => {
 /**
  * Execution Tools for calling OpenAI API
  *
+ * Note: This can be also used for other OpenAI compatible APIs, like Ollama
+ *
  * @public exported from `@promptbook/openai`
  */
 const createOpenAiExecutionTools = Object.assign((options) => {
-    // TODO: [🧠][main] !!4 If browser, auto add `dangerouslyAllowBrowser`
     if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
         options = { ...options, dangerouslyAllowBrowser: true };
     }
@@ -2504,5 +2537,5 @@ const _OpenAiAssistantRegistration = $llmToolsRegister.register(createOpenAiAssi
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
-export { BOOK_LANGUAGE_VERSION, OPENAI_MODELS, OpenAiAssistantExecutionTools, OpenAiExecutionTools, PROMPTBOOK_ENGINE_VERSION, _OpenAiAssistantRegistration, _OpenAiRegistration, createOpenAiAssistantExecutionTools, createOpenAiExecutionTools };
+export { BOOK_LANGUAGE_VERSION, OPENAI_MODELS, OpenAiAssistantExecutionTools, OpenAiCompatibleExecutionTools, OpenAiExecutionTools, PROMPTBOOK_ENGINE_VERSION, _OpenAiAssistantRegistration, _OpenAiRegistration, createOpenAiAssistantExecutionTools, createOpenAiExecutionTools };
 //# sourceMappingURL=index.es.js.map