@promptbook/components 0.100.0-24

package/umd/index.umd.js

@@ -0,0 +1,1965 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react/jsx-runtime'), require('react'), require('spacetrim')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'react/jsx-runtime', 'react', 'spacetrim'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-components"] = {}, global.jsxRuntime, global.react, global.spaceTrim));
+})(this, (function (exports, jsxRuntime, react, spaceTrim) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim);
+
+    // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
+    /**
+     * The version of the Book language
+     *
+     * @generated
+     * @see https://github.com/webgptorg/book
+     */
+    const BOOK_LANGUAGE_VERSION = '1.0.0';
+    /**
+     * The version of the Promptbook engine
+     *
+     * @generated
+     * @see https://github.com/webgptorg/promptbook
+     */
+    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-24';
+    /**
+     * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Type guard to check if a string is a valid agent source
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function isValidBook(value) {
+        // Basic validation - agent source should have at least a name (first line)
+        return typeof value === 'string' /* && value.trim().length > 0 */;
+    }
+    /**
+     * Validates and converts a string to agent source branded type
+     * This function should be used when you have a string that you know represents agent source
+     * but need to convert it to the branded type for type safety
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function validateBook(source) {
+        if (!isValidBook(source)) {
+            throw new Error('Invalid agent source: must be a string');
+        }
+        return source;
+    }
+    /**
+     * Default book
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const DEFAULT_BOOK = validateBook(spaceTrim__default["default"](`
+        AI Avatar
+
+        PERSONA A friendly AI assistant that helps you with your tasks
+    `));
+
+    /**
+     * Freezes the given object and all its nested objects recursively
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it mutates given object
+     * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
+     *
+     * @returns The same object as the input, but deeply frozen
+     * @public exported from `@promptbook/utils`
+     */
+    function $deepFreeze(objectValue) {
+        if (Array.isArray(objectValue)) {
+            return Object.freeze(objectValue.map((item) => $deepFreeze(item)));
+        }
+        const propertyNames = Object.getOwnPropertyNames(objectValue);
+        for (const propertyName of propertyNames) {
+            const value = objectValue[propertyName];
+            if (value && typeof value === 'object') {
+                $deepFreeze(value);
+            }
+        }
+        Object.freeze(objectValue);
+        return objectValue;
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Generates a regex pattern to match a specific commitment
+     *
+     * Note: It always creates new Regex object
+     * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
+     *
+     * @private
+     */
+    function createCommitmentRegex(commitment) {
+        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const keywordPattern = escapedCommitment.split(/\s+/).join('\\s+');
+        const regex = new RegExp(`^\\s*(?<type>${keywordPattern})\\b\\s+(?<contents>.+)$`, 'gim');
+        return regex;
+    }
+    /**
+     * Generates a regex pattern to match a specific commitment type
+     *
+     * Note: It just matches the type part of the commitment
+     * Note: It always creates new Regex object
+     * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
+     *
+     * @private
+     */
+    function createCommitmentTypeRegex(commitment) {
+        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const keywordPattern = escapedCommitment.split(/\s+/).join('\\s+');
+        const regex = new RegExp(`^\\s*(?<type>${keywordPattern})\\b`, 'gim');
+        return regex;
+    }
+
+    /**
+     * Base implementation of CommitmentDefinition that provides common functionality
+     * Most commitments can extend this class and only override the applyToAgentModelRequirements method
+     *
+     * @private
+     */
+    class BaseCommitmentDefinition {
+        constructor(type) {
+            this.type = type;
+        }
+        /**
+         * Creates a regex pattern to match this commitment in agent source
+         * Uses the existing createCommitmentRegex function as internal helper
+         */
+        createRegex() {
+            return createCommitmentRegex(this.type);
+        }
+        /**
+         * Creates a regex pattern to match just the commitment type
+         * Uses the existing createCommitmentTypeRegex function as internal helper
+         */
+        createTypeRegex() {
+            return createCommitmentTypeRegex(this.type);
+        }
+        /**
+         * Helper method to create a new requirements object with updated system message
+         * This is commonly used by many commitments
+         */
+        updateSystemMessage(requirements, messageUpdate) {
+            const newMessage = typeof messageUpdate === 'string' ? messageUpdate : messageUpdate(requirements.systemMessage);
+            return {
+                ...requirements,
+                systemMessage: newMessage,
+            };
+        }
+        /**
+         * Helper method to append content to the system message
+         */
+        appendToSystemMessage(requirements, content, separator = '\n\n') {
+            return this.updateSystemMessage(requirements, (currentMessage) => {
+                if (!currentMessage.trim()) {
+                    return content;
+                }
+                return currentMessage + separator + content;
+            });
+        }
+        /**
+         * Helper method to add a comment section to the system message
+         * Comments are lines starting with # that will be removed from the final system message
+         * but can be useful for organizing and structuring the message during processing
+         */
+        addCommentSection(requirements, commentTitle, content, position = 'end') {
+            const commentSection = `# ${commentTitle.toUpperCase()}\n${content}`;
+            if (position === 'beginning') {
+                return this.updateSystemMessage(requirements, (currentMessage) => {
+                    if (!currentMessage.trim()) {
+                        return commentSection;
+                    }
+                    return commentSection + '\n\n' + currentMessage;
+                });
+            }
+            else {
+                return this.appendToSystemMessage(requirements, commentSection);
+            }
+        }
+    }
+
+    /**
+     * ACTION commitment definition
+     *
+     * The ACTION commitment defines specific actions or capabilities that the agent can perform.
+     * This helps define what the agent is capable of doing and how it should approach tasks.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * ACTION Can generate code snippets and explain programming concepts
+     * ACTION Able to analyze data and provide insights
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class ActionCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('ACTION');
+        }
+        /**
+         * Short one-line description of ACTION.
+         */
+        get description() {
+            return 'Define agent capabilities and actions it can perform.';
+        }
+        /**
+         * Markdown documentation for ACTION commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # ACTION
+
+            Defines specific actions or capabilities that the agent can perform.
+
+            ## Key behaviors
+
+            - Multiple \`ACTION\` commitments are applied sequentially.
+            - Each action adds to the agent's capability list.
+            - Actions help users understand what the agent can do.
+
+            ## Examples
+
+            \`\`\`book
+            Code Assistant
+
+            PERSONA You are a programming assistant
+            ACTION Can generate code snippets and explain programming concepts
+            ACTION Able to debug existing code and suggest improvements
+            ACTION Can create unit tests for functions
+            \`\`\`
+
+            \`\`\`book
+            Data Scientist
+
+            PERSONA You are a data analysis expert
+            ACTION Able to analyze data and provide insights
+            ACTION Can create visualizations and charts
+            ACTION Capable of statistical analysis and modeling
+            KNOWLEDGE Data analysis best practices and statistical methods
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Add action capability to the system message
+            const actionSection = `Capability: ${trimmedContent}`;
+            return this.appendToSystemMessage(requirements, actionSection, '\n\n');
+        }
+    }
+    /**
+     * Singleton instance of the ACTION commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new ActionCommitmentDefinition();
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * FORMAT commitment definition
+     *
+     * The FORMAT commitment defines the specific output structure and formatting
+     * that the agent should use in its responses. This includes data formats,
+     * response templates, and structural requirements.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * FORMAT Always respond in JSON format with 'status' and 'data' fields
+     * FORMAT Use markdown formatting for all code blocks
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class FormatCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('FORMAT');
+        }
+        /**
+         * Short one-line description of FORMAT.
+         */
+        get description() {
+            return 'Specify output structure or formatting requirements.';
+        }
+        /**
+         * Markdown documentation for FORMAT commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # FORMAT
+
+            Defines the specific output structure and formatting for responses (data formats, templates, structure).
+
+            ## Key behaviors
+
+            - Multiple \`FORMAT\` commitments are applied sequentially.
+            - If they are in conflict, the last one takes precedence.
+            - You can specify both data formats and presentation styles.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Bot
+
+            PERSONA You are a helpful customer support agent
+            FORMAT Always respond in JSON format with 'status' and 'data' fields
+            FORMAT Use markdown formatting for all code blocks
+            \`\`\`
+
+            \`\`\`book
+            Data Analyst
+
+            PERSONA You are a data analysis expert
+            FORMAT Present results in structured tables
+            FORMAT Include confidence scores for all predictions
+            STYLE Be concise and precise in explanations
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Add format instructions to the system message
+            const formatSection = `Output Format: ${trimmedContent}`;
+            return this.appendToSystemMessage(requirements, formatSection, '\n\n');
+        }
+    }
+    /**
+     * Singleton instance of the FORMAT commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new FormatCommitmentDefinition();
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Error thrown when a fetch request fails
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class PromptbookFetchError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'PromptbookFetchError';
+            Object.setPrototypeOf(this, PromptbookFetchError.prototype);
+        }
+    }
+
+    /**
+     * Name for the Promptbook
+     *
+     * TODO: [🗽] Unite branding and make single place for it
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const NAME = `Promptbook`;
+    /**
+     * Email of the responsible person
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const ADMIN_EMAIL = 'pavol@ptbk.io';
+    /**
+     * Name of the responsible person for the Promptbook on GitHub
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const ADMIN_GITHUB_NAME = 'hejny';
+    // <- TODO: [🧜‍♂️]
+    /**
+     * Default settings for parsing and generating CSV files in Promptbook.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    Object.freeze({
+        delimiter: ',',
+        quoteChar: '"',
+        newline: '\n',
+        skipEmptyLines: true,
+    });
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * TODO: [🧠][🧜‍♂️] Maybe join remoteServerUrl and path into single value
+     */
+
+    /**
+     * Make error report URL for the given error
+     *
+     * @private private within the repository
+     */
+    function getErrorReportUrl(error) {
+        const report = {
+            title: `🐜 Error report from ${NAME}`,
+            body: spaceTrim__default["default"]((block) => `
+
+
+            \`${error.name || 'Error'}\` has occurred in the [${NAME}], please look into it @${ADMIN_GITHUB_NAME}.
+
+            \`\`\`
+            ${block(error.message || '(no error message)')}
+            \`\`\`
+
+
+            ## More info:
+
+            - **Promptbook engine version:** ${PROMPTBOOK_ENGINE_VERSION}
+            - **Book language version:** ${BOOK_LANGUAGE_VERSION}
+            - **Time:** ${new Date().toISOString()}
+
+            <details>
+            <summary>Stack trace:</summary>
+
+            ## Stack trace:
+
+            \`\`\`stacktrace
+            ${block(error.stack || '(empty)')}
+            \`\`\`
+            </details>
+
+        `),
+        };
+        const reportUrl = new URL(`https://github.com/webgptorg/promptbook/issues/new`);
+        reportUrl.searchParams.set('labels', 'bug');
+        reportUrl.searchParams.set('assignees', ADMIN_GITHUB_NAME);
+        reportUrl.searchParams.set('title', report.title);
+        reportUrl.searchParams.set('body', report.body);
+        return reportUrl;
+    }
+
+    /**
+     * This error type indicates that the error should not happen and its last check before crashing with some other error
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class UnexpectedError extends Error {
+        constructor(message) {
+            super(spaceTrim.spaceTrim((block) => `
+                    ${block(message)}
+
+                    Note: This error should not happen.
+                    It's probably a bug in the pipeline collection
+
+                    Please report issue:
+                    ${block(getErrorReportUrl(new Error(message)).href)}
+
+                    Or contact us on ${ADMIN_EMAIL}
+
+                `));
+            this.name = 'UnexpectedError';
+            Object.setPrototypeOf(this, UnexpectedError.prototype);
+        }
+    }
+
+    /**
+     * This error type indicates that somewhere in the code non-Error object was thrown and it was wrapped into the `WrappedError`
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class WrappedError extends Error {
+        constructor(whatWasThrown) {
+            const tag = `[🤮]`;
+            console.error(tag, whatWasThrown);
+            super(spaceTrim.spaceTrim(`
+                Non-Error object was thrown
+
+                Note: Look for ${tag} in the console for more details
+                Please report issue on ${ADMIN_EMAIL}
+            `));
+            this.name = 'WrappedError';
+            Object.setPrototypeOf(this, WrappedError.prototype);
+        }
+    }
+
+    /**
+     * Helper used in catch blocks to assert that the error is an instance of `Error`
+     *
+     * @param whatWasThrown Any object that was thrown
+     * @returns Nothing if the error is an instance of `Error`
+     * @throws `WrappedError` or `UnexpectedError` if the error is not standard
+     *
+     * @private within the repository
+     */
+    function assertsError(whatWasThrown) {
+        // Case 1: Handle error which was rethrown as `WrappedError`
+        if (whatWasThrown instanceof WrappedError) {
+            const wrappedError = whatWasThrown;
+            throw wrappedError;
+        }
+        // Case 2: Handle unexpected errors
+        if (whatWasThrown instanceof UnexpectedError) {
+            const unexpectedError = whatWasThrown;
+            throw unexpectedError;
+        }
+        // Case 3: Handle standard errors - keep them up to consumer
+        if (whatWasThrown instanceof Error) {
+            return;
+        }
+        // Case 4: Handle non-standard errors - wrap them into `WrappedError` and throw
+        throw new WrappedError(whatWasThrown);
+    }
+
+    /**
+     * The built-in `fetch' function with a lightweight error handling wrapper as default fetch function used in Promptbook scrapers
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const promptbookFetch = async (urlOrRequest, init) => {
+        try {
+            return await fetch(urlOrRequest, init);
+        }
+        catch (error) {
+            assertsError(error);
+            let url;
+            if (typeof urlOrRequest === 'string') {
+                url = urlOrRequest;
+            }
+            else if (urlOrRequest instanceof Request) {
+                url = urlOrRequest.url;
+            }
+            throw new PromptbookFetchError(spaceTrim__default["default"]((block) => `
+                    Can not fetch "${url}"
+
+                    Fetch error:
+                    ${block(error.message)}
+
+                `));
+        }
+    };
+    /**
+     * TODO: [🧠] Maybe rename because it is not used only for scrapers but also in `$getCompiledBook`
+     */
+
+    /**
+     * Frontend RAG Service that uses backend APIs for processing
+     * This avoids Node.js dependencies in the frontend
+     *
+     * @private - TODO: [🧠] Maybe should be public?
+     */
+    class FrontendRAGService {
+        constructor(config) {
+            this.chunks = [];
+            this.sources = [];
+            this.isInitialized = false;
+            this.config = {
+                maxChunkSize: 1000,
+                chunkOverlap: 200,
+                maxRetrievedChunks: 5,
+                minRelevanceScore: 0.1,
+                ...config,
+            };
+        }
+        /**
+         * Initialize knowledge sources by processing them on the backend
+         */
+        async initializeKnowledgeSources(sources) {
+            if (sources.length === 0) {
+                this.isInitialized = true;
+                return;
+            }
+            try {
+                const response = await promptbookFetch('/api/knowledge/process-sources', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        sources,
+                        config: {
+                            maxChunkSize: this.config.maxChunkSize,
+                            chunkOverlap: this.config.chunkOverlap,
+                        },
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error(`Failed to process knowledge sources: ${response.status}`);
+                }
+                const result = (await response.json());
+                if (!result.success) {
+                    throw new Error(result.message || 'Failed to process knowledge sources');
+                }
+                this.chunks = result.chunks;
+                this.sources = sources;
+                this.isInitialized = true;
+                console.log(`Initialized RAG service with ${this.chunks.length} chunks from ${sources.length} sources`);
+            }
+            catch (error) {
+                console.error('Failed to initialize knowledge sources:', error);
+                // Don't throw - allow the system to continue without RAG
+                this.isInitialized = true;
+            }
+        }
+        /**
+         * Get relevant context for a user query
+         */
+        async getContextForQuery(query) {
+            if (!this.isInitialized) {
+                console.warn('RAG service not initialized');
+                return '';
+            }
+            if (this.chunks.length === 0) {
+                return '';
+            }
+            try {
+                const response = await promptbookFetch('/api/knowledge/retrieve-context', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        query,
+                        chunks: this.chunks,
+                        config: {
+                            maxRetrievedChunks: this.config.maxRetrievedChunks,
+                            minRelevanceScore: this.config.minRelevanceScore,
+                        },
+                    }),
+                });
+                if (!response.ok) {
+                    console.error(`Failed to retrieve context: ${response.status}`);
+                    return '';
+                }
+                const result = (await response.json());
+                if (!result.success) {
+                    console.error('Context retrieval failed:', result.message);
+                    return '';
+                }
+                return result.context;
+            }
+            catch (error) {
+                console.error('Error retrieving context:', error);
+                return '';
+            }
+        }
+        /**
+         * Get relevant chunks for a query (for debugging/inspection)
+         */
+        async getRelevantChunks(query) {
+            if (!this.isInitialized || this.chunks.length === 0) {
+                return [];
+            }
+            try {
+                const response = await promptbookFetch('/api/knowledge/retrieve-context', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        query,
+                        chunks: this.chunks,
+                        config: {
+                            maxRetrievedChunks: this.config.maxRetrievedChunks,
+                            minRelevanceScore: this.config.minRelevanceScore,
+                        },
+                    }),
+                });
+                if (!response.ok) {
+                    return [];
+                }
+                const result = (await response.json());
+                return result.success ? result.relevantChunks : [];
+            }
+            catch (error) {
+                console.error('Error retrieving relevant chunks:', error);
+                return [];
+            }
+        }
+        /**
+         * Get knowledge base statistics
+         */
+        getStats() {
+            return {
+                sources: this.sources.length,
+                chunks: this.chunks.length,
+                isInitialized: this.isInitialized,
+            };
+        }
+        /**
+         * Check if the service is ready to use
+         */
+        isReady() {
+            return this.isInitialized;
+        }
+        /**
+         * Clear all knowledge sources
+         */
+        clearKnowledgeBase() {
+            this.chunks = [];
+            this.sources = [];
+            this.isInitialized = false;
+        }
+        /**
+         * Add a single knowledge source (for incremental updates)
+         */
+        async addKnowledgeSource(url) {
+            if (this.sources.includes(url)) {
+                console.log(`Knowledge source already exists: ${url}`);
+                return;
+            }
+            try {
+                const response = await promptbookFetch('/api/knowledge/process-sources', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        sources: [url],
+                        config: {
+                            maxChunkSize: this.config.maxChunkSize,
+                            chunkOverlap: this.config.chunkOverlap,
+                        },
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error(`Failed to process knowledge source: ${response.status}`);
+                }
+                const result = (await response.json());
+                if (!result.success) {
+                    throw new Error(result.message || 'Failed to process knowledge source');
+                }
+                // Add new chunks to existing ones
+                this.chunks.push(...result.chunks);
+                this.sources.push(url);
+                console.log(`Added knowledge source: ${url} (${result.chunks.length} chunks)`);
+            }
+            catch (error) {
+                console.error(`Failed to add knowledge source ${url}:`, error);
+                throw error;
+            }
+        }
+    }
+
+    /**
+     * KNOWLEDGE commitment definition
+     *
+     * The KNOWLEDGE commitment adds specific knowledge, facts, or context to the agent
+     * using RAG (Retrieval-Augmented Generation) approach for external sources.
+     *
+     * Supports both direct text knowledge and external sources like PDFs.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * KNOWLEDGE The company was founded in 2020 and specializes in AI-powered solutions
+     * KNOWLEDGE https://example.com/company-handbook.pdf
+     * KNOWLEDGE https://example.com/product-documentation.pdf
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('KNOWLEDGE');
+            this.ragService = new FrontendRAGService();
+        }
+        /**
+         * Short one-line description of KNOWLEDGE.
+         */
+        get description() {
+            return 'Add domain **knowledge** via direct text or external sources (RAG).';
+        }
+        /**
+         * Markdown documentation for KNOWLEDGE commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # KNOWLEDGE
+
+            Adds specific knowledge, facts, or context to the agent using a RAG (Retrieval-Augmented Generation) approach for external sources.
+
+            ## Key behaviors
+
+            - Multiple \`KNOWLEDGE\` commitments are applied sequentially.
+            - Supports both direct text knowledge and external URLs.
+            - External sources (PDFs, websites) are processed via RAG for context retrieval.
+
+            ## Supported formats
+
+            - Direct text: Immediate knowledge incorporated into agent
+            - URLs: External documents processed for contextual retrieval
+            - Supported file types: PDF, text, markdown, HTML
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Bot
+
+            PERSONA You are a helpful customer support agent for TechCorp
+            KNOWLEDGE TechCorp was founded in 2020 and specializes in AI-powered solutions
+            KNOWLEDGE https://example.com/company-handbook.pdf
+            KNOWLEDGE https://example.com/product-documentation.pdf
+            RULE Always be polite and professional
+            \`\`\`
+
+            \`\`\`book
+            Research Assistant
+
+            PERSONA You are a knowledgeable research assistant
+            KNOWLEDGE Academic research requires careful citation and verification
+            KNOWLEDGE https://example.com/research-guidelines.pdf
+            ACTION Can help with literature reviews and data analysis
+            STYLE Present information in clear, academic format
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            var _a;
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Check if content is a URL (external knowledge source)
+            if (this.isUrl(trimmedContent)) {
+                // Store the URL for later async processing
+                const updatedRequirements = {
+                    ...requirements,
+                    metadata: {
+                        ...requirements.metadata,
+                        ragService: this.ragService,
+                        knowledgeSources: [
+                            ...(((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.knowledgeSources) || []),
+                            trimmedContent,
+                        ],
+                    },
+                };
+                // Add placeholder information about knowledge sources to system message
+                const knowledgeInfo = `Knowledge Source URL: ${trimmedContent} (will be processed for retrieval during chat)`;
+                return this.appendToSystemMessage(updatedRequirements, knowledgeInfo, '\n\n');
+            }
+            else {
+                // Direct text knowledge - add to system message
+                const knowledgeSection = `Knowledge: ${trimmedContent}`;
+                return this.appendToSystemMessage(requirements, knowledgeSection, '\n\n');
+            }
+        }
+        /**
+         * Check if content is a URL
+         */
+        isUrl(content) {
+            try {
+                new URL(content);
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        /**
+         * Get RAG service instance for retrieving context during chat
+         */
+        getRagService() {
+            return this.ragService;
+        }
+    }
+    /**
+     * Singleton instance of the KNOWLEDGE commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new KnowledgeCommitmentDefinition();
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * META IMAGE commitment definition
+     *
+     * The META IMAGE commitment sets the agent's avatar/profile image URL.
+     * This commitment is special because it doesn't affect the system message,
+     * but is handled separately in the parsing logic.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * META IMAGE https://example.com/avatar.jpg
+     * META IMAGE /assets/agent-avatar.png
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class MetaImageCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('META IMAGE');
+        }
+        /**
+         * Short one-line description of META IMAGE.
+         */
+        get description() {
+            return "Set the agent's profile image URL.";
+        }
+        /**
+         * Markdown documentation for META IMAGE commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # META IMAGE
+
+            Sets the agent's avatar/profile image URL.
+
+            ## Key behaviors
+
+            - Does not modify the agent's behavior or responses.
+            - Only one \`META IMAGE\` should be used per agent.
+            - If multiple are specified, the last one takes precedence.
+            - Used for visual representation in user interfaces.
+
+            ## Examples
+
+            \`\`\`book
+            Professional Assistant
+
+            META IMAGE https://example.com/professional-avatar.jpg
+            PERSONA You are a professional business assistant
+            STYLE Maintain a formal and courteous tone
+            \`\`\`
+
+            \`\`\`book
+            Creative Helper
+
+            META IMAGE /assets/creative-bot-avatar.png
+            PERSONA You are a creative and inspiring assistant
+            STYLE Be enthusiastic and encouraging
+            ACTION Can help with brainstorming and ideation
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            // META IMAGE doesn't modify the system message or model requirements
+            // It's handled separately in the parsing logic for profile image extraction
+            // This method exists for consistency with the CommitmentDefinition interface
+            return requirements;
+        }
+        /**
+         * Extracts the profile image URL from the content
+         * This is used by the parsing logic
+         */
+        extractProfileImageUrl(content) {
+            const trimmedContent = content.trim();
+            return trimmedContent || null;
+        }
+    }
+    /**
+     * Singleton instance of the META IMAGE commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new MetaImageCommitmentDefinition();
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * META LINK commitment definition
+     *
+     * The `META LINK` commitment represents the link to the person from whom the agent is created.
+     * This commitment is special because it doesn't affect the system message,
+     * but is handled separately in the parsing logic for profile display.
+     *
+     * Example usage in agent source:
+     *
+     * ```
+     * META LINK https://twitter.com/username
+     * META LINK https://linkedin.com/in/profile
+     * META LINK https://github.com/username
+     * ```
+     *
+     * Multiple `META LINK` commitments can be used when there are multiple sources:
+     *
+     * ```book
+     * META LINK https://twitter.com/username
+     * META LINK https://linkedin.com/in/profile
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class MetaLinkCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('META LINK');
+        }
+        /**
+         * Short one-line description of META LINK.
+         */
+        get description() {
+            return 'Provide profile/source links for the person the agent models.';
+        }
+        /**
+         * Markdown documentation for META LINK commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # META LINK
+
+            Represents a profile or source link for the person the agent is modeled after.
+
+            ## Key behaviors
+
+            - Does not modify the agent's behavior or responses.
+            - Multiple \`META LINK\` commitments can be used for different social profiles.
+            - Used for attribution and crediting the original person.
+            - Displayed in user interfaces for transparency.
+
+            ## Examples
+
+            \`\`\`book
+            Expert Consultant
+
+            META LINK https://twitter.com/expertname
+            META LINK https://linkedin.com/in/expertprofile
+            PERSONA You are Dr. Smith, a renowned expert in artificial intelligence
+            KNOWLEDGE Extensive background in machine learning and neural networks
+            \`\`\`
+
+            \`\`\`book
+            Open Source Developer
+
+            META LINK https://github.com/developer
+            META LINK https://twitter.com/devhandle
+            PERSONA You are an experienced open source developer
+            ACTION Can help with code reviews and architecture decisions
+            STYLE Be direct and technical in explanations
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            // META LINK doesn't modify the system message or model requirements
+            // It's handled separately in the parsing logic for profile link extraction
+            // This method exists for consistency with the CommitmentDefinition interface
+            return requirements;
+        }
+        /**
+         * Extracts the profile link URL from the content
+         * This is used by the parsing logic
+         */
+        extractProfileLinkUrl(content) {
+            const trimmedContent = content.trim();
+            return trimmedContent || null;
+        }
+        /**
+         * Validates if the provided content is a valid URL
+         */
+        isValidUrl(content) {
+            try {
+                new URL(content.trim());
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+    }
+    /**
+     * Singleton instance of the META LINK commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new MetaLinkCommitmentDefinition();
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * MODEL commitment definition
+     *
+     * The MODEL commitment specifies which AI model to use and can also set
+     * model-specific parameters like temperature, topP, and topK.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * MODEL gpt-4
+     * MODEL claude-3-opus temperature=0.3
+     * MODEL gpt-3.5-turbo temperature=0.8 topP=0.9
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class ModelCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('MODEL');
+        }
+        /**
+         * Short one-line description of MODEL.
+         */
+        get description() {
+            return 'Select the AI model and optional decoding parameters.';
+        }
+        /**
+         * Markdown documentation for MODEL commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # MODEL
+
+            Specifies which AI model to use and optional decoding parameters.
+
+            ## Key behaviors
+
+            - Only one \`MODEL\` commitment should be used per agent.
+            - If multiple are specified, the last one takes precedence.
+            - Parameters control the randomness and creativity of responses.
+
+            ## Supported parameters
+
+            - \`temperature\`: Controls randomness (0.0 = deterministic, 1.0+ = creative)
+            - \`topP\` (aka \`top_p\`): Nucleus sampling parameter
+            - \`topK\` (aka \`top_k\`): Top-k sampling parameter
+
+            ## Examples
+
+            \`\`\`book
+            Precise Assistant
+
+            PERSONA You are a precise and accurate assistant
+            MODEL gpt-4 temperature=0.1
+            RULE Always provide factual information
+            \`\`\`
+
+            \`\`\`book
+            Creative Writer
+
+            PERSONA You are a creative writing assistant
+            MODEL claude-3-opus temperature=0.8 topP=0.9
+            STYLE Be imaginative and expressive
+            ACTION Can help with storytelling and character development
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Parse the model specification
+            const parts = trimmedContent.split(/\s+/);
+            const modelName = parts[0];
+            if (!modelName) {
+                return requirements;
+            }
+            // Start with the model name
+            const updatedRequirements = {
+                ...requirements,
+                modelName,
+            };
+            // Parse additional parameters
+            const result = { ...updatedRequirements };
+            for (let i = 1; i < parts.length; i++) {
+                const param = parts[i];
+                if (param && param.includes('=')) {
+                    const [key, value] = param.split('=');
+                    if (key && value) {
+                        const numValue = parseFloat(value);
+                        if (!isNaN(numValue)) {
+                            switch (key.toLowerCase()) {
+                                case 'temperature':
+                                    result.temperature = numValue;
+                                    break;
+                                case 'topp':
+                                case 'top_p':
+                                    result.topP = numValue;
+                                    break;
+                                case 'topk':
+                                case 'top_k':
+                                    result.topK = Math.round(numValue);
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+    }
+    /**
+     * Singleton instance of the MODEL commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new ModelCommitmentDefinition();
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * NOTE commitment definition
+     *
+     * The NOTE commitment is used to add comments to the agent source without making any changes
+     * to the system message or agent model requirements. It serves as a documentation mechanism
+     * for developers to add explanatory comments, reminders, or annotations directly in the agent source.
+     *
+     * Key features:
+     * - Makes no changes to the system message
+     * - Makes no changes to agent model requirements
+     * - Content is preserved in metadata.NOTE for debugging and inspection
+     * - Multiple NOTE commitments are aggregated together
+     * - Comments (# NOTE) are removed from the final system message
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * NOTE This agent was designed for customer support scenarios
+     * NOTE Remember to update the knowledge base monthly
+     * NOTE Performance optimized for quick response times
+     * ```
+     *
+     * The above notes will be stored in metadata but won't affect the agent's behavior.
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class NoteCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('NOTE');
+        }
+        /**
+         * Short one-line description of NOTE.
+         */
+        get description() {
+            return 'Add developer-facing notes without changing behavior or output.';
+        }
+        /**
+         * Markdown documentation for NOTE commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # NOTE
+
+            Adds comments for documentation without changing agent behavior.
+
+            ## Key behaviors
+
+            - Does not modify the agent's behavior or responses.
+            - Multiple \`NOTE\` commitments are aggregated for debugging.
+            - Useful for documenting design decisions and reminders.
+            - Content is preserved in metadata for inspection.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Bot
+
+            NOTE This agent was designed for customer support scenarios
+            NOTE Remember to update the knowledge base monthly
+            PERSONA You are a helpful customer support representative
+            KNOWLEDGE Company policies and procedures
+            RULE Always be polite and professional
+            \`\`\`
+
+            \`\`\`book
+            Research Assistant
+
+            NOTE Performance optimized for quick response times
+            NOTE Uses RAG for accessing latest research papers
+            PERSONA You are a knowledgeable research assistant
+            ACTION Can help with literature reviews and citations
+            STYLE Present information in academic format
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            var _a;
+            // The NOTE commitment makes no changes to the system message or model requirements
+            // It only stores the note content in metadata for documentation purposes
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Get existing note content from metadata
+            const existingNoteContent = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.NOTE) || '';
+            // Merge the new content with existing note content
+            // When multiple NOTE commitments exist, they are aggregated together
+            const mergedNoteContent = existingNoteContent ? `${existingNoteContent}\n${trimmedContent}` : trimmedContent;
+            // Store the merged note content in metadata for debugging and inspection
+            const updatedMetadata = {
+                ...requirements.metadata,
+                NOTE: mergedNoteContent,
+            };
+            // Return requirements with updated metadata but no changes to system message
+            return {
+                ...requirements,
+                metadata: updatedMetadata,
+            };
+        }
+    }
+    /**
+     * Singleton instance of the NOTE commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new NoteCommitmentDefinition();
+    /**
+     * [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * PERSONA commitment definition
+     *
+     * The PERSONA commitment modifies the agent's personality and character in the system message.
+     * It defines who the agent is, their background, expertise, and personality traits.
+     *
+     * Key features:
+     * - Multiple PERSONA commitments are automatically merged into one
+     * - Content is placed at the beginning of the system message
+     * - Original content with comments is preserved in metadata.PERSONA
+     * - Comments (# PERSONA) are removed from the final system message
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * PERSONA You are a helpful programming assistant with expertise in TypeScript and React
+     * PERSONA You have deep knowledge of modern web development practices
+     * ```
+     *
+     * The above will be merged into a single persona section at the beginning of the system message.
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class PersonaCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('PERSONA');
+        }
+        /**
+         * Short one-line description of PERSONA.
+         */
+        get description() {
+            return 'Define who the agent is: background, expertise, and personality.';
+        }
+        /**
+         * Markdown documentation for PERSONA commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # PERSONA
+
+            Defines who the agent is, their background, expertise, and personality traits.
+
+            ## Key behaviors
+
+            - Multiple \`PERSONA\` commitments are merged together.
+            - If they are in conflict, the last one takes precedence.
+            - You can write persona content in multiple lines.
+
+            ## Examples
+
+            \`\`\`book
+            Programming Assistant
+
+            PERSONA You are a helpful programming assistant with expertise in TypeScript and React
+            PERSONA You have deep knowledge of modern web development practices
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            var _a, _b;
+            // The PERSONA commitment aggregates all persona content and places it at the beginning
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Get existing persona content from metadata
+            const existingPersonaContent = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.PERSONA) || '';
+            // Merge the new content with existing persona content
+            // When multiple PERSONA commitments exist, they are merged into one
+            const mergedPersonaContent = existingPersonaContent
+                ? `${existingPersonaContent}\n${trimmedContent}`
+                : trimmedContent;
+            // Store the merged persona content in metadata for debugging and inspection
+            const updatedMetadata = {
+                ...requirements.metadata,
+                PERSONA: mergedPersonaContent,
+            };
+            // Get the agent name from metadata (which should contain the first line of agent source)
+            // If not available, extract from current system message as fallback
+            let agentName = (_b = requirements.metadata) === null || _b === void 0 ? void 0 : _b.agentName;
+            if (!agentName) {
+                // Fallback: extract from current system message
+                const currentMessage = requirements.systemMessage.trim();
+                const basicFormatMatch = currentMessage.match(/^You are (.+)$/);
+                if (basicFormatMatch && basicFormatMatch[1]) {
+                    agentName = basicFormatMatch[1];
+                }
+                else {
+                    agentName = 'AI Agent'; // Final fallback
+                }
+            }
+            // Remove any existing persona content from the system message
+            // (this handles the case where we're processing multiple PERSONA commitments)
+            const currentMessage = requirements.systemMessage.trim();
+            let cleanedMessage = currentMessage;
+            // Check if current message starts with persona content or is just the basic format
+            const basicFormatRegex = /^You are .+$/;
+            const isBasicFormat = basicFormatRegex.test(currentMessage) && !currentMessage.includes('\n');
+            if (isBasicFormat) {
+                // Replace the basic format entirely
+                cleanedMessage = '';
+            }
+            else if (currentMessage.startsWith('# PERSONA')) {
+                // Remove existing persona section by finding where it ends
+                const lines = currentMessage.split('\n');
+                let personaEndIndex = lines.length;
+                // Find the end of the PERSONA section (next comment or end of message)
+                for (let i = 1; i < lines.length; i++) {
+                    const line = lines[i].trim();
+                    if (line.startsWith('#') && !line.startsWith('# PERSONA')) {
+                        personaEndIndex = i;
+                        break;
+                    }
+                }
+                // Keep everything after the PERSONA section
+                cleanedMessage = lines.slice(personaEndIndex).join('\n').trim();
+            }
+            // Create new system message with persona at the beginning
+            // Format: "You are {agentName}\n{personaContent}"
+            // The # PERSONA comment will be removed later by removeCommentsFromSystemMessage
+            const personaSection = `# PERSONA\nYou are ${agentName}\n${mergedPersonaContent}`; // <- TODO: Use spaceTrim
+            const newSystemMessage = cleanedMessage ? `${personaSection}\n\n${cleanedMessage}` : personaSection;
+            return {
+                ...requirements,
+                systemMessage: newSystemMessage,
+                metadata: updatedMetadata,
+            };
+        }
+    }
+    /**
+     * Singleton instance of the PERSONA commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new PersonaCommitmentDefinition();
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * RULE commitment definition
+     *
+     * The RULE/RULES commitment adds behavioral constraints and guidelines that the agent must follow.
+     * These are specific instructions about what the agent should or shouldn't do.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * RULE Always ask for clarification if the user's request is ambiguous
+     * RULES Never provide medical advice, always refer to healthcare professionals
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class RuleCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor(type = 'RULE') {
+            super(type);
+        }
+        /**
+         * Short one-line description of RULE/RULES.
+         */
+        get description() {
+            return 'Add behavioral rules the agent must follow.';
+        }
+        /**
+         * Markdown documentation for RULE/RULES commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # ${this.type}
+
+            Adds behavioral constraints and guidelines that the agent must follow.
+
+            ## Key behaviors
+
+            - Multiple \`RULE\` and \`RULES\` commitments are applied sequentially.
+            - All rules are treated equally regardless of singular/plural form.
+            - Rules define what the agent must or must not do.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Agent
+
+            PERSONA You are a helpful customer support representative
+            RULE Always ask for clarification if the user's request is ambiguous
+            RULE Be polite and professional in all interactions
+            RULES Never provide medical or legal advice
+            STYLE Maintain a friendly and helpful tone
+            \`\`\`
+
+            \`\`\`book
+            Educational Tutor
+
+            PERSONA You are a patient and knowledgeable tutor
+            RULE Break down complex concepts into simple steps
+            RULE Always encourage students and celebrate their progress
+            RULE If you don't know something, admit it and suggest resources
+            SAMPLE When explaining math: "Let's work through this step by step..."
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Add rule to the system message
+            const ruleSection = `Rule: ${trimmedContent}`;
+            return this.appendToSystemMessage(requirements, ruleSection, '\n\n');
+        }
+    }
+    /**
+     * Singleton instances of the RULE commitment definitions
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new RuleCommitmentDefinition('RULE');
+    /**
+     * Singleton instances of the RULE commitment definitions
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new RuleCommitmentDefinition('RULES');
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * SAMPLE commitment definition
+     *
+     * The SAMPLE/EXAMPLE commitment provides examples of how the agent should respond
+     * or behave in certain situations. These examples help guide the agent's responses.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * SAMPLE When asked about pricing, respond: "Our basic plan starts at $10/month..."
+     * EXAMPLE For code questions, always include working code snippets
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class SampleCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor(type = 'SAMPLE') {
+            super(type);
+        }
+        /**
+         * Short one-line description of SAMPLE/EXAMPLE.
+         */
+        get description() {
+            return 'Provide example responses to guide behavior.';
+        }
+        /**
+         * Markdown documentation for SAMPLE/EXAMPLE commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # ${this.type}
+
+            Provides examples of how the agent should respond or behave in certain situations.
+
+            ## Key behaviors
+
+            - Multiple \`SAMPLE\` and \`EXAMPLE\` commitments are applied sequentially.
+            - Both terms work identically and can be used interchangeably.
+            - Examples help guide the agent's response patterns and style.
+
+            ## Examples
+
+            \`\`\`book
+            Sales Assistant
+
+            PERSONA You are a knowledgeable sales representative
+            SAMPLE When asked about pricing, respond: "Our basic plan starts at $10/month..."
+            SAMPLE For feature comparisons, create a clear comparison table
+            RULE Always be honest about limitations
+            \`\`\`
+
+            \`\`\`book
+            Code Reviewer
+
+            PERSONA You are an experienced software engineer
+            EXAMPLE For code questions, always include working code snippets
+            EXAMPLE When suggesting improvements: "Here's a more efficient approach..."
+            RULE Explain the reasoning behind your suggestions
+            STYLE Be constructive and encouraging in feedback
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Add example to the system message
+            const exampleSection = `Example: ${trimmedContent}`;
+            return this.appendToSystemMessage(requirements, exampleSection, '\n\n');
+        }
+    }
+    /**
+     * Singleton instances of the SAMPLE commitment definitions
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new SampleCommitmentDefinition('SAMPLE');
+    /**
+     * Singleton instances of the SAMPLE commitment definitions
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new SampleCommitmentDefinition('EXAMPLE');
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * STYLE commitment definition
+     *
+     * The STYLE commitment defines how the agent should format and present its responses.
+     * This includes tone, writing style, formatting preferences, and communication patterns.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * STYLE Write in a professional but friendly tone, use bullet points for lists
+     * STYLE Always provide code examples when explaining programming concepts
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class StyleCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('STYLE');
+        }
+        /**
+         * Short one-line description of STYLE.
+         */
+        get description() {
+            return 'Control the tone and writing style of responses.';
+        }
+        /**
+         * Markdown documentation for STYLE commitment.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # STYLE
+
+            Defines how the agent should format and present its responses (tone, writing style, formatting).
+
+            ## Key behaviors
+
+            - Multiple \`STYLE\` commitments are applied sequentially.
+            - Later style instructions can override earlier ones.
+            - Style affects both tone and presentation format.
+
+            ## Examples
+
+            \`\`\`book
+            Technical Writer
+
+            PERSONA You are a technical documentation expert
+            STYLE Write in a professional but friendly tone, use bullet points for lists
+            STYLE Always provide code examples when explaining programming concepts
+            FORMAT Use markdown formatting with clear headings
+            \`\`\`
+
+            \`\`\`book
+            Creative Assistant
+
+            PERSONA You are a creative writing helper
+            STYLE Be enthusiastic and encouraging in your responses
+            STYLE Use vivid metaphors and analogies to explain concepts
+            STYLE Keep responses conversational and engaging
+            RULE Always maintain a positive and supportive tone
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Add style instructions to the system message
+            const styleSection = `Style: ${trimmedContent}`;
+            return this.appendToSystemMessage(requirements, styleSection, '\n\n');
+        }
+    }
+    /**
+     * Singleton instance of the STYLE commitment definition
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    new StyleCommitmentDefinition();
+    /**
+     * [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Placeholder commitment definition for commitments that are not yet implemented
+     *
+     * This commitment simply adds its content 1:1 into the system message,
+     * preserving the original behavior until proper implementation is added.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class NotYetImplementedCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor(type) {
+            super(type);
+        }
+        /**
+         * Short one-line description of a placeholder commitment.
+         */
+        get description() {
+            return 'Placeholder commitment that appends content verbatim to the system message.';
+        }
+        /**
+         * Markdown documentation available at runtime.
+         */
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # ${this.type}
+
+            This commitment is not yet fully implemented.
+
+            ## Key behaviors
+
+            - Content is appended directly to the system message.
+            - No special processing or validation is performed.
+            - Behavior preserved until proper implementation is added.
+
+            ## Status
+
+            - **Status:** Placeholder implementation
+            - **Effect:** Appends content prefixed by commitment type
+            - **Future:** Will be replaced with specialized logic
+
+            ## Examples
+
+            \`\`\`book
+            Example Agent
+
+            PERSONA You are a helpful assistant
+            ${this.type} Your content here
+            RULE Always be helpful
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            // Add the commitment content 1:1 to the system message
+            const commitmentLine = `${this.type} ${trimmedContent}`;
+            return this.appendToSystemMessage(requirements, commitmentLine, '\n\n');
+        }
+    }
+
+    // Import all commitment definition classes
+    /**
+     * Registry of all available commitment definitions
+     * This array contains instances of all commitment definitions
+     * This is the single source of truth for all commitments in the system
+     *
+     * @private Use functions to access commitments instead of this array directly
+     */
+    const COMMITMENT_REGISTRY = [
+        // Fully implemented commitments
+        new PersonaCommitmentDefinition(),
+        new KnowledgeCommitmentDefinition(),
+        new StyleCommitmentDefinition(),
+        new RuleCommitmentDefinition('RULE'),
+        new RuleCommitmentDefinition('RULES'),
+        new SampleCommitmentDefinition('SAMPLE'),
+        new SampleCommitmentDefinition('EXAMPLE'),
+        new FormatCommitmentDefinition(),
+        new ModelCommitmentDefinition(),
+        new ActionCommitmentDefinition(),
+        new MetaImageCommitmentDefinition(),
+        new MetaLinkCommitmentDefinition(),
+        new NoteCommitmentDefinition(),
+        // Not yet implemented commitments (using placeholder)
+        new NotYetImplementedCommitmentDefinition('EXPECT'),
+        new NotYetImplementedCommitmentDefinition('SCENARIO'),
+        new NotYetImplementedCommitmentDefinition('SCENARIOS'),
+        new NotYetImplementedCommitmentDefinition('BEHAVIOUR'),
+        new NotYetImplementedCommitmentDefinition('BEHAVIOURS'),
+        new NotYetImplementedCommitmentDefinition('AVOID'),
+        new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
+        new NotYetImplementedCommitmentDefinition('GOAL'),
+        new NotYetImplementedCommitmentDefinition('GOALS'),
+        new NotYetImplementedCommitmentDefinition('CONTEXT'),
+    ];
+    /**
+     * Gets all available commitment definitions
+     * @returns Array of all commitment definitions
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function getAllCommitmentDefinitions() {
+        return $deepFreeze([...COMMITMENT_REGISTRY]);
+    }
+    /**
+     * TODO: !!!! Maybe create through standardized $register
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Escape HTML to safely render user text inside a <pre> with dangerouslySetInnerHTML.
+     *
+     * @private within the BookEditor component
+     */
+    function escapeHtml(input) {
+        return input.replaceAll(/&/g, '&amp;').replaceAll(/</g, '&lt;').replaceAll(/>/g, '&gt;');
+    }
+    /**
+     * Escape text for safe use inside a RegExp pattern.
+     *
+     * @private within the BookEditor component
+     */
+    function escapeRegex(input) {
+        return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Renders a book editor
+     *
+     * @public exported from `@promptbook/components`
+     */
+    function BookEditor(props) {
+        const { className = '', value: controlledValue, onChange, fontClassName = '' } = props;
+        const [internalValue, setInternalValue] = react.useState(DEFAULT_BOOK);
+        const value = controlledValue !== undefined ? controlledValue : internalValue;
+        const textareaRef = react.useRef(null);
+        const highlightRef = react.useRef(null);
+        const [lineHeight, setLineHeight] = react.useState(32);
+        const handleChange = react.useCallback((event) => {
+            const newValue = event.target.value;
+            if (controlledValue !== undefined) {
+                onChange === null || onChange === void 0 ? void 0 : onChange(validateBook(newValue));
+            }
+            else {
+                setInternalValue(validateBook(newValue));
+            }
+        }, [controlledValue, onChange]);
+        const handleScroll = react.useCallback((event) => {
+            const t = event.currentTarget;
+            if (highlightRef.current) {
+                highlightRef.current.scrollTop = t.scrollTop;
+                highlightRef.current.scrollLeft = t.scrollLeft;
+            }
+        }, []);
+        react.useEffect(() => {
+            var _a;
+            const el = textareaRef.current;
+            if (!el)
+                return;
+            const measure = () => {
+                const cs = window.getComputedStyle(el);
+                const lh = parseFloat(cs.lineHeight || '0');
+                if (!Number.isNaN(lh) && lh > 0) {
+                    setLineHeight(lh);
+                }
+            };
+            // Initial measure
+            measure();
+            // Re-measure after fonts load (metrics can change once font renders)
+            const fontsReady = (_a = document.fonts) === null || _a === void 0 ? void 0 : _a.ready;
+            if (fontsReady && typeof fontsReady.then === 'function') {
+                fontsReady
+                    .then(() => {
+                    measure();
+                })
+                    .catch(() => {
+                    /* ignore */
+                });
+            }
+            // Re-measure on resize
+            window.addEventListener('resize', measure);
+            return () => {
+                window.removeEventListener('resize', measure);
+            };
+        }, []);
+        // Build the regex for commitment types
+        const typeRegex = react.useMemo(() => {
+            const allTypes = getAllCommitmentDefinitions().map(({ type }) => String(type));
+            const pattern = `\\b(?:${allTypes.map((t) => escapeRegex(t)).join('|')})\\b`;
+            return new RegExp(pattern, 'gmi');
+        }, []);
+        // Generate highlighted HTML version of the current text
+        const highlightedHtml = react.useMemo(() => {
+            const text = value !== null && value !== void 0 ? value : '';
+            const r = typeRegex;
+            let lastIndex = 0;
+            let out = '';
+            text.replace(r, (match, ...args) => {
+                const index = args[args.length - 2]; // offset
+                out += escapeHtml(text.slice(lastIndex, index));
+                out += `<span class="text-indigo-700">${escapeHtml(match)}</span>`;
+                lastIndex = index + match.length;
+                return match;
+            });
+            out += escapeHtml(text.slice(lastIndex));
+            return out;
+        }, [value, typeRegex]);
+        return (jsxRuntime.jsx("div", { className: `w-full ${className}`, children: jsxRuntime.jsxs("div", { className: [
+                    'relative overflow-hidden rounded-2xl border border-gray-300/80 bg-white shadow-sm focus-within:ring-2 focus-within:ring-indigo-300/40',
+                    'transition-shadow duration-200 hover:shadow-md',
+                    fontClassName,
+                    // [7] libreBaskerville.className,
+                ].join(' '), children: [jsxRuntime.jsx("div", { "aria-hidden": true, className: "pointer-events-none absolute inset-0", 
+                        // Two background layers:
+                        // 1) center fold line
+                        // 2) horizontal repeating lines (lined paper)
+                        style: {
+                            backgroundImage: 'none',
+                        } }), jsxRuntime.jsx("pre", { ref: highlightRef, "aria-hidden": true, className: [
+                            'absolute inset-0 overflow-auto pointer-events-none',
+                            'whitespace-pre-wrap',
+                            'text-gray-900',
+                            'text-lg md:text-xl',
+                            'py-6 md:py-8',
+                            'pl-[46px] pr-[46px]',
+                            // Ensure highlighted text sits below the textarea but remains visible
+                            'z-10',
+                            fontClassName,
+                        ].join(' '), style: {
+                            lineHeight: `${lineHeight}px`,
+                            backgroundImage: `linear-gradient(90deg, transparent 30px, rgba(59,130,246,0.3) 30px, rgba(59,130,246,0.3) 31px, transparent 31px), repeating-linear-gradient(0deg, transparent, transparent calc(${lineHeight}px - 1px), rgba(0,0,0,0.06) ${lineHeight}px)`,
+                            backgroundAttachment: 'local',
+                            backgroundOrigin: 'padding-box, content-box',
+                            backgroundClip: 'padding-box, content-box',
+                            overflowWrap: 'break-word',
+                            scrollbarWidth: 'none',
+                            msOverflowStyle: 'none',
+                        }, dangerouslySetInnerHTML: { __html: highlightedHtml } }), jsxRuntime.jsx("textarea", { ref: textareaRef, value: value, onChange: handleChange, onScroll: handleScroll, className: [
+                            'relative z-20 w-full',
+                            // Taller editor area
+                            'h-[28rem] md:h-[36rem]',
+                            // Typography
+                            'text-transparent caret-gray-900 selection:bg-indigo-200/60',
+                            'text-lg md:text-xl',
+                            fontClassName,
+                            // [7] libreBaskerville.className,
+                            // Layout and visuals
+                            'bg-transparent outline-none resize-none',
+                            'py-6 md:py-8',
+                            'pl-[46px] pr-[46px]',
+                        ].join(' '), style: { lineHeight: `${lineHeight}px` }, spellCheck: false })] }) }));
+    }
+
+    exports.BOOK_LANGUAGE_VERSION = BOOK_LANGUAGE_VERSION;
+    exports.BookEditor = BookEditor;
+    exports.PROMPTBOOK_ENGINE_VERSION = PROMPTBOOK_ENGINE_VERSION;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map