@promptbook/ollama 0.103.0-67 → 0.103.0-68

package/esm/index.es.js

@@ -18,7 +18,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.103.0-67';
+const PROMPTBOOK_ENGINE_VERSION = '0.103.0-68';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2167,12 +2167,18 @@ const OPENAI_MODELS = exportJson({
             },
         },
         /**/
-        /*/
-          {
-              modelTitle: 'dall-e-3',
-              modelName: 'dall-e-3',
-          },
-          /**/
+        /**/
+        {
+            modelVariant: 'IMAGE_GENERATION',
+            modelTitle: 'dall-e-3',
+            modelName: 'dall-e-3',
+            modelDescription: 'DALL·E 3 is the latest version of the DALL·E art generation model. It understands significantly more nuance and detail than our previous systems, allowing you to easily translate your ideas into exceptionally accurate images.',
+            pricing: {
+                prompt: 0,
+                output: 0.04,
+            },
+        },
+        /**/
         /*/
           {
               modelTitle: 'whisper-1',
@@ -2191,12 +2197,18 @@ const OPENAI_MODELS = exportJson({
             },
         },
         /**/
-        /*/
-      {
-          modelTitle: 'dall-e-2',
-          modelName: 'dall-e-2',
-      },
-      /**/
+        /**/
+        {
+            modelVariant: 'IMAGE_GENERATION',
+            modelTitle: 'dall-e-2',
+            modelName: 'dall-e-2',
+            modelDescription: 'DALL·E 2 is an AI system that can create realistic images and art from a description in natural language.',
+            pricing: {
+                prompt: 0,
+                output: 0.02,
+            },
+        },
+        /**/
         /**/
         {
             modelVariant: 'CHAT',
@@ -3407,6 +3419,151 @@ class OpenAiCompatibleExecutionTools {
             return this.callEmbeddingModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
         }
     }
+    /**
+     * Calls OpenAI compatible API to use a image generation model
+     */
+    async callImageGenerationModel(prompt) {
+        // Deep clone prompt and modelRequirements to avoid mutation across calls
+        const clonedPrompt = JSON.parse(JSON.stringify(prompt));
+        const retriedUnsupportedParameters = new Set();
+        return this.callImageGenerationModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters);
+    }
+    /**
+     * Internal method that handles parameter retry for image generation model calls
+     */
+    async callImageGenerationModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set()) {
+        var _a, _b;
+        if (this.options.isVerbose) {
+            console.info(`🎨 ${this.title} callImageGenerationModel call`, { prompt, currentModelRequirements });
+        }
+        const { content, parameters } = prompt;
+        const client = await this.getClient();
+        // TODO: [☂] Use here more modelRequirements
+        if (currentModelRequirements.modelVariant !== 'IMAGE_GENERATION') {
+            throw new PipelineExecutionError('Use callImageGenerationModel only for IMAGE_GENERATION variant');
+        }
+        const modelName = currentModelRequirements.modelName || this.getDefaultImageGenerationModel().modelName;
+        const modelSettings = {
+            model: modelName,
+            // size: currentModelRequirements.size,
+            // quality: currentModelRequirements.quality,
+            // style: currentModelRequirements.style,
+        };
+        const rawPromptContent = templateParameters(content, { ...parameters, modelName });
+        const rawRequest = {
+            ...modelSettings,
+            prompt: rawPromptContent,
+            user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
+            response_format: 'url', // TODO: [🧠] Maybe allow b64_json
+        };
+        const start = $getCurrentDate();
+        if (this.options.isVerbose) {
+            console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
+        }
+        try {
+            const rawResponse = await this.limiter
+                .schedule(() => this.makeRequestWithNetworkRetry(() => client.images.generate(rawRequest)))
+                .catch((error) => {
+                assertsError(error);
+                if (this.options.isVerbose) {
+                    console.info(colors.bgRed('error'), error);
+                }
+                throw error;
+            });
+            if (this.options.isVerbose) {
+                console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
+            }
+            const complete = $getCurrentDate();
+            if (!rawResponse.data[0]) {
+                throw new PipelineExecutionError(`No choises from ${this.title}`);
+            }
+            if (rawResponse.data.length > 1) {
+                throw new PipelineExecutionError(`More than one choise from ${this.title}`);
+            }
+            const resultContent = rawResponse.data[0].url;
+            const modelInfo = this.HARDCODED_MODELS.find((model) => model.modelName === modelName);
+            const price = ((_b = modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.pricing) === null || _b === void 0 ? void 0 : _b.output) ? uncertainNumber(modelInfo.pricing.output) : uncertainNumber();
+            return exportJson({
+                name: 'promptResult',
+                message: `Result of \`OpenAiCompatibleExecutionTools.callImageGenerationModel\``,
+                order: [],
+                value: {
+                    content: resultContent,
+                    modelName: modelName,
+                    timing: {
+                        start,
+                        complete,
+                    },
+                    usage: {
+                        price,
+                        input: {
+                            tokensCount: uncertainNumber(0),
+                            ...computeUsageCounts(rawPromptContent),
+                        },
+                        output: {
+                            tokensCount: uncertainNumber(0),
+                            ...computeUsageCounts(''),
+                        },
+                    },
+                    rawPromptContent,
+                    rawRequest,
+                    rawResponse,
+                },
+            });
+        }
+        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.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.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.callImageGenerationModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
+        }
+    }
     // <- Note: [🤖] callXxxModel
     /**
      * Get the model that should be used as default
@@ -3837,6 +3994,13 @@ class OllamaExecutionTools extends OpenAiCompatibleExecutionTools {
         return this.getDefaultModel('text-embedding-3-large'); // <- TODO: [🧠] Pick the best default model
         // <- TODO: [🛄]
     }
+    /**
+     * Default model for image generation variant.
+     */
+    getDefaultImageGenerationModel() {
+        return this.getDefaultModel('!!!'); // <- TODO: [🧠] Pick the best default model
+        // <- TODO: [🛄]
+    }
 }
 /**
  * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`