@promptbook/wizard 0.101.0-14 → 0.101.0-15

package/esm/index.es.js

@@ -36,7 +36,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @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
@@ -4622,6 +4622,62 @@ resultContent, rawResponse) {
  * 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
  *
@@ -4639,6 +4695,10 @@ class OpenAiCompatibleExecutionTools {
          * 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({
             minTime: 60000 / (this.options.maxRequestsPerMinute || DEFAULT_MAX_REQUESTS_PER_MINUTE),
@@ -4700,21 +4760,27 @@ class OpenAiCompatibleExecutionTools {
      * 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
@@ -4729,12 +4795,12 @@ class OpenAiCompatibleExecutionTools {
         const rawRequest = {
             ...modelSettings,
             messages: [
-                ...(modelRequirements.systemMessage === undefined
+                ...(currentModelRequirements.systemMessage === undefined
                     ? []
                     : [
                         {
                             role: 'system',
-                            content: modelRequirements.systemMessage,
+                            content: currentModelRequirements.systemMessage,
                         },
                     ]),
                 {
@@ -4748,69 +4814,110 @@ class OpenAiCompatibleExecutionTools {
         if (this.options.isVerbose) {
             console.info(colors.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.bgRed('error'), error);
+                }
+                throw error;
+            });
             if (this.options.isVerbose) {
-                console.info(colors.bgRed('error'), error);
+                console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
             }
-            throw error;
-        });
-        if (this.options.isVerbose) {
-            console.info(colors.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.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.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.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: [🧆]
         };
@@ -4824,46 +4931,81 @@ class OpenAiCompatibleExecutionTools {
         if (this.options.isVerbose) {
             console.info(colors.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.bgRed('error'), error);
+                }
+                throw error;
+            });
             if (this.options.isVerbose) {
-                console.info(colors.bgRed('error'), error);
+                console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
             }
-            throw error;
-        });
-        if (this.options.isVerbose) {
-            console.info(colors.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.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.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.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
@@ -4889,7 +5031,7 @@ class OpenAiCompatibleExecutionTools {
             console.info(colors.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) {
@@ -4951,7 +5093,7 @@ class OpenAiCompatibleExecutionTools {
     /**
      * 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 {
@@ -4963,8 +5105,8 @@ class OpenAiCompatibleExecutionTools {
                 // Check if this is a retryable network error
                 const isRetryableError = this.isRetryableNetworkError(error);
                 if (!isRetryableError || attempt === CONNECTION_RETRIES_LIMIT) {
-                    if (this.options.isVerbose) {
-                        console.info(colors.bgRed('Final error after retries'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}:`, error);
+                    if (this.options.isVerbose && this.isRetryableNetworkError(error)) {
+                        console.info(colors.bgRed('Final network error after retries'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}:`, error);
                     }
                     throw error;
                 }
@@ -4974,7 +5116,7 @@ class OpenAiCompatibleExecutionTools {
                 const jitterDelay = Math.random() * 500; // Add some randomness
                 const totalDelay = backoffDelay + jitterDelay;
                 if (this.options.isVerbose) {
-                    console.info(colors.bgYellow('Retrying request'), `Attempt ${attempt}/${CONNECTION_RETRIES_LIMIT}, waiting ${Math.round(totalDelay)}ms:`, error.message);
+                    console.info(colors.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));