@promptbook/openai 0.101.0-14 → 0.101.0-15

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.101.0-14';
+    const PROMPTBOOK_ENGINE_VERSION = '0.101.0-15';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2018,6 +2018,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
      *
@@ -2035,6 +2091,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),
@@ -2096,21 +2156,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
@@ -2125,12 +2191,12 @@
             const rawRequest = {
                 ...modelSettings,
                 messages: [
-                    ...(modelRequirements.systemMessage === undefined
+                    ...(currentModelRequirements.systemMessage === undefined
                         ? []
                         : [
                             {
                                 role: 'system',
-                                content: modelRequirements.systemMessage,
+                                content: currentModelRequirements.systemMessage,
                             },
                         ]),
                     {
@@ -2144,69 +2210,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: [🧆]
             };
@@ -2220,46 +2327,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
@@ -2285,7 +2427,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) {
@@ -2347,7 +2489,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 {
@@ -2359,8 +2501,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;
                     }
@@ -2370,7 +2512,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));