@promptbook/wizard 0.101.0-2 → 0.101.0-20

package/umd/index.umd.js

@@ -48,7 +48,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.101.0-2';
+    const PROMPTBOOK_ENGINE_VERSION = '0.101.0-20';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2826,7 +2826,7 @@
                 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.",
+                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`),
@@ -2838,7 +2838,7 @@
                 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.",
+                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`),
@@ -2850,7 +2850,7 @@
                 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.",
+                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`),
@@ -2862,7 +2862,7 @@
                 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.",
+                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`),
@@ -2874,7 +2874,7 @@
                 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.",
+                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`),
@@ -2886,7 +2886,7 @@
                 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.",
+                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`),
@@ -2898,7 +2898,7 @@
                 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.",
+                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`),
@@ -2910,7 +2910,7 @@
                 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.",
+                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`),
@@ -2922,7 +2922,7 @@
                 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.",
+                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`),
@@ -2934,7 +2934,7 @@
                 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.",
+                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`),
@@ -4634,6 +4634,62 @@
      * TODO: [🤝] DRY Maybe some common abstraction between `computeOpenAiUsage` and `computeAnthropicClaudeUsage`
      */
 
+    /**
+     * Parses an OpenAI error message to identify which parameter is unsupported
+     *
+     * @param errorMessage The error message from OpenAI API
+     * @returns The parameter name that is unsupported, or null if not an unsupported parameter error
+     * @private utility of LLM Tools
+     */
+    function parseUnsupportedParameterError(errorMessage) {
+        // Pattern to match "Unsupported value: 'parameter' does not support ..."
+        const unsupportedValueMatch = errorMessage.match(/Unsupported value:\s*'([^']+)'\s*does not support/i);
+        if (unsupportedValueMatch === null || unsupportedValueMatch === void 0 ? void 0 : unsupportedValueMatch[1]) {
+            return unsupportedValueMatch[1];
+        }
+        // Pattern to match "'parameter' of type ... is not supported with this model"
+        const parameterTypeMatch = errorMessage.match(/'([^']+)'\s*of type.*is not supported with this model/i);
+        if (parameterTypeMatch === null || parameterTypeMatch === void 0 ? void 0 : parameterTypeMatch[1]) {
+            return parameterTypeMatch[1];
+        }
+        return null;
+    }
+    /**
+     * Creates a copy of model requirements with the specified parameter removed
+     *
+     * @param modelRequirements Original model requirements
+     * @param unsupportedParameter The parameter to remove
+     * @returns New model requirements without the unsupported parameter
+     * @private utility of LLM Tools
+     */
+    function removeUnsupportedModelRequirement(modelRequirements, unsupportedParameter) {
+        const newRequirements = { ...modelRequirements };
+        // Map of parameter names that might appear in error messages to ModelRequirements properties
+        const parameterMap = {
+            temperature: 'temperature',
+            max_tokens: 'maxTokens',
+            maxTokens: 'maxTokens',
+            seed: 'seed',
+        };
+        const propertyToRemove = parameterMap[unsupportedParameter];
+        if (propertyToRemove && propertyToRemove in newRequirements) {
+            delete newRequirements[propertyToRemove];
+        }
+        return newRequirements;
+    }
+    /**
+     * Checks if an error is an "Unsupported value" error from OpenAI
+     * @param error The error to check
+     * @returns true if this is an unsupported parameter error
+     * @private utility of LLM Tools
+     */
+    function isUnsupportedParameterError(error) {
+        const errorMessage = error.message.toLowerCase();
+        return (errorMessage.includes('unsupported value:') ||
+            errorMessage.includes('is not supported with this model') ||
+            errorMessage.includes('does not support'));
+    }
+
     /**
      * Execution Tools for calling OpenAI API or other OpenAI compatible provider
      *
@@ -4651,6 +4707,10 @@
              * OpenAI API client.
              */
             this.client = null;
+            /**
+             * Tracks models and parameters that have already been retried to prevent infinite loops
+             */
+            this.retriedUnsupportedParameters = new Set();
             // TODO: Allow configuring rate limits via options
             this.limiter = new Bottleneck__default["default"]({
                 minTime: 60000 / (this.options.maxRequestsPerMinute || DEFAULT_MAX_REQUESTS_PER_MINUTE),
@@ -4712,21 +4772,27 @@
          * Calls OpenAI compatible API to use a chat model.
          */
         async callChatModel(prompt) {
+            return this.callChatModelWithRetry(prompt, prompt.modelRequirements);
+        }
+        /**
+         * Internal method that handles parameter retry for chat model calls
+         */
+        async callChatModelWithRetry(prompt, currentModelRequirements) {
             var _a;
             if (this.options.isVerbose) {
-                console.info(`💬 ${this.title} callChatModel call`, { prompt });
+                console.info(`💬 ${this.title} callChatModel call`, { prompt, currentModelRequirements });
             }
-            const { content, parameters, modelRequirements, format } = prompt;
+            const { content, parameters, format } = prompt;
             const client = await this.getClient();
             // TODO: [☂] Use here more modelRequirements
-            if (modelRequirements.modelVariant !== 'CHAT') {
+            if (currentModelRequirements.modelVariant !== 'CHAT') {
                 throw new PipelineExecutionError('Use callChatModel only for CHAT variant');
             }
-            const modelName = modelRequirements.modelName || this.getDefaultChatModel().modelName;
+            const modelName = currentModelRequirements.modelName || this.getDefaultChatModel().modelName;
             const modelSettings = {
                 model: modelName,
-                max_tokens: modelRequirements.maxTokens,
-                temperature: modelRequirements.temperature,
+                max_tokens: currentModelRequirements.maxTokens,
+                temperature: currentModelRequirements.temperature,
                 // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
                 // <- Note: [🧆]
             }; // <- TODO: [💩] Guard here types better
@@ -4741,12 +4807,12 @@
             const rawRequest = {
                 ...modelSettings,
                 messages: [
-                    ...(modelRequirements.systemMessage === undefined
+                    ...(currentModelRequirements.systemMessage === undefined
                         ? []
                         : [
                             {
                                 role: 'system',
-                                content: modelRequirements.systemMessage,
+                                content: currentModelRequirements.systemMessage,
                             },
                         ]),
                     {
@@ -4760,69 +4826,110 @@
             if (this.options.isVerbose) {
                 console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
-            const rawResponse = await this.limiter
-                .schedule(() => this.makeRequestWithRetry(() => client.chat.completions.create(rawRequest)))
-                .catch((error) => {
-                assertsError(error);
+            try {
+                const rawResponse = await this.limiter
+                    .schedule(() => this.makeRequestWithNetworkRetry(() => client.chat.completions.create(rawRequest)))
+                    .catch((error) => {
+                    assertsError(error);
+                    if (this.options.isVerbose) {
+                        console.info(colors__default["default"].bgRed('error'), error);
+                    }
+                    throw error;
+                });
                 if (this.options.isVerbose) {
-                    console.info(colors__default["default"].bgRed('error'), error);
+                    console.info(colors__default["default"].bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
                 }
-                throw error;
-            });
-            if (this.options.isVerbose) {
-                console.info(colors__default["default"].bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
-            }
-            const complete = $getCurrentDate();
-            if (!rawResponse.choices[0]) {
-                throw new PipelineExecutionError(`No choises from ${this.title}`);
-            }
-            if (rawResponse.choices.length > 1) {
-                // TODO: This should be maybe only warning
-                throw new PipelineExecutionError(`More than one choise from ${this.title}`);
+                const complete = $getCurrentDate();
+                if (!rawResponse.choices[0]) {
+                    throw new PipelineExecutionError(`No choises from ${this.title}`);
+                }
+                if (rawResponse.choices.length > 1) {
+                    // TODO: This should be maybe only warning
+                    throw new PipelineExecutionError(`More than one choise from ${this.title}`);
+                }
+                const resultContent = rawResponse.choices[0].message.content;
+                const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
+                if (resultContent === null) {
+                    throw new PipelineExecutionError(`No response message from ${this.title}`);
+                }
+                return exportJson({
+                    name: 'promptResult',
+                    message: `Result of \`OpenAiCompatibleExecutionTools.callChatModel\``,
+                    order: [],
+                    value: {
+                        content: resultContent,
+                        modelName: rawResponse.model || modelName,
+                        timing: {
+                            start,
+                            complete,
+                        },
+                        usage,
+                        rawPromptContent,
+                        rawRequest,
+                        rawResponse,
+                        // <- [🗯]
+                    },
+                });
             }
-            const resultContent = rawResponse.choices[0].message.content;
-            const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
-            if (resultContent === null) {
-                throw new PipelineExecutionError(`No response message from ${this.title}`);
+            catch (error) {
+                assertsError(error);
+                // Check if this is an unsupported parameter error
+                if (!isUnsupportedParameterError(error)) {
+                    throw error;
+                }
+                // Parse which parameter is unsupported
+                const unsupportedParameter = parseUnsupportedParameterError(error.message);
+                if (!unsupportedParameter) {
+                    if (this.options.isVerbose) {
+                        console.warn(colors__default["default"].bgYellow('Warning'), 'Could not parse unsupported parameter from error:', error.message);
+                    }
+                    throw error;
+                }
+                // Create a unique key for this model + parameter combination to prevent infinite loops
+                const retryKey = `${modelName}-${unsupportedParameter}`;
+                if (this.retriedUnsupportedParameters.has(retryKey)) {
+                    // Already retried this parameter, throw the error
+                    if (this.options.isVerbose) {
+                        console.warn(colors__default["default"].bgRed('Error'), `Parameter '${unsupportedParameter}' for model '${modelName}' already retried once, throwing error:`, error.message);
+                    }
+                    throw error;
+                }
+                // Mark this parameter as retried
+                this.retriedUnsupportedParameters.add(retryKey);
+                // Log warning in verbose mode
+                if (this.options.isVerbose) {
+                    console.warn(colors__default["default"].bgYellow('Warning'), `Removing unsupported parameter '${unsupportedParameter}' for model '${modelName}' and retrying request`);
+                }
+                // Remove the unsupported parameter and retry
+                const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
+                return this.callChatModelWithRetry(prompt, modifiedModelRequirements);
             }
-            return exportJson({
-                name: 'promptResult',
-                message: `Result of \`OpenAiCompatibleExecutionTools.callChatModel\``,
-                order: [],
-                value: {
-                    content: resultContent,
-                    modelName: rawResponse.model || modelName,
-                    timing: {
-                        start,
-                        complete,
-                    },
-                    usage,
-                    rawPromptContent,
-                    rawRequest,
-                    rawResponse,
-                    // <- [🗯]
-                },
-            });
         }
         /**
          * Calls OpenAI API to use a complete model.
          */
         async callCompletionModel(prompt) {
+            return this.callCompletionModelWithRetry(prompt, prompt.modelRequirements);
+        }
+        /**
+         * Internal method that handles parameter retry for completion model calls
+         */
+        async callCompletionModelWithRetry(prompt, currentModelRequirements) {
             var _a;
             if (this.options.isVerbose) {
-                console.info(`🖋 ${this.title} callCompletionModel call`, { prompt });
+                console.info(`🖋 ${this.title} callCompletionModel call`, { prompt, currentModelRequirements });
             }
-            const { content, parameters, modelRequirements } = prompt;
+            const { content, parameters } = prompt;
             const client = await this.getClient();
             // TODO: [☂] Use here more modelRequirements
-            if (modelRequirements.modelVariant !== 'COMPLETION') {
+            if (currentModelRequirements.modelVariant !== 'COMPLETION') {
                 throw new PipelineExecutionError('Use callCompletionModel only for COMPLETION variant');
             }
-            const modelName = modelRequirements.modelName || this.getDefaultCompletionModel().modelName;
+            const modelName = currentModelRequirements.modelName || this.getDefaultCompletionModel().modelName;
             const modelSettings = {
                 model: modelName,
-                max_tokens: modelRequirements.maxTokens,
-                temperature: modelRequirements.temperature,
+                max_tokens: currentModelRequirements.maxTokens,
+                temperature: currentModelRequirements.temperature,
                 // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
                 // <- Note: [🧆]
             };
@@ -4836,46 +4943,81 @@
             if (this.options.isVerbose) {
                 console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
-            const rawResponse = await this.limiter
-                .schedule(() => this.makeRequestWithRetry(() => client.completions.create(rawRequest)))
-                .catch((error) => {
-                assertsError(error);
+            try {
+                const rawResponse = await this.limiter
+                    .schedule(() => this.makeRequestWithNetworkRetry(() => client.completions.create(rawRequest)))
+                    .catch((error) => {
+                    assertsError(error);
+                    if (this.options.isVerbose) {
+                        console.info(colors__default["default"].bgRed('error'), error);
+                    }
+                    throw error;
+                });
                 if (this.options.isVerbose) {
-                    console.info(colors__default["default"].bgRed('error'), error);
+                    console.info(colors__default["default"].bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
                 }
-                throw error;
-            });
-            if (this.options.isVerbose) {
-                console.info(colors__default["default"].bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
-            }
-            const complete = $getCurrentDate();
-            if (!rawResponse.choices[0]) {
-                throw new PipelineExecutionError(`No choises from ${this.title}`);
+                const complete = $getCurrentDate();
+                if (!rawResponse.choices[0]) {
+                    throw new PipelineExecutionError(`No choises from ${this.title}`);
+                }
+                if (rawResponse.choices.length > 1) {
+                    // TODO: This should be maybe only warning
+                    throw new PipelineExecutionError(`More than one choise from ${this.title}`);
+                }
+                const resultContent = rawResponse.choices[0].text;
+                const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
+                return exportJson({
+                    name: 'promptResult',
+                    message: `Result of \`OpenAiCompatibleExecutionTools.callCompletionModel\``,
+                    order: [],
+                    value: {
+                        content: resultContent,
+                        modelName: rawResponse.model || modelName,
+                        timing: {
+                            start,
+                            complete,
+                        },
+                        usage,
+                        rawPromptContent,
+                        rawRequest,
+                        rawResponse,
+                        // <- [🗯]
+                    },
+                });
             }
-            if (rawResponse.choices.length > 1) {
-                // TODO: This should be maybe only warning
-                throw new PipelineExecutionError(`More than one choise from ${this.title}`);
+            catch (error) {
+                assertsError(error);
+                // Check if this is an unsupported parameter error
+                if (!isUnsupportedParameterError(error)) {
+                    throw error;
+                }
+                // Parse which parameter is unsupported
+                const unsupportedParameter = parseUnsupportedParameterError(error.message);
+                if (!unsupportedParameter) {
+                    if (this.options.isVerbose) {
+                        console.warn(colors__default["default"].bgYellow('Warning'), 'Could not parse unsupported parameter from error:', error.message);
+                    }
+                    throw error;
+                }
+                // Create a unique key for this model + parameter combination to prevent infinite loops
+                const retryKey = `${modelName}-${unsupportedParameter}`;
+                if (this.retriedUnsupportedParameters.has(retryKey)) {
+                    // Already retried this parameter, throw the error
+                    if (this.options.isVerbose) {
+                        console.warn(colors__default["default"].bgRed('Error'), `Parameter '${unsupportedParameter}' for model '${modelName}' already retried once, throwing error:`, error.message);
+                    }
+                    throw error;
+                }
+                // Mark this parameter as retried
+                this.retriedUnsupportedParameters.add(retryKey);
+                // Log warning in verbose mode
+                if (this.options.isVerbose) {
+                    console.warn(colors__default["default"].bgYellow('Warning'), `Removing unsupported parameter '${unsupportedParameter}' for model '${modelName}' and retrying request`);
+                }
+                // Remove the unsupported parameter and retry
+                const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
+                return this.callCompletionModelWithRetry(prompt, modifiedModelRequirements);
             }
-            const resultContent = rawResponse.choices[0].text;
-            const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
-            return exportJson({
-                name: 'promptResult',
-                message: `Result of \`OpenAiCompatibleExecutionTools.callCompletionModel\``,
-                order: [],
-                value: {
-                    content: resultContent,
-                    modelName: rawResponse.model || modelName,
-                    timing: {
-                        start,
-                        complete,
-                    },
-                    usage,
-                    rawPromptContent,
-                    rawRequest,
-                    rawResponse,
-                    // <- [🗯]
-                },
-            });
         }
         /**
          * Calls OpenAI compatible API to use a embedding model
@@ -4901,7 +5043,7 @@
                 console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
             const rawResponse = await this.limiter
-                .schedule(() => this.makeRequestWithRetry(() => client.embeddings.create(rawRequest)))
+                .schedule(() => this.makeRequestWithNetworkRetry(() => client.embeddings.create(rawRequest)))
                 .catch((error) => {
                 assertsError(error);
                 if (this.options.isVerbose) {
@@ -4963,7 +5105,7 @@
         /**
          * Makes a request with retry logic for network errors like ECONNRESET
          */
-        async makeRequestWithRetry(requestFn) {
+        async makeRequestWithNetworkRetry(requestFn) {
             let lastError;
             for (let attempt = 1; attempt <= CONNECTION_RETRIES_LIMIT; attempt++) {
                 try {
@@ -4975,8 +5117,8 @@
                     // Check if this is a retryable network error
                     const isRetryableError = this.isRetryableNetworkError(error);
                     if (!isRetryableError || attempt === CONNECTION_RETRIES_LIMIT) {
-                        if (this.options.isVerbose) {
-                            console.info(colors__default["default"].bgRed('Final error after retries'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}:`, error);
+                        if (this.options.isVerbose && this.isRetryableNetworkError(error)) {
+                            console.info(colors__default["default"].bgRed('Final network error after retries'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}:`, error);
                         }
                         throw error;
                     }
@@ -4986,7 +5128,7 @@
                     const jitterDelay = Math.random() * 500; // Add some randomness
                     const totalDelay = backoffDelay + jitterDelay;
                     if (this.options.isVerbose) {
-                        console.info(colors__default["default"].bgYellow('Retrying request'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}, waiting ${Math.round(totalDelay)}ms:`, error.message);
+                        console.info(colors__default["default"].bgYellow('Retrying network request'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}, waiting ${Math.round(totalDelay)}ms:`, error.message);
                     }
                     // Wait before retrying
                     await new Promise((resolve) => setTimeout(resolve, totalDelay));
@@ -6367,11 +6509,12 @@
         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'))) ;
+            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;
@@ -7713,6 +7856,25 @@
      * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
      */
 
+    /**
+     * Takes an item or an array of items and returns an array of items
+     *
+     * 1) Any item except array and undefined returns array with that one item (also null)
+     * 2) Undefined returns empty array
+     * 3) Array returns itself
+     *
+     * @private internal utility
+     */
+    function arrayableToArray(input) {
+        if (input === undefined) {
+            return [];
+        }
+        if (input instanceof Array) {
+            return input;
+        }
+        return [input];
+    }
+
     /**
      * Multiple LLM Execution Tools is a proxy server that uses multiple execution tools internally and exposes the executor interface externally.
      *
@@ -7723,12 +7885,10 @@
         /**
          * Gets array of execution tools in order of priority
          */
-        constructor(...llmExecutionTools) {
+        constructor(title, ...llmExecutionTools) {
+            this.title = title;
             this.llmExecutionTools = llmExecutionTools;
         }
-        get title() {
-            return 'Multiple LLM Providers';
-        }
         get description() {
             const innerModelsTitlesAndDescriptions = this.llmExecutionTools
                 .map(({ title, description }, index) => {
@@ -7814,7 +7974,7 @@
                             return await llmExecutionTools.callEmbeddingModel(prompt);
                         // <- case [🤖]:
                         default:
-                            throw new UnexpectedError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
+                            throw new UnexpectedError(`Unknown model variant "${prompt.modelRequirements.modelVariant}" in ${llmExecutionTools.title}`);
                     }
                 }
                 catch (error) {
@@ -7835,7 +7995,7 @@
                 //     2) AnthropicClaude throw PipelineExecutionError: Parameter `{knowledge}` is not defined
                 //     3) ...
                 spaceTrim__default["default"]((block) => `
-                          All execution tools failed:
+                          All execution tools of ${this.title} failed:
 
                           ${block(errors
                 .map(({ error, llmExecutionTools }, i) => `${i + 1}) **${llmExecutionTools.title}** thrown **${error.name || 'Error'}:** ${error.message}`)
@@ -7844,11 +8004,11 @@
                     `));
             }
             else if (this.llmExecutionTools.length === 0) {
-                throw new PipelineExecutionError(`You have not provided any \`LlmExecutionTools\``);
+                throw new PipelineExecutionError(`You have not provided any \`LlmExecutionTools\` into ${this.title}`);
             }
             else {
                 throw new PipelineExecutionError(spaceTrim__default["default"]((block) => `
-                          You have not provided any \`LlmExecutionTools\` that support model variant "${prompt.modelRequirements.modelVariant}"
+                          You have not provided any \`LlmExecutionTools\` that support model variant "${prompt.modelRequirements.modelVariant}" into ${this.title}
 
                           Available \`LlmExecutionTools\`:
                           ${block(this.description)}
@@ -7878,7 +8038,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    function joinLlmExecutionTools(...llmExecutionTools) {
+    function joinLlmExecutionTools(title, ...llmExecutionTools) {
         if (llmExecutionTools.length === 0) {
             const warningMessage = spaceTrim__default["default"](`
             You have not provided any \`LlmExecutionTools\`
@@ -7910,30 +8070,27 @@
             };
             */
         }
-        return new MultipleLlmExecutionTools(...llmExecutionTools);
+        return new MultipleLlmExecutionTools(title || 'Multiple LLM Providers joined by `joinLlmExecutionTools`', ...llmExecutionTools);
     }
     /**
      * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
      */
 
     /**
-     * Takes an item or an array of items and returns an array of items
-     *
-     * 1) Any item except array and undefined returns array with that one item (also null)
-     * 2) Undefined returns empty array
-     * 3) Array returns itself
+     * Just returns the given `LlmExecutionTools` or joins multiple into one
      *
-     * @private internal utility
+     * @public exported from `@promptbook/core`
      */
-    function arrayableToArray(input) {
-        if (input === undefined) {
-            return [];
-        }
-        if (input instanceof Array) {
-            return input;
-        }
-        return [input];
+    function getSingleLlmExecutionTools(oneOrMoreLlmExecutionTools) {
+        const _llms = arrayableToArray(oneOrMoreLlmExecutionTools);
+        const llmTools = _llms.length === 1
+            ? _llms[0]
+            : joinLlmExecutionTools('Multiple LLM Providers joined by `getSingleLlmExecutionTools`', ..._llms);
+        return llmTools;
     }
+    /**
+     * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+     */
 
     /**
      * Prepares the persona for the pipeline
@@ -7952,8 +8109,7 @@
             pipeline: await collection.getPipelineByUrl('https://promptbook.studio/promptbook/prepare-persona.book'),
             tools,
         });
-        const _llms = arrayableToArray(tools.llm);
-        const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
+        const llmTools = getSingleLlmExecutionTools(tools.llm);
         const availableModels = (await llmTools.listModels())
             .filter(({ modelVariant }) => modelVariant === 'CHAT')
             .map(({ modelName, modelDescription }) => ({
@@ -7997,6 +8153,7 @@
         };
     }
     /**
+     * TODO: [😩] DRY `preparePersona` and `selectBestModelFromAvailable`
      * TODO: [🔃][main] If the persona was prepared with different version or different set of models, prepare it once again
      * TODO: [🏢] Check validity of `modelName` in pipeline
      * TODO: [🏢] Check validity of `systemMessage` in pipeline
@@ -8569,9 +8726,7 @@
         if (tools === undefined || tools.llm === undefined) {
             throw new MissingToolsError('LLM tools are required for preparing the pipeline');
         }
-        // TODO: [🚐] Make arrayable LLMs -> single LLM DRY
-        const _llms = arrayableToArray(tools.llm);
-        const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
+        const llmTools = getSingleLlmExecutionTools(tools.llm);
         const llmToolsWithUsage = countUsage(llmTools);
         //    <- TODO: [🌯]
         /*
@@ -9441,9 +9596,7 @@
             $scriptPipelineExecutionErrors: [],
             $failedResults: [], // Track all failed attempts
         };
-        // TODO: [🚐] Make arrayable LLMs -> single LLM DRY
-        const _llms = arrayableToArray(tools.llm);
-        const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
+        const llmTools = getSingleLlmExecutionTools(tools.llm);
         attempts: for (let attemptIndex = -jokerParameterNames.length; attemptIndex < maxAttempts; attemptIndex++) {
             const isJokerAttempt = attemptIndex < 0;
             const jokerParameterName = jokerParameterNames[jokerParameterNames.length + attemptIndex];
@@ -9963,9 +10116,7 @@
             return ''; // <- Note: Np knowledge present, return empty string
         }
         try {
-            // TODO: [🚐] Make arrayable LLMs -> single LLM DRY
-            const _llms = arrayableToArray(tools.llm);
-            const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
+            const llmTools = getSingleLlmExecutionTools(tools.llm);
             const taskEmbeddingPrompt = {
                 title: 'Knowledge Search',
                 modelRequirements: {
@@ -10566,13 +10717,13 @@
                         // 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;
+                        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;
+                            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) {
@@ -10682,9 +10833,7 @@
                 throw new MissingToolsError('LLM tools are required for scraping external files');
                 // <- Note: This scraper is used in all other scrapers, so saying "external files" not "markdown files"
             }
-            // TODO: [🚐] Make arrayable LLMs -> single LLM DRY
-            const _llms = arrayableToArray(llm);
-            const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
+            const llmTools = getSingleLlmExecutionTools(llm);
             // TODO: [🌼] In future use `ptbk make` and made getPipelineCollection
             const collection = createCollectionFromJson(...PipelineCollection);
             const prepareKnowledgeFromMarkdownExecutor = createPipelineExecutor({
@@ -11461,11 +11610,12 @@
                 catch (error) {
                     // Note: If we can't write to cache, we'll continue without caching
                     //       This handles read-only filesystems like Vercel
-                    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'))) ;
+                    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;
@@ -11765,11 +11915,12 @@
             catch (error) {
                 // Note: If we can't write to cache, we'll continue without caching
                 //       This handles read-only filesystems like Vercel
-                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'))) ;
+                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;
@@ -12523,11 +12674,12 @@
             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'))) {
+                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;
                 }
@@ -12820,7 +12972,7 @@
      * @public exported from `@promptbook/core`
      */
     function createLlmToolsFromConfiguration(configuration, options = {}) {
-        const { isVerbose = DEFAULT_IS_VERBOSE, userId } = options;
+        const { title = 'LLM Tools from Configuration', isVerbose = DEFAULT_IS_VERBOSE, userId } = options;
         const llmTools = configuration.map((llmConfiguration) => {
             const registeredItem = $llmToolsRegister
                 .list()
@@ -12852,7 +13004,7 @@
                 ...llmConfiguration.options,
             });
         });
-        return joinLlmExecutionTools(...llmTools);
+        return joinLlmExecutionTools(title, ...llmTools);
     }
     /**
      * TODO: [🎌] Together with `createLlmToolsFromConfiguration` + 'EXECUTION_TOOLS_CLASSES' gets to `@promptbook/core` ALL model providers, make this more efficient
@@ -12969,7 +13121,9 @@
             });
         }
         else if (strategy === 'BRING_YOUR_OWN_KEYS') {
-            llmExecutionTools = await $provideLlmToolsFromEnv();
+            llmExecutionTools = await $provideLlmToolsFromEnv({
+                title: 'LLM Tools for wizard or CLI with BYOK strategy',
+            });
         }
         else {
             throw new UnexpectedError(`\`$provideLlmToolsForWizardOrCli\` wrong strategy "${strategy}"`);
@@ -17002,7 +17156,7 @@
             throw new EnvironmentMismatchError('Function `$getExecutionToolsForNode` works only in Node.js environment');
         }
         const fs = $provideFilesystemForNode();
-        const llm = await $provideLlmToolsFromEnv(options);
+        const llm = await $provideLlmToolsFromEnv({ title: 'LLM Tools for Node.js', ...options });
         const executables = await $provideExecutablesForNode();
         const tools = {
             llm,
@@ -17411,11 +17565,12 @@
                     catch (error) {
                         // Note: Ignore filesystem errors (like EROFS on read-only systems like Vercel)
                         //       The compiled book can still be used even if it can't be cached
-                        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'))) ;
+                        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;