@promptbook/ollama 0.101.0-9 → 0.102.0-0

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.101.0-9';
+    const PROMPTBOOK_ENGINE_VERSION = '0.102.0-0';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1126,7 +1126,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`),
@@ -1138,7 +1138,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`),
@@ -1150,7 +1150,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`),
@@ -1162,7 +1162,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`),
@@ -1174,7 +1174,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`),
@@ -1186,7 +1186,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`),
@@ -1198,7 +1198,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`),
@@ -1210,7 +1210,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`),
@@ -1222,7 +1222,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`),
@@ -1234,7 +1234,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`),
@@ -1919,6 +1919,62 @@
         return replacedTemplates;
     }
 
+    /**
+     * 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
      *
@@ -1936,6 +1992,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),
@@ -1997,21 +2057,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
@@ -2026,12 +2092,12 @@
             const rawRequest = {
                 ...modelSettings,
                 messages: [
-                    ...(modelRequirements.systemMessage === undefined
+                    ...(currentModelRequirements.systemMessage === undefined
                         ? []
                         : [
                             {
                                 role: 'system',
-                                content: modelRequirements.systemMessage,
+                                content: currentModelRequirements.systemMessage,
                             },
                         ]),
                     {
@@ -2045,69 +2111,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: [🧆]
             };
@@ -2121,46 +2228,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
@@ -2186,7 +2328,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) {
@@ -2248,7 +2390,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 {
@@ -2260,8 +2402,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;
                     }
@@ -2271,7 +2413,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));
@@ -2320,6 +2462,7 @@
      * TODO: [🛄] Maybe make custom `OpenAiCompatibleError`
      * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
      * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
+     * TODO: [🧠][🦢] Make reverse adapter from LlmExecutionTools to OpenAI-compatible:
      */
 
     /**
@@ -2582,6 +2725,14 @@
      */
     const DEFAULT_OLLAMA_BASE_URL = 'http://localhost:11434/v1';
 
+    /**
+     * Profile for Ollama provider
+     */
+    const OLLAMA_PROVIDER_PROFILE = {
+        name: 'OLLAMA',
+        fullname: 'Ollama',
+        color: '#059669',
+    };
     /**
      * Execution Tools for calling Ollama API
      *
@@ -2604,6 +2755,9 @@
         get description() {
             return 'Use all models provided by Ollama';
         }
+        get profile() {
+            return OLLAMA_PROVIDER_PROFILE;
+        }
         /**
          * List all available models (non dynamically)
          *