@promptbook/wizard 0.100.0-5 → 0.100.0-61

package/esm/index.es.js

@@ -12,8 +12,9 @@ import { forTime } from 'waitasecond';
 import { SHA256 } from 'crypto-js';
 import hexEncoder from 'crypto-js/enc-hex';
 import { basename, join, dirname, relative } from 'path';
-import { format } from 'prettier';
 import parserHtml from 'prettier/parser-html';
+import parserMarkdown from 'prettier/parser-markdown';
+import { format } from 'prettier/standalone';
 import { Subject } from 'rxjs';
 import sha256 from 'crypto-js/sha256';
 import { lookup, extension } from 'mime-types';
@@ -38,7 +39,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
@@ -312,6 +313,12 @@ let DEFAULT_IS_VERBOSE = false;
  * @public exported from `@promptbook/core`
  */
 const DEFAULT_IS_AUTO_INSTALLED = false;
+/**
+ * Default simulated duration for a task in milliseconds (used for progress reporting)
+ *
+ * @public exported from `@promptbook/core`
+ */
+const DEFAULT_TASK_SIMULATED_DURATION_MS = 5 * 60 * 1000; // 5 minutes
 /**
  * Default rate limits (requests per minute)
  *
@@ -320,6 +327,13 @@ const DEFAULT_IS_AUTO_INSTALLED = false;
  * @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');
 /**
  * Indicates whether pipeline logic validation is enabled. When true, the pipeline logic is checked for consistency.
  *
@@ -1321,6 +1335,76 @@ function deserializeError(error) {
     return deserializedError;
 }
 
+/**
+ * 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
+ */
+
 /**
  * Tests if given string is valid URL.
  *
@@ -1434,6 +1518,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
      */
@@ -1702,7 +1789,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`
@@ -1712,12 +1799,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`),
             },
         },
         {
@@ -2383,6 +2510,9 @@ class AnthropicClaudeExecutionTools {
     get description() {
         return 'Use all models provided by Anthropic Claude';
     }
+    get profile() {
+        return LLM_PROVIDER_PROFILES.ANTHROPIC;
+    }
     async getClient() {
         if (this.client === null) {
             // Note: Passing only Anthropic Claude relevant options to Anthropic constructor
@@ -2423,8 +2553,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: [
@@ -2483,59 +2612,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
@@ -2557,7 +2633,7 @@ class AnthropicClaudeExecutionTools {
      * Default model for chat variant.
      */
     getDefaultChatModel() {
-        return this.getDefaultModel('claude-3-5-sonnet');
+        return this.getDefaultModel('claude-sonnet-4-20250514');
     }
 }
 /**
@@ -2700,7 +2776,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/
@@ -2709,6 +2785,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',
@@ -3229,7 +3437,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
@@ -3335,8 +3542,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
@@ -3720,7 +3926,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`
@@ -3730,12 +3936,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`),
             },
         },
         {
@@ -3969,7 +4195,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`
@@ -3980,11 +4206,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`),
             },
         },
         {
@@ -4372,7 +4638,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;
     }
@@ -4425,7 +4702,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: [🧆]
@@ -4461,7 +4737,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) {
@@ -4521,8 +4797,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: [🧆]
@@ -4538,7 +4813,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) {
@@ -4602,7 +4877,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) {
@@ -4660,6 +4935,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`
@@ -4671,7 +5016,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`
@@ -4679,6 +5024,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',
@@ -5149,6 +5512,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
     /**
@@ -5173,7 +5539,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.
@@ -5241,8 +5607,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,
 
@@ -6086,7 +6450,7 @@ function prettifyMarkdown(content) {
     try {
         return format(content, {
             parser: 'markdown',
-            plugins: [parserHtml],
+            plugins: [parserMarkdown, parserHtml],
             // TODO: DRY - make some import or auto-copy of .prettierrc
             endOfLine: 'lf',
             tabWidth: 4,
@@ -6985,6 +7349,7 @@ function createTask(options) {
     const errors = [];
     const warnings = [];
     let currentValue = {};
+    let customTldr = null;
     const partialResultSubject = new Subject();
     // <- Note: Not using `BehaviorSubject` because on error we can't access the last value
     const finalResultPromise = /* not await */ taskProcessCallback((newOngoingResult) => {
@@ -6995,6 +7360,9 @@ function createTask(options) {
         Object.assign(currentValue, newOngoingResult);
         // <- TODO: assign deep
         partialResultSubject.next(newOngoingResult);
+    }, (tldrInfo) => {
+        customTldr = tldrInfo;
+        updatedAt = new Date();
     });
     finalResultPromise
         .catch((error) => {
@@ -7048,6 +7416,78 @@ function createTask(options) {
             return status;
             // <- Note: [1] --||--
         },
+        get tldr() {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            // Use custom tldr if available
+            if (customTldr) {
+                return customTldr;
+            }
+            // Fallback to default implementation
+            const cv = currentValue;
+            // If explicit percent is provided, use it
+            let percentRaw = (_f = (_d = (_b = (_a = cv === null || cv === void 0 ? void 0 : cv.tldr) === null || _a === void 0 ? void 0 : _a.percent) !== null && _b !== void 0 ? _b : (_c = cv === null || cv === void 0 ? void 0 : cv.usage) === null || _c === void 0 ? void 0 : _c.percent) !== null && _d !== void 0 ? _d : (_e = cv === null || cv === void 0 ? void 0 : cv.progress) === null || _e === void 0 ? void 0 : _e.percent) !== null && _f !== void 0 ? _f : cv === null || cv === void 0 ? void 0 : cv.percent;
+            // Simulate progress if not provided
+            if (typeof percentRaw !== 'number') {
+                // Simulate progress: evenly split across subtasks, based on elapsed time
+                const now = new Date();
+                const elapsedMs = now.getTime() - createdAt.getTime();
+                const totalMs = DEFAULT_TASK_SIMULATED_DURATION_MS;
+                // If subtasks are defined, split progress evenly
+                const subtaskCount = Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks) ? cv.subtasks.length : 1;
+                const completedSubtasks = Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks)
+                    ? cv.subtasks.filter((s) => s.done || s.completed).length
+                    : 0;
+                // Progress from completed subtasks
+                const subtaskProgress = subtaskCount > 0 ? completedSubtasks / subtaskCount : 0;
+                // Progress from elapsed time for current subtask
+                const timeProgress = Math.min(elapsedMs / totalMs, 1);
+                // Combine: completed subtasks + time progress for current subtask
+                percentRaw = Math.min(subtaskProgress + (1 / subtaskCount) * timeProgress, 1);
+                if (status === 'FINISHED')
+                    percentRaw = 1;
+                if (status === 'ERROR')
+                    percentRaw = 0;
+            }
+            // Clamp to [0,1]
+            let percent = Number(percentRaw) || 0;
+            if (percent < 0)
+                percent = 0;
+            if (percent > 1)
+                percent = 1;
+            // Build a short message: prefer explicit tldr.message, then common summary/message fields, then errors/warnings, then status
+            const messageFromResult = (_k = (_j = (_h = (_g = cv === null || cv === void 0 ? void 0 : cv.tldr) === null || _g === void 0 ? void 0 : _g.message) !== null && _h !== void 0 ? _h : cv === null || cv === void 0 ? void 0 : cv.message) !== null && _j !== void 0 ? _j : cv === null || cv === void 0 ? void 0 : cv.summary) !== null && _k !== void 0 ? _k : cv === null || cv === void 0 ? void 0 : cv.statusMessage;
+            let message = messageFromResult;
+            if (!message) {
+                // If subtasks, show current subtask
+                if (Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks) && cv.subtasks.length > 0) {
+                    const current = cv.subtasks.find((s) => !s.done && !s.completed);
+                    if (current && current.title) {
+                        message = `Working on ${current.title}`;
+                    }
+                }
+                if (!message) {
+                    if (errors.length) {
+                        message = errors[errors.length - 1].message || 'Error';
+                    }
+                    else if (warnings.length) {
+                        message = warnings[warnings.length - 1].message || 'Warning';
+                    }
+                    else if (status === 'FINISHED') {
+                        message = 'Finished';
+                    }
+                    else if (status === 'ERROR') {
+                        message = 'Error';
+                    }
+                    else {
+                        message = 'Running';
+                    }
+                }
+            }
+            return {
+                percent: percent,
+                message,
+            };
+        },
         get createdAt() {
             return createdAt;
             // <- Note: [1] --||--
@@ -7253,7 +7693,7 @@ class MultipleLlmExecutionTools {
             }
             return spaceTrim((block) => `
                         ${headLine}
-                        
+
                           ${ /* <- Note: Indenting the description: */block(description)}
                     `);
         })
@@ -7264,6 +7704,9 @@ class MultipleLlmExecutionTools {
                 ${block(innerModelsTitlesAndDescriptions)}
             `);
     }
+    get profile() {
+        return LLM_PROVIDER_PROFILES.MULTIPLE;
+    }
     /**
      * Check the configuration of all execution tools
      */
@@ -7308,25 +7751,22 @@ class MultipleLlmExecutionTools {
         const errors = [];
         llm: for (const llmExecutionTools of this.llmExecutionTools) {
             try {
-                variant: switch (prompt.modelRequirements.modelVariant) {
+                switch (prompt.modelRequirements.modelVariant) {
                     case 'CHAT':
                         if (llmExecutionTools.callChatModel === undefined) {
                             continue llm;
                         }
                         return await llmExecutionTools.callChatModel(prompt);
-                        break variant;
                     case 'COMPLETION':
                         if (llmExecutionTools.callCompletionModel === undefined) {
                             continue llm;
                         }
                         return await llmExecutionTools.callCompletionModel(prompt);
-                        break variant;
                     case 'EMBEDDING':
                         if (llmExecutionTools.callEmbeddingModel === undefined) {
                             continue llm;
                         }
                         return await llmExecutionTools.callEmbeddingModel(prompt);
-                        break variant;
                     // <- case [🤖]:
                     default:
                         throw new UnexpectedError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
@@ -7479,7 +7919,7 @@ async function preparePersona(personaDescription, tools, options) {
     const result = await preparePersonaExecutor({
         availableModels /* <- Note: Passing as JSON */,
         personaDescription,
-    }).asPromise();
+    }).asPromise({ isCrashedOnError: true });
     const { outputParameters } = result;
     const { modelsRequirements: modelsRequirementsJson } = outputParameters;
     let modelsRequirementsUnchecked = jsonParse(modelsRequirementsJson);
@@ -8092,7 +8532,7 @@ async function preparePipeline(pipeline, tools, options) {
         });
         const result = await prepareTitleExecutor({
             book: sources.map(({ content }) => content).join('\n\n'),
-        }).asPromise();
+        }).asPromise({ isCrashedOnError: true });
         const { outputParameters } = result;
         const { title: titleRaw } = outputParameters;
         if (isVerbose) {
@@ -8920,7 +9360,7 @@ function validatePromptResult(options) {
  */
 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,
@@ -9164,6 +9604,10 @@ async function executeAttempts(options) {
                 result: $ongoingTaskResult.$resultString,
                 error: error,
             });
+            // Report failed attempt
+            onProgress({
+                errors: [error],
+            });
         }
         finally {
             if (!isJokerAttempt &&
@@ -10037,15 +10481,74 @@ function createPipelineExecutor(options) {
             });
         });
     };
-    const pipelineExecutor = (inputParameters) => createTask({
-        taskType: 'EXECUTION',
-        title: pipeline.title,
-        taskProcessCallback(updateOngoingResult) {
-            return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
-                updateOngoingResult(newOngoingResult);
-            });
-        },
-    });
+    const pipelineExecutor = (inputParameters) => {
+        const startTime = new Date().getTime();
+        return createTask({
+            taskType: 'EXECUTION',
+            title: pipeline.title,
+            taskProcessCallback(updateOngoingResult, updateTldr) {
+                return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
+                    var _a, _b;
+                    updateOngoingResult(newOngoingResult);
+                    // Calculate and update tldr based on pipeline progress
+                    const cv = newOngoingResult;
+                    // Calculate progress based on parameters resolved vs total parameters
+                    const totalParameters = pipeline.parameters.filter(p => !p.isInput).length;
+                    let resolvedParameters = 0;
+                    let currentTaskTitle = '';
+                    // Get the resolved parameters from output parameters
+                    if (cv === null || cv === void 0 ? void 0 : cv.outputParameters) {
+                        // Count how many output parameters have non-empty values
+                        resolvedParameters = Object.values(cv.outputParameters).filter(value => value !== undefined && value !== null && String(value).trim() !== '').length;
+                    }
+                    // Try to determine current task from execution report
+                    if (((_a = cv === null || cv === void 0 ? void 0 : cv.executionReport) === null || _a === void 0 ? void 0 : _a.promptExecutions) && cv.executionReport.promptExecutions.length > 0) {
+                        const lastExecution = cv.executionReport.promptExecutions[cv.executionReport.promptExecutions.length - 1];
+                        if ((_b = lastExecution === null || lastExecution === void 0 ? void 0 : lastExecution.prompt) === null || _b === void 0 ? void 0 : _b.title) {
+                            currentTaskTitle = lastExecution.prompt.title;
+                        }
+                    }
+                    // Calculate base progress percentage
+                    let percent = totalParameters > 0 ? resolvedParameters / totalParameters : 0;
+                    // Add time-based progress for current task if we haven't completed all parameters
+                    if (resolvedParameters < totalParameters) {
+                        const elapsedMs = new Date().getTime() - startTime;
+                        const estimatedTotalMs = totalParameters * 30 * 1000; // Estimate 30 seconds per parameter
+                        const timeProgress = Math.min(elapsedMs / estimatedTotalMs, 0.9); // Cap at 90% for time-based progress
+                        // If we have time progress but no parameter progress, show time progress
+                        if (percent === 0 && timeProgress > 0) {
+                            percent = Math.min(timeProgress, 0.1); // Show some progress but not more than 10%
+                        }
+                        else if (percent < 1) {
+                            // Add partial progress for current task
+                            const taskProgress = totalParameters > 0 ? (1 / totalParameters) * 0.5 : 0; // 50% of task progress
+                            percent = Math.min(percent + taskProgress, 0.95); // Cap at 95% until fully complete
+                        }
+                    }
+                    // Clamp to [0,1]
+                    percent = Math.min(Math.max(percent, 0), 1);
+                    // Generate message
+                    let message = '';
+                    if (currentTaskTitle) {
+                        message = `Executing: ${currentTaskTitle}`;
+                    }
+                    else if (resolvedParameters === 0) {
+                        message = 'Starting pipeline execution';
+                    }
+                    else if (resolvedParameters < totalParameters) {
+                        message = `Processing pipeline (${resolvedParameters}/${totalParameters} parameters resolved)`;
+                    }
+                    else {
+                        message = 'Completing pipeline execution';
+                    }
+                    updateTldr({
+                        percent: percent,
+                        message,
+                    });
+                });
+            },
+        });
+    };
     //        <- TODO: Make types such as there is no need to do `as` for `createTask`
     return pipelineExecutor;
 }
@@ -10130,7 +10633,9 @@ class MarkdownScraper {
             },
         });
         const knowledgeContent = await source.asText();
-        const result = await prepareKnowledgeFromMarkdownExecutor({ knowledgeContent }).asPromise();
+        const result = await prepareKnowledgeFromMarkdownExecutor({ knowledgeContent }).asPromise({
+            isCrashedOnError: true,
+        });
         const { outputParameters } = result;
         const { knowledgePieces: knowledgePiecesRaw } = outputParameters;
         const knowledgeTextPieces = (knowledgePiecesRaw || '').split('\n---\n');
@@ -10154,12 +10659,16 @@ class MarkdownScraper {
           ];
           */
             try {
-                const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise();
+                const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise({
+                    isCrashedOnError: true,
+                });
                 const { title: titleRaw = 'Untitled' } = titleResult.outputParameters;
                 title = spaceTrim(titleRaw) /* <- TODO: Maybe do in pipeline */;
                 name = titleToName(title);
                 // --- Keywords
-                const keywordsResult = await prepareKeywordsExecutor({ knowledgePieceContent }).asPromise();
+                const keywordsResult = await prepareKeywordsExecutor({ knowledgePieceContent }).asPromise({
+                    isCrashedOnError: true,
+                });
                 const { keywords: keywordsRaw = '' } = keywordsResult.outputParameters;
                 keywords = (keywordsRaw || '')
                     .split(',')
@@ -12826,31 +13335,23 @@ function extractBlock(markdown) {
     return content;
 }
 
+/**
+ * @private internal for `preserve`
+ */
+const _preserved = [];
 /**
  * Does nothing, but preserves the function in the bundle
  * Compiler is tricked into thinking the function is used
  *
  * @param value any function to preserve
  * @returns nothing
- * @private internal function of `JavascriptExecutionTools` and `JavascriptEvalExecutionTools`
- */
-function preserve(func) {
-    // Note: NOT calling the function
-    (async () => {
-        // TODO: [💩] Change to `await forEver` or `forTime(Infinity)`
-        await forTime(100000000);
-        // [1]
-        try {
-            await func();
-        }
-        finally {
-            // do nothing
-        }
-    })();
+ * @private within the repository
+ */
+function $preserve(...value) {
+    _preserved.push(...value);
 }
 /**
- * TODO: Probably remove in favour of `keepImported`
- * TODO: [1] This maybe does memory leak
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
 // Note: [💎]
@@ -12878,25 +13379,25 @@ class JavascriptEvalExecutionTools {
         // Note: [💎]
         // Note: Using direct eval, following variables are in same scope as eval call so they are accessible from inside the evaluated script:
         const spaceTrim$1 = (_) => spaceTrim(_);
-        preserve(spaceTrim$1);
+        $preserve(spaceTrim$1);
         const removeQuotes$1 = removeQuotes;
-        preserve(removeQuotes$1);
+        $preserve(removeQuotes$1);
         const unwrapResult$1 = unwrapResult;
-        preserve(unwrapResult$1);
+        $preserve(unwrapResult$1);
         const trimEndOfCodeBlock$1 = trimEndOfCodeBlock;
-        preserve(trimEndOfCodeBlock$1);
+        $preserve(trimEndOfCodeBlock$1);
         const trimCodeBlock$1 = trimCodeBlock;
-        preserve(trimCodeBlock$1);
+        $preserve(trimCodeBlock$1);
         // TODO: DRY [🍯]
         const trim = (str) => str.trim();
-        preserve(trim);
+        $preserve(trim);
         // TODO: DRY [🍯]
         const reverse = (str) => str.split('').reverse().join('');
-        preserve(reverse);
+        $preserve(reverse);
         const removeEmojis$1 = removeEmojis;
-        preserve(removeEmojis$1);
+        $preserve(removeEmojis$1);
         const prettifyMarkdown$1 = prettifyMarkdown;
-        preserve(prettifyMarkdown$1);
+        $preserve(prettifyMarkdown$1);
         //-------[n12:]---
         const capitalize$1 = capitalize;
         const decapitalize$1 = decapitalize;
@@ -12912,18 +13413,18 @@ class JavascriptEvalExecutionTools {
         // TODO: DRY [🍯]
         Array.from(parseKeywordsFromString(input)).join(', '); /* <- TODO: [🧠] What is the best format comma list, bullet list,...? */
         const normalizeTo_SCREAMING_CASE$1 = normalizeTo_SCREAMING_CASE;
-        preserve(capitalize$1);
-        preserve(decapitalize$1);
-        preserve(nameToUriPart$1);
-        preserve(nameToUriParts$1);
-        preserve(removeDiacritics$1);
-        preserve(normalizeWhitespaces$1);
-        preserve(normalizeToKebabCase$1);
-        preserve(normalizeTo_camelCase$1);
-        preserve(normalizeTo_snake_case$1);
-        preserve(normalizeTo_PascalCase$1);
-        preserve(parseKeywords);
-        preserve(normalizeTo_SCREAMING_CASE$1);
+        $preserve(capitalize$1);
+        $preserve(decapitalize$1);
+        $preserve(nameToUriPart$1);
+        $preserve(nameToUriParts$1);
+        $preserve(removeDiacritics$1);
+        $preserve(normalizeWhitespaces$1);
+        $preserve(normalizeToKebabCase$1);
+        $preserve(normalizeTo_camelCase$1);
+        $preserve(normalizeTo_snake_case$1);
+        $preserve(normalizeTo_PascalCase$1);
+        $preserve(parseKeywords);
+        $preserve(normalizeTo_SCREAMING_CASE$1);
         //-------[/n12]---
         if (!script.includes('return')) {
             script = `return ${script}`;
@@ -16972,7 +17473,7 @@ class Wizard {
         // ▶ Create executor - the function that will execute the Pipeline
         const pipelineExecutor = createPipelineExecutor({ pipeline, tools });
         // 🚀▶ Execute the Pipeline
-        const result = await pipelineExecutor(inputParameters).asPromise();
+        const result = await pipelineExecutor(inputParameters).asPromise({ isCrashedOnError: true });
         const { outputParameters } = result;
         const outputParametersLength = Object.keys(outputParameters).length;
         let resultString;