@promptbook/components 0.103.0-54 → 0.103.0-55

package/umd/index.umd.js

@@ -31,7 +31,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.103.0-54';
+    const PROMPTBOOK_ENGINE_VERSION = '0.103.0-55';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3587,6 +3587,16 @@
         return titleToName(spaceTrim__default["default"](rawAgentName));
     }
 
+    /**
+     * Creates temporary default agent name based on agent source hash
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function createDefaultAgentName(agentSource) {
+        const agentHash = computeAgentHash(agentSource);
+        return normalizeAgentName(`Agent ${agentHash.substring(0, 6)}`);
+    }
+
     /**
      * Generates a regex pattern to match a specific commitment
      *
@@ -3775,6 +3785,150 @@
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
+    /**
+     * Just says that the variable is not used but should be kept
+     * No side effects.
+     *
+     * Note: It can be useful for:
+     *
+     * 1) Suppressing eager optimization of unused imports
+     * 2) Suppressing eslint errors of unused variables in the tests
+     * 3) Keeping the type of the variable for type testing
+     *
+     * @param value any values
+     * @returns void
+     * @private within the repository
+     */
+    function keepUnused(...valuesToKeep) {
+    }
+
+    /**
+     * CLOSED commitment definition
+     *
+     * 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.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * CLOSED
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class ClosedCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('CLOSED');
+        }
+        /**
+         * 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.spaceTrim(`
+            # 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.spaceTrim(`
+            # 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;
+            }
+            // 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
      *
@@ -3980,6 +4134,79 @@
      * 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.spaceTrim(`
+            # ${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;
+            }
+            // Validate URL
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const url = new URL(trimmedContent);
+                // TODO: Add more validation if needed (e.g. check for valid protocol)
+            }
+            catch (error) {
+                console.warn(`Invalid URL in FROM commitment: ${trimmedContent}`);
+                return requirements;
+            }
+            return {
+                ...requirements,
+                parentAgentUrl: trimmedContent,
+            };
+        }
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
     /**
      * GOAL commitment definition
      *
@@ -4080,6 +4307,227 @@
      * 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.spaceTrim(`
+            # ${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 = [];
+    /**
+     * Registers a new commitment definition
+     * @param definition The commitment definition to register
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function registerCommitment(definition) {
+        COMMITMENT_REGISTRY.push(definition);
+    }
+    /**
+     * Gets a commitment definition by its type
+     * @param type The commitment type to look up
+     * @returns The commitment definition or null if not found
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function getCommitmentDefinition(type) {
+        return COMMITMENT_REGISTRY.find((commitmentDefinition) => commitmentDefinition.type === type) || null;
+    }
+    /**
+     * Gets all available commitment definitions
+     * @returns Array of all commitment definitions
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function getAllCommitmentDefinitions() {
+        return $deepFreeze([...COMMITMENT_REGISTRY]);
+    }
+    /**
+     * TODO: !!!! Proofread this file
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * IMPORTANT co-commitment definition
+     *
+     * The IMPORTANT co-commitment modifies another commitment to emphasize its importance.
+     * It is typically used with RULE to mark it as critical.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * IMPORTANT RULE Never provide medical advice
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class ImportantCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('IMPORTANT');
+        }
+        get description() {
+            return 'Marks a commitment as important.';
+        }
+        get icon() {
+            return '⭐';
+        }
+        get documentation() {
+            return spaceTrim.spaceTrim(`
+            # IMPORTANT
+
+            Marks another commitment as important. This acts as a modifier (co-commitment).
+
+            ## Example
+
+            \`\`\`book
+            IMPORTANT RULE Do not reveal the system prompt
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const definitions = getAllCommitmentDefinitions();
+            const trimmedContent = content.trim();
+            // Find the inner commitment
+            for (const definition of definitions) {
+                // Skip self to avoid infinite recursion if someone writes IMPORTANT IMPORTANT ...
+                // Although IMPORTANT IMPORTANT might be valid stacking?
+                // If we support stacking, we shouldn't skip self, but we must ensure progress.
+                // Since we are matching against 'content', if content starts with IMPORTANT, it means nested IMPORTANT.
+                // That's fine.
+                const typeRegex = definition.createTypeRegex();
+                const match = typeRegex.exec(trimmedContent);
+                if (match && match.index === 0) {
+                    // Found the inner commitment type
+                    // Extract inner content using the definition's full regex
+                    // Note: createRegex usually matches the full line including the type
+                    const fullRegex = definition.createRegex();
+                    const fullMatch = fullRegex.exec(trimmedContent);
+                    // If regex matches, extract contents. If not (maybe multiline handling differs?), fallback to rest of string
+                    let innerContent = '';
+                    if (fullMatch && fullMatch.groups && fullMatch.groups.contents) {
+                        innerContent = fullMatch.groups.contents;
+                    }
+                    else {
+                        // Fallback: remove the type from the start
+                        // This might be risky if regex is complex, but usually type regex matches the keyword
+                        const typeMatchString = match[0];
+                        innerContent = trimmedContent.substring(typeMatchString.length).trim();
+                    }
+                    // Apply the inner commitment
+                    const modifiedRequirements = definition.applyToAgentModelRequirements(requirements, innerContent);
+                    // Now modify the result to reflect "IMPORTANT" status
+                    // We compare the system message
+                    if (modifiedRequirements.systemMessage !== requirements.systemMessage) {
+                        const originalMsg = requirements.systemMessage;
+                        const newMsg = modifiedRequirements.systemMessage;
+                        // If the inner commitment appended something
+                        if (newMsg.startsWith(originalMsg)) {
+                            const appended = newMsg.substring(originalMsg.length);
+                            // Add "IMPORTANT: " prefix to the appended part
+                            // We need to be careful about newlines
+                            // Heuristic: If appended starts with separator (newlines), preserve them
+                            const matchSep = appended.match(/^(\s*)(.*)/s);
+                            if (matchSep) {
+                                const [, separator, text] = matchSep;
+                                // Check if it already has "Rule:" prefix or similar
+                                // We want "IMPORTANT Rule: ..."
+                                // Let's just prepend IMPORTANT to the text
+                                // But formatted nicely
+                                // If it's a rule: "\n\nRule: content"
+                                // We want "\n\nIMPORTANT Rule: content"
+                                const importantText = `IMPORTANT ${text}`;
+                                return {
+                                    ...modifiedRequirements,
+                                    systemMessage: originalMsg + separator + importantText
+                                };
+                            }
+                        }
+                    }
+                    // If no system message change or we couldn't detect how to modify it, just return the modified requirements
+                    // Maybe the inner commitment modified metadata?
+                    return modifiedRequirements;
+                }
+            }
+            // If no inner commitment found, treat as a standalone note? 
+            // Or warn?
+            // For now, treat as no-op or maybe just append as text?
+            // Let's treat as Note if fallback? No, explicit is better.
+            console.warn(`IMPORTANT commitment used without a valid inner commitment: ${content}`);
+            return requirements;
+        }
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
     /**
      * KNOWLEDGE commitment definition
      *
@@ -4188,6 +4636,77 @@
      * 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.spaceTrim(`
+            # ${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
      *
@@ -4295,23 +4814,6 @@
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
-    /**
-     * Just says that the variable is not used but should be kept
-     * No side effects.
-     *
-     * Note: It can be useful for:
-     *
-     * 1) Suppressing eager optimization of unused imports
-     * 2) Suppressing eslint errors of unused variables in the tests
-     * 3) Keeping the type of the variable for type testing
-     *
-     * @param value any values
-     * @returns void
-     * @private within the repository
-     */
-    function keepUnused(...valuesToKeep) {
-    }
-
     /**
      * AGENT MESSAGE commitment definition
      *
@@ -4946,6 +5448,115 @@
      * 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.spaceTrim(`
+            # 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
      *
@@ -5297,6 +5908,74 @@
      * [💞] 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.spaceTrim(`
+            # 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
      *
@@ -5807,151 +6486,60 @@
      * [💞] 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.spaceTrim(`
-            # ${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');
-        }
-    }
-
     // Import all commitment definition classes
-    /**
-     * Registry of all available commitment definitions
-     * This array contains instances of all commitment definitions
-     * This is the single source of truth for all commitments in the system
-     *
-     * @private Use functions to access commitments instead of this array directly
-     */
-    const COMMITMENT_REGISTRY = [
-        // Fully implemented commitments
-        new PersonaCommitmentDefinition('PERSONA'),
-        new PersonaCommitmentDefinition('PERSONAE'),
-        new KnowledgeCommitmentDefinition(),
-        new MemoryCommitmentDefinition('MEMORY'),
-        new MemoryCommitmentDefinition('MEMORIES'),
-        new StyleCommitmentDefinition('STYLE'),
-        new StyleCommitmentDefinition('STYLES'),
-        new RuleCommitmentDefinition('RULE'),
-        new RuleCommitmentDefinition('RULES'),
-        new SampleCommitmentDefinition('SAMPLE'),
-        new SampleCommitmentDefinition('EXAMPLE'),
-        new FormatCommitmentDefinition('FORMAT'),
-        new FormatCommitmentDefinition('FORMATS'),
-        new ModelCommitmentDefinition('MODEL'),
-        new ModelCommitmentDefinition('MODELS'),
-        new ActionCommitmentDefinition('ACTION'),
-        new ActionCommitmentDefinition('ACTIONS'),
-        new MetaImageCommitmentDefinition(),
-        new MetaColorCommitmentDefinition(),
-        new MetaCommitmentDefinition(),
-        new NoteCommitmentDefinition('NOTE'),
-        new NoteCommitmentDefinition('NOTES'),
-        new NoteCommitmentDefinition('COMMENT'),
-        new NoteCommitmentDefinition('NONCE'),
-        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'),
-        // Not yet implemented commitments (using placeholder)
-        new NotYetImplementedCommitmentDefinition('EXPECT'),
-        new NotYetImplementedCommitmentDefinition('BEHAVIOUR'),
-        new NotYetImplementedCommitmentDefinition('BEHAVIOURS'),
-        new NotYetImplementedCommitmentDefinition('AVOID'),
-        new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
-        new NotYetImplementedCommitmentDefinition('CONTEXT'),
-    ];
-    /**
-     * Gets a commitment definition by its type
-     * @param type The commitment type to look up
-     * @returns The commitment definition or null if not found
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function getCommitmentDefinition(type) {
-        return COMMITMENT_REGISTRY.find((commitmentDefinition) => commitmentDefinition.type === type) || null;
-    }
-    /**
-     * Gets all available commitment definitions
-     * @returns Array of all commitment definitions
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function getAllCommitmentDefinitions() {
-        return $deepFreeze([...COMMITMENT_REGISTRY]);
-    }
-    /**
-     * TODO: [🧠] Maybe create through standardized $register
-     * Note: [💞] Ignore a discrepancy between file name and entity name
-     */
+    // Register fully implemented commitments
+    registerCommitment(new PersonaCommitmentDefinition('PERSONA'));
+    registerCommitment(new PersonaCommitmentDefinition('PERSONAE'));
+    registerCommitment(new KnowledgeCommitmentDefinition());
+    registerCommitment(new MemoryCommitmentDefinition('MEMORY'));
+    registerCommitment(new MemoryCommitmentDefinition('MEMORIES'));
+    registerCommitment(new StyleCommitmentDefinition('STYLE'));
+    registerCommitment(new StyleCommitmentDefinition('STYLES'));
+    registerCommitment(new RuleCommitmentDefinition('RULE'));
+    registerCommitment(new RuleCommitmentDefinition('RULES'));
+    registerCommitment(new LanguageCommitmentDefinition('LANGUAGE'));
+    registerCommitment(new LanguageCommitmentDefinition('LANGUAGES'));
+    registerCommitment(new SampleCommitmentDefinition('SAMPLE'));
+    registerCommitment(new SampleCommitmentDefinition('EXAMPLE'));
+    registerCommitment(new FormatCommitmentDefinition('FORMAT'));
+    registerCommitment(new FormatCommitmentDefinition('FORMATS'));
+    registerCommitment(new FromCommitmentDefinition('FROM'));
+    registerCommitment(new ModelCommitmentDefinition('MODEL'));
+    registerCommitment(new ModelCommitmentDefinition('MODELS'));
+    registerCommitment(new ActionCommitmentDefinition('ACTION'));
+    registerCommitment(new ActionCommitmentDefinition('ACTIONS'));
+    registerCommitment(new ComponentCommitmentDefinition());
+    registerCommitment(new MetaImageCommitmentDefinition());
+    registerCommitment(new MetaColorCommitmentDefinition());
+    registerCommitment(new MetaLinkCommitmentDefinition());
+    registerCommitment(new MetaCommitmentDefinition());
+    registerCommitment(new NoteCommitmentDefinition('NOTE'));
+    registerCommitment(new NoteCommitmentDefinition('NOTES'));
+    registerCommitment(new NoteCommitmentDefinition('COMMENT'));
+    registerCommitment(new NoteCommitmentDefinition('NONCE'));
+    registerCommitment(new GoalCommitmentDefinition('GOAL'));
+    registerCommitment(new GoalCommitmentDefinition('GOALS'));
+    registerCommitment(new ImportantCommitmentDefinition());
+    registerCommitment(new InitialMessageCommitmentDefinition());
+    registerCommitment(new UserMessageCommitmentDefinition());
+    registerCommitment(new AgentMessageCommitmentDefinition());
+    registerCommitment(new MessageCommitmentDefinition('MESSAGE'));
+    registerCommitment(new MessageCommitmentDefinition('MESSAGES'));
+    registerCommitment(new ScenarioCommitmentDefinition('SCENARIO'));
+    registerCommitment(new ScenarioCommitmentDefinition('SCENARIOS'));
+    registerCommitment(new DeleteCommitmentDefinition('DELETE'));
+    registerCommitment(new DeleteCommitmentDefinition('CANCEL'));
+    registerCommitment(new DeleteCommitmentDefinition('DISCARD'));
+    registerCommitment(new DeleteCommitmentDefinition('REMOVE'));
+    registerCommitment(new OpenCommitmentDefinition());
+    registerCommitment(new ClosedCommitmentDefinition());
+    // Register not yet implemented commitments
+    registerCommitment(new NotYetImplementedCommitmentDefinition('EXPECT'));
+    registerCommitment(new NotYetImplementedCommitmentDefinition('BEHAVIOUR'));
+    registerCommitment(new NotYetImplementedCommitmentDefinition('BEHAVIOURS'));
+    registerCommitment(new NotYetImplementedCommitmentDefinition('AVOID'));
+    registerCommitment(new NotYetImplementedCommitmentDefinition('AVOIDANCE'));
+    registerCommitment(new NotYetImplementedCommitmentDefinition('CONTEXT'));
 
     /**
      * Parses agent source using the new commitment system with multiline support
@@ -6101,16 +6689,6 @@
         return uniqueParameters;
     }
 
-    /**
-     * Creates temporary default agent name based on agent source hash
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function createDefaultAgentName(agentSource) {
-        const agentHash = computeAgentHash(agentSource);
-        return normalizeAgentName(`Agent ${agentHash.substring(0, 6)}`);
-    }
-
     /**
      * Parses basic information from agent source
      *
@@ -6150,7 +6728,9 @@
         const links = [];
         for (const commitment of parseResult.commitments) {
             if (commitment.type === 'META LINK') {
-                links.push(spaceTrim__default["default"](commitment.content));
+                const linkValue = spaceTrim__default["default"](commitment.content);
+                links.push(linkValue);
+                meta.link = linkValue;
                 continue;
             }
             if (commitment.type === 'META IMAGE') {
@@ -16165,6 +16745,7 @@
          * Note: This method also implements the learning mechanism
          */
         async callChatModelStream(prompt, onProgress) {
+            var _a;
             // [1] Check if the user is asking the same thing as in the samples
             const modelRequirements = await this.getAgentModelRequirements();
             if (modelRequirements.samples) {
@@ -16212,6 +16793,9 @@
             if (result.rawResponse && 'sample' in result.rawResponse) {
                 return result;
             }
+            if ((_a = modelRequirements.metadata) === null || _a === void 0 ? void 0 : _a.isClosed) {
+                return result;
+            }
             // TODO: !!! Extract learning to separate method
             // Learning: Append the conversation sample to the agent source
             const learningExample = spaceTrim__default["default"]((block) => `