@promptbook/wizard 0.98.0-5 → 0.98.0-9

package/esm/index.es.js

@@ -38,7 +38,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.98.0-5';
+const PROMPTBOOK_ENGINE_VERSION = '0.98.0-9';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -232,7 +232,7 @@ const DEFAULT_MAX_PARALLEL_COUNT = 5; // <- TODO: [🤹‍♂️]
  *
  * @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
@@ -4345,7 +4345,7 @@ resultContent, rawResponse) {
  */
 
 /**
- * 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`
  */
@@ -4915,6 +4915,7 @@ class OllamaExecutionTools extends OpenAiCompatibleExecutionTools {
             baseURL: DEFAULT_OLLAMA_BASE_URL,
             ...ollamaOptions,
             apiKey: 'ollama',
+            isProxied: false, // <- Note: Ollama is always local
         };
         super(openAiCompatibleOptions);
     }
@@ -5101,7 +5102,7 @@ const _OpenAiCompatibleMetadataRegistration = $llmToolsMetadataRegister.register
     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() {
@@ -5111,6 +5112,9 @@ const _OpenAiCompatibleMetadataRegistration = $llmToolsMetadataRegister.register
             className: 'OpenAiCompatibleExecutionTools',
             options: {
                 apiKey: 'sk-',
+                baseURL: 'https://api.openai.com/v1',
+                isProxied: false,
+                remoteServerUrl: DEFAULT_REMOTE_SERVER_URL,
                 maxRequestsPerMinute: DEFAULT_MAX_REQUESTS_PER_MINUTE,
             },
         };
@@ -5168,7 +5172,7 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
      * Default model for chat variant.
      */
     getDefaultChatModel() {
-        return this.getDefaultModel('gpt-4o');
+        return this.getDefaultModel('gpt-4-turbo');
     }
     /**
      * Default model for completion variant.
@@ -5198,6 +5202,9 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
      * @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`
@@ -5379,14 +5386,97 @@ const createOpenAiAssistantExecutionTools = Object.assign((options) => {
  * @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"
@@ -5403,6 +5493,9 @@ const createOpenAiExecutionTools = Object.assign((options) => {
     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',
@@ -6782,7 +6875,7 @@ function jsonParse(value) {
         throw new Error(spaceTrim((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
     }
@@ -8691,6 +8784,68 @@ function checkExpectations(expectations, value) {
  * 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$1((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.
@@ -8713,13 +8868,13 @@ async function executeAttempts(options) {
     // 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$1((block) => `
-                        Joker not found in attempt ${attempt}
+                        Joker not found in attempt ${attemptIndex}
 
                         ${block(pipelineIdentification)}
                     `));
@@ -8917,35 +9072,18 @@ async function executeAttempts(options) {
                 }
             }
             // 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$1((block) => `
-                                        Expected valid JSON string
-
-                                        ${block(
-                            /*<- Note: No need for `pipelineIdentification`, it will be catched and added later */ '')}
-                                    `));
-                        }
-                    }
-                }
-                else {
-                    throw new UnexpectedError(spaceTrim$1((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;
         }
@@ -8959,6 +9097,7 @@ async function executeAttempts(options) {
                 $ongoingTaskResult.$failedResults = [];
             }
             $ongoingTaskResult.$failedResults.push({
+                attemptIndex,
                 result: $ongoingTaskResult.$resultString,
                 error: error,
             });
@@ -8983,19 +9122,13 @@ async function executeAttempts(options) {
                 });
             }
         }
-        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$1((block) => {
+                .map((failure) => spaceTrim$1((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'))}
 
@@ -11802,6 +11935,7 @@ function cacheLlmTools(llmTools, options = {}) {
         },
     };
     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
@@ -11857,11 +11991,42 @@ function cacheLlmTools(llmTools, options = {}) {
         // 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,
@@ -11878,7 +12043,7 @@ function cacheLlmTools(llmTools, options = {}) {
                 promptResult,
             });
         }
-        else if (isVerbose) {
+        else if (isVerbose && isBasicFailedResult) {
             console.info('Not caching failed result for key:', key, {
                 content: promptResult.content,
                 error: promptResult.error,
@@ -11965,6 +12130,7 @@ function createLlmToolsFromConfiguration(configuration, options = {}) {
             .list()
             .find(({ packageName, className }) => llmConfiguration.packageName === packageName && llmConfiguration.className === className);
         if (registeredItem === undefined) {
+            console.log('!!! $llmToolsRegister.list()', $llmToolsRegister.list());
             throw new Error(spaceTrim((block) => `
                         There is no constructor for LLM provider \`${llmConfiguration.className}\` from \`${llmConfiguration.packageName}\`