@promptbook/openai 0.102.0-1 → 0.102.0-11

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.102.0-1';
+    const PROMPTBOOK_ENGINE_VERSION = '0.102.0-11';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2010,6 +2010,7 @@
      * @public exported from `@promptbook/openai`
      */
     class OpenAiCompatibleExecutionTools {
+        // Removed retriedUnsupportedParameters and attemptHistory instance fields
         /**
          * Creates OpenAI compatible Execution Tools.
          *
@@ -2021,10 +2022,6 @@
              * 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),
@@ -2086,12 +2083,16 @@
          * Calls OpenAI compatible API to use a chat model.
          */
         async callChatModel(prompt) {
-            return this.callChatModelWithRetry(prompt, prompt.modelRequirements);
+            // Deep clone prompt and modelRequirements to avoid mutation across calls
+            const clonedPrompt = JSON.parse(JSON.stringify(prompt));
+            // Use local Set for retried parameters to ensure independence and thread safety
+            const retriedUnsupportedParameters = new Set();
+            return this.callChatModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters);
         }
         /**
          * Internal method that handles parameter retry for chat model calls
          */
-        async callChatModelWithRetry(prompt, currentModelRequirements) {
+        async callChatModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set()) {
             var _a;
             if (this.options.isVerbose) {
                 console.info(`💬 ${this.title} callChatModel call`, { prompt, currentModelRequirements });
@@ -2118,6 +2119,14 @@
             // <- TODO: [🚸] Not all models are compatible with JSON mode
             //        > 'response_format' of type 'json_object' is not supported with this model.
             const rawPromptContent = templateParameters(content, { ...parameters, modelName });
+            // Convert thread to OpenAI format if present
+            let threadMessages = [];
+            if ('thread' in prompt && Array.isArray(prompt.thread)) {
+                threadMessages = prompt.thread.map((msg) => ({
+                    role: msg.role === 'assistant' ? 'assistant' : 'user',
+                    content: msg.content,
+                }));
+            }
             const rawRequest = {
                 ...modelSettings,
                 messages: [
@@ -2129,6 +2138,7 @@
                                 content: currentModelRequirements.systemMessage,
                             },
                         ]),
+                    ...threadMessages,
                     {
                         role: 'user',
                         content: rawPromptContent,
@@ -2189,6 +2199,17 @@
                 assertsError(error);
                 // Check if this is an unsupported parameter error
                 if (!isUnsupportedParameterError(error)) {
+                    // If we have attemptStack, include it in the error message
+                    if (attemptStack.length > 0) {
+                        throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                            attemptStack
+                                .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                                (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                                `, Error: ${a.errorMessage}` +
+                                (a.stripped ? ' (stripped and retried)' : ''))
+                                .join('\n') +
+                            `\nFinal error: ${error.message}`);
+                    }
                     throw error;
                 }
                 // Parse which parameter is unsupported
@@ -2201,34 +2222,54 @@
                 }
                 // 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;
+                if (retriedUnsupportedParameters.has(retryKey)) {
+                    // Already retried this parameter, throw the error with attemptStack
+                    attemptStack.push({
+                        modelName,
+                        unsupportedParameter,
+                        errorMessage: error.message,
+                        stripped: true,
+                    });
+                    throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                        attemptStack
+                            .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                            (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                            `, Error: ${a.errorMessage}` +
+                            (a.stripped ? ' (stripped and retried)' : ''))
+                            .join('\n') +
+                        `\nFinal error: ${error.message}`);
                 }
                 // Mark this parameter as retried
-                this.retriedUnsupportedParameters.add(retryKey);
+                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`);
                 }
+                // Add to attemptStack
+                attemptStack.push({
+                    modelName,
+                    unsupportedParameter,
+                    errorMessage: error.message,
+                    stripped: true,
+                });
                 // Remove the unsupported parameter and retry
                 const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
-                return this.callChatModelWithRetry(prompt, modifiedModelRequirements);
+                return this.callChatModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
             }
         }
         /**
          * Calls OpenAI API to use a complete model.
          */
         async callCompletionModel(prompt) {
-            return this.callCompletionModelWithRetry(prompt, prompt.modelRequirements);
+            // Deep clone prompt and modelRequirements to avoid mutation across calls
+            const clonedPrompt = JSON.parse(JSON.stringify(prompt));
+            const retriedUnsupportedParameters = new Set();
+            return this.callCompletionModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters);
         }
         /**
          * Internal method that handles parameter retry for completion model calls
          */
-        async callCompletionModelWithRetry(prompt, currentModelRequirements) {
+        async callCompletionModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set()) {
             var _a;
             if (this.options.isVerbose) {
                 console.info(`🖋 ${this.title} callCompletionModel call`, { prompt, currentModelRequirements });
@@ -2244,8 +2285,6 @@
                 model: modelName,
                 max_tokens: currentModelRequirements.maxTokens,
                 temperature: currentModelRequirements.temperature,
-                // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
-                // <- Note: [🧆]
             };
             const rawPromptContent = templateParameters(content, { ...parameters, modelName });
             const rawRequest = {
@@ -2275,7 +2314,6 @@
                     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;
@@ -2295,17 +2333,24 @@
                         rawPromptContent,
                         rawRequest,
                         rawResponse,
-                        // <- [🗯]
                     },
                 });
             }
             catch (error) {
                 assertsError(error);
-                // Check if this is an unsupported parameter error
                 if (!isUnsupportedParameterError(error)) {
+                    if (attemptStack.length > 0) {
+                        throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                            attemptStack
+                                .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                                (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                                `, Error: ${a.errorMessage}` +
+                                (a.stripped ? ' (stripped and retried)' : ''))
+                                .join('\n') +
+                            `\nFinal error: ${error.message}`);
+                    }
                     throw error;
                 }
-                // Parse which parameter is unsupported
                 const unsupportedParameter = parseUnsupportedParameterError(error.message);
                 if (!unsupportedParameter) {
                     if (this.options.isVerbose) {
@@ -2313,40 +2358,59 @@
                     }
                     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;
+                if (retriedUnsupportedParameters.has(retryKey)) {
+                    attemptStack.push({
+                        modelName,
+                        unsupportedParameter,
+                        errorMessage: error.message,
+                        stripped: true,
+                    });
+                    throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                        attemptStack
+                            .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                            (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                            `, Error: ${a.errorMessage}` +
+                            (a.stripped ? ' (stripped and retried)' : ''))
+                            .join('\n') +
+                        `\nFinal error: ${error.message}`);
                 }
-                // Mark this parameter as retried
-                this.retriedUnsupportedParameters.add(retryKey);
-                // Log warning in verbose mode
+                retriedUnsupportedParameters.add(retryKey);
                 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
+                attemptStack.push({
+                    modelName,
+                    unsupportedParameter,
+                    errorMessage: error.message,
+                    stripped: true,
+                });
                 const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
-                return this.callCompletionModelWithRetry(prompt, modifiedModelRequirements);
+                return this.callCompletionModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
             }
         }
         /**
          * Calls OpenAI compatible API to use a embedding model
          */
         async callEmbeddingModel(prompt) {
+            // Deep clone prompt and modelRequirements to avoid mutation across calls
+            const clonedPrompt = JSON.parse(JSON.stringify(prompt));
+            const retriedUnsupportedParameters = new Set();
+            return this.callEmbeddingModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters);
+        }
+        /**
+         * Internal method that handles parameter retry for embedding model calls
+         */
+        async callEmbeddingModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set()) {
             if (this.options.isVerbose) {
-                console.info(`🖋 ${this.title} embedding call`, { prompt });
+                console.info(`🖋 ${this.title} embedding 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 !== 'EMBEDDING') {
+            if (currentModelRequirements.modelVariant !== 'EMBEDDING') {
                 throw new PipelineExecutionError('Use embed only for EMBEDDING variant');
             }
-            const modelName = modelRequirements.modelName || this.getDefaultEmbeddingModel().modelName;
+            const modelName = currentModelRequirements.modelName || this.getDefaultEmbeddingModel().modelName;
             const rawPromptContent = templateParameters(content, { ...parameters, modelName });
             const rawRequest = {
                 input: rawPromptContent,
@@ -2356,44 +2420,95 @@
             if (this.options.isVerbose) {
                 console.info(colors__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
-            const rawResponse = await this.limiter
-                .schedule(() => this.makeRequestWithNetworkRetry(() => client.embeddings.create(rawRequest)))
-                .catch((error) => {
-                assertsError(error);
+            try {
+                const rawResponse = await this.limiter
+                    .schedule(() => this.makeRequestWithNetworkRetry(() => client.embeddings.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.data.length !== 1) {
+                    throw new PipelineExecutionError(`Expected exactly 1 data item in response, got ${rawResponse.data.length}`);
+                }
+                const resultContent = rawResponse.data[0].embedding;
+                const usage = this.computeUsage(content || '', '', rawResponse);
+                return exportJson({
+                    name: 'promptResult',
+                    message: `Result of \`OpenAiCompatibleExecutionTools.callEmbeddingModel\``,
+                    order: [],
+                    value: {
+                        content: resultContent,
+                        modelName: rawResponse.model || modelName,
+                        timing: {
+                            start,
+                            complete,
+                        },
+                        usage,
+                        rawPromptContent,
+                        rawRequest,
+                        rawResponse,
+                    },
+                });
             }
-            const complete = $getCurrentDate();
-            if (rawResponse.data.length !== 1) {
-                throw new PipelineExecutionError(`Expected exactly 1 data item in response, got ${rawResponse.data.length}`);
+            catch (error) {
+                assertsError(error);
+                if (!isUnsupportedParameterError(error)) {
+                    if (attemptStack.length > 0) {
+                        throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                            attemptStack
+                                .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                                (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                                `, Error: ${a.errorMessage}` +
+                                (a.stripped ? ' (stripped and retried)' : ''))
+                                .join('\n') +
+                            `\nFinal error: ${error.message}`);
+                    }
+                    throw error;
+                }
+                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;
+                }
+                const retryKey = `${modelName}-${unsupportedParameter}`;
+                if (retriedUnsupportedParameters.has(retryKey)) {
+                    attemptStack.push({
+                        modelName,
+                        unsupportedParameter,
+                        errorMessage: error.message,
+                        stripped: true,
+                    });
+                    throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                        attemptStack
+                            .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                            (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                            `, Error: ${a.errorMessage}` +
+                            (a.stripped ? ' (stripped and retried)' : ''))
+                            .join('\n') +
+                        `\nFinal error: ${error.message}`);
+                }
+                retriedUnsupportedParameters.add(retryKey);
+                if (this.options.isVerbose) {
+                    console.warn(colors__default["default"].bgYellow('Warning'), `Removing unsupported parameter '${unsupportedParameter}' for model '${modelName}' and retrying request`);
+                }
+                attemptStack.push({
+                    modelName,
+                    unsupportedParameter,
+                    errorMessage: error.message,
+                    stripped: true,
+                });
+                const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
+                return this.callEmbeddingModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
             }
-            const resultContent = rawResponse.data[0].embedding;
-            const usage = this.computeUsage(content || '', '', 
-            // <- Note: Embedding does not have result content
-            rawResponse);
-            return exportJson({
-                name: 'promptResult',
-                message: `Result of \`OpenAiCompatibleExecutionTools.callEmbeddingModel\``,
-                order: [],
-                value: {
-                    content: resultContent,
-                    modelName: rawResponse.model || modelName,
-                    timing: {
-                        start,
-                        complete,
-                    },
-                    usage,
-                    rawPromptContent,
-                    rawRequest,
-                    rawResponse,
-                    // <- [🗯]
-                },
-            });
         }
         // <- Note: [🤖] callXxxModel
         /**