@promptbook/ollama 0.100.0-8 → 0.100.0

package/esm/typings/src/utils/take/classes/TakeChain.d.ts

@@ -0,0 +1,11 @@
+import type { ITakeChain } from '../interfaces/ITakeChain';
+import type { Takeable } from '../interfaces/Takeable';
+/**
+ * @private util of `@promptbook/color`
+ * @de
+ */
+export declare class TakeChain<TValue extends Takeable> implements ITakeChain<TValue> {
+    value: TValue;
+    constructor(value: TValue);
+    then<TResultValue extends Takeable>(callback: (oldValue: TValue) => TResultValue): TResultValue & ITakeChain<TResultValue>;
+}

package/esm/typings/src/utils/take/interfaces/ITakeChain.d.ts

@@ -0,0 +1,12 @@
+import type { Takeable } from './Takeable';
+/**
+ * Represents any value with take chain functionality
+ *
+ * @private util of `@promptbook/color`
+ * @deprecated [🤡] Use some better functional library instead of `TakeChain`
+ */
+export type WithTake<TValue extends Takeable> = TValue & ITakeChain<TValue>;
+export interface ITakeChain<TValue extends Takeable> {
+    readonly value: TValue;
+    then<TResultValue extends Takeable>(callback: (value: TValue) => TResultValue): WithTake<TResultValue>;
+}

package/esm/typings/src/utils/take/interfaces/Takeable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Represents a type that can be chained in take pipe
+ *
+ * @private util of `@promptbook/color`
+ * @deprecated [🤡] Use some better functional library instead of `TakeChain`
+ */
+export type Takeable = Exclude<object, null>;

package/esm/typings/src/utils/take/take.d.ts

@@ -0,0 +1,12 @@
+import type { WithTake } from './interfaces/ITakeChain';
+import type { Takeable } from './interfaces/Takeable';
+/**
+ * A function that takes an initial value and returns a proxy object with chainable methods.
+ *
+ * @param {*} initialValue - The initial value.
+ * @returns {Proxy<WithTake<TValue>>} - A proxy object with a `take` method.
+ *
+ * @private util of `@promptbook/color`
+ * @deprecated [🤡] Use some better functional library instead of `TakeChain`
+ */
+export declare function take<TValue extends Takeable>(initialValue: TValue): WithTake<TValue>;

package/esm/typings/src/utils/take/take.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.100.0-7`).
+ * It follows semantic versioning (e.g., `0.100.0-65`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/ollama",
-    "version": "0.100.0-8",
+    "version": "0.100.0",
     "description": "Promptbook: Run AI apps in plain human language across multiple models and platforms",
     "private": false,
     "sideEffects": false,
@@ -94,7 +94,7 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/ollama.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.100.0-8"
+        "@promptbook/core": "0.100.0"
     },
     "dependencies": {
         "bottleneck": "^2.19.5",

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-8';
+    const PROMPTBOOK_ENGINE_VERSION = '0.100.0';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -229,6 +229,13 @@
      * @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.
@@ -249,6 +256,13 @@
      * @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
@@ -1076,7 +1090,7 @@
     /**
      * 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/
@@ -1085,6 +1099,138 @@
     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',
@@ -1791,7 +1937,18 @@
                 const openAiOptions = { ...this.options };
                 delete openAiOptions.isVerbose;
                 delete openAiOptions.userId;
-                this.client = new OpenAI__default["default"](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__default["default"](enhancedOptions);
             }
             return this.client;
         }
@@ -1844,7 +2001,6 @@
             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: [🧆]
@@ -1880,7 +2036,7 @@
                 console.info(colors__default["default"].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) {
@@ -1940,8 +2096,7 @@
             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: [🧆]
@@ -1957,7 +2112,7 @@
                 console.info(colors__default["default"].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) {
@@ -2021,7 +2176,7 @@
                 console.info(colors__default["default"].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) {
@@ -2079,6 +2234,76 @@
             }
             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__default["default"].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__default["default"].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`
@@ -2090,7 +2315,7 @@
     /**
      * 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`
@@ -2098,6 +2323,24 @@
     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',