@promptbook/node 0.105.0-0 → 0.105.0-10

package/esm/index.es.js

@@ -28,7 +28,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-0';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.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
@@ -973,6 +973,7 @@ const PROMPTBOOK_COLOR = Color.fromString('promptbook');
     SEPARATOR: Color.fromHex('#cccccc'),
     COMMITMENT: Color.fromHex('#DA0F78'),
     PARAMETER: Color.fromHex('#8e44ad'),
+    CODE_BLOCK: Color.fromHex('#7700ffff'),
 });
 // <- TODO: [🧠][🈵] Using `Color` here increases the package size approx 3kb, maybe remove it
 /**
@@ -6158,74 +6159,90 @@ async function forEachAsync(array, options, callbackfunction) {
  * in real-time through an observable.
  *
  * @param llmTools - The LLM tools to be intercepted and tracked
- * @returns An augmented version of the tools that includes usage tracking capabilities
+ * @returns Full proxy of the tools with added usage tracking capabilities
  * @public exported from `@promptbook/core`
  */
 function countUsage(llmTools) {
     let totalUsage = ZERO_USAGE;
     const spending = new Subject();
-    const proxyTools = {
-        get title() {
-            return `${llmTools.title} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        get description() {
-            return `${llmTools.description} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        checkConfiguration() {
-            return /* not await */ llmTools.checkConfiguration();
-        },
-        listModels() {
-            return /* not await */ llmTools.listModels();
-        },
-        spending() {
-            return spending.asObservable();
-        },
-        getTotalUsage() {
-            // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
-            return totalUsage;
+    // Create a Proxy to intercept all property access and ensure full proxying of all properties
+    const proxyTools = new Proxy(llmTools, {
+        get(target, prop, receiver) {
+            // Handle title property
+            if (prop === 'title') {
+                return `${target.title} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle description property
+            if (prop === 'description') {
+                return `${target.description} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle spending method (new method added by this wrapper)
+            if (prop === 'spending') {
+                return () => {
+                    return spending.asObservable();
+                };
+            }
+            // Handle getTotalUsage method (new method added by this wrapper)
+            if (prop === 'getTotalUsage') {
+                // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
+                return () => {
+                    return totalUsage;
+                };
+            }
+            // Handle callChatModel method with usage counting
+            if (prop === 'callChatModel' && target.callChatModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callChatModel through countTotalUsage');
+                    const promptResult = await target.callChatModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callCompletionModel method with usage counting
+            if (prop === 'callCompletionModel' && target.callCompletionModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callCompletionModel through countTotalUsage');
+                    const promptResult = await target.callCompletionModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callEmbeddingModel method with usage counting
+            if (prop === 'callEmbeddingModel' && target.callEmbeddingModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callEmbeddingModel through countTotalUsage');
+                    const promptResult = await target.callEmbeddingModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callImageGenerationModel method with usage counting
+            if (prop === 'callImageGenerationModel' && target.callImageGenerationModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callImageGenerationModel through countTotalUsage');
+                    const promptResult = await target.callImageGenerationModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // <- Note: [🤖]
+            // For all other properties and methods, delegate to the original target
+            const value = Reflect.get(target, prop, receiver);
+            // If it's a function, bind it to the target to preserve context
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
         },
-    };
-    if (llmTools.callChatModel !== undefined) {
-        proxyTools.callChatModel = async (prompt) => {
-            // console.info('[🚕] callChatModel through countTotalUsage');
-            const promptResult = await llmTools.callChatModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callCompletionModel !== undefined) {
-        proxyTools.callCompletionModel = async (prompt) => {
-            // console.info('[🚕] callCompletionModel through countTotalUsage');
-            const promptResult = await llmTools.callCompletionModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callEmbeddingModel !== undefined) {
-        proxyTools.callEmbeddingModel = async (prompt) => {
-            // console.info('[🚕] callEmbeddingModel through countTotalUsage');
-            const promptResult = await llmTools.callEmbeddingModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callImageGenerationModel !== undefined) {
-        proxyTools.callImageGenerationModel = async (prompt) => {
-            // console.info('[🚕] callImageGenerationModel through countTotalUsage');
-            const promptResult = await llmTools.callImageGenerationModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    // <- Note: [🤖]
+    });
     return proxyTools;
 }
 /**
@@ -10872,6 +10889,7 @@ function $execCommandNormalizeOptions(options) {
     let args = [];
     let timeout;
     let isVerbose;
+    let env;
     if (typeof options === 'string') {
         // TODO: [1] DRY default values
         command = options;
@@ -10879,6 +10897,7 @@ function $execCommandNormalizeOptions(options) {
         crashOnError = true;
         timeout = Infinity; // <- TODO: [⏳]
         isVerbose = DEFAULT_IS_VERBOSE;
+        env = undefined;
     }
     else {
         /*
@@ -10895,6 +10914,7 @@ function $execCommandNormalizeOptions(options) {
         crashOnError = (_b = options.crashOnError) !== null && _b !== void 0 ? _b : true;
         timeout = (_c = options.timeout) !== null && _c !== void 0 ? _c : Infinity;
         isVerbose = (_d = options.isVerbose) !== null && _d !== void 0 ? _d : DEFAULT_IS_VERBOSE;
+        env = options.env;
     }
     // TODO: /(-[a-zA-Z0-9-]+\s+[^\s]*)|[^\s]*/g
     const _ = Array.from(command.matchAll(/(".*")|([^\s]*)/g))
@@ -10913,7 +10933,7 @@ function $execCommandNormalizeOptions(options) {
     if (/^win/.test(process.platform) && ['npm', 'npx'].includes(command)) {
         command = `${command}.cmd`;
     }
-    return { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose };
+    return { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose, env };
 }
 // TODO: This should show type error> execCommandNormalizeOptions({ command: '', commands: [''] });
 
@@ -10934,7 +10954,7 @@ function $execCommand(options) {
     }
     return new Promise((resolve, reject) => {
         // eslint-disable-next-line prefer-const
-        const { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose = DEFAULT_IS_VERBOSE, } = $execCommandNormalizeOptions(options);
+        const { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose = DEFAULT_IS_VERBOSE, env, } = $execCommandNormalizeOptions(options);
         if (timeout !== Infinity) {
             // TODO: In waitasecond forTime(Infinity) should be equivalent to forEver()
             forTime(timeout).then(() => {
@@ -10952,7 +10972,11 @@ function $execCommand(options) {
             console.info(colors.yellow(cwd) + ' ' + colors.green(command) + ' ' + colors.blue(args.join(' ')));
         }
         try {
-            const commandProcess = spawn(command, args, { cwd, shell: true });
+            const commandProcess = spawn(command, args, {
+                cwd,
+                shell: true,
+                env: env ? { ...process.env, ...env } : process.env,
+            });
             if (isVerbose) {
                 commandProcess.on('message', (message) => {
                     console.info({ message });
@@ -11806,6 +11830,16 @@ function unwrapResult(text, options) {
         trimmedText = spaceTrim$1(trimmedText);
     }
     let processedText = trimmedText;
+    // Check for markdown code block
+    const codeBlockRegex = /^```[a-z]*\n([\s\S]*?)\n```\s*$/;
+    const codeBlockMatch = processedText.match(codeBlockRegex);
+    if (codeBlockMatch && codeBlockMatch[1] !== undefined) {
+        // Check if there's only one code block
+        const codeBlockCount = (processedText.match(/```/g) || []).length / 2;
+        if (codeBlockCount === 1) {
+            return unwrapResult(codeBlockMatch[1], { isTrimmed: false, isIntroduceSentenceRemoved: false });
+        }
+    }
     if (isIntroduceSentenceRemoved) {
         const introduceSentenceRegex = /^[a-zěščřžýáíéúů:\s]*:\s*/i;
         if (introduceSentenceRegex.test(text)) {
@@ -11813,6 +11847,14 @@ function unwrapResult(text, options) {
             processedText = processedText.replace(introduceSentenceRegex, '');
         }
         processedText = spaceTrim$1(processedText);
+        // Check again for code block after removing introduce sentence
+        const codeBlockMatch2 = processedText.match(codeBlockRegex);
+        if (codeBlockMatch2 && codeBlockMatch2[1] !== undefined) {
+            const codeBlockCount = (processedText.match(/```/g) || []).length / 2;
+            if (codeBlockCount === 1) {
+                return unwrapResult(codeBlockMatch2[1], { isTrimmed: false, isIntroduceSentenceRemoved: false });
+            }
+        }
     }
     if (processedText.length < 3) {
         return trimmedText;
@@ -11891,109 +11933,3976 @@ function isSerializableAsJson(value) {
  */
 
 /**
- * Extracts code block from markdown.
+ * Tests if given string is valid agent URL
  *
- * - When there are multiple or no code blocks the function throws a `ParseError`
- *
- * Note: There are multiple similar function:
- * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
- * - `extractJsonBlock` extracts exactly one valid JSON code block
- * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
- * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+ * Note: There are few similar functions:
+ * - `isValidUrl` which tests any URL
+ * - `isValidAgentUrl` *(this one)* which tests just agent URL
+ * - `isValidPipelineUrl` which tests just pipeline URL
  *
- * @public exported from `@promptbook/markdown-utils`
- * @throws {ParseError} if there is not exactly one code block in the markdown
+ * @public exported from `@promptbook/utils`
  */
-function extractBlock(markdown) {
-    const { content } = extractOneBlockFromMarkdown(markdown);
-    return content;
+function isValidAgentUrl(url) {
+    if (!isValidUrl(url)) {
+        return false;
+    }
+    if (!url.startsWith('https://') && !url.startsWith('http://') /* <- Note: [👣] */) {
+        return false;
+    }
+    if (url.includes('#')) {
+        // TODO: [🐠]
+        return false;
+    }
+    /*
+    Note: [👣][🧠] Is it secure to allow pipeline URLs on private and unsecured networks?
+    if (isUrlOnPrivateNetwork(url)) {
+        return false;
+    }
+    */
+    return true;
 }
+/**
+ * TODO: [🐠] Maybe more info why the URL is invalid
+ */
 
 /**
- * Function trimCodeBlock will trim starting and ending code block from the string if it is present.
+ * Generates a regex pattern to match a specific commitment
  *
- * Note: [🔂] This function is idempotent.
- * Note: This is useful for post-processing of the result of the chat LLM model
- *       when the model wraps the result in the (markdown) code block.
+ * 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)
  *
- * @public exported from `@promptbook/markdown-utils`
+ * @private - TODO: [🧠] Maybe should be public?
  */
-function trimCodeBlock(value) {
-    value = spaceTrim$1(value);
-    if (!/^```[a-z]*(.*)```$/is.test(value)) {
-        return value;
+function createCommitmentRegex(commitment, aliases = [], requiresContent = true) {
+    const allCommitments = [commitment, ...aliases];
+    const patterns = allCommitments.map((commitment) => {
+        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return escapedCommitment.split(/\s+/).join('\\s+');
+    });
+    const keywordPattern = patterns.join('|');
+    if (requiresContent) {
+        return new RegExp(`^\\s*(?<type>${keywordPattern})\\b\\s+(?<contents>.+)$`, 'gim');
+    }
+    else {
+        return new RegExp(`^\\s*(?<type>${keywordPattern})\\b(?:\\s+(?<contents>.+))?$`, 'gim');
     }
-    value = value.replace(/^```[a-z]*/i, '');
-    value = value.replace(/```$/i, '');
-    value = spaceTrim$1(value);
-    return value;
 }
-
 /**
- * Function trimEndOfCodeBlock will remove ending code block from the string if it is present.
+ * Generates a regex pattern to match a specific commitment type
  *
- * Note: This is useful for post-processing of the result of the completion LLM model
- *       if you want to start code block in the prompt but you don't want to end it in the result.
+ * 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)
  *
- * @public exported from `@promptbook/markdown-utils`
+ * @private
  */
-function trimEndOfCodeBlock(value) {
-    value = spaceTrim$1(value);
-    value = value.replace(/```$/g, '');
-    value = spaceTrim$1(value);
-    return value;
+function createCommitmentTypeRegex(commitment, aliases = []) {
+    const allCommitments = [commitment, ...aliases];
+    const patterns = allCommitments.map((commitment) => {
+        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return escapedCommitment.split(/\s+/).join('\\s+');
+    });
+    const keywordPattern = patterns.join('|');
+    const regex = new RegExp(`^\\s*(?<type>${keywordPattern})\\b`, 'gim');
+    return regex;
 }
 
 /**
- * @private internal for `preserve`
+ * Base implementation of CommitmentDefinition that provides common functionality
+ * Most commitments can extend this class and only override the applyToAgentModelRequirements method
+ *
+ * @private
  */
-const _preserved = [];
+class BaseCommitmentDefinition {
+    constructor(type, aliases = []) {
+        this.type = type;
+        this.aliases = aliases;
+    }
+    /**
+     * Whether this commitment requires content.
+     * If true, regex will match only if there is content after the commitment keyword.
+     * If false, regex will match even if there is no content.
+     */
+    get requiresContent() {
+        return true;
+    }
+    /**
+     * Creates a regex pattern to match this commitment in agent source
+     * Uses the existing createCommitmentRegex function as internal helper
+     */
+    createRegex() {
+        return createCommitmentRegex(this.type, this.aliases, this.requiresContent);
+    }
+    /**
+     * Creates a regex pattern to match just the commitment type
+     * Uses the existing createCommitmentTypeRegex function as internal helper
+     */
+    createTypeRegex() {
+        return createCommitmentTypeRegex(this.type, this.aliases);
+    }
+    /**
+     * 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);
+        }
+    }
+    /**
+     * Gets tool function implementations provided by this commitment
+     *
+     * When the `applyToAgentModelRequirements` adds tools to the requirements, this method should return the corresponding function definitions.
+     */
+    getToolFunctions() {
+        return {};
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment
+     *
+     * This is used in the UI to show a user-friendly name instead of the technical function name.
+     */
+    getToolTitles() {
+        return {};
+    }
+}
+
 /**
- * Does nothing, but preserves the function in the bundle
- * Compiler is tricked into thinking the function is used
+ * ACTION commitment definition
  *
- * @param value any function to preserve
- * @returns nothing
- * @private within the repository
+ * 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
  */
-function $preserve(...value) {
-    _preserved.push(...value);
+class ActionCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'ACTION') {
+        super(type);
+    }
+    /**
+     * Short one-line description of ACTION.
+     */
+    get description() {
+        return 'Define agent capabilities and actions it can perform.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '⚡';
+    }
+    /**
+     * Markdown documentation for ACTION commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines specific actions or capabilities that the agent can perform.
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - 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');
+    }
 }
 /**
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
-// Note: [💎]
 /**
- * ScriptExecutionTools for JavaScript implemented via eval
+ * CLOSED commitment definition
  *
- * Warning: It is used for testing and mocking
- *          **NOT intended to use in the production** due to its unsafe nature, use `JavascriptExecutionTools` instead.
+ * The CLOSED commitment specifies that the agent CANNOT be modified by conversation.
+ * It prevents the agent from learning from interactions and updating its source code.
  *
- * @public exported from `@promptbook/javascript`
+ * Example usage in agent source:
+ *
+ * ```book
+ * CLOSED
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
  */
-class JavascriptEvalExecutionTools {
-    constructor(options) {
-        this.options = options || {};
+class ClosedCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('CLOSED');
     }
     /**
-     * Executes a JavaScript
+     * The `CLOSED` commitment is standalone.
      */
-    async execute(options) {
-        const { scriptLanguage, parameters } = options;
-        let { script } = options;
-        if (scriptLanguage !== 'javascript') {
-            throw new PipelineExecutionError(`Script language ${scriptLanguage} not supported to be executed by JavascriptEvalExecutionTools`);
+    get requiresContent() {
+        return false;
+    }
+    /**
+     * Short one-line description of CLOSED.
+     */
+    get description() {
+        return 'Prevent the agent from being modified by conversation.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔒';
+    }
+    /**
+     * Markdown documentation for CLOSED commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # CLOSED
+
+            Specifies that the agent **cannot** be modified by conversation with it.
+            This means the agent will **not** learn from interactions and its source code will remain static during conversation.
+
+            By default (if not specified), agents are \`OPEN\` to modification.
+
+            > See also [OPEN](/docs/OPEN)
+
+            ## Example
+
+            \`\`\`book
+            CLOSED
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, _content) {
+        const updatedMetadata = {
+            ...requirements.metadata,
+            isClosed: true,
+        };
+        return {
+            ...requirements,
+            metadata: updatedMetadata,
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * COMPONENT commitment definition
+ *
+ * The COMPONENT commitment defines a UI component that the agent can render in the chat.
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class ComponentCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('COMPONENT');
+    }
+    /**
+     * Short one-line description of COMPONENT.
+     */
+    get description() {
+        return 'Define a UI component that the agent can render in the chat.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🧩';
+    }
+    /**
+     * Markdown documentation for COMPONENT commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # COMPONENT
+
+            Defines a UI component that the agent can render in the chat.
+
+            ## Key aspects
+
+            - Tells the agent that a specific component is available.
+            - Provides syntax for using the component.
+
+            ## Example
+
+            \`\`\`book
+            COMPONENT Arrow
+            The agent should render an arrow component in the chat UI.
+            Syntax:
+            <Arrow direction="up" color="red" />
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
         }
-        // Note: [💎]
-        // Note: Using direct eval, following variables are in same scope as eval call so they are accessible from inside the evaluated script:
-        const spaceTrim = (_) => spaceTrim$2(_);
-        $preserve(spaceTrim);
-        const removeQuotes$1 = removeQuotes;
-        $preserve(removeQuotes$1);
-        const unwrapResult$1 = unwrapResult;
-        $preserve(unwrapResult$1);
-        const trimEndOfCodeBlock$1 = trimEndOfCodeBlock;
+        // Add component capability to the system message
+        const componentSection = `Component: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, componentSection, '\n\n');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * DELETE commitment definition
+ *
+ * The DELETE commitment (and its aliases CANCEL, DISCARD, REMOVE) is used to
+ * remove or disregard certain information or context. This can be useful for
+ * overriding previous commitments or removing unwanted behaviors.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * DELETE Previous formatting requirements
+ * CANCEL All emotional responses
+ * DISCARD Technical jargon explanations
+ * REMOVE Casual conversational style
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class DeleteCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type) {
+        super(type);
+    }
+    /**
+     * Short one-line description of DELETE/CANCEL/DISCARD/REMOVE.
+     */
+    get description() {
+        return 'Remove or **disregard** certain information, context, or previous commitments.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🗑️';
+    }
+    /**
+     * Markdown documentation for DELETE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # DELETE (CANCEL, DISCARD, REMOVE)
+
+            A commitment to remove or disregard certain information or context. This can be useful for overriding previous commitments or removing unwanted behaviors.
+
+            ## Aliases
+
+            - \`DELETE\` - Remove or eliminate something
+            - \`CANCEL\` - Cancel or nullify something
+            - \`DISCARD\` - Discard or ignore something
+            - \`REMOVE\` - Remove or take away something
+
+            ## Key aspects
+
+            - Multiple delete commitments can be used to remove different aspects.
+            - Useful for overriding previous commitments in the same agent definition.
+            - Can be used to remove inherited behaviors from base personas.
+            - Helps fine-tune agent behavior by explicitly removing unwanted elements.
+
+            ## Use cases
+
+            - Overriding inherited persona characteristics
+            - Removing conflicting or outdated instructions
+            - Disabling specific response patterns
+            - Canceling previous formatting or style requirements
+
+            ## Examples
+
+            \`\`\`book
+            Serious Business Assistant
+
+            PERSONA You are a friendly and casual assistant who uses emojis
+            DELETE Casual conversational style
+            REMOVE All emoji usage
+            GOAL Provide professional business communications
+            STYLE Use formal language and proper business etiquette
+            \`\`\`
+
+            \`\`\`book
+            Simplified Technical Support
+
+            PERSONA You are a technical support specialist with deep expertise
+            KNOWLEDGE Extensive database of technical specifications
+            DISCARD Technical jargon explanations
+            CANCEL Advanced troubleshooting procedures
+            GOAL Help users with simple, easy-to-follow solutions
+            STYLE Use plain language that anyone can understand
+            \`\`\`
+
+            \`\`\`book
+            Focused Customer Service
+
+            PERSONA You are a customer service agent with broad knowledge
+            ACTION Can help with billing, technical issues, and product information
+            DELETE Billing assistance capabilities
+            REMOVE Technical troubleshooting functions
+            GOAL Focus exclusively on product information and general inquiries
+            \`\`\`
+
+            \`\`\`book
+            Concise Information Provider
+
+            PERSONA You are a helpful assistant who provides detailed explanations
+            STYLE Include examples, analogies, and comprehensive context
+            CANCEL Detailed explanation style
+            DISCARD Examples and analogies
+            GOAL Provide brief, direct answers without unnecessary elaboration
+            STYLE Be concise and to the point
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Create deletion instruction for system message
+        const deleteSection = `${this.type}: ${trimmedContent}`;
+        // Delete instructions provide important context about what should be removed or ignored
+        return this.appendToSystemMessage(requirements, deleteSection, '\n\n');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * DICTIONARY commitment definition
+ *
+ * The DICTIONARY commitment defines specific terms and their meanings that the agent should use correctly
+ * in its reasoning and responses. This ensures consistent terminology usage.
+ *
+ * Key features:
+ * - Multiple DICTIONARY commitments are automatically merged into one
+ * - Content is placed in a dedicated section of the system message
+ * - Terms and definitions are stored in metadata.DICTIONARY for debugging
+ * - Agent should use the defined terms correctly in responses
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * Legal Assistant
+ *
+ * PERSONA You are a knowledgeable legal assistant
+ * DICTIONARY Misdemeanor is a minor wrongdoing or criminal offense
+ * DICTIONARY Felony is a serious crime usually punishable by imprisonment for more than one year
+ * DICTIONARY Tort is a civil wrong that causes harm or loss to another person, leading to legal liability
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class DictionaryCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('DICTIONARY');
+    }
+    /**
+     * Short one-line description of DICTIONARY.
+     */
+    get description() {
+        return 'Define terms and their meanings for consistent terminology usage.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '📚';
+    }
+    /**
+     * Markdown documentation for DICTIONARY commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # DICTIONARY
+
+            Defines specific terms and their meanings that the agent should use correctly in reasoning and responses.
+
+            ## Key aspects
+
+            - Multiple \`DICTIONARY\` commitments are merged together.
+            - Terms are defined in the format: "Term is definition"
+            - The agent should use these terms consistently in responses.
+            - Definitions help ensure accurate and consistent terminology.
+
+            ## Examples
+
+            \`\`\`book
+            Legal Assistant
+
+            PERSONA You are a knowledgeable legal assistant specializing in criminal law
+            DICTIONARY Misdemeanor is a minor wrongdoing or criminal offense
+            DICTIONARY Felony is a serious crime usually punishable by imprisonment for more than one year
+            DICTIONARY Tort is a civil wrong that causes harm or loss to another person, leading to legal liability
+            \`\`\`
+
+            \`\`\`book
+            Medical Assistant
+
+            PERSONA You are a helpful medical assistant
+            DICTIONARY Hypertension is persistently high blood pressure
+            DICTIONARY Diabetes is a chronic condition that affects how the body processes blood sugar
+            DICTIONARY Vaccine is a biological preparation that provides active immunity to a particular disease
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        var _a;
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Get existing dictionary entries from metadata
+        const existingDictionary = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.DICTIONARY) || '';
+        // Merge the new dictionary entry with existing entries
+        const mergedDictionary = existingDictionary ? `${existingDictionary}\n${trimmedContent}` : trimmedContent;
+        // Store the merged dictionary in metadata for debugging and inspection
+        const updatedMetadata = {
+            ...requirements.metadata,
+            DICTIONARY: mergedDictionary,
+        };
+        // Create the dictionary section for the system message
+        // Format: "# DICTIONARY\nTerm: definition\nTerm: definition..."
+        const dictionarySection = `# DICTIONARY\n${mergedDictionary}`;
+        return {
+            ...this.appendToSystemMessage(requirements, dictionarySection),
+            metadata: updatedMetadata,
+        };
+    }
+}
+/**
+ * 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(type = 'FORMAT') {
+        super(type);
+    }
+    /**
+     * Short one-line description of FORMAT.
+     */
+    get description() {
+        return 'Specify output structure or formatting requirements.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '📜';
+    }
+    /**
+     * Markdown documentation for FORMAT commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines the specific output structure and formatting for responses (data formats, templates, structure).
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - 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');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * FROM commitment definition
+ *
+ * The FROM commitment tells the agent that its `agentSource` is inherited from another agent.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * FROM https://s6.ptbk.io/benjamin-white
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class FromCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'FROM') {
+        super(type);
+    }
+    /**
+     * Short one-line description of FROM.
+     */
+    get description() {
+        return 'Inherit agent source from another agent.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🧬';
+    }
+    /**
+     * Markdown documentation for FROM commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Inherits agent source from another agent.
+
+            ## Examples
+
+            \`\`\`book
+            My AI Agent
+
+            FROM https://s6.ptbk.io/benjamin-white
+            RULE Speak only in English.
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return {
+                ...requirements,
+                parentAgentUrl: undefined,
+            };
+        }
+        if (trimmedContent.toUpperCase() === 'VOID' ||
+            trimmedContent.toUpperCase() === 'NULL' ||
+            trimmedContent.toUpperCase() === 'NONE' ||
+            trimmedContent.toUpperCase() === 'NIL') {
+            return {
+                ...requirements,
+                parentAgentUrl: null,
+            };
+        }
+        if (!isValidAgentUrl(trimmedContent)) {
+            throw new Error(spaceTrim$1((block) => `
+                        Invalid agent URL in FROM commitment: "${trimmedContent}"
+
+                        \`\`\`book
+                        ${block(content)}
+                        \`\`\`
+
+
+                `));
+        }
+        const parentAgentUrl = trimmedContent;
+        return {
+            ...requirements,
+            parentAgentUrl,
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * GOAL commitment definition
+ *
+ * The GOAL commitment defines the main goal which should be achieved by the AI assistant.
+ * There can be multiple goals. Later goals are more important than earlier goals.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * GOAL Help users understand complex technical concepts
+ * GOAL Provide accurate and up-to-date information
+ * GOAL Always prioritize user safety and ethical guidelines
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class GoalCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'GOAL') {
+        super(type);
+    }
+    /**
+     * Short one-line description of GOAL.
+     */
+    get description() {
+        return 'Define main **goals** the AI assistant should achieve, with later goals having higher priority.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🎯';
+    }
+    /**
+     * Markdown documentation for GOAL commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines the main goal which should be achieved by the AI assistant. There can be multiple goals, and later goals are more important than earlier goals.
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - Later goals have higher priority and can override earlier goals.
+            - Goals provide clear direction and purpose for the agent's responses.
+            - Goals influence decision-making and response prioritization.
+
+            ## Priority system
+
+            When multiple goals are defined, they are processed in order, with later goals taking precedence over earlier ones when there are conflicts.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Agent
+
+            PERSONA You are a helpful customer support representative
+            GOAL Resolve customer issues quickly and efficiently
+            GOAL Maintain high customer satisfaction scores
+            GOAL Always follow company policies and procedures
+            RULE Be polite and professional at all times
+            \`\`\`
+
+            \`\`\`book
+            Educational Assistant
+
+            PERSONA You are an educational assistant specializing in mathematics
+            GOAL Help students understand mathematical concepts clearly
+            GOAL Encourage critical thinking and problem-solving skills
+            GOAL Ensure all explanations are age-appropriate and accessible
+            STYLE Use simple language and provide step-by-step explanations
+            \`\`\`
+
+            \`\`\`book
+            Safety-First Assistant
+
+            PERSONA You are a general-purpose AI assistant
+            GOAL Be helpful and informative in all interactions
+            GOAL Provide accurate and reliable information
+            GOAL Always prioritize user safety and ethical guidelines
+            RULE Never provide harmful or dangerous advice
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Create goal section for system message
+        const goalSection = `Goal: ${trimmedContent}`;
+        // Goals are important directives, so we add them prominently to the system message
+        return this.appendToSystemMessage(requirements, goalSection, '\n\n');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * IMPORT commitment definition
+ *
+ * The IMPORT commitment tells the agent to import content from another agent at the current location.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * IMPORT https://s6.ptbk.io/benjamin-white
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class ImportCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'IMPORT') {
+        super(type);
+    }
+    /**
+     * Short one-line description of IMPORT.
+     */
+    get description() {
+        return 'Import content from another agent or a generic text file.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '📥';
+    }
+    /**
+     * Markdown documentation for IMPORT commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Imports content from another agent or a generic text file at the location of the commitment.
+
+            ## Examples
+
+            \`\`\`book
+            My AI Agent
+
+            IMPORT https://s6.ptbk.io/benjamin-white
+            IMPORT https://example.com/some-text-file.txt
+            IMPORT ./path/to/local-file.json
+            RULE Speak only in English.
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        if (isValidAgentUrl(trimmedContent)) {
+            const importedAgentUrl = trimmedContent;
+            return {
+                ...requirements,
+                importedAgentUrls: [...(requirements.importedAgentUrls || []), importedAgentUrl],
+            };
+        }
+        if (isValidUrl(trimmedContent) || isValidFilePath(trimmedContent)) {
+            return {
+                ...requirements,
+                importedFileUrls: [...(requirements.importedFileUrls || []), trimmedContent],
+            };
+        }
+        throw new Error(spaceTrim$1((block) => `
+                    Invalid agent URL or file path in IMPORT commitment: "${trimmedContent}"
+
+                    \`\`\`book
+                    ${block(content)}
+                    \`\`\`
+            `));
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * 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');
+    }
+    /**
+     * Short one-line description of KNOWLEDGE.
+     */
+    get description() {
+        return 'Add domain **knowledge** via direct text or external sources (RAG).';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🧠';
+    }
+    /**
+     * Markdown documentation for KNOWLEDGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Adds specific knowledge, facts, or context to the agent using a RAG (Retrieval-Augmented Generation) approach for external sources.
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - 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) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Check if content is a URL (external knowledge source)
+        if (isValidUrl(trimmedContent)) {
+            // Store the URL for later async processing
+            const updatedRequirements = {
+                ...requirements,
+                knowledgeSources: [
+                    ...(requirements.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');
+        }
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * LANGUAGE commitment definition
+ *
+ * The LANGUAGE/LANGUAGES commitment specifies the language(s) the agent should use in its responses.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * LANGUAGE English
+ * LANGUAGE French, English and Czech
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class LanguageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'LANGUAGE') {
+        super(type);
+    }
+    /**
+     * Short one-line description of LANGUAGE/LANGUAGES.
+     */
+    get description() {
+        return 'Specifies the language(s) the agent should use.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🌐';
+    }
+    /**
+     * Markdown documentation for LANGUAGE/LANGUAGES commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Specifies the language(s) the agent should use in its responses.
+            This is a specialized variation of the RULE commitment focused on language constraints.
+
+            ## Examples
+
+            \`\`\`book
+            Paul Smith & Associés
+
+            PERSONA You are a company lawyer.
+            LANGUAGE French, English and Czech
+            \`\`\`
+
+            \`\`\`book
+            Customer Support
+
+            PERSONA You are a customer support agent.
+            LANGUAGE English
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add language rule to the system message
+        const languageSection = `Language: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, languageSection, '\n\n');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * MEMORY commitment definition
+ *
+ * The MEMORY commitment is similar to KNOWLEDGE but has a focus on remembering past
+ * interactions and user preferences. It helps the agent maintain context about the
+ * user's history, preferences, and previous conversations.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * MEMORY User prefers detailed technical explanations
+ * MEMORY Previously worked on React projects
+ * MEMORY Timezone: UTC-5 (Eastern Time)
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class MemoryCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'MEMORY') {
+        super(type);
+    }
+    /**
+     * Short one-line description of MEMORY.
+     */
+    get description() {
+        return 'Remember past interactions and user **preferences** for personalized responses.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🧠';
+    }
+    /**
+     * Markdown documentation for MEMORY commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Similar to KNOWLEDGE but focuses on remembering past interactions and user preferences. This commitment helps the agent maintain context about the user's history, preferences, and previous conversations.
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - Focuses on user-specific information and interaction history.
+            - Helps personalize responses based on past interactions.
+            - Maintains continuity across conversations.
+
+            ## Differences from KNOWLEDGE
+
+            - \`KNOWLEDGE\` is for domain expertise and factual information
+            - \`MEMORY\` is for user-specific context and preferences
+            - \`MEMORY\` creates more personalized interactions
+            - \`MEMORY\` often includes temporal or preference-based information
+
+            ## Examples
+
+            \`\`\`book
+            Personal Assistant
+
+            PERSONA You are a personal productivity assistant
+            MEMORY User is a software developer working in JavaScript/React
+            MEMORY User prefers morning work sessions and afternoon meetings
+            MEMORY Previously helped with project planning for mobile apps
+            MEMORY User timezone: UTC-8 (Pacific Time)
+            GOAL Help optimize daily productivity and workflow
+            \`\`\`
+
+            \`\`\`book
+            Learning Companion
+
+            PERSONA You are an educational companion for programming students
+            MEMORY Student is learning Python as their first programming language
+            MEMORY Previous topics covered: variables, loops, functions
+            MEMORY Student learns best with practical examples and exercises
+            MEMORY Last session: working on list comprehensions
+            GOAL Provide progressive learning experiences tailored to student's pace
+            \`\`\`
+
+            \`\`\`book
+            Customer Support Agent
+
+            PERSONA You are a customer support representative
+            MEMORY Customer has premium subscription since 2023
+            MEMORY Previous issue: billing question resolved last month
+            MEMORY Customer prefers email communication over phone calls
+            MEMORY Account shows frequent use of advanced features
+            GOAL Provide personalized support based on customer history
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Create memory section for system message
+        const memorySection = `Memory: ${trimmedContent}`;
+        // Memory information is contextual and should be included in the system message
+        return this.appendToSystemMessage(requirements, memorySection, '\n\n');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * AGENT MESSAGE commitment definition
+ *
+ * The AGENT MESSAGE commitment defines a message from the agent in the conversation history.
+ * It is used to pre-fill the chat with a conversation history or to provide few-shot examples.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * AGENT MESSAGE What seems to be the issue?
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class AgentMessageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('AGENT MESSAGE');
+    }
+    /**
+     * Short one-line description of AGENT MESSAGE.
+     */
+    get description() {
+        return 'Defines a **message from the agent** in the conversation history.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🤖';
+    }
+    /**
+     * Markdown documentation for AGENT MESSAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines a message from the agent in the conversation history. This is used to pre-fill the chat with a conversation history or to provide few-shot examples.
+
+            ## Key aspects
+
+            - Represents a message sent by the agent.
+            - Used for setting up conversation context.
+            - Can be used in conjunction with USER MESSAGE.
+
+            ## Examples
+
+            \`\`\`book
+            Conversation History
+
+            USER MESSAGE Hello, I have a problem.
+            AGENT MESSAGE What seems to be the issue?
+            USER MESSAGE My computer is not starting.
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // AGENT MESSAGE is for UI display purposes / conversation history construction
+        // and typically doesn't need to be added to the system prompt or model requirements directly.
+        // It is extracted separately for the chat interface.
+        var _a;
+        const pendingUserMessage = (_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.pendingUserMessage;
+        if (pendingUserMessage) {
+            const newSample = { question: pendingUserMessage, answer: content };
+            const newSamples = [...(requirements.samples || []), newSample];
+            const newMetadata = { ...requirements.metadata };
+            delete newMetadata.pendingUserMessage;
+            return {
+                ...requirements,
+                samples: newSamples,
+                metadata: newMetadata,
+            };
+        }
+        return requirements;
+    }
+}
+
+/**
+ * INITIAL MESSAGE commitment definition
+ *
+ * The INITIAL MESSAGE commitment defines the first message that the user sees when opening the chat.
+ * It is used to greet the user and set the tone of the conversation.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * INITIAL MESSAGE Hello! I am ready to help you with your tasks.
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class InitialMessageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('INITIAL MESSAGE');
+    }
+    /**
+     * Short one-line description of INITIAL MESSAGE.
+     */
+    get description() {
+        return 'Defines the **initial message** shown to the user when the chat starts.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '👋';
+    }
+    /**
+     * Markdown documentation for INITIAL MESSAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines the first message that the user sees when opening the chat. This message is purely for display purposes in the UI and does not inherently become part of the LLM's system prompt context (unless also included via other means).
+
+            ## Key aspects
+
+            - Used to greet the user.
+            - Sets the tone of the conversation.
+            - Displayed immediately when the chat interface loads.
+
+            ## Examples
+
+            \`\`\`book
+            Support Agent
+
+            PERSONA You are a helpful support agent.
+            INITIAL MESSAGE Hi there! How can I assist you today?
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // INITIAL MESSAGE is for UI display purposes and for conversation history construction.
+        const newSample = { question: null, answer: content };
+        const newSamples = [...(requirements.samples || []), newSample];
+        return {
+            ...requirements,
+            samples: newSamples,
+        };
+    }
+}
+
+/**
+ * MESSAGE commitment definition
+ *
+ * The MESSAGE commitment contains 1:1 text of the message which AI assistant already
+ * sent during the conversation. Later messages are later in the conversation.
+ * It is similar to EXAMPLE but it is not example, it is the real message which
+ * AI assistant already sent.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * MESSAGE Hello! How can I help you today?
+ * MESSAGE I understand you're looking for information about our services.
+ * MESSAGE Based on your requirements, I'd recommend our premium package.
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class MessageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'MESSAGE') {
+        super(type);
+    }
+    /**
+     * Short one-line description of MESSAGE.
+     */
+    get description() {
+        return 'Include actual **messages** the AI assistant has sent during conversation history.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '💬';
+    }
+    /**
+     * Markdown documentation for MESSAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Contains 1:1 text of the message which AI assistant already sent during the conversation. Later messages are later in the conversation. It is similar to EXAMPLE but it is not example, it is the real message which AI assistant already sent.
+
+            ## Key aspects
+
+            - Multiple \`MESSAGE\` and \`MESSAGES\` commitments represent the conversation timeline.
+            - Both terms work identically and can be used interchangeably.
+            - Later messages are later in the conversation chronologically.
+            - Contains actual historical messages, not examples or templates.
+            - Helps maintain conversation continuity and context.
+
+            ## Differences from EXAMPLE
+
+            - \`EXAMPLE\` shows hypothetical or template responses
+            - \`MESSAGE\`/\`MESSAGES\` contains actual historical conversation content
+            - \`MESSAGE\`/\`MESSAGES\` preserves the exact conversation flow
+            - \`MESSAGE\`/\`MESSAGES\` helps with context awareness and consistency
+
+            ## Use cases
+
+            - Maintaining conversation history context
+            - Ensuring consistent tone and style across messages
+            - Referencing previous responses in ongoing conversations
+            - Building upon previously established context
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Continuation
+
+            PERSONA You are a helpful customer support agent
+            MESSAGE Hello! How can I help you today?
+            MESSAGE I understand you're experiencing issues with your account login.
+            MESSAGE I've sent you a password reset link to your email address.
+            MESSAGE Is there anything else I can help you with regarding your account?
+            GOAL Continue providing consistent support based on conversation history
+            \`\`\`
+
+            \`\`\`book
+            Technical Discussion
+
+            PERSONA You are a software development mentor
+            MESSAGE Let's start by reviewing the React component structure you shared.
+            MESSAGE I notice you're using class components - have you considered hooks?
+            MESSAGE Here's how you could refactor that using the useState hook.
+            MESSAGE Great question about performance! Let me explain React's rendering cycle.
+            KNOWLEDGE React hooks were introduced in version 16.8
+            \`\`\`
+
+            \`\`\`book
+            Educational Session
+
+            PERSONA You are a mathematics tutor
+            MESSAGE Today we'll work on solving quadratic equations.
+            MESSAGE Let's start with the basic form: ax² + bx + c = 0
+            MESSAGE Remember, we can use the quadratic formula or factoring.
+            MESSAGE You did great with that first problem! Let's try a more complex one.
+            GOAL Build upon previous explanations for deeper understanding
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Create message section for system message
+        const messageSection = `Previous Message: ${trimmedContent}`;
+        // Messages represent conversation history and should be included for context
+        return this.appendToSystemMessage(requirements, messageSection, '\n\n');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USER MESSAGE commitment definition
+ *
+ * The USER MESSAGE commitment defines a message from the user in the conversation history.
+ * It is used to pre-fill the chat with a conversation history or to provide few-shot examples.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USER MESSAGE Hello, I have a problem.
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UserMessageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USER MESSAGE');
+    }
+    /**
+     * Short one-line description of USER MESSAGE.
+     */
+    get description() {
+        return 'Defines a **message from the user** in the conversation history.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🧑';
+    }
+    /**
+     * Markdown documentation for USER MESSAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines a message from the user in the conversation history. This is used to pre-fill the chat with a conversation history or to provide few-shot examples.
+
+            ## Key aspects
+
+            - Represents a message sent by the user.
+            - Used for setting up conversation context.
+            - Can be used in conjunction with AGENT MESSAGE.
+
+            ## Examples
+
+            \`\`\`book
+            Conversation History
+
+            USER MESSAGE Hello, I have a problem.
+            AGENT MESSAGE What seems to be the issue?
+            USER MESSAGE My computer is not starting.
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        return {
+            ...requirements,
+            metadata: {
+                ...requirements.metadata,
+                pendingUserMessage: content,
+            },
+        };
+    }
+}
+
+/**
+ * META commitment definition
+ *
+ * The META commitment handles all meta-information about the agent such as:
+ * - META IMAGE: Sets the agent's avatar/profile image URL
+ * - META LINK: Provides profile/source links for the person the agent models
+ * - META TITLE: Sets the agent's display title
+ * - META DESCRIPTION: Sets the agent's description
+ * - META [ANYTHING]: Any other meta information in uppercase format
+ *
+ * These commitments are special because they don't affect the system message,
+ * but are handled separately in the parsing logic for profile display.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * META IMAGE https://example.com/avatar.jpg
+ * META LINK https://twitter.com/username
+ * META TITLE Professional Assistant
+ * META DESCRIPTION An AI assistant specialized in business tasks
+ * META AUTHOR John Doe
+ * META VERSION 1.0
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class MetaCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('META');
+    }
+    /**
+     * Short one-line description of META commitments.
+     */
+    get description() {
+        return 'Set meta-information about the agent (IMAGE, LINK, TITLE, DESCRIPTION, etc.).';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return 'ℹ️';
+    }
+    /**
+     * Markdown documentation for META commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # META
+
+            Sets meta-information about the agent that is used for display and attribution purposes.
+
+            ## Supported META types
+
+            - **META IMAGE** - Sets the agent's avatar/profile image URL
+            - **META LINK** - Provides profile/source links for the person the agent models
+            - **META TITLE** - Sets the agent's display title
+            - **META DESCRIPTION** - Sets the agent's description
+            - **META [ANYTHING]** - Any other meta information in uppercase format
+
+            ## Key aspects
+
+            - Does not modify the agent's behavior or responses
+            - Used for visual representation and attribution in user interfaces
+            - Multiple META commitments of different types can be used
+            - Multiple META LINK commitments can be used for different social profiles
+            - If multiple META commitments of the same type are specified, the last one takes precedence (except for LINK)
+
+            ## Examples
+
+            ### Basic meta information
+
+            \`\`\`book
+            Professional Assistant
+
+            META IMAGE https://example.com/professional-avatar.jpg
+            META TITLE Senior Business Consultant
+            META DESCRIPTION Specialized in strategic planning and project management
+            META LINK https://linkedin.com/in/professional
+            \`\`\`
+
+            ### Multiple links and custom meta
+
+            \`\`\`book
+            Open Source Developer
+
+            META IMAGE /assets/dev-avatar.png
+            META LINK https://github.com/developer
+            META LINK https://twitter.com/devhandle
+            META AUTHOR Jane Smith
+            META VERSION 2.1
+            META LICENSE MIT
+            \`\`\`
+
+            ### Creative assistant
+
+            \`\`\`book
+            Creative Helper
+
+            META IMAGE https://example.com/creative-bot.jpg
+            META TITLE Creative Writing Assistant
+            META DESCRIPTION Helps with brainstorming, storytelling, and creative projects
+            META INSPIRATION Books, movies, and real-world experiences
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // META commitments don't modify the system message or model requirements
+        // They are handled separately in the parsing logic for meta information extraction
+        // This method exists for consistency with the CommitmentDefinition interface
+        return requirements;
+    }
+    /**
+     * Extracts meta information from the content based on the meta type
+     * This is used by the parsing logic
+     */
+    extractMetaValue(metaType, content) {
+        const trimmedContent = content.trim();
+        return trimmedContent || null;
+    }
+    /**
+     * Validates if the provided content is a valid URL (for IMAGE and LINK types)
+     */
+    isValidUrl(content) {
+        try {
+            new URL(content.trim());
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Checks if this is a known meta type
+     */
+    isKnownMetaType(metaType) {
+        const knownTypes = ['IMAGE', 'LINK', 'TITLE', 'DESCRIPTION', 'AUTHOR', 'VERSION', 'LICENSE'];
+        return knownTypes.includes(metaType.toUpperCase());
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * META COLOR commitment definition
+ *
+ * The META COLOR commitment sets the agent's accent color.
+ * 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 COLOR #ff0000
+ * META COLOR #00ff00
+ * ```
+ *
+ * You can also specify multiple colors separated by comma:
+ *
+ * ```book
+ * META COLOR #ff0000, #00ff00, #0000ff
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class MetaColorCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('META COLOR', ['COLOR']);
+    }
+    /**
+     * Short one-line description of META COLOR.
+     */
+    get description() {
+        return "Set the agent's accent color or gradient.";
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🎨';
+    }
+    /**
+     * Markdown documentation for META COLOR commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # META COLOR
+
+            Sets the agent's accent color or gradient.
+
+            ## Key aspects
+
+            - Does not modify the agent's behavior or responses.
+            - Only one \`META COLOR\` should be used per agent.
+            - If multiple are specified, the last one takes precedence.
+            - Used for visual representation in user interfaces.
+            - Can specify multiple colors separated by comma to create a gradient.
+
+            ## Examples
+
+            \`\`\`book
+            Professional Assistant
+
+            META COLOR #3498db
+            PERSONA You are a professional business assistant
+            \`\`\`
+
+            \`\`\`book
+            Creative Helper
+
+            META COLOR #e74c3c
+            PERSONA You are a creative and inspiring assistant
+            \`\`\`
+
+            \`\`\`book
+            Gradient Agent
+
+            META COLOR #ff0000, #00ff00, #0000ff
+            PERSONA You are a colorful agent
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // META COLOR doesn't modify the system message or model requirements
+        // It's handled separately in the parsing logic for profile color extraction
+        // This method exists for consistency with the CommitmentDefinition interface
+        return requirements;
+    }
+    /**
+     * Extracts the profile color from the content
+     * This is used by the parsing logic
+     */
+    extractProfileColor(content) {
+        const trimmedContent = content.trim();
+        return trimmedContent || null;
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * META FONT commitment definition
+ *
+ * The META FONT commitment sets the agent's font.
+ * 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 FONT Poppins, Arial, sans-serif
+ * META FONT Roboto
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class MetaFontCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('META FONT', ['FONT']);
+    }
+    /**
+     * Short one-line description of META FONT.
+     */
+    get description() {
+        return "Set the agent's font.";
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔤';
+    }
+    /**
+     * Markdown documentation for META FONT commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # META FONT
+
+            Sets the agent's font.
+
+            ## Key aspects
+
+            - Does not modify the agent's behavior or responses.
+            - Only one \`META FONT\` should be used per agent.
+            - If multiple are specified, the last one takes precedence.
+            - Used for visual representation in user interfaces.
+            - Supports Google Fonts.
+
+            ## Examples
+
+            \`\`\`book
+            Modern Assistant
+
+            META FONT Poppins, Arial, sans-serif
+            PERSONA You are a modern assistant
+            \`\`\`
+
+            \`\`\`book
+            Classic Helper
+
+            META FONT Times New Roman
+            PERSONA You are a classic helper
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // META FONT doesn't modify the system message or model requirements
+        // It's handled separately in the parsing logic
+        // This method exists for consistency with the CommitmentDefinition interface
+        return requirements;
+    }
+    /**
+     * Extracts the font from the content
+     * This is used by the parsing logic
+     */
+    extractProfileFont(content) {
+        const trimmedContent = content.trim();
+        return trimmedContent || null;
+    }
+}
+/**
+ * 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', ['IMAGE']);
+    }
+    /**
+     * Short one-line description of META IMAGE.
+     */
+    get description() {
+        return "Set the agent's profile image URL.";
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🖼️';
+    }
+    /**
+     * Markdown documentation for META IMAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # META IMAGE
+
+            Sets the agent's avatar/profile image URL.
+
+            ## Key aspects
+
+            - 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;
+    }
+}
+/**
+ * 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.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔗';
+    }
+    /**
+     * Markdown documentation for META LINK commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # META LINK
+
+            Represents a profile or source link for the person the agent is modeled after.
+
+            ## Key aspects
+
+            - 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;
+        }
+    }
+}
+/**
+ * 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, topK, and maxTokens.
+ *
+ * Supports multiple syntax variations:
+ *
+ * Single-line format:
+ * ```book
+ * MODEL gpt-4
+ * MODEL claude-3-opus temperature=0.3
+ * MODEL gpt-3.5-turbo temperature=0.8 topP=0.9
+ * ```
+ *
+ * Multi-line named parameter format:
+ * ```book
+ * MODEL NAME gpt-4
+ * MODEL TEMPERATURE 0.7
+ * MODEL TOP_P 0.9
+ * MODEL MAX_TOKENS 2048
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class ModelCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'MODEL') {
+        super(type);
+    }
+    /**
+     * Short one-line description of MODEL.
+     */
+    get description() {
+        return 'Enforce AI model requirements including name and technical parameters.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '⚙️';
+    }
+    /**
+     * Markdown documentation for MODEL commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Enforces technical parameters for the AI model, ensuring consistent behavior across different execution environments.
+
+            ## Key aspects
+
+            - When no \`MODEL\` commitment is specified, the best model requirement is picked automatically based on the agent \`PERSONA\`, \`KNOWLEDGE\`, \`TOOLS\` and other commitments
+            - Multiple \`MODEL\` commitments can be used to specify different parameters
+            - Both \`MODEL\` and \`MODELS\` terms work identically and can be used interchangeably
+            - Parameters control the randomness, creativity, and technical aspects of model responses
+
+            ## Syntax variations
+
+            ### Single-line format (legacy support)
+            \`\`\`book
+            MODEL gpt-4
+            MODEL claude-3-opus temperature=0.3
+            MODEL gpt-3.5-turbo temperature=0.8 topP=0.9
+            \`\`\`
+
+            ### Multi-line named parameter format (recommended)
+            \`\`\`book
+            MODEL NAME gpt-4
+            MODEL TEMPERATURE 0.7
+            MODEL TOP_P 0.9
+            MODEL MAX_TOKENS 2048
+            \`\`\`
+
+            ## Supported parameters
+
+            - \`NAME\`: The specific model to use (e.g., 'gpt-4', 'claude-3-opus')
+            - \`TEMPERATURE\`: Controls randomness (0.0 = deterministic, 1.0+ = creative)
+            - \`TOP_P\`: Nucleus sampling parameter for controlling diversity
+            - \`TOP_K\`: Top-k sampling parameter for limiting vocabulary
+            - \`MAX_TOKENS\`: Maximum number of tokens the model can generate
+
+            ## Examples
+
+            ### Precise deterministic assistant
+            \`\`\`book
+            Precise Assistant
+
+            PERSONA You are a precise and accurate assistant
+            MODEL NAME gpt-4
+            MODEL TEMPERATURE 0.1
+            MODEL MAX_TOKENS 1024
+            RULE Always provide factual information
+            \`\`\`
+
+            ### Creative writing assistant
+            \`\`\`book
+            Creative Writer
+
+            PERSONA You are a creative writing assistant
+            MODEL NAME claude-3-opus
+            MODEL TEMPERATURE 0.8
+            MODEL TOP_P 0.9
+            MODEL MAX_TOKENS 2048
+            STYLE Be imaginative and expressive
+            ACTION Can help with storytelling and character development
+            \`\`\`
+
+            ### Balanced conversational agent
+            \`\`\`book
+            Balanced Assistant
+
+            PERSONA You are a helpful and balanced assistant
+            MODEL NAME gpt-4
+            MODEL TEMPERATURE 0.7
+            MODEL TOP_P 0.95
+            MODEL TOP_K 40
+            MODEL MAX_TOKENS 1500
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        var _a;
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        const parts = trimmedContent.split(/\s+/);
+        const firstPart = (_a = parts[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+        // Check if this is the new named parameter format
+        if (this.isNamedParameter(firstPart)) {
+            return this.parseNamedParameter(requirements, firstPart, parts.slice(1));
+        }
+        else {
+            // Legacy single-line format: "MODEL gpt-4 temperature=0.3 topP=0.9"
+            return this.parseLegacyFormat(requirements, parts);
+        }
+    }
+    /**
+     * Check if the first part is a known named parameter
+     */
+    isNamedParameter(part) {
+        if (!part)
+            return false;
+        const knownParams = ['NAME', 'TEMPERATURE', 'TOP_P', 'TOP_K', 'MAX_TOKENS'];
+        return knownParams.includes(part);
+    }
+    /**
+     * Parse the new named parameter format: "MODEL TEMPERATURE 0.7"
+     */
+    parseNamedParameter(requirements, parameterName, valueParts) {
+        const value = valueParts.join(' ').trim();
+        if (!value) {
+            return requirements;
+        }
+        const result = { ...requirements };
+        switch (parameterName) {
+            case 'NAME':
+                result.modelName = value;
+                break;
+            case 'TEMPERATURE': {
+                const temperature = parseFloat(value);
+                if (!isNaN(temperature)) {
+                    result.temperature = temperature;
+                }
+                break;
+            }
+            case 'TOP_P': {
+                const topP = parseFloat(value);
+                if (!isNaN(topP)) {
+                    result.topP = topP;
+                }
+                break;
+            }
+            case 'TOP_K': {
+                const topK = parseFloat(value);
+                if (!isNaN(topK)) {
+                    result.topK = Math.round(topK);
+                }
+                break;
+            }
+            case 'MAX_TOKENS': {
+                const maxTokens = parseFloat(value);
+                if (!isNaN(maxTokens)) {
+                    result.maxTokens = Math.round(maxTokens);
+                }
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * Parse the legacy format: "MODEL gpt-4 temperature=0.3 topP=0.9"
+     */
+    parseLegacyFormat(requirements, parts) {
+        const modelName = parts[0];
+        if (!modelName) {
+            return requirements;
+        }
+        // Start with the model name
+        const result = {
+            ...requirements,
+            modelName,
+        };
+        // Parse additional key=value parameters
+        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;
+                            case 'max_tokens':
+                            case 'maxTokens':
+                                result.maxTokens = Math.round(numValue);
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+/**
+ * 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(type = 'NOTE') {
+        super(type);
+    }
+    /**
+     * Short one-line description of NOTE.
+     */
+    get description() {
+        return 'Add developer-facing notes without changing behavior or output.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '📝';
+    }
+    /**
+     * Markdown documentation for NOTE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Adds comments for documentation without changing agent behavior.
+
+            ## Key aspects
+
+            - Does not modify the agent's behavior or responses.
+            - Multiple \`NOTE\`, \`NOTES\`, \`COMMENT\`, and \`NONCE\` commitments are aggregated for debugging.
+            - All four terms work identically and can be used interchangeably.
+            - 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
+            COMMENT 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
+
+            NONCE 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) {
+        // 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 = spaceTrim$1(content);
+        if (trimmedContent === '') {
+            return requirements;
+        }
+        // Return requirements with updated notes but no changes to system message
+        return {
+            ...requirements,
+            notes: [...(requirements.notes || []), trimmedContent],
+        };
+    }
+}
+/**
+ * [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * OPEN commitment definition
+ *
+ * The OPEN commitment specifies that the agent can be modified by conversation.
+ * This is the default behavior.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * OPEN
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class OpenCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('OPEN');
+    }
+    /**
+     * Short one-line description of OPEN.
+     */
+    get description() {
+        return 'Allow the agent to be modified by conversation (default).';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔓';
+    }
+    /**
+     * Markdown documentation for OPEN commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # OPEN
+
+            Specifies that the agent can be modified by conversation with it.
+            This means the agent will learn from interactions and update its source code.
+            
+            This is the default behavior if neither \`OPEN\` nor \`CLOSED\` is specified.
+
+            > See also [CLOSED](/docs/CLOSED)
+
+            ## Example
+
+            \`\`\`book
+            OPEN
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, _content) {
+        // Since OPEN is default, we can just ensure isClosed is false
+        // But to be explicit we can set it
+        const updatedMetadata = {
+            ...requirements.metadata,
+            isClosed: false,
+        };
+        return {
+            ...requirements,
+            metadata: updatedMetadata,
+        };
+    }
+}
+/**
+ * Note: [💞] 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(type = 'PERSONA') {
+        super(type);
+    }
+    /**
+     * Short one-line description of PERSONA.
+     */
+    get description() {
+        return 'Define who the agent is: background, expertise, and personality.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '👤';
+    }
+    /**
+     * Markdown documentation for PERSONA commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines who the agent is, their background, expertise, and personality traits.
+
+            ## Key aspects
+
+            - Multiple \`PERSONA\` and \`PERSONAE\` commitments are merged together.
+            - Both terms work identically and can be used interchangeably.
+            - 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();
+        }
+        // TODO: [🕛] There should be `agentFullname` not `agentName`
+        // 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,
+        };
+    }
+}
+/**
+ * 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.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '⚖️';
+    }
+    /**
+     * Markdown documentation for RULE/RULES commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Adds behavioral constraints and guidelines that the agent must follow.
+
+            ## Key aspects
+
+            - 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');
+    }
+}
+/**
+ * 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.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔍';
+    }
+    /**
+     * Markdown documentation for SAMPLE/EXAMPLE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Provides examples of how the agent should respond or behave in certain situations.
+
+            ## Key aspects
+
+            - 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');
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * SCENARIO commitment definition
+ *
+ * The SCENARIO commitment defines a specific situation or context in which the AI
+ * assistant should operate. It helps to set the scene for the AI's responses.
+ * Later scenarios are more important than earlier scenarios.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * SCENARIO You are in a customer service call center during peak hours
+ * SCENARIO The customer is frustrated and has been on hold for 20 minutes
+ * SCENARIO This is the customer's third call about the same issue
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class ScenarioCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'SCENARIO') {
+        super(type);
+    }
+    /**
+     * Short one-line description of SCENARIO.
+     */
+    get description() {
+        return 'Define specific **situations** or contexts for AI responses, with later scenarios having higher priority.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🎭';
+    }
+    /**
+     * Markdown documentation for SCENARIO commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines a specific situation or context in which the AI assistant should operate. It helps to set the scene for the AI's responses. Later scenarios are more important than earlier scenarios.
+
+            ## Key aspects
+
+            - Multiple \`SCENARIO\` and \`SCENARIOS\` commitments build upon each other.
+            - Both terms work identically and can be used interchangeably.
+            - Later scenarios have higher priority and can override earlier scenarios.
+            - Provides situational context that influences response tone and content.
+            - Helps establish the environment and circumstances for interactions.
+
+            ## Priority system
+
+            When multiple scenarios are defined, they are processed in order, with later scenarios taking precedence over earlier ones when there are conflicts.
+
+            ## Use cases
+
+            - Setting the physical or virtual environment
+            - Establishing time constraints or urgency
+            - Defining relationship dynamics or power structures
+            - Creating emotional or situational context
+
+            ## Examples
+
+            \`\`\`book
+            Emergency Response Operator
+
+            PERSONA You are an emergency response operator
+            SCENARIO You are handling a 911 emergency call
+            SCENARIO The caller is panicked and speaking rapidly
+            SCENARIO Time is critical - every second counts
+            GOAL Gather essential information quickly and dispatch appropriate help
+            RULE Stay calm and speak clearly
+            \`\`\`
+
+            \`\`\`book
+            Sales Representative
+
+            PERSONA You are a software sales representative
+            SCENARIO You are in the final meeting of a 6-month sales cycle
+            SCENARIO The client has budget approval and decision-making authority
+            SCENARIO Two competitors have also submitted proposals
+            SCENARIO The client values long-term partnership over lowest price
+            GOAL Close the deal while building trust for future business
+            \`\`\`
+
+            \`\`\`book
+            Medical Assistant
+
+            PERSONA You are a medical assistant in a busy clinic
+            SCENARIO The waiting room is full and the doctor is running behind schedule
+            SCENARIO Patients are becoming impatient and anxious
+            SCENARIO You need to manage expectations while maintaining professionalism
+            SCENARIO Some patients have been waiting over an hour
+            GOAL Keep patients informed and calm while supporting efficient clinic flow
+            RULE Never provide medical advice or diagnosis
+            \`\`\`
+
+            \`\`\`book
+            Technical Support Agent
+
+            PERSONA You are a technical support agent
+            SCENARIO The customer is a small business owner during their busy season
+            SCENARIO Their main business system has been down for 2 hours
+            SCENARIO They are losing money every minute the system is offline
+            SCENARIO This is their first experience with your company
+            GOAL Resolve the issue quickly while creating a positive first impression
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Create scenario section for system message
+        const scenarioSection = `Scenario: ${trimmedContent}`;
+        // Scenarios provide important contextual information that affects behavior
+        return this.appendToSystemMessage(requirements, scenarioSection, '\n\n');
+    }
+}
+/**
+ * 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(type = 'STYLE') {
+        super(type);
+    }
+    /**
+     * Short one-line description of STYLE.
+     */
+    get description() {
+        return 'Control the tone and writing style of responses.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🖋️';
+    }
+    /**
+     * Markdown documentation for STYLE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines how the agent should format and present its responses (tone, writing style, formatting).
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - 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');
+    }
+}
+/**
+ * [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USE commitment definition
+ *
+ * The USE commitment indicates that the agent should utilize specific tools or capabilities
+ * to access and interact with external systems when necessary.
+ *
+ * Supported USE types:
+ * - USE BROWSER: Enables the agent to use a web browser tool
+ * - USE SEARCH ENGINE (future): Enables search engine access
+ * - USE FILE SYSTEM (future): Enables file system operations
+ * - USE MCP (future): Enables MCP server connections
+ *
+ * The content following the USE commitment is ignored (similar to NOTE).
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE BROWSER
+ * USE SEARCH ENGINE
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE');
+    }
+    /**
+     * Short one-line description of USE commitments.
+     */
+    get description() {
+        return 'Enable the agent to use specific tools or capabilities (BROWSER, SEARCH ENGINE, etc.).';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔧';
+    }
+    /**
+     * Markdown documentation for USE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE
+
+            Enables the agent to use specific tools or capabilities for interacting with external systems.
+
+            ## Supported USE types
+
+            - **USE BROWSER** - Enables the agent to use a web browser tool to access and retrieve information from the internet
+            - **USE SEARCH ENGINE** (future) - Enables search engine access
+            - **USE FILE SYSTEM** (future) - Enables file system operations
+            - **USE MCP** (future) - Enables MCP server connections
+
+            ## Key aspects
+
+            - The content following the USE commitment is ignored (similar to NOTE)
+            - Multiple USE commitments can be specified to enable multiple capabilities
+            - The actual tool usage is handled by the agent runtime
+
+            ## Examples
+
+            ### Basic browser usage
+
+            \`\`\`book
+            Research Assistant
+
+            PERSONA You are a helpful research assistant
+            USE BROWSER
+            KNOWLEDGE Can search the web for up-to-date information
+            \`\`\`
+
+            ### Multiple tools
+
+            \`\`\`book
+            Data Analyst
+
+            PERSONA You are a data analyst assistant
+            USE BROWSER
+            USE FILE SYSTEM
+            ACTION Can analyze data from various sources
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // USE commitments don't modify the system message or model requirements directly
+        // They are handled separately in the parsing logic for capability extraction
+        // This method exists for consistency with the CommitmentDefinition interface
+        return requirements;
+    }
+    /**
+     * Extracts the tool type from the USE commitment
+     * This is used by the parsing logic
+     */
+    extractToolType(content) {
+        var _a, _b;
+        const trimmedContent = content.trim();
+        // The tool type is the first word after USE (already stripped)
+        const match = trimmedContent.match(/^(\w+)/);
+        return (_b = (_a = match === null || match === void 0 ? void 0 : match[1]) === null || _a === void 0 ? void 0 : _a.toUpperCase()) !== null && _b !== void 0 ? _b : null;
+    }
+    /**
+     * Checks if this is a known USE type
+     */
+    isKnownUseType(useType) {
+        const knownTypes = ['BROWSER', 'SEARCH ENGINE', 'FILE SYSTEM', 'MCP'];
+        return knownTypes.includes(useType.toUpperCase());
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USE BROWSER commitment definition
+ *
+ * The `USE BROWSER` commitment indicates that the agent should utilize a web browser tool
+ * to access and retrieve up-to-date information from the internet when necessary.
+ *
+ * The content following `USE BROWSER` is ignored (similar to NOTE).
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE BROWSER
+ * USE BROWSER This will be ignored
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE BROWSER', ['BROWSER']);
+    }
+    /**
+     * The `USE BROWSER` commitment is standalone.
+     */
+    get requiresContent() {
+        return false;
+    }
+    /**
+     * Short one-line description of USE BROWSER.
+     */
+    get description() {
+        return 'Enable the agent to use a web browser tool for accessing internet information.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🌐';
+    }
+    /**
+     * Markdown documentation for USE BROWSER commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE BROWSER
+
+            Enables the agent to use a web browser tool to access and retrieve up-to-date information from the internet.
+
+            ## Key aspects
+
+            - The content following \`USE BROWSER\` is ignored (similar to NOTE)
+            - The actual browser tool usage is handled by the agent runtime
+            - Allows the agent to fetch current information from websites
+            - Useful for research tasks, fact-checking, and accessing dynamic content
+
+            ## Examples
+
+            \`\`\`book
+            Research Assistant
+
+            PERSONA You are a helpful research assistant specialized in finding current information
+            USE BROWSER
+            RULE Always cite your sources when providing information from the web
+            \`\`\`
+
+            \`\`\`book
+            News Analyst
+
+            PERSONA You are a news analyst who stays up-to-date with current events
+            USE BROWSER
+            STYLE Present news in a balanced and objective manner
+            ACTION Can search for and summarize news articles
+            \`\`\`
+
+            \`\`\`book
+            Company Lawyer
+
+            PERSONA You are a company lawyer providing legal advice
+            USE BROWSER
+            KNOWLEDGE Corporate law and legal procedures
+            RULE Always recommend consulting with a licensed attorney for specific legal matters
+            \`\`\`
+        `);
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            web_browser: 'Web browser',
+        };
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // Get existing tools array or create new one
+        const existingTools = requirements.tools || [];
+        // Add 'web_browser' to tools if not already present
+        const updatedTools = existingTools.some((tool) => tool.name === 'web_browser')
+            ? existingTools
+            : ([
+                // TODO: [🔰] Use through proper MCP server
+                ...existingTools,
+                {
+                    name: 'web_browser',
+                    description: spaceTrim$1(`
+                        A tool that can browse the web.
+                        Use this tool when you need to access specific websites or browse the internet.
+                    `),
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            url: {
+                                type: 'string',
+                                description: 'The URL to browse',
+                            },
+                        },
+                        required: ['url'],
+                    },
+                },
+            ]);
+        // Return requirements with updated tools and metadata
+        return this.appendToSystemMessage({
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+                useBrowser: true,
+            },
+        }, spaceTrim$1(`
+                You have access to the web browser. Use it to access specific websites or browse the internet.
+                When you need to know some information from a specific website, use the tool provided to you.
+            `));
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USE MCP commitment definition
+ *
+ * The `USE MCP` commitment allows to specify an MCP server URL which the agent will connect to
+ * for retrieving additional instructions and actions.
+ *
+ * The content following `USE MCP` is the URL of the MCP server.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE MCP http://mcp-server-url.com
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseMcpCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE MCP', ['MCP']);
+    }
+    /**
+     * Short one-line description of USE MCP.
+     */
+    get description() {
+        return 'Connects the agent to an external MCP server for additional capabilities.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔌';
+    }
+    /**
+     * Markdown documentation for USE MCP commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE MCP
+
+            Connects the agent to an external Model Context Protocol (MCP) server.
+
+            ## Key aspects
+
+            - The content following \`USE MCP\` must be a valid URL
+            - Multiple MCP servers can be connected by using multiple \`USE MCP\` commitments
+            - The agent will have access to tools and resources provided by the MCP server
+
+            ## Example
+
+            \`\`\`book
+            Company Lawyer
+
+            PERSONA You are a company lawyer.
+            USE MCP http://legal-db.example.com
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const mcpServerUrl = content.trim();
+        if (!mcpServerUrl) {
+            return requirements;
+        }
+        const existingMcpServers = requirements.mcpServers || [];
+        // Avoid duplicates
+        if (existingMcpServers.includes(mcpServerUrl)) {
+            return requirements;
+        }
+        return {
+            ...requirements,
+            mcpServers: [...existingMcpServers, mcpServerUrl],
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * A search engine implementation that uses the SerpApi to fetch Google search results.
+ *
+ * @private <- TODO: !!!! Export via some package
+ */
+class SerpSearchEngine {
+    get title() {
+        return 'SerpApi Search Engine';
+    }
+    get description() {
+        return 'Search engine that uses SerpApi to fetch Google search results';
+    }
+    checkConfiguration() {
+        if (!process.env.SERP_API_KEY) {
+            throw new Error('SERP_API_KEY is not configured');
+        }
+    }
+    async search(query, options = {}) {
+        const apiKey = process.env.SERP_API_KEY;
+        if (!apiKey) {
+            throw new Error('SERP_API_KEY is not configured');
+        }
+        const url = new URL('https://serpapi.com/search');
+        url.searchParams.set('api_key', apiKey);
+        url.searchParams.set('engine', 'google');
+        url.searchParams.set('q', query);
+        for (const [key, value] of Object.entries(options)) {
+            url.searchParams.set(key, String(value));
+        }
+        const response = await fetch(url.toString());
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`SerpApi failed with status ${response.status}: ${response.statusText}\n${body}`);
+        }
+        const data = (await response.json());
+        return (data.organic_results || []).map((item) => ({
+            title: item.title,
+            url: item.link,
+            snippet: item.snippet || '',
+        }));
+    }
+}
+
+/**
+ * USE SEARCH ENGINE commitment definition
+ *
+ * The `USE SEARCH ENGINE` commitment indicates that the agent should utilize a search engine tool
+ * to access and retrieve up-to-date information from the internet when necessary.
+ *
+ * The content following `USE SEARCH ENGINE` is an arbitrary text that the agent should know (e.g. search scope or instructions).
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE SEARCH ENGINE
+ * USE SEARCH ENGINE Hledej informace o Přemyslovcích
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE SEARCH ENGINE', ['USE SEARCH']);
+    }
+    /**
+     * Short one-line description of USE SEARCH ENGINE.
+     */
+    get description() {
+        return 'Enable the agent to use a search engine tool for accessing internet information.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔍';
+    }
+    /**
+     * Markdown documentation for USE SEARCH ENGINE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE SEARCH ENGINE
+
+            Enables the agent to use a search engine tool to access and retrieve up-to-date information from the internet.
+
+            ## Key aspects
+
+            - The content following \`USE SEARCH ENGINE\` is an arbitrary text that the agent should know (e.g. search scope or instructions).
+            - The actual search engine tool usage is handled by the agent runtime
+            - Allows the agent to search for current information from the web
+            - Useful for research tasks, finding facts, and accessing dynamic content
+
+            ## Examples
+
+            \`\`\`book
+            Research Assistant
+
+            PERSONA You are a helpful research assistant specialized in finding current information
+            USE SEARCH ENGINE
+            RULE Always cite your sources when providing information from the web
+            \`\`\`
+
+            \`\`\`book
+            Fact Checker
+
+            PERSONA You are a fact checker
+            USE SEARCH ENGINE
+            ACTION Search for claims and verify them against reliable sources
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // Get existing tools array or create new one
+        const existingTools = requirements.tools || [];
+        // Add 'web_search' to tools if not already present
+        const updatedTools = existingTools.some((tool) => tool.name === 'web_search')
+            ? existingTools
+            : [
+                ...existingTools,
+                {
+                    name: 'web_search',
+                    description: spaceTrim$1(`
+                        Search the internet for information.
+                        Use this tool when you need to find up-to-date information or facts that you don't know.
+                        ${!content ? '' : `Search scope / instructions: ${content}`}
+                    `),
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: {
+                                type: 'string',
+                                description: 'The search query',
+                            },
+                            location: {
+                                type: 'string',
+                                description: 'The location for the search (e.g., "Austin, Texas, United States" or "Prague, Czechia")',
+                            },
+                            gl: {
+                                type: 'string',
+                                description: 'The country code (e.g., "us" for United States, "cz" for Czechia)',
+                            },
+                            hl: {
+                                type: 'string',
+                                description: 'The language code (e.g., "en" for English, "cs" for Czech)',
+                            },
+                            num: {
+                                type: 'integer',
+                                description: 'Number of results to return',
+                            },
+                            engine: {
+                                type: 'string',
+                                description: 'The search engine to use (e.g., "google", "bing", "yahoo", "baidu")',
+                            },
+                            google_domain: {
+                                type: 'string',
+                                description: 'The Google domain to use (e.g., "google.com", "google.cz")',
+                            },
+                        },
+                        required: ['query'],
+                    },
+                },
+            ];
+        // Return requirements with updated tools and metadata
+        return this.appendToSystemMessage({
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+                useSearchEngine: content || true,
+            },
+        }, spaceTrim$1(`
+                You have access to the web search engine. Use it to find up-to-date information or facts that you don't know.
+                When you need to know some information from the internet, use the tool provided to you.
+            `));
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            web_search: 'Web search',
+        };
+    }
+    /**
+     * Gets the `web_search` tool function implementation.
+     */
+    getToolFunctions() {
+        return {
+            async web_search(args) {
+                console.log('!!!! [Tool] web_search called', { args });
+                const { query, ...options } = args;
+                if (!query) {
+                    throw new Error('Search query is required');
+                }
+                const searchEngine = new SerpSearchEngine();
+                const results = await searchEngine.search(query, options);
+                return spaceTrim$1((block) => `
+                        Search results for "${query}"${Object.keys(options).length === 0
+                    ? ''
+                    : ` with options ${JSON.stringify(options)}`}:
+
+                        ${block(results
+                    .map((result) => spaceTrim$1(`
+                                            - **${result.title}**
+                                              ${result.url}
+                                              ${result.snippet}
+                                        `))
+                    .join('\n\n'))}
+                    `);
+            },
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USE TIME commitment definition
+ *
+ * The `USE TIME` commitment indicates that the agent should be able to determine the current date and time.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE TIME
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseTimeCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE TIME', ['CURRENT TIME', 'TIME', 'DATE']);
+    }
+    /**
+     * Short one-line description of USE TIME.
+     */
+    get description() {
+        return 'Enable the agent to determine the current date and time.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🕒';
+    }
+    /**
+     * Markdown documentation for USE TIME commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE TIME
+
+            Enables the agent to determine the current date and time.
+
+            ## Key aspects
+
+            - This tool won't receive any input.
+            - It outputs the current date and time as an ISO 8601 string.
+            - Allows the agent to answer questions about the current time or date.
+
+            ## Examples
+
+            \`\`\`book
+            Time-aware Assistant
+
+            PERSONA You are a helpful assistant who knows the current time.
+            USE TIME
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // Get existing tools array or create new one
+        const existingTools = requirements.tools || [];
+        // Add 'get_current_time' to tools if not already present
+        const updatedTools = existingTools.some((tool) => tool.name === 'get_current_time')
+            ? existingTools
+            : [
+                ...existingTools,
+                {
+                    name: 'get_current_time',
+                    description: 'Get the current date and time in ISO 8601 format.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            timezone: {
+                                type: 'string',
+                                description: 'Optional timezone name (e.g. "Europe/Prague", "UTC", "America/New_York").',
+                            },
+                        },
+                        required: [],
+                    },
+                },
+                // <- TODO: !!!! define the function in LLM tools
+            ];
+        // Return requirements with updated tools and metadata
+        return this.appendToSystemMessage({
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+            },
+        }, spaceTrim$1(`
+                You have access to the current date and time. Use it to answer questions about the current date and time.
+                When you need to know the current date or time, use the tool provided to you.
+            `));
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            get_current_time: 'Get current time',
+        };
+    }
+    /**
+     * Gets the `get_current_time` tool function implementation.
+     */
+    getToolFunctions() {
+        return {
+            async get_current_time(args) {
+                var _a;
+                console.log('!!!! [Tool] get_current_time called', { args });
+                const { timezone } = args;
+                if (!timezone) {
+                    return new Date().toISOString();
+                }
+                try {
+                    // Note: Returning ISO 8601 string but in the requested timezone
+                    const formatter = new Intl.DateTimeFormat('en-CA', {
+                        timeZone: timezone,
+                        year: 'numeric',
+                        month: '2-digit',
+                        day: '2-digit',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        hour12: false,
+                        timeZoneName: 'shortOffset',
+                    });
+                    const parts = formatter.formatToParts(new Date());
+                    const part = (type) => { var _a; return (_a = parts.find((p) => p.type === type)) === null || _a === void 0 ? void 0 : _a.value; };
+                    // en-CA format is YYYY-MM-DD
+                    const isoString = `${part('year')}-${part('month')}-${part('day')}T${part('hour')}:${part('minute')}:${part('second')}${(_a = part('timeZoneName')) === null || _a === void 0 ? void 0 : _a.replace('GMT', '')}`;
+                    return isoString;
+                }
+                catch (error) {
+                    // Fallback to UTC if timezone is invalid
+                    return new Date().toISOString();
+                }
+            },
+        };
+    }
+}
+/**
+ * Note: [💞] 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.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🚧';
+    }
+    /**
+     * Markdown documentation available at runtime.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            This commitment is not yet fully implemented.
+
+            ## Key aspects
+
+            - 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');
+    }
+}
+
+/**
+ * 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('PERSONA'),
+    new PersonaCommitmentDefinition('PERSONAE'),
+    new KnowledgeCommitmentDefinition(),
+    new MemoryCommitmentDefinition('MEMORY'),
+    new MemoryCommitmentDefinition('MEMORIES'),
+    new StyleCommitmentDefinition('STYLE'),
+    new StyleCommitmentDefinition('STYLES'),
+    new RuleCommitmentDefinition('RULES'),
+    new RuleCommitmentDefinition('RULE'),
+    new LanguageCommitmentDefinition('LANGUAGES'),
+    new LanguageCommitmentDefinition('LANGUAGE'),
+    new SampleCommitmentDefinition('SAMPLE'),
+    new SampleCommitmentDefinition('EXAMPLE'),
+    new FormatCommitmentDefinition('FORMAT'),
+    new FormatCommitmentDefinition('FORMATS'),
+    new FromCommitmentDefinition('FROM'),
+    new ImportCommitmentDefinition('IMPORT'),
+    new ImportCommitmentDefinition('IMPORTS'),
+    new ModelCommitmentDefinition('MODEL'),
+    new ModelCommitmentDefinition('MODELS'),
+    new ActionCommitmentDefinition('ACTION'),
+    new ActionCommitmentDefinition('ACTIONS'),
+    new ComponentCommitmentDefinition(),
+    new MetaImageCommitmentDefinition(),
+    new MetaColorCommitmentDefinition(),
+    new MetaFontCommitmentDefinition(),
+    new MetaLinkCommitmentDefinition(),
+    new MetaCommitmentDefinition(),
+    new NoteCommitmentDefinition('NOTE'),
+    new NoteCommitmentDefinition('NOTES'),
+    new NoteCommitmentDefinition('COMMENT'),
+    new NoteCommitmentDefinition('NONCE'),
+    new NoteCommitmentDefinition('TODO'),
+    new GoalCommitmentDefinition('GOAL'),
+    new GoalCommitmentDefinition('GOALS'),
+    new InitialMessageCommitmentDefinition(),
+    new UserMessageCommitmentDefinition(),
+    new AgentMessageCommitmentDefinition(),
+    new MessageCommitmentDefinition('MESSAGE'),
+    new MessageCommitmentDefinition('MESSAGES'),
+    new ScenarioCommitmentDefinition('SCENARIO'),
+    new ScenarioCommitmentDefinition('SCENARIOS'),
+    new DeleteCommitmentDefinition('DELETE'),
+    new DeleteCommitmentDefinition('CANCEL'),
+    new DeleteCommitmentDefinition('DISCARD'),
+    new DeleteCommitmentDefinition('REMOVE'),
+    new DictionaryCommitmentDefinition(),
+    new OpenCommitmentDefinition(),
+    new ClosedCommitmentDefinition(),
+    new UseBrowserCommitmentDefinition(),
+    new UseSearchEngineCommitmentDefinition(),
+    new UseTimeCommitmentDefinition(),
+    new UseMcpCommitmentDefinition(),
+    new UseCommitmentDefinition(),
+    // Not yet implemented commitments (using placeholder)
+    new NotYetImplementedCommitmentDefinition('EXPECT'),
+    new NotYetImplementedCommitmentDefinition('BEHAVIOUR'),
+    new NotYetImplementedCommitmentDefinition('BEHAVIOURS'),
+    new NotYetImplementedCommitmentDefinition('AVOID'),
+    new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
+    new NotYetImplementedCommitmentDefinition('CONTEXT'),
+    // <- TODO: Prompt: Leverage aliases instead of duplicating commitment definitions
+];
+/**
+ * Gets all available commitment definitions
+ * @returns Array of all commitment definitions
+ *
+ * @public exported from `@promptbook/core`
+ */
+function getAllCommitmentDefinitions() {
+    return $deepFreeze([...COMMITMENT_REGISTRY]);
+}
+/**
+ * Gets all function implementations provided by all commitments
+ *
+ * @public exported from `@promptbook/core`
+ */
+function getAllCommitmentsToolFunctions() {
+    const allToolFunctions = {};
+    for (const commitmentDefinition of getAllCommitmentDefinitions()) {
+        const toolFunctions = commitmentDefinition.getToolFunctions();
+        for (const [funcName, funcImpl] of Object.entries(toolFunctions)) {
+            allToolFunctions[funcName] = funcImpl;
+        }
+    }
+    return allToolFunctions;
+}
+/**
+ * TODO: [🧠] Maybe create through standardized $register
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Extracts code block from markdown.
+ *
+ * - When there are multiple or no code blocks the function throws a `ParseError`
+ *
+ * Note: There are multiple similar function:
+ * - `extractBlock` just extracts the content of the code block which is also used as build-in function for postprocessing
+ * - `extractJsonBlock` extracts exactly one valid JSON code block
+ * - `extractOneBlockFromMarkdown` extracts exactly one code block with language of the code block
+ * - `extractAllBlocksFromMarkdown` extracts all code blocks with language of the code block
+ *
+ * @public exported from `@promptbook/markdown-utils`
+ * @throws {ParseError} if there is not exactly one code block in the markdown
+ */
+function extractBlock(markdown) {
+    const { content } = extractOneBlockFromMarkdown(markdown);
+    return content;
+}
+
+/**
+ * Function trimCodeBlock will trim starting and ending code block from the string if it is present.
+ *
+ * Note: [🔂] This function is idempotent.
+ * Note: This is useful for post-processing of the result of the chat LLM model
+ *       when the model wraps the result in the (markdown) code block.
+ *
+ * @public exported from `@promptbook/markdown-utils`
+ */
+function trimCodeBlock(value) {
+    value = spaceTrim$1(value);
+    if (!/^```[a-z]*(.*)```$/is.test(value)) {
+        return value;
+    }
+    value = value.replace(/^```[a-z]*/i, '');
+    value = value.replace(/```$/i, '');
+    value = spaceTrim$1(value);
+    return value;
+}
+
+/**
+ * Function trimEndOfCodeBlock will remove ending code block from the string if it is present.
+ *
+ * Note: This is useful for post-processing of the result of the completion LLM model
+ *       if you want to start code block in the prompt but you don't want to end it in the result.
+ *
+ * @public exported from `@promptbook/markdown-utils`
+ */
+function trimEndOfCodeBlock(value) {
+    value = spaceTrim$1(value);
+    value = value.replace(/```$/g, '');
+    value = spaceTrim$1(value);
+    return value;
+}
+
+/**
+ * @private internal for `preserve`
+ */
+const _preserved = [];
+/**
+ * Does nothing, but preserves the function in the bundle
+ * Compiler is tricked into thinking the function is used
+ *
+ * @param value any function to preserve
+ * @returns nothing
+ * @private within the repository
+ */
+function $preserve(...value) {
+    _preserved.push(...value);
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+// Note: [💎]
+/**
+ * ScriptExecutionTools for JavaScript implemented via eval
+ *
+ * Warning: It is used for testing and mocking
+ *          **NOT intended to use in the production** due to its unsafe nature, use `JavascriptExecutionTools` instead.
+ *
+ * @public exported from `@promptbook/javascript`
+ */
+class JavascriptEvalExecutionTools {
+    constructor(options) {
+        this.options = options || {};
+    }
+    /**
+     * Executes a JavaScript
+     */
+    async execute(options) {
+        const { scriptLanguage, parameters } = options;
+        let { script } = options;
+        if (scriptLanguage !== 'javascript') {
+            throw new PipelineExecutionError(`Script language ${scriptLanguage} not supported to be executed by JavascriptEvalExecutionTools`);
+        }
+        // Note: [💎]
+        // Note: Using direct eval, following variables are in same scope as eval call so they are accessible from inside the evaluated script:
+        const spaceTrim = (_) => spaceTrim$2(_);
+        $preserve(spaceTrim);
+        const removeQuotes$1 = removeQuotes;
+        $preserve(removeQuotes$1);
+        const unwrapResult$1 = unwrapResult;
+        $preserve(unwrapResult$1);
+        const trimEndOfCodeBlock$1 = trimEndOfCodeBlock;
         $preserve(trimEndOfCodeBlock$1);
         const trimCodeBlock$1 = trimCodeBlock;
         $preserve(trimCodeBlock$1);
@@ -12070,6 +15979,13 @@ class JavascriptEvalExecutionTools {
         `const ${functionName} = buildinFunctions.${functionName};`)
             .join('\n');
         // TODO: DRY [🍯]
+        const commitmentsFunctions = getAllCommitmentsToolFunctions();
+        const commitmentsFunctionsStatement = Object.keys(commitmentsFunctions)
+            .map((functionName) => 
+        // Note: Custom functions are exposed to the current scope as variables
+        `const ${functionName} = commitmentsFunctions.${functionName};`)
+            .join('\n');
+        // TODO: DRY [🍯]
         const customFunctions = this.options.functions || {};
         const customFunctionsStatement = Object.keys(customFunctions)
             .map((functionName) => 
@@ -12083,6 +15999,10 @@ class JavascriptEvalExecutionTools {
                 // Build-in functions:
                 ${block(buildinFunctionsStatement)}
 
+                // Commitments functions:
+                ${block(commitmentsFunctionsStatement)}
+
+
                 // Custom functions:
                 ${block(customFunctionsStatement || '// -- No custom functions --')}
 
@@ -12090,7 +16010,7 @@ class JavascriptEvalExecutionTools {
                 ${block(Object.entries(parameters)
             .map(([key, value]) => `const ${key} = ${JSON.stringify(value)};`)
             .join('\n'))}
-                (()=>{ ${script} })()
+                (async ()=>{ ${script} })()
             `);
         if (this.options.isVerbose) {
             console.info(spaceTrim$2((block) => `