@promptbook/wizard 0.95.0 → 0.98.0-10

package/README.md

@@ -25,6 +25,10 @@ Write AI applications using plain human language across multiple models and plat
 
 
 
+<blockquote style="color: #ff8811">
+    <b>⚠ Warning:</b> This is a pre-release version of the library. It is not yet ready for production use. Please look at <a href="https://www.npmjs.com/package/@promptbook/core?activeTab=versions">latest stable release</a>.
+</blockquote>
+
 ## 📦 Package `@promptbook/wizard`
 
 - Promptbooks are [divided into several](#-packages) packages, all are published from [single monorepo](https://github.com/webgptorg/promptbook).
@@ -70,6 +74,8 @@ Rest of the documentation is common for **entire promptbook ecosystem**:
 
 During the computer revolution, we have seen [multiple generations of computer languages](https://github.com/webgptorg/promptbook/discussions/180), from the physical rewiring of the vacuum tubes through low-level machine code to the high-level languages like Python or JavaScript. And now, we're on the edge of the **next revolution**!
 
+
+
 It's a revolution of writing software in **plain human language** that is understandable and executable by both humans and machines – and it's going to change everything!
 
 The incredible growth in power of microprocessors and the Moore's Law have been the driving force behind the ever-more powerful languages, and it's been an amazing journey! Similarly, the large language models (like GPT or Claude) are the next big thing in language technology, and they're set to transform the way we interact with computers.
@@ -195,6 +201,8 @@ Join our growing community of developers and users:
 
 _A concise, Markdown-based DSL for crafting AI workflows and automations._
 
+
+
 ### Introduction
 
 Book is a Markdown-based language that simplifies the creation of AI applications, workflows, and automations. With human-readable commands, you can define inputs, outputs, personas, knowledge sources, and actions—without needing model-specific details.
@@ -244,6 +252,8 @@ Personas can have access to different knowledge, tools and actions. They can als
 
 -   [PERSONA](https://github.com/webgptorg/promptbook/blob/main/documents/commands/PERSONA.md)
 
+
+
 ### **3. How:** Knowledge, Instruments and Actions
 
 The resources used by the personas are used to do the work.
@@ -343,6 +353,8 @@ The following glossary is used to clarify certain concepts:
 
 _Note: This section is not a complete dictionary, more list of general AI / LLM terms that has connection with Promptbook_
 
+
+
 ### 💯 Core concepts
 
 -   [📚 Collection of pipelines](https://github.com/webgptorg/promptbook/discussions/65)

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.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
@@ -232,7 +232,7 @@ const DEFAULT_MAX_PARALLEL_COUNT = 5; // <- TODO: [🤹‍♂️]
  *
  * @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
@@ -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);
     }
@@ -5087,6 +5088,42 @@ const _OpenAiAssistantMetadataRegistration = $llmToolsMetadataRegister.register(
         */
     },
 });
+/**
+ * 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
  */
@@ -5136,7 +5173,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.
@@ -5166,6 +5203,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`
@@ -5339,6 +5379,110 @@ const createOpenAiAssistantExecutionTools = Object.assign((options) => {
  * 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
  *
@@ -5350,6 +5494,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',
@@ -5360,6 +5507,7 @@ const createOpenAiExecutionTools = Object.assign((options) => {
  * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
  */
 
+// Note: OpenAiCompatibleExecutionTools is an abstract class and cannot be instantiated directly
 /**
  * Registration of LLM provider
  *
@@ -5380,6 +5528,20 @@ const _OpenAiRegistration = $llmToolsRegister.register(createOpenAiExecutionTool
  * @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
@@ -6714,7 +6876,7 @@ function jsonParse(value) {
         throw new Error(spaceTrim((block) => `
                     ${block(error.message)}
 
-                    The JSON text:
+                    The expected JSON text:
                     ${block(value)}
                 `));
     }
@@ -8623,6 +8785,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.
@@ -8640,17 +8864,18 @@ async function executeAttempts(options) {
         $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$1((block) => `
-                        Joker not found in attempt ${attempt}
+                        Joker not found in attempt ${attemptIndex}
 
                         ${block(pipelineIdentification)}
                     `));
@@ -8848,35 +9073,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;
         }
@@ -8885,6 +9093,15 @@ async function executeAttempts(options) {
                 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 &&
@@ -8906,35 +9123,41 @@ async function executeAttempts(options) {
                 });
             }
         }
-        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$1((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$1(failure.result)
+                        .split('\n')
+                        .map((line) => `> ${line}`)
+                        .join('\n'))}
+                        `;
+            }))
+                .join('\n\n---\n\n');
             throw new PipelineExecutionError(spaceTrim$1((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$1($ongoingTaskResult.$resultString)
-                        .split('\n')
-                        .map((line) => `> ${line}`)
-                        .join('\n'))}
-                        ---
+                        All Failed Attempts:
+                        ${block(failuresSummary)}
                     `;
             }));
         }
@@ -11713,6 +11936,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
@@ -11763,21 +11987,70 @@ function cacheLlmTools(llmTools, options = {}) {
         }
         // 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) {
@@ -11858,8 +12131,10 @@ 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}\`
+                        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:
@@ -16645,5 +16920,5 @@ const wizard = new Wizard();
  * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */
 
-export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION, _AnthropicClaudeMetadataRegistration, _AnthropicClaudeRegistration, _AzureOpenAiMetadataRegistration, _AzureOpenAiRegistration, _BoilerplateScraperMetadataRegistration, _BoilerplateScraperRegistration, _DeepseekMetadataRegistration, _DeepseekRegistration, _DocumentScraperMetadataRegistration, _DocumentScraperRegistration, _GoogleMetadataRegistration, _GoogleRegistration, _LegacyDocumentScraperMetadataRegistration, _LegacyDocumentScraperRegistration, _MarkdownScraperMetadataRegistration, _MarkdownScraperRegistration, _MarkitdownScraperMetadataRegistration, _MarkitdownScraperRegistration, _OllamaMetadataRegistration, _OllamaRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiAssistantRegistration, _OpenAiMetadataRegistration, _OpenAiRegistration, _PdfScraperMetadataRegistration, _PdfScraperRegistration, _WebsiteScraperMetadataRegistration, _WebsiteScraperRegistration, wizard };
+export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION, _AnthropicClaudeMetadataRegistration, _AnthropicClaudeRegistration, _AzureOpenAiMetadataRegistration, _AzureOpenAiRegistration, _BoilerplateScraperMetadataRegistration, _BoilerplateScraperRegistration, _DeepseekMetadataRegistration, _DeepseekRegistration, _DocumentScraperMetadataRegistration, _DocumentScraperRegistration, _GoogleMetadataRegistration, _GoogleRegistration, _LegacyDocumentScraperMetadataRegistration, _LegacyDocumentScraperRegistration, _MarkdownScraperMetadataRegistration, _MarkdownScraperRegistration, _MarkitdownScraperMetadataRegistration, _MarkitdownScraperRegistration, _OllamaMetadataRegistration, _OllamaRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiAssistantRegistration, _OpenAiCompatibleMetadataRegistration, _OpenAiCompatibleRegistration, _OpenAiMetadataRegistration, _OpenAiRegistration, _PdfScraperMetadataRegistration, _PdfScraperRegistration, _WebsiteScraperMetadataRegistration, _WebsiteScraperRegistration, wizard };
 //# sourceMappingURL=index.es.js.map