@promptbook/wizard 0.98.0-5 → 0.98.0-8

package/umd/index.umd.js

@@ -49,7 +49,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.98.0-5';
+    const PROMPTBOOK_ENGINE_VERSION = '0.98.0-8';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -243,7 +243,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const DEFAULT_MAX_EXECUTION_ATTEMPTS = 3; // <- TODO: [🤹‍♂️]
+    const DEFAULT_MAX_EXECUTION_ATTEMPTS = 7; // <- TODO: [🤹‍♂️]
     // <- TODO: [🐝]
     /**
      * Where to store your books
@@ -4356,7 +4356,7 @@
      */
 
     /**
-     * Execution Tools for calling OpenAI API or other OpeenAI compatible provider
+     * Execution Tools for calling OpenAI API or other OpenAI compatible provider
      *
      * @public exported from `@promptbook/openai`
      */
@@ -4926,6 +4926,7 @@
                 baseURL: DEFAULT_OLLAMA_BASE_URL,
                 ...ollamaOptions,
                 apiKey: 'ollama',
+                isProxied: false, // <- Note: Ollama is always local
             };
             super(openAiCompatibleOptions);
         }
@@ -5112,7 +5113,7 @@
         title: 'Open AI Compatible',
         packageName: '@promptbook/openai',
         className: 'OpenAiCompatibleExecutionTools',
-        envVariables: ['OPENAI_API_KEY'],
+        envVariables: ['OPENAI_API_KEY', 'OPENAI_BASE_URL'],
         trustLevel: 'CLOSED',
         order: MODEL_ORDERS.TOP_TIER,
         getBoilerplateConfiguration() {
@@ -5122,11 +5123,35 @@
                 className: 'OpenAiCompatibleExecutionTools',
                 options: {
                     apiKey: 'sk-',
+                    baseURL: 'https://api.openai.com/v1',
+                    isProxied: false,
+                    remoteServerUrl: DEFAULT_REMOTE_SERVER_URL,
                     maxRequestsPerMinute: DEFAULT_MAX_REQUESTS_PER_MINUTE,
                 },
             };
         },
         createConfigurationFromEnv(env) {
+            // Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be instantiated directly
+            // However, we can provide configuration for users who want to manually instantiate it
+            if (typeof env.OPENAI_API_KEY === 'string') {
+                const options = {
+                    apiKey: env.OPENAI_API_KEY,
+                    isProxied: false,
+                    remoteServerUrl: DEFAULT_REMOTE_SERVER_URL,
+                    maxRequestsPerMinute: DEFAULT_MAX_REQUESTS_PER_MINUTE,
+                    defaultModelName: 'gpt-4-turbo',
+                };
+                // Add baseURL if provided in environment
+                if (typeof env.OPENAI_BASE_URL === 'string') {
+                    options.baseURL = env.OPENAI_BASE_URL;
+                }
+                return {
+                    title: 'Open AI Compatible (from env)',
+                    packageName: '@promptbook/openai',
+                    className: 'OpenAiCompatibleExecutionTools',
+                    options,
+                };
+            }
             return null;
         },
     });
@@ -5179,7 +5204,7 @@
          * Default model for chat variant.
          */
         getDefaultChatModel() {
-            return this.getDefaultModel('gpt-4o');
+            return this.getDefaultModel('gpt-4-turbo');
         }
         /**
          * Default model for completion variant.
@@ -5209,6 +5234,9 @@
          * @param options which are relevant are directly passed to the OpenAI client
          */
         constructor(options) {
+            if (options.isProxied) {
+                throw new NotYetImplementedError(`Proxy mode is not yet implemented for OpenAI assistants`);
+            }
             super(options);
             this.assistantId = options.assistantId;
             // TODO: [👱] Make limiter same as in `OpenAiExecutionTools`
@@ -5390,14 +5418,97 @@
      * @public exported from `@promptbook/openai`
      */
     const createOpenAiCompatibleExecutionTools = Object.assign((options) => {
+        if (options.isProxied) {
+            return new RemoteLlmExecutionTools({
+                ...options,
+                identification: {
+                    isAnonymous: true,
+                    llmToolsConfiguration: [
+                        {
+                            title: 'OpenAI Compatible (proxied)',
+                            packageName: '@promptbook/openai',
+                            className: 'OpenAiCompatibleExecutionTools',
+                            options: {
+                                ...options,
+                                isProxied: false,
+                            },
+                        },
+                    ],
+                },
+            });
+        }
         if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
             options = { ...options, dangerouslyAllowBrowser: true };
         }
-        return new OpenAiExecutionTools(options);
+        return new HardcodedOpenAiCompatibleExecutionTools(options.defaultModelName, options);
     }, {
         packageName: '@promptbook/openai',
         className: 'OpenAiCompatibleExecutionTools',
     });
+    /**
+     * Execution Tools for calling ONE SPECIFIC PRECONFIGURED OpenAI compatible provider
+     *
+     * @private for `createOpenAiCompatibleExecutionTools`
+     */
+    class HardcodedOpenAiCompatibleExecutionTools extends OpenAiCompatibleExecutionTools {
+        /**
+         * Creates OpenAI compatible Execution Tools.
+         *
+         * @param options which are relevant are directly passed to the OpenAI compatible client
+         */
+        constructor(defaultModelName, options) {
+            super(options);
+            this.defaultModelName = defaultModelName;
+            this.options = options;
+        }
+        get title() {
+            return `${this.defaultModelName} on ${this.options.baseURL}`;
+        }
+        get description() {
+            return `OpenAI compatible connected to "${this.options.baseURL}" model "${this.defaultModelName}"`;
+        }
+        /**
+         * List all available models (non dynamically)
+         *
+         * Note: Purpose of this is to provide more information about models than standard listing from API
+         */
+        get HARDCODED_MODELS() {
+            return [
+                {
+                    modelName: this.defaultModelName,
+                    modelVariant: 'CHAT',
+                    modelDescription: '', // <- TODO: What is the best value here, maybe `this.description`?
+                },
+            ];
+        }
+        /**
+         * Computes the usage
+         */
+        computeUsage(...args) {
+            return {
+                ...computeOpenAiUsage(...args),
+                price: UNCERTAIN_ZERO_VALUE, // <- TODO: Maybe in future pass this counting mechanism, but for now, we dont know
+            };
+        }
+        /**
+         * Default model for chat variant.
+         */
+        getDefaultChatModel() {
+            return this.getDefaultModel(this.defaultModelName);
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultCompletionModel() {
+            throw new PipelineExecutionError(`${this.title} does not support COMPLETION model variant`);
+        }
+        /**
+         * Default model for completion variant.
+         */
+        getDefaultEmbeddingModel() {
+            throw new PipelineExecutionError(`${this.title} does not support EMBEDDING model variant`);
+        }
+    }
     /**
      * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
@@ -5414,6 +5525,9 @@
         if (($isRunningInBrowser() || $isRunningInWebWorker()) && !options.dangerouslyAllowBrowser) {
             options = { ...options, dangerouslyAllowBrowser: true };
         }
+        if (options.isProxied) {
+            throw new NotYetImplementedError(`Proxy mode is not yet implemented in createOpenAiExecutionTools`);
+        }
         return new OpenAiExecutionTools(options);
     }, {
         packageName: '@promptbook/openai',
@@ -6793,7 +6907,7 @@
             throw new Error(spaceTrim__default["default"]((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
         }
@@ -8702,6 +8816,68 @@
      * Note: [💝] and [🤠] are interconnected together
      */
 
+    /**
+     * Validates a prompt result against expectations and format requirements.
+     * This function provides a common abstraction for result validation that can be used
+     * by both execution logic and caching logic to ensure consistency.
+     *
+     * @param options - The validation options including result string, expectations, and format
+     * @returns Validation result with processed string and validity status
+     * @private internal function of `createPipelineExecutor` and `cacheLlmTools`
+     */
+    function validatePromptResult(options) {
+        const { resultString, expectations, format } = options;
+        let processedResultString = resultString;
+        let validationError;
+        try {
+            // TODO: [💝] Unite object for expecting amount and format
+            if (format) {
+                if (format === 'JSON') {
+                    if (!isValidJsonString(processedResultString)) {
+                        // TODO: [🏢] Do more universally via `FormatParser`
+                        try {
+                            processedResultString = extractJsonBlock(processedResultString);
+                        }
+                        catch (error) {
+                            keepUnused(error);
+                            throw new ExpectError(spaceTrim.spaceTrim((block) => `
+                                    Expected valid JSON string
+
+                                    The expected JSON text:
+                                    ${block(processedResultString)}
+                                `));
+                        }
+                    }
+                }
+                else {
+                    throw new UnexpectedError(`Unknown format "${format}"`);
+                }
+            }
+            // TODO: [💝] Unite object for expecting amount and format
+            if (expectations) {
+                checkExpectations(expectations, processedResultString);
+            }
+            return {
+                isValid: true,
+                processedResultString,
+            };
+        }
+        catch (error) {
+            if (error instanceof ExpectError) {
+                validationError = error;
+            }
+            else {
+                // Re-throw non-ExpectError errors (like UnexpectedError)
+                throw error;
+            }
+            return {
+                isValid: false,
+                processedResultString,
+                error: validationError,
+            };
+        }
+    }
+
     /**
      * Executes a pipeline task with multiple attempts, including joker and retry logic. Handles different task types
      * (prompt, script, dialog, etc.), applies postprocessing, checks expectations, and updates the execution report.
@@ -8724,13 +8900,13 @@
         // TODO: [🚐] Make arrayable LLMs -> single LLM DRY
         const _llms = arrayableToArray(tools.llm);
         const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
-        attempts: for (let attempt = -jokerParameterNames.length; attempt < maxAttempts; attempt++) {
-            const isJokerAttempt = attempt < 0;
-            const jokerParameterName = jokerParameterNames[jokerParameterNames.length + attempt];
+        attempts: for (let attemptIndex = -jokerParameterNames.length; attemptIndex < maxAttempts; attemptIndex++) {
+            const isJokerAttempt = attemptIndex < 0;
+            const jokerParameterName = jokerParameterNames[jokerParameterNames.length + attemptIndex];
             // TODO: [🧠][🍭] JOKERS, EXPECTATIONS, POSTPROCESSING and FOREACH
             if (isJokerAttempt && !jokerParameterName) {
                 throw new UnexpectedError(spaceTrim.spaceTrim((block) => `
-                        Joker not found in attempt ${attempt}
+                        Joker not found in attempt ${attemptIndex}
 
                         ${block(pipelineIdentification)}
                     `));
@@ -8928,35 +9104,18 @@
                     }
                 }
                 // TODO: [💝] Unite object for expecting amount and format
-                if (task.format) {
-                    if (task.format === 'JSON') {
-                        if (!isValidJsonString($ongoingTaskResult.$resultString || '')) {
-                            // TODO: [🏢] Do more universally via `FormatParser`
-                            try {
-                                $ongoingTaskResult.$resultString = extractJsonBlock($ongoingTaskResult.$resultString || '');
-                            }
-                            catch (error) {
-                                keepUnused(error);
-                                throw new ExpectError(spaceTrim.spaceTrim((block) => `
-                                        Expected valid JSON string
-
-                                        ${block(
-                            /*<- Note: No need for `pipelineIdentification`, it will be catched and added later */ '')}
-                                    `));
-                            }
-                        }
-                    }
-                    else {
-                        throw new UnexpectedError(spaceTrim.spaceTrim((block) => `
-                                Unknown format "${task.format}"
-
-                                ${block(pipelineIdentification)}
-                            `));
+                // Use the common validation function for both format and expectations
+                if (task.format || task.expectations) {
+                    const validationResult = validatePromptResult({
+                        resultString: $ongoingTaskResult.$resultString || '',
+                        expectations: task.expectations,
+                        format: task.format,
+                    });
+                    if (!validationResult.isValid) {
+                        throw validationResult.error;
                     }
-                }
-                // TODO: [💝] Unite object for expecting amount and format
-                if (task.expectations) {
-                    checkExpectations(task.expectations, $ongoingTaskResult.$resultString || '');
+                    // Update the result string in case format processing modified it (e.g., JSON extraction)
+                    $ongoingTaskResult.$resultString = validationResult.processedResultString;
                 }
                 break attempts;
             }
@@ -8970,6 +9129,7 @@
                     $ongoingTaskResult.$failedResults = [];
                 }
                 $ongoingTaskResult.$failedResults.push({
+                    attemptIndex,
                     result: $ongoingTaskResult.$resultString,
                     error: error,
                 });
@@ -8994,19 +9154,13 @@
                     });
                 }
             }
-            if ($ongoingTaskResult.$expectError !== null && attempt === maxAttempts - 1) {
-                // Store the current failure before throwing
-                $ongoingTaskResult.$failedResults = $ongoingTaskResult.$failedResults || [];
-                $ongoingTaskResult.$failedResults.push({
-                    result: $ongoingTaskResult.$resultString,
-                    error: $ongoingTaskResult.$expectError,
-                });
-                // Create a summary of all failures
+            if ($ongoingTaskResult.$expectError !== null && attemptIndex === maxAttempts - 1) {
+                // Note: Create a summary of all failures
                 const failuresSummary = $ongoingTaskResult.$failedResults
-                    .map((failure, index) => spaceTrim.spaceTrim((block) => {
+                    .map((failure) => spaceTrim.spaceTrim((block) => {
                     var _a, _b;
                     return `
-                            Attempt ${index + 1}:
+                            Attempt ${failure.attemptIndex + 1}:
                             Error ${((_a = failure.error) === null || _a === void 0 ? void 0 : _a.name) || ''}:
                             ${block((_b = failure.error) === null || _b === void 0 ? void 0 : _b.message.split('\n').map((line) => `> ${line}`).join('\n'))}
 
@@ -11813,6 +11967,7 @@
             },
         };
         const callCommonModel = async (prompt) => {
+            var _a;
             const { parameters, content, modelRequirements } = prompt;
             // <- Note: These are relevant things from the prompt that the cache key should depend on.
             // TODO: Maybe some standalone function for normalization of content for cache
@@ -11868,11 +12023,42 @@
             // 1. It has a content property that is null or undefined
             // 2. It has an error property that is truthy
             // 3. It has a success property that is explicitly false
-            const isFailedResult = promptResult.content === null ||
+            // 4. It doesn't meet the prompt's expectations or format requirements
+            const isBasicFailedResult = promptResult.content === null ||
                 promptResult.content === undefined ||
                 promptResult.error ||
                 promptResult.success === false;
-            if (!isFailedResult) {
+            let shouldCache = !isBasicFailedResult;
+            // If the basic result is valid, check against expectations and format
+            if (shouldCache && promptResult.content) {
+                try {
+                    const validationResult = validatePromptResult({
+                        resultString: promptResult.content,
+                        expectations: prompt.expectations,
+                        format: prompt.format,
+                    });
+                    shouldCache = validationResult.isValid;
+                    if (!shouldCache && isVerbose) {
+                        console.info('Not caching result that fails expectations/format validation for key:', key, {
+                            content: promptResult.content,
+                            expectations: prompt.expectations,
+                            format: prompt.format,
+                            validationError: (_a = validationResult.error) === null || _a === void 0 ? void 0 : _a.message,
+                        });
+                    }
+                }
+                catch (error) {
+                    // If validation throws an unexpected error, don't cache
+                    shouldCache = false;
+                    if (isVerbose) {
+                        console.info('Not caching result due to validation error for key:', key, {
+                            content: promptResult.content,
+                            validationError: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+            if (shouldCache) {
                 await storage.setItem(key, {
                     date: $getCurrentDate(),
                     promptbookVersion: PROMPTBOOK_ENGINE_VERSION,
@@ -11889,7 +12075,7 @@
                     promptResult,
                 });
             }
-            else if (isVerbose) {
+            else if (isVerbose && isBasicFailedResult) {
                 console.info('Not caching failed result for key:', key, {
                     content: promptResult.content,
                     error: promptResult.error,