@promptbook/wizard 0.95.0 → 0.98.0-10

package/umd/index.umd.js

@@ -49,7 +49,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.95.0';
+    const PROMPTBOOK_ENGINE_VERSION = '0.98.0-10';
     /**
      * 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 = 10; // <- 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);
         }
@@ -5098,6 +5099,42 @@
             */
         },
     });
+    /**
+     * Registration of the OpenAI Compatible metadata
+     *
+     * Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be instantiated directly.
+     * It serves as a base class for OpenAiExecutionTools and other compatible implementations.
+     *
+     * @public exported from `@promptbook/core`
+     * @public exported from `@promptbook/wizard`
+     * @public exported from `@promptbook/cli`
+     */
+    const _OpenAiCompatibleMetadataRegistration = $llmToolsMetadataRegister.register({
+        title: 'Open AI Compatible',
+        packageName: '@promptbook/openai',
+        className: 'OpenAiCompatibleExecutionTools',
+        envVariables: ['OPENAI_API_KEY', 'OPENAI_BASE_URL'],
+        trustLevel: 'CLOSED',
+        order: MODEL_ORDERS.TOP_TIER,
+        getBoilerplateConfiguration() {
+            return {
+                title: 'Open AI Compatible',
+                packageName: '@promptbook/openai',
+                className: 'OpenAiCompatibleExecutionTools',
+                options: {
+                    apiKey: 'sk-',
+                    baseURL: 'https://api.openai.com/v1',
+                    defaultModelName: 'gpt-4-turbo',
+                    isProxied: false,
+                    remoteServerUrl: DEFAULT_REMOTE_SERVER_URL,
+                    maxRequestsPerMinute: DEFAULT_MAX_REQUESTS_PER_MINUTE,
+                },
+            };
+        },
+        createConfigurationFromEnv(env) {
+            return null;
+        },
+    });
     /**
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
@@ -5147,7 +5184,7 @@
          * Default model for chat variant.
          */
         getDefaultChatModel() {
-            return this.getDefaultModel('gpt-4o');
+            return this.getDefaultModel('gpt-4-turbo');
         }
         /**
          * Default model for completion variant.
@@ -5177,6 +5214,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`
@@ -5350,6 +5390,110 @@
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      */
 
+    /**
+     * Execution Tools for calling OpenAI compatible API
+     *
+     * Note: This can be used for any OpenAI compatible APIs
+     *
+     * @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 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"
+     */
+
     /**
      * Execution Tools for calling OpenAI API
      *
@@ -5361,6 +5505,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',
@@ -5371,6 +5518,7 @@
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      */
 
+    // Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be instantiated directly
     /**
      * Registration of LLM provider
      *
@@ -5391,6 +5539,20 @@
      * @public exported from `@promptbook/cli`
      */
     const _OpenAiAssistantRegistration = $llmToolsRegister.register(createOpenAiAssistantExecutionTools);
+    /**
+     * Registration of the OpenAI Compatible provider
+     *
+     * Note: [🏐] Configurations registrations are done in register-constructor.ts BUT constructor register-constructor.ts
+     *
+     * @public exported from `@promptbook/openai`
+     * @public exported from `@promptbook/wizard`
+     * @public exported from `@promptbook/cli`
+     */
+    const _OpenAiCompatibleRegistration = $llmToolsRegister.register(createOpenAiCompatibleExecutionTools);
+    /**
+     * Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be registered directly.
+     * It serves as a base class for OpenAiExecutionTools and other compatible implementations.
+     */
     /**
      * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -6725,7 +6887,7 @@
             throw new Error(spaceTrim__default["default"]((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
         }
@@ -8634,6 +8796,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.
@@ -8651,17 +8875,18 @@
             $resultString: null,
             $expectError: null,
             $scriptPipelineExecutionErrors: [],
+            $failedResults: [], // Track all failed attempts
         };
         // 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)}
                     `));
@@ -8859,35 +9084,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;
             }
@@ -8896,6 +9104,15 @@
                     throw error;
                 }
                 $ongoingTaskResult.$expectError = error;
+                // Store each failed attempt
+                if (!Array.isArray($ongoingTaskResult.$failedResults)) {
+                    $ongoingTaskResult.$failedResults = [];
+                }
+                $ongoingTaskResult.$failedResults.push({
+                    attemptIndex,
+                    result: $ongoingTaskResult.$resultString,
+                    error: error,
+                });
             }
             finally {
                 if (!isJokerAttempt &&
@@ -8917,35 +9134,41 @@
                     });
                 }
             }
-            if ($ongoingTaskResult.$expectError !== null && attempt === maxAttempts - 1) {
+            if ($ongoingTaskResult.$expectError !== null && attemptIndex === maxAttempts - 1) {
+                // Note: Create a summary of all failures
+                const failuresSummary = $ongoingTaskResult.$failedResults
+                    .map((failure) => spaceTrim.spaceTrim((block) => {
+                    var _a, _b;
+                    return `
+                            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'))}
+
+                            Result:
+                            ${block(failure.result === null
+                    ? 'null'
+                    : spaceTrim.spaceTrim(failure.result)
+                        .split('\n')
+                        .map((line) => `> ${line}`)
+                        .join('\n'))}
+                        `;
+                }))
+                    .join('\n\n---\n\n');
                 throw new PipelineExecutionError(spaceTrim.spaceTrim((block) => {
-                    var _a, _b, _c;
+                    var _a;
                     return `
                         LLM execution failed ${maxExecutionAttempts}x
 
                         ${block(pipelineIdentification)}
 
-                        ---
                         The Prompt:
                         ${block((((_a = $ongoingTaskResult.$prompt) === null || _a === void 0 ? void 0 : _a.content) || '')
                     .split('\n')
                     .map((line) => `> ${line}`)
                     .join('\n'))}
 
-                        Last error ${((_b = $ongoingTaskResult.$expectError) === null || _b === void 0 ? void 0 : _b.name) || ''}:
-                        ${block((((_c = $ongoingTaskResult.$expectError) === null || _c === void 0 ? void 0 : _c.message) || '')
-                    .split('\n')
-                    .map((line) => `> ${line}`)
-                    .join('\n'))}
-
-                        Last result:
-                        ${block($ongoingTaskResult.$resultString === null
-                    ? 'null'
-                    : spaceTrim.spaceTrim($ongoingTaskResult.$resultString)
-                        .split('\n')
-                        .map((line) => `> ${line}`)
-                        .join('\n'))}
-                        ---
+                        All Failed Attempts:
+                        ${block(failuresSummary)}
                     `;
                 }));
             }
@@ -11724,6 +11947,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
@@ -11774,21 +11998,70 @@
             }
             // TODO: [🧠] !!5 How to do timing in mixed cache / non-cache situation
             // promptResult.timing: FromtoItems
-            await storage.setItem(key, {
-                date: $getCurrentDate(),
-                promptbookVersion: PROMPTBOOK_ENGINE_VERSION,
-                bookVersion: BOOK_LANGUAGE_VERSION,
-                prompt: {
-                    ...prompt,
-                    parameters: Object.entries(parameters).length === Object.entries(relevantParameters).length
-                        ? parameters
-                        : {
-                            ...relevantParameters,
-                            note: `<- Note: Only relevant parameters are stored in the cache`,
-                        },
-                },
-                promptResult,
-            });
+            // Check if the result is valid and should be cached
+            // A result is considered failed if:
+            // 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
+            // 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;
+            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,
+                    bookVersion: BOOK_LANGUAGE_VERSION,
+                    prompt: {
+                        ...prompt,
+                        parameters: Object.entries(parameters).length === Object.entries(relevantParameters).length
+                            ? parameters
+                            : {
+                                ...relevantParameters,
+                                note: `<- Note: Only relevant parameters are stored in the cache`,
+                            },
+                    },
+                    promptResult,
+                });
+            }
+            else if (isVerbose && isBasicFailedResult) {
+                console.info('Not caching failed result for key:', key, {
+                    content: promptResult.content,
+                    error: promptResult.error,
+                    success: promptResult.success,
+                });
+            }
             return promptResult;
         };
         if (llmTools.callChatModel !== undefined) {
@@ -11869,8 +12142,10 @@
                 .list()
                 .find(({ packageName, className }) => llmConfiguration.packageName === packageName && llmConfiguration.className === className);
             if (registeredItem === undefined) {
+                console.log('!!! $llmToolsRegister.list()', $llmToolsRegister.list());
                 throw new Error(spaceTrim__default["default"]((block) => `
                         There is no constructor for LLM provider \`${llmConfiguration.className}\` from \`${llmConfiguration.packageName}\`
+                        Running in ${!$isRunningInBrowser() ? '' : 'browser environment'}${!$isRunningInNode() ? '' : 'node environment'}${!$isRunningInWebWorker() ? '' : 'worker environment'}
 
                         You have probably forgotten install and import the provider package.
                         To fix this issue, you can:
@@ -16680,6 +16955,8 @@
     exports._OllamaRegistration = _OllamaRegistration;
     exports._OpenAiAssistantMetadataRegistration = _OpenAiAssistantMetadataRegistration;
     exports._OpenAiAssistantRegistration = _OpenAiAssistantRegistration;
+    exports._OpenAiCompatibleMetadataRegistration = _OpenAiCompatibleMetadataRegistration;
+    exports._OpenAiCompatibleRegistration = _OpenAiCompatibleRegistration;
     exports._OpenAiMetadataRegistration = _OpenAiMetadataRegistration;
     exports._OpenAiRegistration = _OpenAiRegistration;
     exports._PdfScraperMetadataRegistration = _PdfScraperMetadataRegistration;