@promptbook/components 0.112.0-56 → 0.112.0-57

package/umd/index.umd.js

@@ -30,7 +30,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-56';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-57';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -4889,403 +4889,6 @@
         return (jsxRuntime.jsxs("div", { className: classNames(styles$f.AvatarChip, className, isSelected ? styles$f.Selected : undefined), onClick: () => onSelect === null || onSelect === void 0 ? void 0 : onSelect(avatarBasicInformation), style: { cursor: onSelect ? 'pointer' : undefined }, children: [avatarUrl && jsxRuntime.jsx("img", { src: avatarUrl, alt: agentName || '', className: styles$f.Avatar }), meta.fullname || agentName, isTemplate && jsxRuntime.jsx("span", { className: styles$f.TemplateLabel, children: "Template" })] }));
     }
 
-    /**
-     * Hostnames accepted for GitHub repository references.
-     *
-     * @private internal USE PROJECT constant
-     */
-    const GITHUB_HOSTNAMES = new Set(['github.com', 'www.github.com']);
-    /**
-     * Pattern for validating owner/repository slugs.
-     *
-     * @private internal USE PROJECT constant
-     */
-    const GITHUB_REPOSITORY_SLUG_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
-    /**
-     * Parses a repository reference into canonical owner/repository details.
-     *
-     * Supported input forms:
-     * - `https://github.com/owner/repository`
-     * - `github.com/owner/repository`
-     * - `owner/repository`
-     * - optional `.git` suffix and trailing slash are supported
-     *
-     * @private internal utility of USE PROJECT commitment
-     */
-    function parseGitHubRepositoryReference(rawReference) {
-        const trimmedReference = rawReference.trim();
-        if (!trimmedReference) {
-            return null;
-        }
-        const normalizedReference = trimmedReference.replace(/\/+$/g, '');
-        if (normalizedReference.startsWith('http://') || normalizedReference.startsWith('https://')) {
-            return parseGitHubRepositoryReferenceFromUrl(normalizedReference);
-        }
-        if (normalizedReference.startsWith('github.com/')) {
-            return parseGitHubRepositoryReferenceFromUrl(`https://${normalizedReference}`);
-        }
-        if (!GITHUB_REPOSITORY_SLUG_PATTERN.test(normalizedReference)) {
-            return null;
-        }
-        const [owner, repositoryRaw] = normalizedReference.split('/');
-        if (!owner || !repositoryRaw) {
-            return null;
-        }
-        const repository = repositoryRaw.replace(/\.git$/i, '');
-        if (!isValidGitHubRepositoryPart(owner) || !isValidGitHubRepositoryPart(repository)) {
-            return null;
-        }
-        return createGitHubRepositoryReference(owner, repository);
-    }
-    /**
-     * Parses `USE PROJECT` commitment content into repository reference + optional instructions.
-     *
-     * @private internal utility of USE PROJECT commitment
-     */
-    function parseUseProjectCommitmentContent(content) {
-        const trimmedContent = spacetrim.spaceTrim(content);
-        if (!trimmedContent) {
-            return {
-                repository: null,
-                repositoryReferenceRaw: null,
-                instructions: '',
-            };
-        }
-        const lines = trimmedContent
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter(Boolean);
-        if (lines.length === 0) {
-            return {
-                repository: null,
-                repositoryReferenceRaw: null,
-                instructions: '',
-            };
-        }
-        const firstLine = lines[0] || '';
-        const firstLineTokens = firstLine.split(/\s+/).filter(Boolean);
-        let repositoryReferenceRaw = null;
-        let repositoryReference = null;
-        let repositoryTokenIndex = -1;
-        for (let index = 0; index < firstLineTokens.length; index++) {
-            const token = firstLineTokens[index] || '';
-            const cleanedToken = token.replace(/[),.;:!?]+$/g, '');
-            const parsedReference = parseGitHubRepositoryReference(cleanedToken);
-            if (!parsedReference) {
-                continue;
-            }
-            repositoryReferenceRaw = cleanedToken;
-            repositoryReference = parsedReference;
-            repositoryTokenIndex = index;
-            break;
-        }
-        const instructionParts = [];
-        if (repositoryTokenIndex >= 0) {
-            const firstLineInstruction = firstLineTokens
-                .filter((_token, index) => index !== repositoryTokenIndex)
-                .join(' ')
-                .trim();
-            if (firstLineInstruction) {
-                instructionParts.push(firstLineInstruction);
-            }
-        }
-        else if (firstLine) {
-            instructionParts.push(firstLine);
-        }
-        if (lines.length > 1) {
-            const extraLines = lines.slice(1).join('\n').trim();
-            if (extraLines) {
-                instructionParts.push(extraLines);
-            }
-        }
-        return {
-            repository: repositoryReference,
-            repositoryReferenceRaw,
-            instructions: instructionParts.join('\n').trim(),
-        };
-    }
-    /**
-     * Parses URL-like repository references.
-     *
-     * @private utility of USE PROJECT commitment
-     */
-    function parseGitHubRepositoryReferenceFromUrl(rawUrl) {
-        let parsedUrl;
-        try {
-            parsedUrl = new URL(rawUrl);
-        }
-        catch (_a) {
-            return null;
-        }
-        if (!GITHUB_HOSTNAMES.has(parsedUrl.hostname.toLowerCase())) {
-            return null;
-        }
-        const segments = parsedUrl.pathname.split('/').filter(Boolean);
-        if (segments.length < 2) {
-            return null;
-        }
-        const owner = segments[0];
-        const repositoryRaw = segments[1];
-        if (!owner || !repositoryRaw) {
-            return null;
-        }
-        const repository = repositoryRaw.replace(/\.git$/i, '');
-        if (!isValidGitHubRepositoryPart(owner) || !isValidGitHubRepositoryPart(repository)) {
-            return null;
-        }
-        let defaultBranch;
-        if (segments[2] === 'tree' && segments[3]) {
-            defaultBranch = decodeURIComponent(segments[3]);
-        }
-        return createGitHubRepositoryReference(owner, repository, defaultBranch);
-    }
-    /**
-     * Validates one owner/repository slug part.
-     *
-     * @private utility of USE PROJECT commitment
-     */
-    function isValidGitHubRepositoryPart(value) {
-        return /^[A-Za-z0-9_.-]+$/.test(value);
-    }
-    /**
-     * Builds canonical repository reference object.
-     *
-     * @private utility of USE PROJECT commitment
-     */
-    function createGitHubRepositoryReference(owner, repository, defaultBranch) {
-        const slug = `${owner}/${repository}`;
-        return {
-            owner,
-            repository,
-            slug,
-            url: `https://github.com/${slug}`,
-            defaultBranch,
-        };
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * Normalizes a given text to camelCase format.
-     *
-     * Note: [🔂] This function is idempotent.
-     *
-     * @param text The text to be normalized.
-     * @param _isFirstLetterCapital Whether the first letter should be capitalized.
-     * @returns The camelCase formatted string.
-     * @example 'helloWorld'
-     * @example 'iLovePromptbook'
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function normalizeTo_camelCase(text, _isFirstLetterCapital = false) {
-        let charType;
-        let lastCharType = null;
-        let normalizedName = '';
-        for (const char of text) {
-            let normalizedChar;
-            if (/^[a-z]$/.test(char)) {
-                charType = 'LOWERCASE';
-                normalizedChar = char;
-            }
-            else if (/^[A-Z]$/.test(char)) {
-                charType = 'UPPERCASE';
-                normalizedChar = char.toLowerCase();
-            }
-            else if (/^[0-9]$/.test(char)) {
-                charType = 'NUMBER';
-                normalizedChar = char;
-            }
-            else {
-                charType = 'OTHER';
-                normalizedChar = '';
-            }
-            if (!lastCharType) {
-                if (_isFirstLetterCapital) {
-                    normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
-                }
-            }
-            else if (charType !== lastCharType &&
-                !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
-                !(lastCharType === 'NUMBER') &&
-                !(charType === 'NUMBER')) {
-                normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
-            }
-            normalizedName += normalizedChar;
-            lastCharType = charType;
-        }
-        return normalizedName;
-    }
-    // TODO: [🌺] Use some intermediate util splitWords
-
-    /**
-     * Tests if given string is valid URL.
-     *
-     * Note: [🔂] This function is idempotent.
-     * Note: Dataurl are considered perfectly valid.
-     * Note: There are few similar functions:
-     * - `isValidUrl` *(this one)* which tests any URL
-     * - `isValidAgentUrl` which tests just agent URL
-     * - `isValidPipelineUrl` which tests just pipeline URL
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function isValidUrl(url) {
-        if (typeof url !== 'string') {
-            return false;
-        }
-        try {
-            if (url.startsWith('blob:')) {
-                url = url.replace(/^blob:/, '');
-            }
-            const urlObject = new URL(url /* because fail is handled */);
-            if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-
-    /**
-     * Matches URL-like candidates inside arbitrary text.
-     *
-     * @private
-     */
-    const URL_CANDIDATE_PATTERN = /https?:\/\/[^\s<>"'`]+/g;
-    /**
-     * Trims punctuation that commonly trails URLs in prose.
-     *
-     * @private
-     */
-    const TRAILING_PUNCTUATION_PATTERN = /[.,!?;:'"`]+$/;
-    /**
-     * Extracts all valid URLs from arbitrary text while removing common trailing punctuation.
-     *
-     * @param text - Input text that may contain one or more URLs.
-     * @returns Unique URLs in their first-seen order.
-     *
-     * @private utility of KNOWLEDGE parsing
-     */
-    function extractUrlsFromText(text) {
-        if (!text) {
-            return [];
-        }
-        const candidates = text.match(URL_CANDIDATE_PATTERN);
-        if (!candidates) {
-            return [];
-        }
-        const urls = [];
-        const seen = new Set();
-        for (const candidate of candidates) {
-            const normalizedCandidate = normalizeUrlCandidate(candidate);
-            if (!normalizedCandidate) {
-                continue;
-            }
-            if (!isValidUrl(normalizedCandidate)) {
-                continue;
-            }
-            if (seen.has(normalizedCandidate)) {
-                continue;
-            }
-            seen.add(normalizedCandidate);
-            urls.push(normalizedCandidate);
-        }
-        return urls;
-    }
-    /**
-     * Normalizes one extracted URL candidate by stripping trailing punctuation and unmatched closing wrappers.
-     *
-     * @private
-     */
-    function normalizeUrlCandidate(candidate) {
-        let normalized = candidate.trim();
-        if (!normalized) {
-            return '';
-        }
-        let shouldContinue = true;
-        while (shouldContinue) {
-            const before = normalized;
-            normalized = normalized.replace(TRAILING_PUNCTUATION_PATTERN, '');
-            normalized = stripTrailingUnmatchedClosing(normalized, '(', ')');
-            normalized = stripTrailingUnmatchedClosing(normalized, '[', ']');
-            normalized = stripTrailingUnmatchedClosing(normalized, '{', '}');
-            normalized = normalized.replace(TRAILING_PUNCTUATION_PATTERN, '');
-            shouldContinue = normalized !== before;
-        }
-        return normalized;
-    }
-    /**
-     * Removes trailing closing wrappers when they are unmatched in the candidate.
-     *
-     * @private
-     */
-    function stripTrailingUnmatchedClosing(candidate, openingChar, closingChar) {
-        let normalized = candidate;
-        while (normalized.endsWith(closingChar)) {
-            const openingCount = countOccurrences(normalized, openingChar);
-            const closingCount = countOccurrences(normalized, closingChar);
-            if (closingCount <= openingCount) {
-                break;
-            }
-            normalized = normalized.slice(0, -1);
-        }
-        return normalized;
-    }
-    /**
-     * Counts character occurrences in a string.
-     *
-     * @private
-     */
-    function countOccurrences(value, searchedChar) {
-        let count = 0;
-        for (const currentChar of value) {
-            if (currentChar === searchedChar) {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    /**
-     * Normalizes a domain-like string into a comparable hostname form.
-     *
-     * The returned value is lowercased and stripped to hostname only
-     * (protocol, path, query, hash, and port are removed).
-     *
-     * @param rawDomain - Raw domain value (for example `my-agent.com` or `https://my-agent.com/path`).
-     * @returns Normalized hostname or `null` when the value cannot be normalized.
-     *
-     * @private utility for host/domain matching
-     */
-    function normalizeDomainForMatching(rawDomain) {
-        const trimmedDomain = rawDomain.trim();
-        if (!trimmedDomain) {
-            return null;
-        }
-        const candidateUrl = hasHttpProtocol(trimmedDomain) ? trimmedDomain : `https://${trimmedDomain}`;
-        try {
-            const parsedUrl = new URL(candidateUrl);
-            const normalizedHostname = parsedUrl.hostname.trim().toLowerCase();
-            return normalizedHostname || null;
-        }
-        catch (_a) {
-            return null;
-        }
-    }
-    /**
-     * Checks whether the value already includes an HTTP(S) protocol prefix.
-     *
-     * @param value - Raw value to inspect.
-     * @returns True when the value starts with `http://` or `https://`.
-     *
-     * @private utility for host/domain matching
-     */
-    function hasHttpProtocol(value) {
-        return value.startsWith('http://') || value.startsWith('https://');
-    }
-
     /**
      * Make error report URL for the given error
      *
@@ -5872,6 +5475,59 @@
     };
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Normalizes a given text to camelCase format.
+     *
+     * Note: [🔂] This function is idempotent.
+     *
+     * @param text The text to be normalized.
+     * @param _isFirstLetterCapital Whether the first letter should be capitalized.
+     * @returns The camelCase formatted string.
+     * @example 'helloWorld'
+     * @example 'iLovePromptbook'
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_camelCase(text, _isFirstLetterCapital = false) {
+        let charType;
+        let lastCharType = null;
+        let normalizedName = '';
+        for (const char of text) {
+            let normalizedChar;
+            if (/^[a-z]$/.test(char)) {
+                charType = 'LOWERCASE';
+                normalizedChar = char;
+            }
+            else if (/^[A-Z]$/.test(char)) {
+                charType = 'UPPERCASE';
+                normalizedChar = char.toLowerCase();
+            }
+            else if (/^[0-9]$/.test(char)) {
+                charType = 'NUMBER';
+                normalizedChar = char;
+            }
+            else {
+                charType = 'OTHER';
+                normalizedChar = '';
+            }
+            if (!lastCharType) {
+                if (_isFirstLetterCapital) {
+                    normalizedChar = normalizedChar.toUpperCase(); //TODO: DRY
+                }
+            }
+            else if (charType !== lastCharType &&
+                !(charType === 'LOWERCASE' && lastCharType === 'UPPERCASE') &&
+                !(lastCharType === 'NUMBER') &&
+                !(charType === 'NUMBER')) {
+                normalizedChar = normalizedChar.toUpperCase(); //TODO: [🌺] DRY
+            }
+            normalizedName += normalizedChar;
+            lastCharType = charType;
+        }
+        return normalizedName;
+    }
+    // TODO: [🌺] Use some intermediate util splitWords
+
     /**
      * Tests if given string is valid file path.
      *
@@ -5927,6 +5583,37 @@
     }
     // TODO: [🍏] Implement for MacOs
 
+    /**
+     * Tests if given string is valid URL.
+     *
+     * Note: [🔂] This function is idempotent.
+     * Note: Dataurl are considered perfectly valid.
+     * Note: There are few similar functions:
+     * - `isValidUrl` *(this one)* which tests any URL
+     * - `isValidAgentUrl` which tests just agent URL
+     * - `isValidPipelineUrl` which tests just pipeline URL
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidUrl(url) {
+        if (typeof url !== 'string') {
+            return false;
+        }
+        try {
+            if (url.startsWith('blob:')) {
+                url = url.replace(/^blob:/, '');
+            }
+            const urlObject = new URL(url /* because fail is handled */);
+            if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+
     /**
      * Collection of default diacritics removal map.
      */
@@ -10926,6 +10613,106 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Matches URL-like candidates inside arbitrary text.
+     *
+     * @private
+     */
+    const URL_CANDIDATE_PATTERN = /https?:\/\/[^\s<>"'`]+/g;
+    /**
+     * Trims punctuation that commonly trails URLs in prose.
+     *
+     * @private
+     */
+    const TRAILING_PUNCTUATION_PATTERN = /[.,!?;:'"`]+$/;
+    /**
+     * Extracts all valid URLs from arbitrary text while removing common trailing punctuation.
+     *
+     * @param text - Input text that may contain one or more URLs.
+     * @returns Unique URLs in their first-seen order.
+     *
+     * @private utility of KNOWLEDGE parsing
+     */
+    function extractUrlsFromText(text) {
+        if (!text) {
+            return [];
+        }
+        const candidates = text.match(URL_CANDIDATE_PATTERN);
+        if (!candidates) {
+            return [];
+        }
+        const urls = [];
+        const seen = new Set();
+        for (const candidate of candidates) {
+            const normalizedCandidate = normalizeUrlCandidate(candidate);
+            if (!normalizedCandidate) {
+                continue;
+            }
+            if (!isValidUrl(normalizedCandidate)) {
+                continue;
+            }
+            if (seen.has(normalizedCandidate)) {
+                continue;
+            }
+            seen.add(normalizedCandidate);
+            urls.push(normalizedCandidate);
+        }
+        return urls;
+    }
+    /**
+     * Normalizes one extracted URL candidate by stripping trailing punctuation and unmatched closing wrappers.
+     *
+     * @private
+     */
+    function normalizeUrlCandidate(candidate) {
+        let normalized = candidate.trim();
+        if (!normalized) {
+            return '';
+        }
+        let shouldContinue = true;
+        while (shouldContinue) {
+            const before = normalized;
+            normalized = normalized.replace(TRAILING_PUNCTUATION_PATTERN, '');
+            normalized = stripTrailingUnmatchedClosing(normalized, '(', ')');
+            normalized = stripTrailingUnmatchedClosing(normalized, '[', ']');
+            normalized = stripTrailingUnmatchedClosing(normalized, '{', '}');
+            normalized = normalized.replace(TRAILING_PUNCTUATION_PATTERN, '');
+            shouldContinue = normalized !== before;
+        }
+        return normalized;
+    }
+    /**
+     * Removes trailing closing wrappers when they are unmatched in the candidate.
+     *
+     * @private
+     */
+    function stripTrailingUnmatchedClosing(candidate, openingChar, closingChar) {
+        let normalized = candidate;
+        while (normalized.endsWith(closingChar)) {
+            const openingCount = countOccurrences(normalized, openingChar);
+            const closingCount = countOccurrences(normalized, closingChar);
+            if (closingCount <= openingCount) {
+                break;
+            }
+            normalized = normalized.slice(0, -1);
+        }
+        return normalized;
+    }
+    /**
+     * Counts character occurrences in a string.
+     *
+     * @private
+     */
+    function countOccurrences(value, searchedChar) {
+        let count = 0;
+        for (const currentChar of value) {
+            if (currentChar === searchedChar) {
+                count++;
+            }
+        }
+        return count;
+    }
+
     /**
      * The default base name for inline knowledge files when the content lacks identifying text.
      *
@@ -16264,6 +16051,44 @@
      * @private constant of createUseCalendarTools
      */
     const CALENDAR_URL_PARAMETER_DESCRIPTION = 'Google Calendar URL configured by USE CALENDAR (for example "https://calendar.google.com/...").';
+    /**
+     * Shared schema for string arrays used by USE CALENDAR tools.
+     *
+     * @private constant of createUseCalendarTools
+     */
+    const STRING_ARRAY_ITEMS_SCHEMA = {
+        type: 'string',
+    };
+    /**
+     * Shared schema for integer arrays used by USE CALENDAR tools.
+     *
+     * @private constant of createUseCalendarTools
+     */
+    const INTEGER_ARRAY_ITEMS_SCHEMA = {
+        type: 'integer',
+    };
+    /**
+     * Shared `sendUpdates` schema used by USE CALENDAR tools.
+     *
+     * @private constant of createUseCalendarTools
+     */
+    const SEND_UPDATES_PARAMETER_SCHEMA = {
+        type: 'string',
+        description: 'Guest update policy ("all", "externalOnly", "none").',
+        enum: ['all', 'externalOnly', 'none'],
+    };
+    /**
+     * Creates an array parameter schema with explicit item definition so OpenAI accepts it.
+     *
+     * @private function of createUseCalendarTools
+     */
+    function createArrayParameterSchema(description, items) {
+        return {
+            type: 'array',
+            description,
+            items,
+        };
+    }
     /**
      * Adds USE CALENDAR tool definitions while keeping already registered tools untouched.
      *
@@ -16370,18 +16195,9 @@
                         type: 'string',
                         description: 'Optional timezone for datetime values.',
                     },
-                    attendees: {
-                        type: 'array',
-                        description: 'Optional guest email list.',
-                    },
-                    reminderMinutes: {
-                        type: 'array',
-                        description: 'Optional popup reminder minute offsets.',
-                    },
-                    sendUpdates: {
-                        type: 'string',
-                        description: 'Guest update policy ("all", "externalOnly", "none").',
-                    },
+                    attendees: createArrayParameterSchema('Optional guest email list.', STRING_ARRAY_ITEMS_SCHEMA),
+                    reminderMinutes: createArrayParameterSchema('Optional popup reminder minute offsets.', INTEGER_ARRAY_ITEMS_SCHEMA),
+                    sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
                 },
                 required: ['summary', 'start', 'end'],
             },
@@ -16424,18 +16240,9 @@
                         type: 'string',
                         description: 'Optional timezone for datetime values.',
                     },
-                    attendees: {
-                        type: 'array',
-                        description: 'Optional replacement guest email list.',
-                    },
-                    reminderMinutes: {
-                        type: 'array',
-                        description: 'Optional replacement popup reminder minute offsets.',
-                    },
-                    sendUpdates: {
-                        type: 'string',
-                        description: 'Guest update policy ("all", "externalOnly", "none").',
-                    },
+                    attendees: createArrayParameterSchema('Optional replacement guest email list.', STRING_ARRAY_ITEMS_SCHEMA),
+                    reminderMinutes: createArrayParameterSchema('Optional replacement popup reminder minute offsets.', INTEGER_ARRAY_ITEMS_SCHEMA),
+                    sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
                 },
                 required: ['eventId'],
             },
@@ -16454,10 +16261,7 @@
                         type: 'string',
                         description: 'Google Calendar event id.',
                     },
-                    sendUpdates: {
-                        type: 'string',
-                        description: 'Guest update policy ("all", "externalOnly", "none").',
-                    },
+                    sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
                 },
                 required: ['eventId'],
             },
@@ -16476,14 +16280,8 @@
                         type: 'string',
                         description: 'Google Calendar event id.',
                     },
-                    guests: {
-                        type: 'array',
-                        description: 'Guest email list to add to the event.',
-                    },
-                    sendUpdates: {
-                        type: 'string',
-                        description: 'Guest update policy ("all", "externalOnly", "none").',
-                    },
+                    guests: createArrayParameterSchema('Guest email list to add to the event.', STRING_ARRAY_ITEMS_SCHEMA),
+                    sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
                 },
                 required: ['eventId', 'guests'],
             },
@@ -18276,6 +18074,181 @@
         return normalized;
     }
 
+    /**
+     * Hostnames accepted for GitHub repository references.
+     *
+     * @private internal USE PROJECT constant
+     */
+    const GITHUB_HOSTNAMES = new Set(['github.com', 'www.github.com']);
+    /**
+     * Pattern for validating owner/repository slugs.
+     *
+     * @private internal USE PROJECT constant
+     */
+    const GITHUB_REPOSITORY_SLUG_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+    /**
+     * Parses a repository reference into canonical owner/repository details.
+     *
+     * Supported input forms:
+     * - `https://github.com/owner/repository`
+     * - `github.com/owner/repository`
+     * - `owner/repository`
+     * - optional `.git` suffix and trailing slash are supported
+     *
+     * @private internal utility of USE PROJECT commitment
+     */
+    function parseGitHubRepositoryReference(rawReference) {
+        const trimmedReference = rawReference.trim();
+        if (!trimmedReference) {
+            return null;
+        }
+        const normalizedReference = trimmedReference.replace(/\/+$/g, '');
+        if (normalizedReference.startsWith('http://') || normalizedReference.startsWith('https://')) {
+            return parseGitHubRepositoryReferenceFromUrl(normalizedReference);
+        }
+        if (normalizedReference.startsWith('github.com/')) {
+            return parseGitHubRepositoryReferenceFromUrl(`https://${normalizedReference}`);
+        }
+        if (!GITHUB_REPOSITORY_SLUG_PATTERN.test(normalizedReference)) {
+            return null;
+        }
+        const [owner, repositoryRaw] = normalizedReference.split('/');
+        if (!owner || !repositoryRaw) {
+            return null;
+        }
+        const repository = repositoryRaw.replace(/\.git$/i, '');
+        if (!isValidGitHubRepositoryPart(owner) || !isValidGitHubRepositoryPart(repository)) {
+            return null;
+        }
+        return createGitHubRepositoryReference(owner, repository);
+    }
+    /**
+     * Parses `USE PROJECT` commitment content into repository reference + optional instructions.
+     *
+     * @private internal utility of USE PROJECT commitment
+     */
+    function parseUseProjectCommitmentContent(content) {
+        const trimmedContent = spacetrim.spaceTrim(content);
+        if (!trimmedContent) {
+            return {
+                repository: null,
+                repositoryReferenceRaw: null,
+                instructions: '',
+            };
+        }
+        const lines = trimmedContent
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        if (lines.length === 0) {
+            return {
+                repository: null,
+                repositoryReferenceRaw: null,
+                instructions: '',
+            };
+        }
+        const firstLine = lines[0] || '';
+        const firstLineTokens = firstLine.split(/\s+/).filter(Boolean);
+        let repositoryReferenceRaw = null;
+        let repositoryReference = null;
+        let repositoryTokenIndex = -1;
+        for (let index = 0; index < firstLineTokens.length; index++) {
+            const token = firstLineTokens[index] || '';
+            const cleanedToken = token.replace(/[),.;:!?]+$/g, '');
+            const parsedReference = parseGitHubRepositoryReference(cleanedToken);
+            if (!parsedReference) {
+                continue;
+            }
+            repositoryReferenceRaw = cleanedToken;
+            repositoryReference = parsedReference;
+            repositoryTokenIndex = index;
+            break;
+        }
+        const instructionParts = [];
+        if (repositoryTokenIndex >= 0) {
+            const firstLineInstruction = firstLineTokens
+                .filter((_token, index) => index !== repositoryTokenIndex)
+                .join(' ')
+                .trim();
+            if (firstLineInstruction) {
+                instructionParts.push(firstLineInstruction);
+            }
+        }
+        else if (firstLine) {
+            instructionParts.push(firstLine);
+        }
+        if (lines.length > 1) {
+            const extraLines = lines.slice(1).join('\n').trim();
+            if (extraLines) {
+                instructionParts.push(extraLines);
+            }
+        }
+        return {
+            repository: repositoryReference,
+            repositoryReferenceRaw,
+            instructions: instructionParts.join('\n').trim(),
+        };
+    }
+    /**
+     * Parses URL-like repository references.
+     *
+     * @private utility of USE PROJECT commitment
+     */
+    function parseGitHubRepositoryReferenceFromUrl(rawUrl) {
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(rawUrl);
+        }
+        catch (_a) {
+            return null;
+        }
+        if (!GITHUB_HOSTNAMES.has(parsedUrl.hostname.toLowerCase())) {
+            return null;
+        }
+        const segments = parsedUrl.pathname.split('/').filter(Boolean);
+        if (segments.length < 2) {
+            return null;
+        }
+        const owner = segments[0];
+        const repositoryRaw = segments[1];
+        if (!owner || !repositoryRaw) {
+            return null;
+        }
+        const repository = repositoryRaw.replace(/\.git$/i, '');
+        if (!isValidGitHubRepositoryPart(owner) || !isValidGitHubRepositoryPart(repository)) {
+            return null;
+        }
+        let defaultBranch;
+        if (segments[2] === 'tree' && segments[3]) {
+            defaultBranch = decodeURIComponent(segments[3]);
+        }
+        return createGitHubRepositoryReference(owner, repository, defaultBranch);
+    }
+    /**
+     * Validates one owner/repository slug part.
+     *
+     * @private utility of USE PROJECT commitment
+     */
+    function isValidGitHubRepositoryPart(value) {
+        return /^[A-Za-z0-9_.-]+$/.test(value);
+    }
+    /**
+     * Builds canonical repository reference object.
+     *
+     * @private utility of USE PROJECT commitment
+     */
+    function createGitHubRepositoryReference(owner, repository, defaultBranch) {
+        const slug = `${owner}/${repository}`;
+        return {
+            owner,
+            repository,
+            slug,
+            url: `https://github.com/${slug}`,
+            defaultBranch,
+        };
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * Wallet metadata used by USE PROJECT when resolving GitHub credentials.
      *
@@ -21186,126 +21159,16 @@
     }
 
     /**
-     * Parses basic information from agent source
-     *
-     * There are 2 similar functions:
-     * - `parseAgentSource` which is a lightweight parser for agent source, it parses basic information and its purpose is to be quick and synchronous. The commitments there are hardcoded.
-     * - `createAgentModelRequirements` which is an asynchronous function that creates model requirements it applies each commitment one by one and works asynchronously.
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function parseAgentSource(agentSource) {
-        const parseResult = parseAgentSourceWithCommitments(agentSource);
-        const resolvedAgentName = parseResult.agentName || createDefaultAgentName(agentSource);
-        const personaDescription = extractAgentProfileText(parseResult.commitments);
-        const initialMessage = extractInitialMessage(parseResult.commitments);
-        const parsedProfile = extractParsedAgentProfile(parseResult.commitments);
-        ensureMetaFullname(parsedProfile.meta, resolvedAgentName);
-        return {
-            agentName: normalizeAgentName(resolvedAgentName),
-            agentHash: computeAgentHash(agentSource),
-            permanentId: parsedProfile.meta.id,
-            personaDescription,
-            initialMessage,
-            meta: parsedProfile.meta,
-            links: parsedProfile.links,
-            parameters: parseParameters(agentSource),
-            capabilities: parsedProfile.capabilities,
-            samples: parsedProfile.samples,
-            knowledgeSources: parsedProfile.knowledgeSources,
-        };
-    }
-    /**
-     * Static capability descriptors for commitments that map one-to-one to a visible capability.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    const SIMPLE_CAPABILITY_BY_COMMITMENT_TYPE = {
-        'USE BROWSER': {
-            type: 'browser',
-            label: 'Browser',
-            iconName: 'Globe',
-        },
-        'USE SEARCH ENGINE': {
-            type: 'search-engine',
-            label: 'Internet',
-            iconName: 'Search',
-        },
-        'USE SEARCH': {
-            type: 'search-engine',
-            label: 'Internet',
-            iconName: 'Search',
-        },
-        'USE DEEPSEARCH': {
-            type: 'search-engine',
-            label: 'DeepSearch',
-            iconName: 'Search',
-        },
-        'USE TIME': {
-            type: 'time',
-            label: 'Time',
-            iconName: 'Clock',
-        },
-        'USE TIMEOUT': {
-            type: 'timeout',
-            label: 'Timers',
-            iconName: 'Clock',
-        },
-        'USE USER LOCATION': {
-            type: 'user-location',
-            label: 'User location',
-            iconName: 'MapPin',
-        },
-        'USE EMAIL': {
-            type: 'email',
-            label: 'Email',
-            iconName: 'Mail',
-        },
-        'USE POPUP': {
-            type: 'popup',
-            label: 'Popup',
-            iconName: 'SquareArrowOutUpRight',
-        },
-        'USE IMAGE GENERATOR': {
-            type: 'image-generator',
-            label: 'Image Generator',
-            iconName: 'Image',
-        },
-        'USE PRIVACY': {
-            type: 'privacy',
-            label: 'Privacy',
-            iconName: 'Shield',
-        },
-        'USE CALENDAR': {
-            type: 'calendar',
-            label: 'Calendar',
-            iconName: 'Calendar',
-        },
-    };
-    /**
-     * Dedicated handlers for META-style commitments that directly map onto parsed meta fields.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    const META_COMMITMENT_APPLIERS = {
-        'META AVATAR': applyMetaAvatarContent,
-        'META LINK': applyMetaLinkContent,
-        'META DOMAIN': applyMetaDomainContent,
-        'META IMAGE': applyMetaImageContent,
-        'META DESCRIPTION': applyMetaDescriptionContent,
-        'META DISCLAIMER': applyMetaDisclaimerContent,
-        'META INPUT PLACEHOLDER': applyMetaInputPlaceholderContent,
-        'MESSAGE SUFFIX': applyMessageSuffixContent,
-        'META COLOR': applyMetaColorContent,
-        'META FONT': applyMetaFontContent,
-        'META VOICE': applyMetaVoiceContent,
-    };
-    /**
-     * Detects local slash-based references used by FROM and IMPORT commitments.
+     * Ensures the parsed profile always exposes a fullname value.
      *
      * @private internal utility of `parseAgentSource`
      */
-    const LOCAL_AGENT_REFERENCE_PREFIXES = ['./', '../', '/'];
+    function ensureMetaFullname(meta, fallbackFullname) {
+        if (!meta.fullname) {
+            meta.fullname = fallbackFullname;
+        }
+    }
+
     /**
      * Resolves the public agent profile text from the last GOAL/GOALS commitment,
      * falling back to the deprecated PERSONA/PERSONAE commitments when no goal exists.
@@ -21335,6 +21198,7 @@
         }
         return null;
     }
+
     /**
      * Resolves the last INITIAL MESSAGE commitment, which is the public initial-message value.
      *
@@ -21349,48 +21213,189 @@
         }
         return initialMessage;
     }
+
     /**
-     * Collects capability, sample, meta, link, and knowledge-source data from commitments.
+     * Normalizes a domain-like string into a comparable hostname form.
      *
-     * @private internal utility of `parseAgentSource`
+     * The returned value is lowercased and stripped to hostname only
+     * (protocol, path, query, hash, and port are removed).
+     *
+     * @param rawDomain - Raw domain value (for example `my-agent.com` or `https://my-agent.com/path`).
+     * @returns Normalized hostname or `null` when the value cannot be normalized.
+     *
+     * @private utility for host/domain matching
      */
-    function extractParsedAgentProfile(commitments) {
-        const state = {
-            meta: {},
-            links: [],
-            capabilities: [],
-            samples: [],
-            knowledgeSources: [],
-            pendingUserMessage: null,
-            knownKnowledgeSourceUrls: new Set(),
-        };
-        for (const commitment of commitments) {
-            processParsedCommitment(state, commitment);
+    function normalizeDomainForMatching(rawDomain) {
+        const trimmedDomain = rawDomain.trim();
+        if (!trimmedDomain) {
+            return null;
+        }
+        const candidateUrl = hasHttpProtocol(trimmedDomain) ? trimmedDomain : `https://${trimmedDomain}`;
+        try {
+            const parsedUrl = new URL(candidateUrl);
+            const normalizedHostname = parsedUrl.hostname.trim().toLowerCase();
+            return normalizedHostname || null;
+        }
+        catch (_a) {
+            return null;
         }
-        return {
-            meta: state.meta,
-            links: state.links,
-            capabilities: state.capabilities,
-            samples: state.samples,
-            knowledgeSources: state.knowledgeSources,
-        };
     }
     /**
-     * Processes one parsed commitment through the sample, capability, and meta stages.
+     * Checks whether the value already includes an HTTP(S) protocol prefix.
+     *
+     * @param value - Raw value to inspect.
+     * @returns True when the value starts with `http://` or `https://`.
+     *
+     * @private utility for host/domain matching
+     */
+    function hasHttpProtocol(value) {
+        return value.startsWith('http://') || value.startsWith('https://');
+    }
+
+    /**
+     * Dedicated handlers for META-style commitments that directly map onto parsed meta fields.
+     */
+    const META_COMMITMENT_APPLIERS = {
+        'META AVATAR': applyMetaAvatarContent,
+        'META LINK': applyMetaLinkContent,
+        'META DOMAIN': applyMetaDomainContent,
+        'META IMAGE': applyMetaImageContent,
+        'META DESCRIPTION': applyMetaDescriptionContent,
+        'META DISCLAIMER': applyMetaDisclaimerContent,
+        'META INPUT PLACEHOLDER': applyMetaInputPlaceholderContent,
+        'MESSAGE SUFFIX': applyMessageSuffixContent,
+        'META COLOR': applyMetaColorContent,
+        'META FONT': applyMetaFontContent,
+        'META VOICE': applyMetaVoiceContent,
+    };
+    /**
+     * Applies META-style commitments that mutate parsed profile metadata.
      *
      * @private internal utility of `parseAgentSource`
      */
-    function processParsedCommitment(state, commitment) {
-        if (consumeConversationSampleCommitment(state, commitment)) {
+    function applyMetaCommitment(state, commitment) {
+        const applyMetaContent = META_COMMITMENT_APPLIERS[commitment.type];
+        if (applyMetaContent) {
+            applyMetaContent(state, commitment.content);
             return;
         }
-        const capabilities = createCapabilitiesFromCommitment(state, commitment);
-        if (capabilities.length > 0) {
-            state.capabilities.push(...capabilities);
+        if (commitment.type === 'META') {
+            applyGenericMetaCommitment(state, commitment.content);
+        }
+    }
+    /**
+     * Applies the generic META commitment form (`META TYPE value`).
+     */
+    function applyGenericMetaCommitment(state, content) {
+        const metaTypeRaw = content.split(' ')[0] || 'NONE';
+        const metaValue = spacetrim.spaceTrim(content.substring(metaTypeRaw.length));
+        if (metaTypeRaw === 'LINK') {
+            state.links.push(metaValue);
+        }
+        if (metaTypeRaw.toUpperCase() === 'AVATAR') {
+            applyMetaAvatarContent(state, metaValue);
             return;
         }
-        applyMetaCommitment(state, commitment);
+        const metaType = normalizeTo_camelCase(metaTypeRaw);
+        state.meta[metaType] = metaValue;
     }
+    /**
+     * Applies META AVATAR content into the canonical `meta.avatar` field.
+     */
+    function applyMetaAvatarContent(state, content) {
+        const avatarVisualId = resolveAvatarVisualId(content);
+        if (avatarVisualId) {
+            state.meta.avatar = avatarVisualId;
+            return;
+        }
+        delete state.meta.avatar;
+    }
+    /**
+     * Applies META LINK content into links and the canonical `meta.link` field.
+     */
+    function applyMetaLinkContent(state, content) {
+        const linkValue = spacetrim.spaceTrim(content);
+        state.links.push(linkValue);
+        state.meta.link = linkValue;
+    }
+    /**
+     * Applies META DOMAIN content into the normalized `meta.domain` field.
+     */
+    function applyMetaDomainContent(state, content) {
+        state.meta.domain = normalizeMetaDomain(content);
+    }
+    /**
+     * Applies META IMAGE content into the canonical `meta.image` field.
+     */
+    function applyMetaImageContent(state, content) {
+        state.meta.image = spacetrim.spaceTrim(content);
+    }
+    /**
+     * Applies META DESCRIPTION content into the canonical `meta.description` field.
+     */
+    function applyMetaDescriptionContent(state, content) {
+        state.meta.description = spacetrim.spaceTrim(content);
+    }
+    /**
+     * Applies META DISCLAIMER content into the canonical `meta.disclaimer` field.
+     */
+    function applyMetaDisclaimerContent(state, content) {
+        state.meta.disclaimer = content;
+    }
+    /**
+     * Applies META INPUT PLACEHOLDER content into the canonical `meta.inputPlaceholder` field.
+     */
+    function applyMetaInputPlaceholderContent(state, content) {
+        state.meta.inputPlaceholder = spacetrim.spaceTrim(content);
+    }
+    /**
+     * Applies MESSAGE SUFFIX content into the canonical `meta.messageSuffix` field.
+     */
+    function applyMessageSuffixContent(state, content) {
+        state.meta.messageSuffix = content;
+    }
+    /**
+     * Applies META COLOR content into the canonical `meta.color` field.
+     */
+    function applyMetaColorContent(state, content) {
+        state.meta.color = normalizeSeparator(content);
+    }
+    /**
+     * Applies META FONT content into the canonical `meta.font` field.
+     */
+    function applyMetaFontContent(state, content) {
+        state.meta.font = normalizeSeparator(content);
+    }
+    /**
+     * Applies META VOICE content into the canonical `meta.voice` field.
+     */
+    function applyMetaVoiceContent(state, content) {
+        state.meta.voice = spacetrim.spaceTrim(content);
+    }
+    /**
+     * Normalizes the separator in the content
+     *
+     * @param content - The content to normalize
+     * @returns The content with normalized separators
+     */
+    function normalizeSeparator(content) {
+        const trimmed = spacetrim.spaceTrim(content);
+        if (trimmed.includes(',')) {
+            return trimmed;
+        }
+        return trimmed.split(/\s+/).join(', ');
+    }
+    /**
+     * Normalizes META DOMAIN content to a hostname-like value when possible.
+     *
+     * @param content - Raw META DOMAIN content.
+     * @returns Normalized domain or a trimmed fallback.
+     */
+    function normalizeMetaDomain(content) {
+        const trimmed = spacetrim.spaceTrim(content);
+        return normalizeDomainForMatching(trimmed) || trimmed.toLowerCase();
+    }
+
     /**
      * Updates sample-conversation state for communication commitments.
      *
@@ -21417,6 +21422,76 @@
                 return false;
         }
     }
+
+    /**
+     * Static capability descriptors for commitments that map one-to-one to a visible capability.
+     */
+    const SIMPLE_CAPABILITY_BY_COMMITMENT_TYPE = {
+        'USE BROWSER': {
+            type: 'browser',
+            label: 'Browser',
+            iconName: 'Globe',
+        },
+        'USE SEARCH ENGINE': {
+            type: 'search-engine',
+            label: 'Internet',
+            iconName: 'Search',
+        },
+        'USE SEARCH': {
+            type: 'search-engine',
+            label: 'Internet',
+            iconName: 'Search',
+        },
+        'USE DEEPSEARCH': {
+            type: 'search-engine',
+            label: 'DeepSearch',
+            iconName: 'Search',
+        },
+        'USE TIME': {
+            type: 'time',
+            label: 'Time',
+            iconName: 'Clock',
+        },
+        'USE TIMEOUT': {
+            type: 'timeout',
+            label: 'Timers',
+            iconName: 'Clock',
+        },
+        'USE USER LOCATION': {
+            type: 'user-location',
+            label: 'User location',
+            iconName: 'MapPin',
+        },
+        'USE EMAIL': {
+            type: 'email',
+            label: 'Email',
+            iconName: 'Mail',
+        },
+        'USE POPUP': {
+            type: 'popup',
+            label: 'Popup',
+            iconName: 'SquareArrowOutUpRight',
+        },
+        'USE IMAGE GENERATOR': {
+            type: 'image-generator',
+            label: 'Image Generator',
+            iconName: 'Image',
+        },
+        'USE PRIVACY': {
+            type: 'privacy',
+            label: 'Privacy',
+            iconName: 'Shield',
+        },
+        'USE CALENDAR': {
+            type: 'calendar',
+            label: 'Calendar',
+            iconName: 'Calendar',
+        },
+    };
+    /**
+     * Detects local slash-based references used by FROM and IMPORT commitments.
+     */
+    const LOCAL_AGENT_REFERENCE_PREFIXES = ['./', '../', '/'];
     /**
      * Creates the visible capabilities produced by one parsed commitment.
      *
@@ -21446,8 +21521,6 @@
     }
     /**
      * Clones one static capability descriptor for a simple capability commitment.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createSimpleCapability(commitmentType) {
         const capability = SIMPLE_CAPABILITY_BY_COMMITMENT_TYPE[commitmentType];
@@ -21455,8 +21528,6 @@
     }
     /**
      * Creates the USE PROJECT capability badge.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createProjectCapability(content) {
         var _a;
@@ -21470,8 +21541,6 @@
     }
     /**
      * Creates the FROM inheritance capability when the reference should stay visible in the profile.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createInheritanceCapability(content) {
         const reference = extractFirstCommitmentLine(content);
@@ -21498,8 +21567,6 @@
     }
     /**
      * Creates the IMPORT capability badge.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createImportCapability(content) {
         const reference = extractFirstCommitmentLine(content);
@@ -21527,8 +21594,6 @@
     }
     /**
      * Creates TEAM capability badges for all parsed teammates.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createTeamCapabilities(content) {
         const teammates = parseTeamCommitmentContent(content);
@@ -21541,8 +21606,6 @@
     }
     /**
      * Creates the KNOWLEDGE capability badge and records URL-based knowledge sources.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createKnowledgeCapability(state, content) {
         const trimmedContent = spacetrim.spaceTrim(content);
@@ -21557,8 +21620,6 @@
     }
     /**
      * Stores unique URL-based knowledge sources for later citation resolution.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function rememberKnowledgeSources(state, extractedUrls) {
         for (const extractedUrl of extractedUrls) {
@@ -21582,8 +21643,6 @@
     }
     /**
      * Derives the visible KNOWLEDGE badge label and icon from commitment content.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createKnowledgeCapabilityPresentation(content, extractedUrls) {
         let label = content;
@@ -21616,8 +21675,6 @@
     }
     /**
      * Shortens text-only KNOWLEDGE commitments into the same preview label as before.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function createKnowledgeTextLabel(content) {
         const words = content.split(/\s+/);
@@ -21626,186 +21683,89 @@
         }
         return content;
     }
-    /**
-     * Applies META-style commitments that mutate parsed profile metadata.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaCommitment(state, commitment) {
-        const applyMetaContent = META_COMMITMENT_APPLIERS[commitment.type];
-        if (applyMetaContent) {
-            applyMetaContent(state, commitment.content);
-            return;
-        }
-        if (commitment.type === 'META') {
-            applyGenericMetaCommitment(state, commitment.content);
-        }
-    }
-    /**
-     * Applies the generic META commitment form (`META TYPE value`).
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyGenericMetaCommitment(state, content) {
-        const metaTypeRaw = content.split(' ')[0] || 'NONE';
-        const metaValue = spacetrim.spaceTrim(content.substring(metaTypeRaw.length));
-        if (metaTypeRaw === 'LINK') {
-            state.links.push(metaValue);
-        }
-        if (metaTypeRaw.toUpperCase() === 'AVATAR') {
-            applyMetaAvatarContent(state, metaValue);
-            return;
-        }
-        const metaType = normalizeTo_camelCase(metaTypeRaw);
-        state.meta[metaType] = metaValue;
-    }
-    /**
-     * Applies META AVATAR content into the canonical `meta.avatar` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaAvatarContent(state, content) {
-        const avatarVisualId = resolveAvatarVisualId(content);
-        if (avatarVisualId) {
-            state.meta.avatar = avatarVisualId;
-            return;
-        }
-        delete state.meta.avatar;
-    }
-    /**
-     * Applies META LINK content into links and the canonical `meta.link` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaLinkContent(state, content) {
-        const linkValue = spacetrim.spaceTrim(content);
-        state.links.push(linkValue);
-        state.meta.link = linkValue;
-    }
-    /**
-     * Applies META DOMAIN content into the normalized `meta.domain` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaDomainContent(state, content) {
-        state.meta.domain = normalizeMetaDomain(content);
-    }
-    /**
-     * Applies META IMAGE content into the canonical `meta.image` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaImageContent(state, content) {
-        state.meta.image = spacetrim.spaceTrim(content);
-    }
-    /**
-     * Applies META DESCRIPTION content into the canonical `meta.description` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaDescriptionContent(state, content) {
-        state.meta.description = spacetrim.spaceTrim(content);
-    }
-    /**
-     * Applies META DISCLAIMER content into the canonical `meta.disclaimer` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaDisclaimerContent(state, content) {
-        state.meta.disclaimer = content;
-    }
-    /**
-     * Applies META INPUT PLACEHOLDER content into the canonical `meta.inputPlaceholder` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaInputPlaceholderContent(state, content) {
-        state.meta.inputPlaceholder = spacetrim.spaceTrim(content);
-    }
-    /**
-     * Applies MESSAGE SUFFIX content into the canonical `meta.messageSuffix` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMessageSuffixContent(state, content) {
-        state.meta.messageSuffix = content;
-    }
-    /**
-     * Applies META COLOR content into the canonical `meta.color` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaColorContent(state, content) {
-        state.meta.color = normalizeSeparator(content);
-    }
-    /**
-     * Applies META FONT content into the canonical `meta.font` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaFontContent(state, content) {
-        state.meta.font = normalizeSeparator(content);
-    }
-    /**
-     * Applies META VOICE content into the canonical `meta.voice` field.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function applyMetaVoiceContent(state, content) {
-        state.meta.voice = spacetrim.spaceTrim(content);
-    }
-    /**
-     * Ensures the parsed profile always exposes a fullname value.
-     *
-     * @private internal utility of `parseAgentSource`
-     */
-    function ensureMetaFullname(meta, fallbackFullname) {
-        if (!meta.fullname) {
-            meta.fullname = fallbackFullname;
-        }
-    }
     /**
      * Extracts the first logical line from multiline commitment content.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function extractFirstCommitmentLine(content) {
         return spacetrim.spaceTrim(content).split(/\r?\n/)[0] || '';
     }
     /**
      * Detects local FROM/IMPORT references that should use local-link labels and icons.
-     *
-     * @private internal utility of `parseAgentSource`
      */
     function isLocalAgentReference(reference) {
         return LOCAL_AGENT_REFERENCE_PREFIXES.some((prefix) => reference.startsWith(prefix));
     }
+
     /**
-     * Normalizes the separator in the content
-     *
-     * @param content - The content to normalize
-     * @returns The content with normalized separators
+     * Collects capability, sample, meta, link, and knowledge-source data from commitments.
      *
      * @private internal utility of `parseAgentSource`
      */
-    function normalizeSeparator(content) {
-        const trimmed = spacetrim.spaceTrim(content);
-        if (trimmed.includes(',')) {
-            return trimmed;
+    function extractParsedAgentProfile(commitments) {
+        const state = {
+            meta: {},
+            links: [],
+            capabilities: [],
+            samples: [],
+            knowledgeSources: [],
+            pendingUserMessage: null,
+            knownKnowledgeSourceUrls: new Set(),
+        };
+        for (const commitment of commitments) {
+            processParsedCommitment(state, commitment);
         }
-        return trimmed.split(/\s+/).join(', ');
+        return {
+            meta: state.meta,
+            links: state.links,
+            capabilities: state.capabilities,
+            samples: state.samples,
+            knowledgeSources: state.knowledgeSources,
+        };
     }
     /**
-     * Normalizes META DOMAIN content to a hostname-like value when possible.
+     * Processes one parsed commitment through the sample, capability, and meta stages.
+     */
+    function processParsedCommitment(state, commitment) {
+        if (consumeConversationSampleCommitment(state, commitment)) {
+            return;
+        }
+        const capabilities = createCapabilitiesFromCommitment(state, commitment);
+        if (capabilities.length > 0) {
+            state.capabilities.push(...capabilities);
+            return;
+        }
+        applyMetaCommitment(state, commitment);
+    }
+
+    /**
+     * Parses basic information from agent source
      *
-     * @param content - Raw META DOMAIN content.
-     * @returns Normalized domain or a trimmed fallback.
+     * There are 2 similar functions:
+     * - `parseAgentSource` which is a lightweight parser for agent source, it parses basic information and its purpose is to be quick and synchronous. The commitments there are hardcoded.
+     * - `createAgentModelRequirements` which is an asynchronous function that creates model requirements it applies each commitment one by one and works asynchronously.
      *
-     * @private internal utility of `parseAgentSource`
+     * @public exported from `@promptbook/core`
      */
-    function normalizeMetaDomain(content) {
-        const trimmed = spacetrim.spaceTrim(content);
-        return normalizeDomainForMatching(trimmed) || trimmed.toLowerCase();
+    function parseAgentSource(agentSource) {
+        const parseResult = parseAgentSourceWithCommitments(agentSource);
+        const resolvedAgentName = parseResult.agentName || createDefaultAgentName(agentSource);
+        const personaDescription = extractAgentProfileText(parseResult.commitments);
+        const initialMessage = extractInitialMessage(parseResult.commitments);
+        const parsedProfile = extractParsedAgentProfile(parseResult.commitments);
+        ensureMetaFullname(parsedProfile.meta, resolvedAgentName);
+        return {
+            agentName: normalizeAgentName(resolvedAgentName),
+            agentHash: computeAgentHash(agentSource),
+            permanentId: parsedProfile.meta.id,
+            personaDescription,
+            initialMessage,
+            meta: parsedProfile.meta,
+            links: parsedProfile.links,
+            parameters: parseParameters(agentSource),
+            capabilities: parsedProfile.capabilities,
+            samples: parsedProfile.samples,
+            knowledgeSources: parsedProfile.knowledgeSources,
+        };
     }
     // TODO: [🕛] Unite `AgentBasicInformation`, `ChatParticipant`, `LlmExecutionTools` +  `LlmToolsMetadata`
 
@@ -35650,422 +35610,123 @@
                         updateTldr({
                             percent: percent,
                             message,
-                        });
-                    });
-                },
-            });
-        };
-        //        <- TODO: Make types such as there is no need to do `as` for `createTask`
-        return pipelineExecutor;
-    }
-
-    /**
-     * Prepares the persona for the pipeline
-     *
-     * @see https://github.com/webgptorg/promptbook/discussions/22
-     *
-     * @public exported from `@promptbook/core`
-     */
-    async function preparePersona(personaDescription, tools, options) {
-        const { isVerbose = DEFAULT_IS_VERBOSE } = options;
-        if (tools === undefined || tools.llm === undefined) {
-            throw new MissingToolsError('LLM tools are required for preparing persona');
-        }
-        // TODO: [🌼] In future use `ptbk make` and made getPipelineCollection
-        const collection = createPipelineCollectionFromJson(...PipelineCollection);
-        const preparePersonaExecutor = createPipelineExecutor({
-            pipeline: await collection.getPipelineByUrl('https://promptbook.studio/promptbook/prepare-persona.book'),
-            tools,
-        });
-        const llmTools = getSingleLlmExecutionTools(tools.llm);
-        const availableModels = (await llmTools.listModels())
-            .filter(({ modelVariant }) => modelVariant === 'CHAT')
-            .map(({ modelName, modelDescription }) => ({
-            modelName,
-            modelDescription,
-            // <- Note: `modelTitle` and `modelVariant` is not relevant for this task
-        }));
-        const result = await preparePersonaExecutor({
-            availableModels /* <- Note: Passing as JSON */,
-            personaDescription,
-        }).asPromise({ isCrashedOnError: true });
-        const { outputParameters } = result;
-        const { modelsRequirements: modelsRequirementsJson } = outputParameters;
-        let modelsRequirementsUnchecked = jsonParse(modelsRequirementsJson);
-        if (isVerbose) {
-            console.info(`PERSONA ${personaDescription}`, modelsRequirementsUnchecked);
-        }
-        if (!Array.isArray(modelsRequirementsUnchecked)) {
-            // <- TODO: Book should have syntax and system to enforce shape of JSON
-            modelsRequirementsUnchecked = [modelsRequirementsUnchecked];
-            /*
-            throw new UnexpectedError(
-                spaceTrim(
-                    (block) => `
-                        Invalid \`modelsRequirements\`:
-
-                        \`\`\`json
-                        ${block(JSON.stringify(modelsRequirementsUnchecked, null, 4))}
-                        \`\`\`
-                    `,
-                ),
-            );
-            */
-        }
-        const modelsRequirements = modelsRequirementsUnchecked.map((modelRequirements) => ({
-            modelVariant: 'CHAT',
-            ...modelRequirements,
-        }));
-        return {
-            modelsRequirements,
-        };
-    }
-    // TODO: [😩] DRY `preparePersona` and `selectBestModelFromAvailable`
-    // TODO: [🔃][main] If the persona was prepared with different version or different set of models, prepare it once again
-    // TODO: [🏢] Check validity of `modelName` in pipeline
-    // TODO: [🏢] Check validity of `systemMessage` in pipeline
-    // TODO: [🏢] Check validity of `temperature` in pipeline
-
-    /**
-     * Creates an empty/basic agent model requirements object
-     * This serves as the starting point for the reduce-like pattern
-     * where each commitment applies its changes to build the final requirements
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function createEmptyAgentModelRequirements() {
-        return {
-            systemMessage: '',
-            promptSuffix: '',
-            // modelName: 'gpt-5',
-            modelName: 'gpt-5.4-mini',
-            temperature: 0.7,
-            topP: 0.9,
-            topK: 50,
-            parentAgentUrl: null,
-            isClosed: false,
-        };
-    }
-    /**
-     * Creates a basic agent model requirements with just the agent name
-     * This is used when we have an agent name but no commitments
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function createBasicAgentModelRequirements(agentName) {
-        const empty = createEmptyAgentModelRequirements();
-        return {
-            ...empty,
-            systemMessage: `You are ${agentName || 'AI Agent'}`,
-        };
-    }
-    // TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
-
-    /**
-     * Plugin for importing agent books *(`.book` files)*
-     *
-     * @private [🥝] Maybe export the import plugins through some package
-     */
-    const AgentFileImportPlugin = {
-        name: 'agent-file-import-plugin',
-        canImport(mimeType) {
-            // [🧠] Should we have a specific MIME type for agent books?
-            // For now, let's assume it's identified by .book extension or certain MIME types if provided
-            return mimeType === 'text/x-promptbook' || mimeType === 'application/x-promptbook';
-        },
-        import(content) {
-            const parseResult = parseAgentSourceWithCommitments(content);
-            // Bring only the agent corpus (non-commitment lines and relevant commitments)
-            // Stripping the agent name (which is usually the first line)
-            const corpus = parseResult.nonCommitmentLines
-                .filter((line, index) => index > 0 || !parseResult.agentName)
-                .join('\n')
-                .trim();
-            // Also include relevant commitments that make up the "corpus" of the agent
-            // For example PERSONA, RULE, KNOWLEDGE
-            const relevantCommitments = parseResult.commitments
-                .filter((c) => ['PERSONA', 'RULE', 'KNOWLEDGE'].includes(c.type))
-                .map((c) => `${c.type} ${c.content}`)
-                .join('\n\n');
-            return spacetrim.spaceTrim((block) => `
-                ${block(relevantCommitments)}
-
-                ${block(corpus)}
-            `).trim();
-        },
-    };
-
-    /**
-     * Plugin for importing JSON files
-     *
-     * @private [🥝] Maybe export the import plugins through some package
-     */
-    const JsonFileImportPlugin = {
-        name: 'json-file-import-plugin',
-        canImport(mimeType) {
-            return mimeType === 'application/json' || mimeType.endsWith('+json');
-        },
-        import(content) {
-            try {
-                const json = JSON.parse(content);
-                const formattedJson = JSON.stringify(json, null, 4);
-                return `\`\`\`json\n${formattedJson}\n\`\`\``;
-            }
-            catch (error) {
-                // If JSON is invalid, still import it but maybe not as pretty JSON
-                return `\`\`\`json\n${content}\n\`\`\``;
-            }
-        },
-    };
-
-    /**
-     * Plugin for importing generic text files
-     *
-     * @private [🥝] Maybe export the import plugins through some package
-     */
-    const TextFileImportPlugin = {
-        name: 'text-file-import-plugin',
-        canImport(mimeType) {
-            return (mimeType === 'text/plain' ||
-                mimeType === 'text/markdown' ||
-                mimeType === 'text/x-typescript' ||
-                mimeType === 'text/javascript' ||
-                mimeType === 'text/css' ||
-                mimeType === 'text/html' ||
-                mimeType.startsWith('text/'));
-        },
-        import(content, mimeType) {
-            const extension = mimeTypeToExtension(mimeType);
-            const codeBlockType = extension || 'txt';
-            return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
-        },
-    };
-
-    /**
-     * All available file import plugins
-     *
-     * @private [🥝] Maybe export the import plugins through some package
-     */
-    const $fileImportPlugins = [
-        AgentFileImportPlugin,
-        JsonFileImportPlugin,
-        TextFileImportPlugin,
-    ];
-
-    /**
-     * Removes single-hash comment lines (`# Comment`) from a system message
-     * This is used to clean up the final system message before sending it to the AI model
-     * while preserving the original content with comments in metadata
-     *
-     * @param systemMessage The system message that may contain comment lines
-     * @returns The system message with single-hash comment lines removed
-     *
-     * @private - TODO: [🧠] Maybe should be public?
-     */
-    function removeCommentsFromSystemMessage(systemMessage) {
-        if (!systemMessage) {
-            return systemMessage;
-        }
-        const lines = systemMessage.split(/\r?\n/);
-        const filteredLines = lines.filter((line) => {
-            const trimmedLine = line.trim();
-            // Remove only single-hash comment markers (`# Comment`) and keep markdown headings (`## Heading`).
-            return !/^#(?!#)\s/.test(trimmedLine);
-        });
-        return filteredLines.join('\n').trim();
-    }
-
-    /**
-     * Commitment types whose content may contain compact agent references that must be resolved before applying the commitment.
-     *
-     * @private internal constant of `createAgentModelRequirementsWithCommitments`
-     */
-    const COMMITMENTS_WITH_AGENT_REFERENCES = new Set(['FROM', 'IMPORT', 'IMPORTS', 'TEAM']);
-    /**
-     * DELETE-like commitment types that invalidate earlier tagged commitments.
-     *
-     * @private internal constant of `createAgentModelRequirementsWithCommitments`
-     */
-    const DELETE_COMMITMENT_TYPES = new Set(['DELETE', 'CANCEL', 'DISCARD', 'REMOVE']);
-    /**
-     * Commitments whose earlier occurrences are overwritten by the last occurrence in source order.
-     *
-     * @private internal constant of `createAgentModelRequirementsWithCommitments`
-     */
-    const OVERWRITTEN_COMMITMENT_GROUP_BY_TYPE = new Map([
-        ['GOAL', 'GOAL'],
-        ['GOALS', 'GOAL'],
-    ]);
-    /**
-     * Regex pattern matching markdown horizontal lines that should not be copied into the final system message.
-     *
-     * @private internal constant of `createAgentModelRequirementsWithCommitments`
-     */
-    const HORIZONTAL_LINE_PATTERN = /^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/;
-    /**
-     * MIME type prefixes treated as binary and therefore not eligible for text import plugins.
-     *
-     * @private internal constant of `createAgentModelRequirementsWithCommitments`
-     */
-    const BINARY_MIME_TYPE_PREFIXES = [
-        'image/',
-        'video/',
-        'audio/',
-        'application/octet-stream',
-        'application/pdf',
-        'application/zip',
-    ];
-    /**
-     * Returns a safe fallback content when a resolver fails to transform a reference commitment.
-     *
-     * @param commitmentType - Commitment being resolved.
-     * @param originalContent - Original unresolved commitment content.
-     * @returns Fallback content that keeps requirement creation resilient.
-     *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
-     */
-    function getSafeReferenceCommitmentFallback(commitmentType, originalContent) {
-        if (commitmentType === 'FROM') {
-            return 'VOID';
-        }
-        if (commitmentType === 'IMPORT' || commitmentType === 'IMPORTS' || commitmentType === 'TEAM') {
-            return '';
-        }
-        return originalContent;
-    }
-    /**
-     * Creates agent model requirements by parsing commitments, applying them in source order,
-     * and finalizing derived sections such as imports, example interactions, and inline knowledge uploads.
-     *
-     * @param agentSource - Agent source book to parse.
-     * @param modelName - Optional override for the agent model name.
-     * @param options - Additional options such as reference and teammate resolvers.
-     * @returns Fully prepared model requirements for the parsed agent source.
-     *
-     * @private internal utility of `createAgentModelRequirements`
-     */
-    async function createAgentModelRequirementsWithCommitments(agentSource, modelName, options) {
-        const parseResult = parseAgentSourceWithCommitments(agentSource);
-        const filteredCommitments = filterOverwrittenCommitments(filterDeletedCommitments(parseResult.commitments));
-        let requirements = createInitialAgentModelRequirements(parseResult.agentName, modelName);
-        requirements = await applyCommitmentsToRequirements(requirements, filteredCommitments, options);
-        requirements = aggregateUseCommitmentSystemMessages(requirements, filteredCommitments);
-        requirements = await importReferencedFiles(requirements);
-        requirements = appendMcpServers(requirements, agentSource);
-        requirements = appendNonCommitmentContent(requirements, parseResult);
-        requirements = appendExampleInteractions(requirements, parseResult);
-        requirements = await applyPendingInlineKnowledgeSources(requirements, options === null || options === void 0 ? void 0 : options.inlineKnowledgeSourceUploader);
-        return finalizeRequirements(requirements);
-    }
-    /**
-     * Removes earlier commitments that are overwritten by later commitments of the same semantic group.
-     *
-     * This currently keeps only the last `GOAL` / `GOALS` commitment so inheritance rewrites
-     * and multi-goal sources expose one effective goal to the runtime.
-     *
-     * @param commitments - Parsed commitments after DELETE-like filtering.
-     * @returns Commitments with overwritten entries removed while preserving source order.
-     *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
-     */
-    function filterOverwrittenCommitments(commitments) {
-        const seenOverwriteGroups = new Set();
-        const keptCommitments = [];
-        for (let index = commitments.length - 1; index >= 0; index--) {
-            const commitment = commitments[index];
-            const overwriteGroup = OVERWRITTEN_COMMITMENT_GROUP_BY_TYPE.get(commitment.type);
-            if (!overwriteGroup) {
-                keptCommitments.push(commitment);
-                continue;
-            }
-            if (seenOverwriteGroups.has(overwriteGroup)) {
-                continue;
-            }
-            seenOverwriteGroups.add(overwriteGroup);
-            keptCommitments.push(commitment);
-        }
-        return keptCommitments.reverse();
+                        });
+                    });
+                },
+            });
+        };
+        //        <- TODO: Make types such as there is no need to do `as` for `createTask`
+        return pipelineExecutor;
     }
+
     /**
-     * Creates the initial requirements object with the parsed agent name stored in metadata and an optional model override.
+     * Prepares the persona for the pipeline
      *
-     * @param agentName - Parsed agent name from the source prelude.
-     * @param modelName - Optional explicit model name override.
-     * @returns Initial requirements before any commitment is applied.
+     * @see https://github.com/webgptorg/promptbook/discussions/22
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @public exported from `@promptbook/core`
      */
-    function createInitialAgentModelRequirements(agentName, modelName) {
-        const initialRequirements = createBasicAgentModelRequirements(agentName);
-        const requirementsWithMetadata = {
-            ...initialRequirements,
-            _metadata: {
-                ...initialRequirements._metadata,
-                agentName,
-            },
-        };
-        if (!modelName) {
-            return requirementsWithMetadata;
+    async function preparePersona(personaDescription, tools, options) {
+        const { isVerbose = DEFAULT_IS_VERBOSE } = options;
+        if (tools === undefined || tools.llm === undefined) {
+            throw new MissingToolsError('LLM tools are required for preparing persona');
         }
-        return {
-            ...requirementsWithMetadata,
+        // TODO: [🌼] In future use `ptbk make` and made getPipelineCollection
+        const collection = createPipelineCollectionFromJson(...PipelineCollection);
+        const preparePersonaExecutor = createPipelineExecutor({
+            pipeline: await collection.getPipelineByUrl('https://promptbook.studio/promptbook/prepare-persona.book'),
+            tools,
+        });
+        const llmTools = getSingleLlmExecutionTools(tools.llm);
+        const availableModels = (await llmTools.listModels())
+            .filter(({ modelVariant }) => modelVariant === 'CHAT')
+            .map(({ modelName, modelDescription }) => ({
             modelName,
+            modelDescription,
+            // <- Note: `modelTitle` and `modelVariant` is not relevant for this task
+        }));
+        const result = await preparePersonaExecutor({
+            availableModels /* <- Note: Passing as JSON */,
+            personaDescription,
+        }).asPromise({ isCrashedOnError: true });
+        const { outputParameters } = result;
+        const { modelsRequirements: modelsRequirementsJson } = outputParameters;
+        let modelsRequirementsUnchecked = jsonParse(modelsRequirementsJson);
+        if (isVerbose) {
+            console.info(`PERSONA ${personaDescription}`, modelsRequirementsUnchecked);
+        }
+        if (!Array.isArray(modelsRequirementsUnchecked)) {
+            // <- TODO: Book should have syntax and system to enforce shape of JSON
+            modelsRequirementsUnchecked = [modelsRequirementsUnchecked];
+            /*
+            throw new UnexpectedError(
+                spaceTrim(
+                    (block) => `
+                        Invalid \`modelsRequirements\`:
+
+                        \`\`\`json
+                        ${block(JSON.stringify(modelsRequirementsUnchecked, null, 4))}
+                        \`\`\`
+                    `,
+                ),
+            );
+            */
+        }
+        const modelsRequirements = modelsRequirementsUnchecked.map((modelRequirements) => ({
+            modelVariant: 'CHAT',
+            ...modelRequirements,
+        }));
+        return {
+            modelsRequirements,
         };
     }
+    // TODO: [😩] DRY `preparePersona` and `selectBestModelFromAvailable`
+    // TODO: [🔃][main] If the persona was prepared with different version or different set of models, prepare it once again
+    // TODO: [🏢] Check validity of `modelName` in pipeline
+    // TODO: [🏢] Check validity of `systemMessage` in pipeline
+    // TODO: [🏢] Check validity of `temperature` in pipeline
+
     /**
-     * Applies DELETE-like invalidation commitments and returns only commitments that should continue through the pipeline.
-     *
-     * @param commitments - Parsed commitments in original source order.
-     * @returns Filtered commitments with earlier deleted items removed.
+     * Creates an empty/basic agent model requirements object
+     * This serves as the starting point for the reduce-like pattern
+     * where each commitment applies its changes to build the final requirements
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @public exported from `@promptbook/core`
      */
-    function filterDeletedCommitments(commitments) {
-        const filteredCommitments = [];
-        for (const commitment of commitments) {
-            if (!isDeleteCommitmentType(commitment.type)) {
-                filteredCommitments.push(commitment);
-                continue;
-            }
-            const targetParameterNames = getCommitmentParameterNames(commitment.content);
-            if (targetParameterNames.length === 0) {
-                continue;
-            }
-            for (let index = filteredCommitments.length - 1; index >= 0; index--) {
-                const previousCommitment = filteredCommitments[index];
-                const previousParameterNames = getCommitmentParameterNames(previousCommitment.content);
-                const isTargeted = previousParameterNames.some((parameterName) => targetParameterNames.includes(parameterName));
-                if (isTargeted) {
-                    filteredCommitments.splice(index, 1);
-                }
-            }
-        }
-        return filteredCommitments;
+    function createEmptyAgentModelRequirements() {
+        return {
+            systemMessage: '',
+            promptSuffix: '',
+            // modelName: 'gpt-5',
+            modelName: 'gpt-5.4-mini',
+            temperature: 0.7,
+            topP: 0.9,
+            topK: 50,
+            parentAgentUrl: null,
+            isClosed: false,
+        };
     }
     /**
-     * Checks whether a commitment type behaves like DELETE and therefore invalidates earlier tagged commitments.
-     *
-     * @param commitmentType - Commitment type to check.
-     * @returns `true` when the commitment removes prior tagged commitments.
+     * Creates a basic agent model requirements with just the agent name
+     * This is used when we have an agent name but no commitments
      *
-     * @private internal utility of `filterDeletedCommitments`
+     * @public exported from `@promptbook/core`
      */
-    function isDeleteCommitmentType(commitmentType) {
-        return DELETE_COMMITMENT_TYPES.has(commitmentType);
+    function createBasicAgentModelRequirements(agentName) {
+        const empty = createEmptyAgentModelRequirements();
+        return {
+            ...empty,
+            systemMessage: `You are ${agentName || 'AI Agent'}`,
+        };
     }
+    // TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
+
     /**
-     * Extracts normalized parameter names used for DELETE-like invalidation matching.
-     *
-     * @param content - Commitment content to parse.
-     * @returns Lower-cased non-empty parameter names.
+     * Commitment types whose content may contain compact agent references that must be resolved before applying the commitment.
      *
-     * @private internal utility of `filterDeletedCommitments`
+     * @private internal constant of `applyCommitmentsToAgentModelRequirements`
      */
-    function getCommitmentParameterNames(content) {
-        return parseParameters(content)
-            .map((parameter) => parameter.name.trim().toLowerCase())
-            .filter(Boolean);
-    }
+    const COMMITMENTS_WITH_AGENT_REFERENCES = new Set(['FROM', 'IMPORT', 'IMPORTS', 'TEAM']);
     /**
      * Applies parsed commitments one by one while keeping the per-commitment steps focused and easy to follow.
      *
@@ -36074,9 +35735,9 @@
      * @param options - Optional reference and teammate resolvers.
      * @returns Requirements after all applicable commitments are processed.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private function of `createAgentModelRequirementsWithCommitments`
      */
-    async function applyCommitmentsToRequirements(requirements, commitments, options) {
+    async function applyCommitmentsToAgentModelRequirements(requirements, commitments, options) {
         for (const [index, commitment] of commitments.entries()) {
             if (shouldSkipCommitmentApplication(commitment, index, commitments.length)) {
                 continue;
@@ -36094,7 +35755,7 @@
      * @param agentReferenceResolver - Optional resolver for compact agent references.
      * @returns Original or resolved commitment content.
      *
-     * @private internal utility of `applyCommitmentsToRequirements`
+     * @private internal utility of `applyCommitmentsToAgentModelRequirements`
      */
     async function resolveCommitmentContent(commitment, agentReferenceResolver) {
         if (!agentReferenceResolver || !isAgentReferenceCommitment(commitment.type)) {
@@ -36108,6 +35769,24 @@
             return getSafeReferenceCommitmentFallback(commitment.type, commitment.content);
         }
     }
+    /**
+     * Returns a safe fallback content when a resolver fails to transform a reference commitment.
+     *
+     * @param commitmentType - Commitment being resolved.
+     * @param originalContent - Original unresolved commitment content.
+     * @returns Fallback content that keeps requirement creation resilient.
+     *
+     * @private internal utility of `applyCommitmentsToAgentModelRequirements`
+     */
+    function getSafeReferenceCommitmentFallback(commitmentType, originalContent) {
+        if (commitmentType === 'FROM') {
+            return 'VOID';
+        }
+        if (commitmentType === 'IMPORT' || commitmentType === 'IMPORTS' || commitmentType === 'TEAM') {
+            return '';
+        }
+        return originalContent;
+    }
     /**
      * Checks whether the commitment content may need agent-reference resolution before application.
      *
@@ -36127,7 +35806,7 @@
      * @param commitmentCount - Total number of filtered commitments.
      * @returns `true` when the commitment should not be applied.
      *
-     * @private internal utility of `applyCommitmentsToRequirements`
+     * @private internal utility of `applyCommitmentsToAgentModelRequirements`
      */
     function shouldSkipCommitmentApplication(commitment, commitmentIndex, commitmentCount) {
         return commitment.type === 'CLOSED' && commitmentIndex !== commitmentCount - 1;
@@ -36141,7 +35820,7 @@
      * @param options - Optional teammate profile resolvers.
      * @returns Requirements with pre-resolved teammate profiles stored in metadata when possible.
      *
-     * @private internal utility of `applyCommitmentsToRequirements`
+     * @private internal utility of `applyCommitmentsToAgentModelRequirements`
      */
     async function preResolveTeammateProfilesForTeamCommitment(requirements, commitment, commitmentContent, options) {
         var _a;
@@ -36196,7 +35875,7 @@
      * @param commitmentContent - Final content passed into the definition.
      * @returns Updated requirements, or the original requirements when the commitment fails.
      *
-     * @private internal utility of `applyCommitmentsToRequirements`
+     * @private internal utility of `applyCommitmentsToAgentModelRequirements`
      */
     function applyCommitmentDefinitionSafely(requirements, commitment, commitmentContent) {
         const definition = getCommitmentDefinition(commitment.type);
@@ -36211,13 +35890,140 @@
             return requirements;
         }
     }
+
+    /**
+     * Plugin for importing agent books *(`.book` files)*
+     *
+     * @private [🥝] Maybe export the import plugins through some package
+     */
+    const AgentFileImportPlugin = {
+        name: 'agent-file-import-plugin',
+        canImport(mimeType) {
+            // [🧠] Should we have a specific MIME type for agent books?
+            // For now, let's assume it's identified by .book extension or certain MIME types if provided
+            return mimeType === 'text/x-promptbook' || mimeType === 'application/x-promptbook';
+        },
+        import(content) {
+            const parseResult = parseAgentSourceWithCommitments(content);
+            // Bring only the agent corpus (non-commitment lines and relevant commitments)
+            // Stripping the agent name (which is usually the first line)
+            const corpus = parseResult.nonCommitmentLines
+                .filter((line, index) => index > 0 || !parseResult.agentName)
+                .join('\n')
+                .trim();
+            // Also include relevant commitments that make up the "corpus" of the agent
+            // For example PERSONA, RULE, KNOWLEDGE
+            const relevantCommitments = parseResult.commitments
+                .filter((c) => ['PERSONA', 'RULE', 'KNOWLEDGE'].includes(c.type))
+                .map((c) => `${c.type} ${c.content}`)
+                .join('\n\n');
+            return spacetrim.spaceTrim((block) => `
+                ${block(relevantCommitments)}
+
+                ${block(corpus)}
+            `).trim();
+        },
+    };
+
+    /**
+     * Plugin for importing JSON files
+     *
+     * @private [🥝] Maybe export the import plugins through some package
+     */
+    const JsonFileImportPlugin = {
+        name: 'json-file-import-plugin',
+        canImport(mimeType) {
+            return mimeType === 'application/json' || mimeType.endsWith('+json');
+        },
+        import(content) {
+            try {
+                const json = JSON.parse(content);
+                const formattedJson = JSON.stringify(json, null, 4);
+                return `\`\`\`json\n${formattedJson}\n\`\`\``;
+            }
+            catch (error) {
+                // If JSON is invalid, still import it but maybe not as pretty JSON
+                return `\`\`\`json\n${content}\n\`\`\``;
+            }
+        },
+    };
+
+    /**
+     * Plugin for importing generic text files
+     *
+     * @private [🥝] Maybe export the import plugins through some package
+     */
+    const TextFileImportPlugin = {
+        name: 'text-file-import-plugin',
+        canImport(mimeType) {
+            return (mimeType === 'text/plain' ||
+                mimeType === 'text/markdown' ||
+                mimeType === 'text/x-typescript' ||
+                mimeType === 'text/javascript' ||
+                mimeType === 'text/css' ||
+                mimeType === 'text/html' ||
+                mimeType.startsWith('text/'));
+        },
+        import(content, mimeType) {
+            const extension = mimeTypeToExtension(mimeType);
+            const codeBlockType = extension || 'txt';
+            return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+        },
+    };
+
+    /**
+     * All available file import plugins
+     *
+     * @private [🥝] Maybe export the import plugins through some package
+     */
+    const $fileImportPlugins = [
+        AgentFileImportPlugin,
+        JsonFileImportPlugin,
+        TextFileImportPlugin,
+    ];
+
+    /**
+     * Regex pattern matching markdown horizontal lines that should not be copied into the final system message.
+     *
+     * @private internal constant of `augmentAgentModelRequirementsFromSource`
+     */
+    const HORIZONTAL_LINE_PATTERN = /^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/;
+    /**
+     * MIME type prefixes treated as binary and therefore not eligible for text import plugins.
+     *
+     * @private internal constant of `augmentAgentModelRequirementsFromSource`
+     */
+    const BINARY_MIME_TYPE_PREFIXES = [
+        'image/',
+        'video/',
+        'audio/',
+        'application/octet-stream',
+        'application/pdf',
+        'application/zip',
+    ];
+    /**
+     * Adds source-derived sections after commitments have been applied.
+     *
+     * @param requirements - Requirements after commitment application and USE aggregation.
+     * @param parseResult - Parsed source used to recover non-commitment prose and examples.
+     * @param agentSource - Original source used to recover MCP server declarations.
+     * @returns Requirements with source-derived sections appended.
+     *
+     * @private function of `createAgentModelRequirementsWithCommitments`
+     */
+    async function augmentAgentModelRequirementsFromSource(requirements, parseResult, agentSource) {
+        requirements = await importReferencedFiles(requirements);
+        requirements = appendMcpServers(requirements, agentSource);
+        requirements = appendNonCommitmentContent(requirements, parseResult);
+        return appendExampleInteractions(requirements, parseResult);
+    }
     /**
      * Imports text files referenced by IMPORT commitments and appends their transformed content to the system message.
      *
      * @param requirements - Requirements possibly containing `importedFileUrls`.
      * @returns Requirements with imported file content appended to the system message.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private internal utility of `augmentAgentModelRequirementsFromSource`
      */
     async function importReferencedFiles(requirements) {
         const importedFileUrls = requirements.importedFileUrls;
@@ -36303,7 +36109,7 @@
      * @param agentSource - Original agent source used for MCP extraction.
      * @returns Requirements with `mcpServers` set when MCP commitments are present.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private internal utility of `augmentAgentModelRequirementsFromSource`
      */
     function appendMcpServers(requirements, agentSource) {
         const mcpServers = extractMcpServers(agentSource);
@@ -36322,7 +36128,7 @@
      * @param parseResult - Parsed source including non-commitment lines.
      * @returns Requirements with the remaining prose appended to the system message.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private internal utility of `augmentAgentModelRequirementsFromSource`
      */
     function appendNonCommitmentContent(requirements, parseResult) {
         const nonCommitmentContent = getNonCommitmentContent(parseResult);
@@ -36365,7 +36171,7 @@
      * @param parseResult - Parsed source used to recover initial message content.
      * @returns Requirements with the example interaction block appended when examples exist.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private internal utility of `augmentAgentModelRequirementsFromSource`
      */
     function appendExampleInteractions(requirements, parseResult) {
         const exampleInteractionsContent = createExampleInteractionsContent(parseResult, requirements.samples);
@@ -36420,7 +36226,7 @@
      * @param section - Section content to append.
      * @returns Requirements with the additional system-message block appended.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private internal utility of `augmentAgentModelRequirementsFromSource`
      */
     function appendSystemMessageSection(requirements, section) {
         return {
@@ -36429,29 +36235,149 @@
         };
     }
     /**
-     * Performs the final system-message cleanup pass after all other augmentation steps are complete.
+     * Mocked security check for imported files.
      *
-     * @param requirements - Fully built requirements before final cleanup.
-     * @returns Requirements with comment lines removed from the final system message.
+     * @param urlOrPath - The URL or local path of the file to check.
+     * @returns A promise that resolves if the file is considered safe.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private internal utility of `createImportedFileSystemMessage`
      */
-    function finalizeRequirements(requirements) {
-        return {
-            ...requirements,
-            systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
-        };
+    async function mockedSecurityCheck(urlOrPath) {
+        // TODO: Implement proper security checks
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        if (urlOrPath.includes('malicious')) {
+            throw new Error(`Security check failed for: ${urlOrPath}`);
+        }
+    }
+    /**
+     * Checks whether the given MIME type belongs to a binary file.
+     *
+     * @param mimeType - The MIME type to check.
+     * @returns `true` when the MIME type is treated as binary.
+     *
+     * @private internal utility of `createImportedFileSystemMessage`
+     */
+    function isBinaryMimeType(mimeType) {
+        return BINARY_MIME_TYPE_PREFIXES.some((prefix) => mimeType.startsWith(prefix));
+    }
+
+    /**
+     * DELETE-like commitment types that invalidate earlier tagged commitments.
+     *
+     * @private internal constant of `filterCommitmentsForAgentModelRequirements`
+     */
+    const DELETE_COMMITMENT_TYPES = new Set(['DELETE', 'CANCEL', 'DISCARD', 'REMOVE']);
+    /**
+     * Commitments whose earlier occurrences are overwritten by the last occurrence in source order.
+     *
+     * @private internal constant of `filterCommitmentsForAgentModelRequirements`
+     */
+    const OVERWRITTEN_COMMITMENT_GROUP_BY_TYPE = new Map([
+        ['GOAL', 'GOAL'],
+        ['GOALS', 'GOAL'],
+    ]);
+    /**
+     * Applies the commitment filtering rules used before commitment definitions are executed.
+     *
+     * @param commitments - Parsed commitments in original source order.
+     * @returns Commitments after DELETE-like invalidation and overwritten-goal filtering.
+     *
+     * @private function of `createAgentModelRequirementsWithCommitments`
+     */
+    function filterCommitmentsForAgentModelRequirements(commitments) {
+        return filterOverwrittenCommitments(filterDeletedCommitments(commitments));
+    }
+    /**
+     * Removes earlier commitments that are overwritten by later commitments of the same semantic group.
+     *
+     * @param commitments - Parsed commitments after DELETE-like filtering.
+     * @returns Commitments with overwritten entries removed while preserving source order.
+     *
+     * @private internal utility of `filterCommitmentsForAgentModelRequirements`
+     */
+    function filterOverwrittenCommitments(commitments) {
+        const seenOverwriteGroups = new Set();
+        const keptCommitments = [];
+        for (let index = commitments.length - 1; index >= 0; index--) {
+            const commitment = commitments[index];
+            const overwriteGroup = OVERWRITTEN_COMMITMENT_GROUP_BY_TYPE.get(commitment.type);
+            if (!overwriteGroup) {
+                keptCommitments.push(commitment);
+                continue;
+            }
+            if (seenOverwriteGroups.has(overwriteGroup)) {
+                continue;
+            }
+            seenOverwriteGroups.add(overwriteGroup);
+            keptCommitments.push(commitment);
+        }
+        return keptCommitments.reverse();
+    }
+    /**
+     * Applies DELETE-like invalidation commitments and returns only commitments that should continue through the pipeline.
+     *
+     * @param commitments - Parsed commitments in original source order.
+     * @returns Filtered commitments with earlier deleted items removed.
+     *
+     * @private internal utility of `filterCommitmentsForAgentModelRequirements`
+     */
+    function filterDeletedCommitments(commitments) {
+        const filteredCommitments = [];
+        for (const commitment of commitments) {
+            if (!isDeleteCommitmentType(commitment.type)) {
+                filteredCommitments.push(commitment);
+                continue;
+            }
+            const targetParameterNames = getCommitmentParameterNames(commitment.content);
+            if (targetParameterNames.length === 0) {
+                continue;
+            }
+            for (let index = filteredCommitments.length - 1; index >= 0; index--) {
+                const previousCommitment = filteredCommitments[index];
+                const previousParameterNames = getCommitmentParameterNames(previousCommitment.content);
+                const isTargeted = previousParameterNames.some((parameterName) => targetParameterNames.includes(parameterName));
+                if (isTargeted) {
+                    filteredCommitments.splice(index, 1);
+                }
+            }
+        }
+        return filteredCommitments;
+    }
+    /**
+     * Checks whether a commitment type behaves like DELETE and therefore invalidates earlier tagged commitments.
+     *
+     * @param commitmentType - Commitment type to check.
+     * @returns `true` when the commitment removes prior tagged commitments.
+     *
+     * @private internal utility of `filterDeletedCommitments`
+     */
+    function isDeleteCommitmentType(commitmentType) {
+        return DELETE_COMMITMENT_TYPES.has(commitmentType);
+    }
+    /**
+     * Extracts normalized parameter names used for DELETE-like invalidation matching.
+     *
+     * @param content - Commitment content to parse.
+     * @returns Lower-cased non-empty parameter names.
+     *
+     * @private internal utility of `filterDeletedCommitments`
+     */
+    function getCommitmentParameterNames(content) {
+        return parseParameters(content)
+            .map((parameter) => parameter.name.trim().toLowerCase())
+            .filter(Boolean);
     }
+
     /**
-     * Attempts to upload inline knowledge entries, falling back to legacy data URLs when the upload fails or is not configured.
+     * Converts staged inline knowledge files into the final knowledge source URLs stored on requirements.
      *
      * @param requirements - Current requirements snapshot.
      * @param uploader - Optional uploader for inline knowledge files.
      * @returns Requirements with inline knowledge converted into upload URLs or data URLs.
      *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     * @private function of `createAgentModelRequirementsWithCommitments`
      */
-    async function applyPendingInlineKnowledgeSources(requirements, uploader) {
+    async function materializeInlineKnowledgeSources(requirements, uploader) {
         var _a;
         const inlineSources = extractInlineKnowledgeSources(requirements._metadata);
         if (inlineSources.length === 0) {
@@ -36477,7 +36403,7 @@
      * @param uploader - Upload implementation provided by the caller.
      * @returns Uploaded knowledge URL or a legacy data URL fallback.
      *
-     * @private internal utility of `applyPendingInlineKnowledgeSources`
+     * @private internal utility of `materializeInlineKnowledgeSources`
      */
     async function uploadInlineKnowledgeSourceWithFallback(inlineSource, uploader) {
         try {
@@ -36497,7 +36423,7 @@
      * @param metadata - Current requirements metadata.
      * @returns Inline knowledge files collected during commitment application.
      *
-     * @private internal utility of `applyPendingInlineKnowledgeSources`
+     * @private internal utility of `materializeInlineKnowledgeSources`
      */
     function extractInlineKnowledgeSources(metadata) {
         if (!metadata) {
@@ -36512,7 +36438,7 @@
      * @param metadata - Current requirements metadata.
      * @returns Metadata without the temporary inline knowledge staging field.
      *
-     * @private internal utility of `applyPendingInlineKnowledgeSources`
+     * @private internal utility of `materializeInlineKnowledgeSources`
      */
     function stripInlineKnowledgeMetadata(metadata) {
         if (!metadata || !Object.prototype.hasOwnProperty.call(metadata, 'inlineKnowledgeSources')) {
@@ -36521,31 +36447,90 @@
         const { inlineKnowledgeSources: _unusedInlineKnowledgeSources, ...rest } = metadata;
         return Object.keys(rest).length > 0 ? rest : undefined;
     }
+
     /**
-     * Mocked security check for imported files.
+     * Removes single-hash comment lines (`# Comment`) from a system message
+     * This is used to clean up the final system message before sending it to the AI model
+     * while preserving the original content with comments in metadata
      *
-     * @param urlOrPath - The URL or local path of the file to check.
-     * @returns A promise that resolves if the file is considered safe.
+     * @param systemMessage The system message that may contain comment lines
+     * @returns The system message with single-hash comment lines removed
      *
-     * @private internal utility of `createImportedFileSystemMessage`
+     * @private - TODO: [🧠] Maybe should be public?
      */
-    async function mockedSecurityCheck(urlOrPath) {
-        // TODO: Implement proper security checks
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        if (urlOrPath.includes('malicious')) {
-            throw new Error(`Security check failed for: ${urlOrPath}`);
+    function removeCommentsFromSystemMessage(systemMessage) {
+        if (!systemMessage) {
+            return systemMessage;
+        }
+        const lines = systemMessage.split(/\r?\n/);
+        const filteredLines = lines.filter((line) => {
+            const trimmedLine = line.trim();
+            // Remove only single-hash comment markers (`# Comment`) and keep markdown headings (`## Heading`).
+            return !/^#(?!#)\s/.test(trimmedLine);
+        });
+        return filteredLines.join('\n').trim();
+    }
+
+    /**
+     * Creates agent model requirements by parsing commitments, applying them in source order,
+     * and finalizing derived sections such as imports, example interactions, and inline knowledge uploads.
+     *
+     * @param agentSource - Agent source book to parse.
+     * @param modelName - Optional override for the agent model name.
+     * @param options - Additional options such as reference and teammate resolvers.
+     * @returns Fully prepared model requirements for the parsed agent source.
+     *
+     * @private internal utility of `createAgentModelRequirements`
+     */
+    async function createAgentModelRequirementsWithCommitments(agentSource, modelName, options) {
+        const parseResult = parseAgentSourceWithCommitments(agentSource);
+        const filteredCommitments = filterCommitmentsForAgentModelRequirements(parseResult.commitments);
+        let requirements = createInitialAgentModelRequirements(parseResult.agentName, modelName);
+        requirements = await applyCommitmentsToAgentModelRequirements(requirements, filteredCommitments, options);
+        requirements = aggregateUseCommitmentSystemMessages(requirements, filteredCommitments);
+        requirements = await augmentAgentModelRequirementsFromSource(requirements, parseResult, agentSource);
+        requirements = await materializeInlineKnowledgeSources(requirements, options === null || options === void 0 ? void 0 : options.inlineKnowledgeSourceUploader);
+        return finalizeRequirements(requirements);
+    }
+    /**
+     * Creates the initial requirements object with the parsed agent name stored in metadata and an optional model override.
+     *
+     * @param agentName - Parsed agent name from the source prelude.
+     * @param modelName - Optional explicit model name override.
+     * @returns Initial requirements before any commitment is applied.
+     *
+     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     */
+    function createInitialAgentModelRequirements(agentName, modelName) {
+        const initialRequirements = createBasicAgentModelRequirements(agentName);
+        const requirementsWithMetadata = {
+            ...initialRequirements,
+            _metadata: {
+                ...initialRequirements._metadata,
+                agentName,
+            },
+        };
+        if (!modelName) {
+            return requirementsWithMetadata;
         }
+        return {
+            ...requirementsWithMetadata,
+            modelName,
+        };
     }
     /**
-     * Checks whether the given MIME type belongs to a binary file.
+     * Performs the final system-message cleanup pass after all other augmentation steps are complete.
      *
-     * @param mimeType - The MIME type to check.
-     * @returns `true` when the MIME type is treated as binary.
+     * @param requirements - Fully built requirements before final cleanup.
+     * @returns Requirements with comment lines removed from the final system message.
      *
-     * @private internal utility of `createImportedFileSystemMessage`
+     * @private internal utility of `createAgentModelRequirementsWithCommitments`
      */
-    function isBinaryMimeType(mimeType) {
-        return BINARY_MIME_TYPE_PREFIXES.some((prefix) => mimeType.startsWith(prefix));
+    function finalizeRequirements(requirements) {
+        return {
+            ...requirements,
+            systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
+        };
     }
 
     /**