@promptbook/ollama 0.100.0-9 → 0.100.1

package/README.md

@@ -10,14 +10,18 @@ Write AI applications using plain human language across multiple models and plat
 [![NPM Version of ![Promptbook logo - cube with letters P and B](./design/logo-h1.png) Promptbook](https://badge.fury.io/js/promptbook.svg)](https://www.npmjs.com/package/promptbook)
 [![Quality of package ![Promptbook logo - cube with letters P and B](./design/logo-h1.png) Promptbook](https://packagequality.com/shield/promptbook.svg)](https://packagequality.com/#?package=promptbook)
 [![Known Vulnerabilities](https://snyk.io/test/github/webgptorg/promptbook/badge.svg)](https://snyk.io/test/github/webgptorg/promptbook)
-[![Build Status](https://github.com/webgptorg/promptbook/actions/workflows/ci.yml/badge.svg)](https://github.com/webgptorg/promptbook/actions)
-[![Coverage Status](https://coveralls.io/repos/github/webgptorg/promptbook/badge.svg?branch=main)](https://coveralls.io/github/webgptorg/promptbook?branch=main)
+[![🧪 Test Books](https://github.com/webgptorg/promptbook/actions/workflows/test-books.yml/badge.svg)](https://github.com/webgptorg/promptbook/actions/workflows/test-books.yml)
+[![🧪 Test build](https://github.com/webgptorg/promptbook/actions/workflows/test-build.yml/badge.svg)](https://github.com/webgptorg/promptbook/actions/workflows/test-build.yml)
+[![🧪 Lint](https://github.com/webgptorg/promptbook/actions/workflows/test-lint.yml/badge.svg)](https://github.com/webgptorg/promptbook/actions/workflows/test-lint.yml)
+[![🧪 Spell check](https://github.com/webgptorg/promptbook/actions/workflows/test-spell-check.yml/badge.svg)](https://github.com/webgptorg/promptbook/actions/workflows/test-spell-check.yml)
+[![🧪 Test types](https://github.com/webgptorg/promptbook/actions/workflows/test-types.yml/badge.svg)](https://github.com/webgptorg/promptbook/actions/workflows/test-types.yml)
 [![Issues](https://img.shields.io/github/issues/webgptorg/promptbook.svg?style=flat)](https://github.com/webgptorg/promptbook/issues)
 
 
 
 ## 🌟 New Features
 
+-   🚀 **GPT-5 Support** - Now includes OpenAI's most advanced language model with unprecedented reasoning capabilities and 200K context window
 -   💡 VS Code support for `.book` files with syntax highlighting and IntelliSense
 -   🐳 Official Docker image (`hejny/promptbook`) for seamless containerized usage
 -   🔥 Native support for OpenAI `o3-mini`, GPT-4 and other leading LLMs
@@ -25,10 +29,6 @@ Write AI applications using plain human language across multiple models and plat
 
 
 
-<blockquote style="color: #ff8811">
-    <b>⚠ Warning:</b> This is a pre-release version of the library. It is not yet ready for production use. Please look at <a href="https://www.npmjs.com/package/@promptbook/core?activeTab=versions">latest stable release</a>.
-</blockquote>
-
 ## 📦 Package `@promptbook/ollama`
 
 - Promptbooks are [divided into several](#-packages) packages, all are published from [single monorepo](https://github.com/webgptorg/promptbook).
@@ -64,8 +64,6 @@ Rest of the documentation is common for **entire promptbook ecosystem**:
 
 During the computer revolution, we have seen [multiple generations of computer languages](https://github.com/webgptorg/promptbook/discussions/180), from the physical rewiring of the vacuum tubes through low-level machine code to the high-level languages like Python or JavaScript. And now, we're on the edge of the **next revolution**!
 
-
-
 It's a revolution of writing software in **plain human language** that is understandable and executable by both humans and machines – and it's going to change everything!
 
 The incredible growth in power of microprocessors and the Moore's Law have been the driving force behind the ever-more powerful languages, and it's been an amazing journey! Similarly, the large language models (like GPT or Claude) are the next big thing in language technology, and they're set to transform the way we interact with computers.
@@ -191,8 +189,6 @@ Join our growing community of developers and users:
 
 _A concise, Markdown-based DSL for crafting AI workflows and automations._
 
-
-
 ### Introduction
 
 Book is a Markdown-based language that simplifies the creation of AI applications, workflows, and automations. With human-readable commands, you can define inputs, outputs, personas, knowledge sources, and actions—without needing model-specific details.
@@ -242,8 +238,6 @@ Personas can have access to different knowledge, tools and actions. They can als
 
 -   [PERSONA](https://github.com/webgptorg/promptbook/blob/main/documents/commands/PERSONA.md)
 
-
-
 ### **3. How:** Knowledge, Instruments and Actions
 
 The resources used by the personas are used to do the work.
@@ -318,6 +312,7 @@ Or you can install them separately:
 -   **[@promptbook/editable](https://www.npmjs.com/package/@promptbook/editable)** - Editable book as native javascript object with imperative object API
 -   **[@promptbook/templates](https://www.npmjs.com/package/@promptbook/templates)** - Useful templates and examples of books which can be used as a starting point
 -   **[@promptbook/types](https://www.npmjs.com/package/@promptbook/types)** - Just typescript types used in the library
+-   **[@promptbook/color](https://www.npmjs.com/package/@promptbook/color)** - Color manipulation library
 -   ⭐ **[@promptbook/cli](https://www.npmjs.com/package/@promptbook/cli)** - Command line interface utilities for promptbooks
 -   🐋 **[Docker image](https://hub.docker.com/r/hejny/promptbook/)** - Promptbook server
 
@@ -343,8 +338,6 @@ The following glossary is used to clarify certain concepts:
 
 _Note: This section is not a complete dictionary, more list of general AI / LLM terms that has connection with Promptbook_
 
-
-
 ### 💯 Core concepts
 
 -   [📚 Collection of pipelines](https://github.com/webgptorg/promptbook/discussions/65)

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.100.0-9';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.1';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -222,6 +222,13 @@ const VALUE_STRINGS = {
  * @public exported from `@promptbook/utils`
  */
 const SMALL_NUMBER = 0.001;
+// <- TODO: [⏳] Standardize timeouts, Make DEFAULT_TIMEOUT_MS as global constant
+/**
+ * How many times to retry the connections
+ *
+ * @private within the repository - too low-level in comparison with other `MAX_...`
+ */
+const CONNECTION_RETRIES_LIMIT = 5;
 // <- TODO: [🧜‍♂️]
 /**
  * Default settings for parsing and generating CSV files in Promptbook.
@@ -242,6 +249,13 @@ Object.freeze({
  * @public exported from `@promptbook/core`
  */
 const DEFAULT_MAX_REQUESTS_PER_MINUTE = 60;
+/**
+ * API request timeout in milliseconds
+ * Can be overridden via API_REQUEST_TIMEOUT environment variable
+ *
+ * @public exported from `@promptbook/core`
+ */
+const API_REQUEST_TIMEOUT = parseInt(process.env.API_REQUEST_TIMEOUT || '90000');
 /**
  * Note: [💞] Ignore a discrepancy between file name and entity name
  * TODO: [🧠][🧜‍♂️] Maybe join remoteServerUrl and path into single value
@@ -1069,7 +1083,7 @@ function pricing(value) {
 /**
  * List of available OpenAI models with pricing
  *
- * Note: Done at 2025-05-06
+ * Note: Synced with official API docs at 2025-08-20
  *
  * @see https://platform.openai.com/docs/models/
  * @see https://openai.com/api/pricing/
@@ -1078,6 +1092,138 @@ function pricing(value) {
 const OPENAI_MODELS = exportJson({
     name: 'OPENAI_MODELS',
     value: [
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'gpt-5',
+            modelName: 'gpt-5',
+            modelDescription: "OpenAI's most advanced language model with unprecedented reasoning capabilities and 200K context window. Features revolutionary improvements in complex problem-solving, scientific reasoning, and creative tasks. Demonstrates human-level performance across diverse domains with enhanced safety measures and alignment. Represents the next generation of AI with superior understanding, nuanced responses, and advanced multimodal capabilities.",
+            pricing: {
+                prompt: pricing(`$1.25 / 1M tokens`),
+                output: pricing(`$10.00 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'gpt-5-mini',
+            modelName: 'gpt-5-mini',
+            modelDescription: "A faster, cost-efficient version of GPT-5 for well-defined tasks with 200K context window. Maintains core GPT-5 capabilities while offering 5x faster inference and significantly lower costs. Features enhanced instruction following and reduced latency for production applications requiring quick responses with high quality.",
+            pricing: {
+                prompt: pricing(`$0.25 / 1M tokens`),
+                output: pricing(`$2.00 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'gpt-5-nano',
+            modelName: 'gpt-5-nano',
+            modelDescription: "The fastest, most cost-efficient version of GPT-5 with 200K context window. Optimized for summarization, classification, and simple reasoning tasks. Features 10x faster inference than base GPT-5 while maintaining good quality for straightforward applications. Ideal for high-volume, cost-sensitive deployments.",
+            pricing: {
+                prompt: pricing(`$0.05 / 1M tokens`),
+                output: pricing(`$0.40 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'gpt-4.1',
+            modelName: 'gpt-4.1',
+            modelDescription: "Smartest non-reasoning model with 128K context window. Enhanced version of GPT-4 with improved instruction following, better factual accuracy, and reduced hallucinations. Features advanced function calling capabilities and superior performance on coding tasks. Ideal for applications requiring high intelligence without reasoning overhead.",
+            pricing: {
+                prompt: pricing(`$3.00 / 1M tokens`),
+                output: pricing(`$12.00 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'gpt-4.1-mini',
+            modelName: 'gpt-4.1-mini',
+            modelDescription: "Smaller, faster version of GPT-4.1 with 128K context window. Balances intelligence and efficiency with 3x faster inference than base GPT-4.1. Maintains strong capabilities across text generation, reasoning, and coding while offering better cost-performance ratio for most applications.",
+            pricing: {
+                prompt: pricing(`$0.80 / 1M tokens`),
+                output: pricing(`$3.20 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'gpt-4.1-nano',
+            modelName: 'gpt-4.1-nano',
+            modelDescription: "Fastest, most cost-efficient version of GPT-4.1 with 128K context window. Optimized for high-throughput applications requiring good quality at minimal cost. Features 5x faster inference than GPT-4.1 while maintaining adequate performance for most general-purpose tasks.",
+            pricing: {
+                prompt: pricing(`$0.20 / 1M tokens`),
+                output: pricing(`$0.80 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'o3',
+            modelName: 'o3',
+            modelDescription: "Advanced reasoning model with 128K context window specializing in complex logical, mathematical, and analytical tasks. Successor to o1 with enhanced step-by-step problem-solving capabilities and superior performance on STEM-focused problems. Ideal for professional applications requiring deep analytical thinking and precise reasoning.",
+            pricing: {
+                prompt: pricing(`$15.00 / 1M tokens`),
+                output: pricing(`$60.00 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'o3-pro',
+            modelName: 'o3-pro',
+            modelDescription: "Enhanced version of o3 with more compute allocated for better responses on the most challenging problems. Features extended reasoning time and improved accuracy on complex analytical tasks. Designed for applications where maximum reasoning quality is more important than response speed.",
+            pricing: {
+                prompt: pricing(`$30.00 / 1M tokens`),
+                output: pricing(`$120.00 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'o4-mini',
+            modelName: 'o4-mini',
+            modelDescription: "Fast, cost-efficient reasoning model with 128K context window. Successor to o1-mini with improved analytical capabilities while maintaining speed advantages. Features enhanced mathematical reasoning and logical problem-solving at significantly lower cost than full reasoning models.",
+            pricing: {
+                prompt: pricing(`$4.00 / 1M tokens`),
+                output: pricing(`$16.00 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'o3-deep-research',
+            modelName: 'o3-deep-research',
+            modelDescription: "Most powerful deep research model with 128K context window. Specialized for comprehensive research tasks, literature analysis, and complex information synthesis. Features advanced citation capabilities and enhanced factual accuracy for academic and professional research applications.",
+            pricing: {
+                prompt: pricing(`$25.00 / 1M tokens`),
+                output: pricing(`$100.00 / 1M tokens`),
+            },
+        },
+        /**/
+        /**/
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'o4-mini-deep-research',
+            modelName: 'o4-mini-deep-research',
+            modelDescription: "Faster, more affordable deep research model with 128K context window. Balances research capabilities with cost efficiency, offering good performance on literature review, fact-checking, and information synthesis tasks at a more accessible price point.",
+            pricing: {
+                prompt: pricing(`$12.00 / 1M tokens`),
+                output: pricing(`$48.00 / 1M tokens`),
+            },
+        },
+        /**/
         /*/
           {
               modelTitle: 'dall-e-3',
@@ -1784,7 +1930,18 @@ class OpenAiCompatibleExecutionTools {
             const openAiOptions = { ...this.options };
             delete openAiOptions.isVerbose;
             delete openAiOptions.userId;
-            this.client = new OpenAI(openAiOptions);
+            // Enhanced configuration for better ECONNRESET handling
+            const enhancedOptions = {
+                ...openAiOptions,
+                timeout: API_REQUEST_TIMEOUT,
+                maxRetries: CONNECTION_RETRIES_LIMIT,
+                defaultHeaders: {
+                    Connection: 'keep-alive',
+                    'Keep-Alive': 'timeout=30, max=100',
+                    ...openAiOptions.defaultHeaders,
+                },
+            };
+            this.client = new OpenAI(enhancedOptions);
         }
         return this.client;
     }
@@ -1837,7 +1994,6 @@ class OpenAiCompatibleExecutionTools {
         const modelSettings = {
             model: modelName,
             max_tokens: modelRequirements.maxTokens,
-            //                                   <- TODO: [🌾] Make some global max cap for maxTokens
             temperature: modelRequirements.temperature,
             // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
             // <- Note: [🧆]
@@ -1873,7 +2029,7 @@ class OpenAiCompatibleExecutionTools {
             console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
         }
         const rawResponse = await this.limiter
-            .schedule(() => client.chat.completions.create(rawRequest))
+            .schedule(() => this.makeRequestWithRetry(() => client.chat.completions.create(rawRequest)))
             .catch((error) => {
             assertsError(error);
             if (this.options.isVerbose) {
@@ -1933,8 +2089,7 @@ class OpenAiCompatibleExecutionTools {
         const modelName = modelRequirements.modelName || this.getDefaultCompletionModel().modelName;
         const modelSettings = {
             model: modelName,
-            max_tokens: modelRequirements.maxTokens || 2000,
-            //                                                  <- TODO: [🌾] Make some global max cap for maxTokens
+            max_tokens: modelRequirements.maxTokens,
             temperature: modelRequirements.temperature,
             // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
             // <- Note: [🧆]
@@ -1950,7 +2105,7 @@ class OpenAiCompatibleExecutionTools {
             console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
         }
         const rawResponse = await this.limiter
-            .schedule(() => client.completions.create(rawRequest))
+            .schedule(() => this.makeRequestWithRetry(() => client.completions.create(rawRequest)))
             .catch((error) => {
             assertsError(error);
             if (this.options.isVerbose) {
@@ -2014,7 +2169,7 @@ class OpenAiCompatibleExecutionTools {
             console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
         }
         const rawResponse = await this.limiter
-            .schedule(() => client.embeddings.create(rawRequest))
+            .schedule(() => this.makeRequestWithRetry(() => client.embeddings.create(rawRequest)))
             .catch((error) => {
             assertsError(error);
             if (this.options.isVerbose) {
@@ -2072,6 +2227,76 @@ class OpenAiCompatibleExecutionTools {
         }
         return model;
     }
+    // <- Note: [🤖] getDefaultXxxModel
+    /**
+     * Makes a request with retry logic for network errors like ECONNRESET
+     */
+    async makeRequestWithRetry(requestFn) {
+        let lastError;
+        for (let attempt = 1; attempt <= CONNECTION_RETRIES_LIMIT; attempt++) {
+            try {
+                return await requestFn();
+            }
+            catch (error) {
+                assertsError(error);
+                lastError = error;
+                // Check if this is a retryable network error
+                const isRetryableError = this.isRetryableNetworkError(error);
+                if (!isRetryableError || attempt === CONNECTION_RETRIES_LIMIT) {
+                    if (this.options.isVerbose) {
+                        console.info(colors.bgRed('Final error after retries'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}:`, error);
+                    }
+                    throw error;
+                }
+                // Calculate exponential backoff delay
+                const baseDelay = 1000; // 1 second
+                const backoffDelay = baseDelay * Math.pow(2, attempt - 1);
+                const jitterDelay = Math.random() * 500; // Add some randomness
+                const totalDelay = backoffDelay + jitterDelay;
+                if (this.options.isVerbose) {
+                    console.info(colors.bgYellow('Retrying request'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}, waiting ${Math.round(totalDelay)}ms:`, error.message);
+                }
+                // Wait before retrying
+                await new Promise((resolve) => setTimeout(resolve, totalDelay));
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Determines if an error is retryable (network-related errors)
+     */
+    isRetryableNetworkError(error) {
+        const errorMessage = error.message.toLowerCase();
+        const errorCode = error.code;
+        // Network connection errors that should be retried
+        const retryableErrors = [
+            'econnreset',
+            'enotfound',
+            'econnrefused',
+            'etimedout',
+            'socket hang up',
+            'network error',
+            'fetch failed',
+            'connection reset',
+            'connection refused',
+            'timeout',
+        ];
+        // Check error message
+        if (retryableErrors.some((retryableError) => errorMessage.includes(retryableError))) {
+            return true;
+        }
+        // Check error code
+        if (errorCode && retryableErrors.includes(errorCode.toLowerCase())) {
+            return true;
+        }
+        // Check for specific HTTP status codes that are retryable
+        const errorWithStatus = error;
+        const httpStatus = errorWithStatus.status || errorWithStatus.statusCode;
+        if (httpStatus && [429, 500, 502, 503, 504].includes(httpStatus)) {
+            return true;
+        }
+        return false;
+    }
 }
 /**
  * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`
@@ -2083,7 +2308,7 @@ class OpenAiCompatibleExecutionTools {
 /**
  * List of available models in Ollama library
  *
- * Note: Done at 2025-05-19
+ * Note: Synced with official API docs at 2025-08-20
  *
  * @see https://ollama.com/library
  * @public exported from `@promptbook/ollama`
@@ -2091,6 +2316,24 @@ class OpenAiCompatibleExecutionTools {
 const OLLAMA_MODELS = exportJson({
     name: 'OLLAMA_MODELS',
     value: [
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'llama3.3',
+            modelName: 'llama3.3',
+            modelDescription: 'Meta Llama 3.3 (70B parameters) with 128K context window. Latest generation foundation model with significantly enhanced reasoning, instruction following, and multilingual capabilities. Features improved performance on complex tasks and better factual accuracy compared to Llama 3.1.',
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'llama3.2',
+            modelName: 'llama3.2',
+            modelDescription: 'Meta Llama 3.2 (1B-90B parameters) with 128K context window. Enhanced model with improved reasoning capabilities, better instruction following, and multimodal support in larger variants. Features significant performance improvements over Llama 3.1 across diverse tasks.',
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'llama3.1',
+            modelName: 'llama3.1',
+            modelDescription: 'Meta Llama 3.1 (8B-405B parameters) with 128K context window. Advanced foundation model with enhanced reasoning, improved multilingual capabilities, and better performance on complex tasks. Features significant improvements in code generation and mathematical reasoning.',
+        },
         {
             modelVariant: 'CHAT',
             modelTitle: 'llama3',