@promptbook/openai 0.100.0-5 → 0.100.0-61

package/README.md

@@ -18,6 +18,7 @@ Write AI applications using plain human language across multiple models and plat
 
 ## 🌟 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
@@ -312,8 +313,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.
@@ -439,8 +438,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.
@@ -490,8 +487,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.
@@ -566,6 +561,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
 
@@ -591,8 +587,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

@@ -19,7 +19,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.100.0-5';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.0-61';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -310,6 +310,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
@@ -858,6 +865,76 @@ function templateParameters(template, parameters) {
     return replacedTemplates;
 }
 
+/**
+ * Predefined profiles for LLM providers to maintain consistency across the application
+ * These profiles represent each provider as a virtual persona in chat interfaces
+ *
+ * @private !!!!
+ */
+const LLM_PROVIDER_PROFILES = {
+    OPENAI: {
+        name: 'OPENAI',
+        fullname: 'OpenAI GPT',
+        color: '#10a37f', // OpenAI's signature green
+        // Note: avatarSrc could be added when we have provider logos available
+    },
+    ANTHROPIC: {
+        name: 'ANTHROPIC',
+        fullname: 'Anthropic Claude',
+        color: '#d97706', // Anthropic's orange/amber color
+    },
+    AZURE_OPENAI: {
+        name: 'AZURE_OPENAI',
+        fullname: 'Azure OpenAI',
+        color: '#0078d4', // Microsoft Azure blue
+    },
+    GOOGLE: {
+        name: 'GOOGLE',
+        fullname: 'Google Gemini',
+        color: '#4285f4', // Google blue
+    },
+    DEEPSEEK: {
+        name: 'DEEPSEEK',
+        fullname: 'DeepSeek',
+        color: '#7c3aed', // Purple color for DeepSeek
+    },
+    OLLAMA: {
+        name: 'OLLAMA',
+        fullname: 'Ollama',
+        color: '#059669', // Emerald green for local models
+    },
+    REMOTE: {
+        name: 'REMOTE',
+        fullname: 'Remote Server',
+        color: '#6b7280', // Gray for remote/proxy connections
+    },
+    MOCKED_ECHO: {
+        name: 'MOCKED_ECHO',
+        fullname: 'Echo (Test)',
+        color: '#8b5cf6', // Purple for test/mock tools
+    },
+    MOCKED_FAKE: {
+        name: 'MOCKED_FAKE',
+        fullname: 'Fake LLM (Test)',
+        color: '#ec4899', // Pink for fake/test tools
+    },
+    VERCEL: {
+        name: 'VERCEL',
+        fullname: 'Vercel AI',
+        color: '#000000', // Vercel's black
+    },
+    MULTIPLE: {
+        name: 'MULTIPLE',
+        fullname: 'Multiple Providers',
+        color: '#6366f1', // Indigo for combined/multiple providers
+    },
+};
+/**
+ * TODO: Refactor this - each profile must be alongside the provider definition
+ * TODO: Unite `AvatarProfileProps` and `ChatParticipant`
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
 /**
  * Counts number of characters in the text
  *
@@ -1283,7 +1360,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/
@@ -1292,6 +1369,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',
@@ -1821,7 +2030,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;
     }
@@ -1874,7 +2094,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: [🧆]
@@ -1910,7 +2129,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) {
@@ -1970,8 +2189,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: [🧆]
@@ -1987,7 +2205,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) {
@@ -2051,7 +2269,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) {
@@ -2109,6 +2327,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`
@@ -2138,6 +2426,9 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
     get description() {
         return 'Use all models provided by OpenAI';
     }
+    get profile() {
+        return LLM_PROVIDER_PROFILES.OPENAI;
+    }
     /*
     Note: Commenting this out to avoid circular dependency
     /**
@@ -2162,7 +2453,7 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
      * Default model for chat variant.
      */
     getDefaultChatModel() {
-        return this.getDefaultModel('gpt-4-turbo');
+        return this.getDefaultModel('gpt-5');
     }
     /**
      * Default model for completion variant.
@@ -2230,8 +2521,6 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         const modelName = modelRequirements.modelName || this.getDefaultChatModel().modelName;
         const modelSettings = {
             model: modelName,
-            max_tokens: modelRequirements.maxTokens,
-            //                                   <- TODO: [🌾] Make some global max cap for maxTokens
 
             temperature: modelRequirements.temperature,
 
@@ -2736,6 +3025,9 @@ class RemoteLlmExecutionTools {
     get description() {
         return `Models from Promptbook remote server ${this.options.remoteServerUrl}`;
     }
+    get profile() {
+        return LLM_PROVIDER_PROFILES.REMOTE;
+    }
     /**
      * Check the configuration of all execution tools
      */