@promptbook/cli 0.100.0-3 → 0.100.0-31

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

package/esm/index.es.js

@@ -47,7 +47,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.100.0-3';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.0-31';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2198,8 +2198,27 @@ class FileCacheStorage {
             throw new UnexpectedError(`The "${key}" you want to store in JSON file is not serializable as JSON`);
         }
         const fileContent = stringifyPipelineJson(value);
-        await mkdir(dirname(filename), { recursive: true }); // <- [0]
-        await writeFile(filename, fileContent, 'utf-8');
+        // Note: Try to create cache directory and write file, but don't fail if filesystem is read-only or has permission issues
+        try {
+            await mkdir(dirname(filename), { recursive: true }); // <- [0]
+            await writeFile(filename, fileContent, 'utf-8');
+        }
+        catch (error) {
+            // Note: If we can't write to cache, silently ignore the error
+            //       This handles read-only filesystems, permission issues, and missing parent directories
+            if (error instanceof Error && (error.message.includes('EROFS') ||
+                error.message.includes('read-only') ||
+                error.message.includes('EACCES') ||
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) {
+                // Silently ignore filesystem errors - caching is optional
+                return;
+            }
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
     }
     /**
      * Removes the key/value pair with the given key from the storage, if a key/value pair with the given key exists.
@@ -6374,7 +6393,7 @@ function templateParameters(template, parameters) {
  */
 async function executeAttempts(options) {
     const { jokerParameterNames, priority, maxAttempts, // <- Note: [💂]
-    preparedContent, parameters, task, preparedPipeline, tools, $executionReport, pipelineIdentification, maxExecutionAttempts, } = options;
+    preparedContent, parameters, task, preparedPipeline, tools, $executionReport, pipelineIdentification, maxExecutionAttempts, onProgress, } = options;
     const $ongoingTaskResult = {
         $result: null,
         $resultString: null,
@@ -6618,6 +6637,10 @@ async function executeAttempts(options) {
                 result: $ongoingTaskResult.$resultString,
                 error: error,
             });
+            // Report failed attempt
+            onProgress({
+                errors: [error],
+            });
         }
         finally {
             if (!isJokerAttempt &&
@@ -7706,7 +7729,23 @@ async function makeKnowledgeSourceHandler(knowledgeSource, tools, options) {
         //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
         const rootDirname = join(process.cwd(), DEFAULT_DOWNLOAD_CACHE_DIRNAME);
         const filepath = join(...nameToSubfolderPath(hash /* <- TODO: [🎎] Maybe add some SHA256 prefix */), `${basename.substring(0, MAX_FILENAME_LENGTH)}.${mimeTypeToExtension(mimeType)}`);
-        await tools.fs.mkdir(dirname(join(rootDirname, filepath)), { recursive: true });
+        // Note: Try to create cache directory, but don't fail if filesystem has issues
+        try {
+            await tools.fs.mkdir(dirname(join(rootDirname, filepath)), { recursive: true });
+        }
+        catch (error) {
+            // Note: If we can't create cache directory, we'll handle it when trying to write the file
+            //       This handles read-only filesystems, permission issues, and missing parent directories
+            if (error instanceof Error && (error.message.includes('EROFS') ||
+                error.message.includes('read-only') ||
+                error.message.includes('EACCES') ||
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) ;
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
         const fileContent = Buffer.from(await response.arrayBuffer());
         if (fileContent.length > DEFAULT_MAX_FILE_SIZE /* <- TODO: Allow to pass different value to remote server */) {
             throw new LimitReachedError(`File is too large (${Math.round(fileContent.length / 1024 / 1024)}MB). Maximum allowed size is ${Math.round(DEFAULT_MAX_FILE_SIZE / 1024 / 1024)}MB.`);
@@ -7721,7 +7760,8 @@ async function makeKnowledgeSourceHandler(knowledgeSource, tools, options) {
             if (error instanceof Error && (error.message.includes('EROFS') ||
                 error.message.includes('read-only') ||
                 error.message.includes('EACCES') ||
-                error.message.includes('EPERM'))) {
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) {
                 // Return a handler that works directly with the downloaded content
                 return {
                     source: name,
@@ -13367,7 +13407,8 @@ async function $getCompiledBook(tools, pipelineSource, options) {
                     if (error instanceof Error && (error.message.includes('EROFS') ||
                         error.message.includes('read-only') ||
                         error.message.includes('EACCES') ||
-                        error.message.includes('EPERM'))) ;
+                        error.message.includes('EPERM') ||
+                        error.message.includes('ENOENT'))) ;
                     else {
                         // Re-throw other unexpected errors
                         throw error;
@@ -15298,7 +15339,7 @@ function pricing(value) {
 /**
  * List of available Anthropic Claude models with pricing
  *
- * Note: Done at 2025-05-06
+ * Note: Synced with official API docs at 2025-08-20
  *
  * @see https://docs.anthropic.com/en/docs/models-overview
  * @public exported from `@promptbook/anthropic-claude`
@@ -15308,12 +15349,52 @@ const ANTHROPIC_CLAUDE_MODELS = exportJson({
     value: [
         {
             modelVariant: 'CHAT',
-            modelTitle: 'Claude 3.5 Sonnet',
-            modelName: 'claude-3-5-sonnet-20240620',
-            modelDescription: 'Latest Claude model with 200K token context window. Features state-of-the-art reasoning capabilities, sophisticated code generation, and enhanced multilingual understanding. Offers superior accuracy with 30% fewer hallucinations than Claude 3 Sonnet. Provides exceptional performance for complex enterprise applications while maintaining fast response times.',
+            modelTitle: 'Claude Opus 4.1',
+            modelName: 'claude-opus-4-1-20250805',
+            modelDescription: 'Most powerful and capable Claude model with 200K token context window. Features superior reasoning capabilities, exceptional coding abilities, and advanced multimodal understanding. Sets new standards in complex reasoning and analytical tasks with enhanced safety measures. Ideal for the most demanding enterprise applications requiring maximum intelligence.',
             pricing: {
-                prompt: pricing(`$2.50 / 1M tokens`),
-                output: pricing(`$12.50 / 1M tokens`),
+                prompt: pricing(`$15.00 / 1M tokens`),
+                output: pricing(`$75.00 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Claude Opus 4',
+            modelName: 'claude-opus-4-20250514',
+            modelDescription: 'Previous flagship Claude model with 200K token context window. Features very high intelligence and capability with exceptional performance across reasoning, coding, and creative tasks. Maintains strong safety guardrails while delivering sophisticated outputs for complex professional applications.',
+            pricing: {
+                prompt: pricing(`$15.00 / 1M tokens`),
+                output: pricing(`$75.00 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Claude Sonnet 4',
+            modelName: 'claude-sonnet-4-20250514',
+            modelDescription: 'High-performance Claude model with exceptional reasoning capabilities and 200K token context window (1M context beta available). Features balanced intelligence and efficiency with enhanced multimodal understanding. Offers optimal performance for most enterprise applications requiring sophisticated AI capabilities.',
+            pricing: {
+                prompt: pricing(`$3.00 / 1M tokens`),
+                output: pricing(`$15.00 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Claude Sonnet 3.7',
+            modelName: 'claude-3-7-sonnet-20250219',
+            modelDescription: 'High-performance Claude model with early extended thinking capabilities and 200K token context window. Features enhanced reasoning chains, improved factual accuracy, and toggleable extended thinking for complex problem-solving. Ideal for applications requiring deep analytical capabilities.',
+            pricing: {
+                prompt: pricing(`$3.00 / 1M tokens`),
+                output: pricing(`$15.00 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Claude Haiku 3.5',
+            modelName: 'claude-3-5-haiku-20241022',
+            modelDescription: 'Fastest Claude model with 200K token context window optimized for intelligence at blazing speeds. Features enhanced reasoning and contextual understanding while maintaining sub-second response times. Perfect for real-time applications, customer-facing deployments, and high-throughput services.',
+            pricing: {
+                prompt: pricing(`$0.80 / 1M tokens`),
+                output: pricing(`$4.00 / 1M tokens`),
             },
         },
         {
@@ -15576,8 +15657,7 @@ class AnthropicClaudeExecutionTools {
         const rawPromptContent = templateParameters(content, { ...parameters, modelName });
         const rawRequest = {
             model: modelRequirements.modelName || this.getDefaultChatModel().modelName,
-            max_tokens: modelRequirements.maxTokens || 4096,
-            //                                            <- TODO: [🌾] Make some global max cap for maxTokens
+            max_tokens: modelRequirements.maxTokens || 8192,
             temperature: modelRequirements.temperature,
             system: modelRequirements.systemMessage,
             messages: [
@@ -15636,59 +15716,6 @@ class AnthropicClaudeExecutionTools {
             },
         });
     }
-    /**
-     * Calls Anthropic Claude API to use a completion model.
-     */
-    async callCompletionModel(prompt) {
-        if (this.options.isVerbose) {
-            console.info('🖋 Anthropic Claude callCompletionModel call');
-        }
-        const { content, parameters, modelRequirements } = prompt;
-        if (modelRequirements.modelVariant !== 'COMPLETION') {
-            throw new PipelineExecutionError('Use callCompletionModel only for COMPLETION variant');
-        }
-        const client = await this.getClient();
-        const modelName = modelRequirements.modelName || this.getDefaultChatModel().modelName;
-        const rawPromptContent = templateParameters(content, { ...parameters, modelName });
-        const rawRequest = {
-            model: modelName,
-            max_tokens_to_sample: modelRequirements.maxTokens || 2000,
-            temperature: modelRequirements.temperature,
-            prompt: rawPromptContent,
-        };
-        const start = $getCurrentDate();
-        const rawResponse = await this.limiter
-            .schedule(() => client.completions.create(rawRequest))
-            .catch((error) => {
-            if (this.options.isVerbose) {
-                console.info(colors.bgRed('error'), error);
-            }
-            throw error;
-        });
-        if (this.options.isVerbose) {
-            console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
-        }
-        if (!rawResponse.completion) {
-            throw new PipelineExecutionError('No completion from Anthropic Claude');
-        }
-        const resultContent = rawResponse.completion;
-        const complete = $getCurrentDate();
-        const usage = computeAnthropicClaudeUsage(rawPromptContent, resultContent, rawResponse);
-        return exportJson({
-            name: 'promptResult',
-            message: `Result of \`AnthropicClaudeExecutionTools.callCompletionModel\``,
-            order: [],
-            value: {
-                content: resultContent,
-                modelName: rawResponse.model || modelName,
-                timing: { start, complete },
-                usage,
-                rawPromptContent,
-                rawRequest,
-                rawResponse,
-            },
-        });
-    }
     // <- Note: [🤖] callXxxModel
     /**
      * Get the model that should be used as default
@@ -15710,7 +15737,7 @@ class AnthropicClaudeExecutionTools {
      * Default model for chat variant.
      */
     getDefaultChatModel() {
-        return this.getDefaultModel('claude-3-5-sonnet');
+        return this.getDefaultModel('claude-sonnet-4-20250514');
     }
 }
 /**
@@ -15853,7 +15880,7 @@ const _AzureOpenAiMetadataRegistration = $llmToolsMetadataRegister.register({
 /**
  * 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/
@@ -15862,6 +15889,138 @@ const _AzureOpenAiMetadataRegistration = $llmToolsMetadataRegister.register({
 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',
@@ -16382,7 +16541,6 @@ class AzureOpenAiExecutionTools {
             const modelName = prompt.modelRequirements.modelName || this.options.deploymentName;
             const modelSettings = {
                 maxTokens: modelRequirements.maxTokens,
-                //                                      <- TODO: [🌾] Make some global max cap for maxTokens
                 temperature: modelRequirements.temperature,
                 user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
                 // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
@@ -16488,8 +16646,7 @@ class AzureOpenAiExecutionTools {
         try {
             const modelName = prompt.modelRequirements.modelName || this.options.deploymentName;
             const modelSettings = {
-                maxTokens: modelRequirements.maxTokens || 2000,
-                //                                                  <- TODO: [🌾] Make some global max cap for maxTokens
+                maxTokens: modelRequirements.maxTokens,
                 temperature: modelRequirements.temperature,
                 user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
                 // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
@@ -16855,7 +17012,7 @@ function createExecutionToolsFromVercelProvider(options) {
 /**
  * List of available Deepseek models with descriptions
  *
- * Note: Done at 2025-05-06
+ * Note: Synced with official API docs at 2025-08-20
  *
  * @see https://www.deepseek.com/models
  * @public exported from `@promptbook/deepseek`
@@ -16865,12 +17022,32 @@ const DEEPSEEK_MODELS = exportJson({
     value: [
         {
             modelVariant: 'CHAT',
-            modelTitle: 'Deepseek Chat Pro',
-            modelName: 'deepseek-chat-pro',
-            modelDescription: 'Latest flagship general-purpose model with 256K context window. Enhanced from base Chat model with 40% improvement on complex reasoning tasks and specialized domain knowledge. Features advanced prompt optimization and improved contextual memory. Ideal for enterprise applications requiring highest quality responses.',
+            modelTitle: 'DeepSeek V3',
+            modelName: 'deepseek-chat',
+            modelDescription: 'Latest flagship general-purpose model with 128K context window. Features exceptional reasoning capabilities, advanced code generation, and strong performance across diverse domains. Offers competitive performance with leading models while maintaining cost efficiency. Ideal for complex reasoning, coding, and knowledge-intensive tasks.',
             pricing: {
-                prompt: pricing(`$1.20 / 1M tokens`),
-                output: pricing(`$2.40 / 1M tokens`),
+                prompt: pricing(`$0.14 / 1M tokens`),
+                output: pricing(`$0.28 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'DeepSeek R1',
+            modelName: 'deepseek-reasoner',
+            modelDescription: 'Advanced reasoning model with 128K context window specializing in complex problem-solving and analytical thinking. Features explicit reasoning chains, enhanced mathematical capabilities, and superior performance on STEM tasks. Designed for applications requiring deep analytical reasoning and step-by-step problem solving.',
+            pricing: {
+                prompt: pricing(`$0.55 / 1M tokens`),
+                output: pricing(`$2.19 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'DeepSeek Coder V2',
+            modelName: 'deepseek-coder',
+            modelDescription: 'Specialized coding model with 128K context window optimized for software development tasks. Features exceptional code generation, debugging, and refactoring capabilities across 40+ programming languages. Particularly strong in understanding complex codebases and implementing solutions based on natural language specifications.',
+            pricing: {
+                prompt: pricing(`$0.14 / 1M tokens`),
+                output: pricing(`$0.28 / 1M tokens`),
             },
         },
         {
@@ -17104,7 +17281,7 @@ const _GoogleMetadataRegistration = $llmToolsMetadataRegister.register({
 /**
  * List of available Google models with descriptions
  *
- * Note: Done at 2025-05-06
+ * Note: Synced with official API docs at 2025-08-20
  *
  * @see https://ai.google.dev/models/gemini
  * @public exported from `@promptbook/google`
@@ -17115,11 +17292,51 @@ const GOOGLE_MODELS = exportJson({
         {
             modelVariant: 'CHAT',
             modelTitle: 'Gemini 2.5 Pro',
-            modelName: 'gemini-2.5-pro-preview-03-25',
-            modelDescription: 'Latest advanced multimodal model with 1M token context window. Features exceptional reasoning across complex tasks, sophisticated function calling, and advanced image analysis (16MP resolution). Demonstrates superior performance in math, coding, and knowledge-intensive tasks with 30% improvement over Gemini 1.5 Pro. Ideal for enterprise applications requiring deep contextual understanding.',
+            modelName: 'gemini-2.5-pro',
+            modelDescription: 'State-of-the-art thinking model with 1M token context window capable of reasoning over complex problems in code, math, and STEM. Features enhanced thinking capabilities, advanced multimodal understanding, and superior performance on analytical tasks. Ideal for complex enterprise applications requiring maximum intelligence and reasoning.',
             pricing: {
-                prompt: pricing(`$8.00 / 1M tokens`),
-                output: pricing(`$24.00 / 1M tokens`),
+                prompt: pricing(`$7.00 / 1M tokens`),
+                output: pricing(`$21.00 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Gemini 2.5 Flash',
+            modelName: 'gemini-2.5-flash',
+            modelDescription: 'Best model in terms of price-performance with 1M token context window offering well-rounded capabilities. Features adaptive thinking, cost efficiency, and enhanced reasoning for large-scale processing. Ideal for low-latency, high-volume tasks that require thinking and agentic use cases.',
+            pricing: {
+                prompt: pricing(`$0.35 / 1M tokens`),
+                output: pricing(`$1.05 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Gemini 2.5 Flash Lite',
+            modelName: 'gemini-2.5-flash-lite',
+            modelDescription: 'Cost-efficient Gemini 2.5 Flash model optimized for high throughput with 1M token context window. Features thinking capabilities while maintaining the most cost-efficient pricing. Perfect for real-time, low-latency use cases requiring good quality at scale.',
+            pricing: {
+                prompt: pricing(`$0.20 / 1M tokens`),
+                output: pricing(`$0.60 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Gemini 2.0 Flash',
+            modelName: 'gemini-2.0-flash',
+            modelDescription: 'Next-generation model with 1M token context window delivering improved capabilities, superior speed, and realtime streaming. Features enhanced function calling, code execution, and search capabilities. Ideal for applications requiring cutting-edge AI capabilities with fast response times.',
+            pricing: {
+                prompt: pricing(`$0.25 / 1M tokens`),
+                output: pricing(`$0.75 / 1M tokens`),
+            },
+        },
+        {
+            modelVariant: 'CHAT',
+            modelTitle: 'Gemini 2.0 Flash Lite',
+            modelName: 'gemini-2.0-flash-lite',
+            modelDescription: 'Cost-efficient Gemini 2.0 Flash model optimized for low latency with 1M token context window. Balances performance and cost with enhanced efficiency for high-volume applications. Perfect for applications requiring good quality responses at minimal cost.',
+            pricing: {
+                prompt: pricing(`$0.15 / 1M tokens`),
+                output: pricing(`$0.45 / 1M tokens`),
             },
         },
         {
@@ -17520,7 +17737,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: [🧆]
@@ -17616,8 +17832,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: [🧆]
@@ -17766,7 +17981,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`
@@ -17774,6 +17989,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',
@@ -18268,7 +18501,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.
@@ -18336,8 +18569,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,
 
@@ -18667,7 +18898,23 @@ async function getScraperIntermediateSource(source, options) {
         .join('/') +
         '.' +
         extension;
-    await mkdir(dirname(cacheFilename), { recursive: true });
+    // Note: Try to create cache directory, but don't fail if filesystem has issues
+    try {
+        await mkdir(dirname(cacheFilename), { recursive: true });
+    }
+    catch (error) {
+        // Note: If we can't create cache directory, continue without it
+        //       This handles read-only filesystems, permission issues, and missing parent directories
+        if (error instanceof Error && (error.message.includes('EROFS') ||
+            error.message.includes('read-only') ||
+            error.message.includes('EACCES') ||
+            error.message.includes('EPERM') ||
+            error.message.includes('ENOENT'))) ;
+        else {
+            // Re-throw other unexpected errors
+            throw error;
+        }
+    }
     let isDestroyed = true;
     const fileHandler = {
         filename: cacheFilename,
@@ -19527,7 +19774,8 @@ class MarkitdownScraper {
                 if (error instanceof Error && (error.message.includes('EROFS') ||
                     error.message.includes('read-only') ||
                     error.message.includes('EACCES') ||
-                    error.message.includes('EPERM'))) ;
+                    error.message.includes('EPERM') ||
+                    error.message.includes('ENOENT'))) ;
                 else {
                     // Re-throw other unexpected errors
                     throw error;
@@ -19830,7 +20078,8 @@ class WebsiteScraper {
             if (error instanceof Error && (error.message.includes('EROFS') ||
                 error.message.includes('read-only') ||
                 error.message.includes('EACCES') ||
-                error.message.includes('EPERM'))) ;
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) ;
             else {
                 // Re-throw other unexpected errors
                 throw error;