@promptbook/browser 0.114.0-3 → 0.114.0-4

package/umd/index.umd.js

@@ -1,14 +1,13 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('destroyable'), require('rxjs'), require('crypto-js'), require('crypto-js/enc-hex'), require('path'), require('crypto'), require('moment'), require('mime-types'), require('waitasecond'), require('crypto-js/sha256'), require('papaparse'), require('colors'), require('bottleneck')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'destroyable', 'rxjs', 'crypto-js', 'crypto-js/enc-hex', 'path', 'crypto', 'moment', 'mime-types', 'waitasecond', 'crypto-js/sha256', 'papaparse', 'colors', 'bottleneck'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-browser"] = {}, global.spacetrim, global.destroyable, global.rxjs, global.CryptoJS, global.hexEncoder, global.path, null, global.moment, global.mimeTypes, global.waitasecond, global.sha256, global.papaparse, global.colors, global.Bottleneck));
-})(this, (function (exports, spacetrim, destroyable, rxjs, CryptoJS, hexEncoder, path, crypto, moment, mimeTypes, waitasecond, sha256, papaparse, colors, Bottleneck) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('destroyable'), require('rxjs'), require('crypto-js'), require('crypto-js/enc-hex'), require('path'), require('crypto'), require('mime-types'), require('waitasecond'), require('crypto-js/sha256'), require('papaparse'), require('colors'), require('bottleneck')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'destroyable', 'rxjs', 'crypto-js', 'crypto-js/enc-hex', 'path', 'crypto', 'mime-types', 'waitasecond', 'crypto-js/sha256', 'papaparse', 'colors', 'bottleneck'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-browser"] = {}, global.spacetrim, global.destroyable, global.rxjs, global.CryptoJS, global.hexEncoder, global.path, null, global.mimeTypes, global.waitasecond, global.sha256, global.papaparse, global.colors, global.Bottleneck));
+})(this, (function (exports, spacetrim, destroyable, rxjs, CryptoJS, hexEncoder, path, crypto, mimeTypes, waitasecond, sha256, papaparse, colors, Bottleneck) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
     var CryptoJS__default = /*#__PURE__*/_interopDefaultLegacy(CryptoJS);
     var hexEncoder__default = /*#__PURE__*/_interopDefaultLegacy(hexEncoder);
-    var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
     var sha256__default = /*#__PURE__*/_interopDefaultLegacy(sha256);
     var papaparse__default = /*#__PURE__*/_interopDefaultLegacy(papaparse);
     var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
@@ -28,7 +27,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-3';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-4';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1673,7 +1672,7 @@
             Research Assistant
 
             PERSONA You are a helpful research assistant
-            USE SEARCH ENGINE
+            USE MCP https://mcp.example.com/server
             RULE Always cite your sources when providing information from the web
             \`\`\`
 
@@ -1693,8 +1692,8 @@
             Code Assistant
 
             PERSONA You are a programming assistant
-            USE BROWSER
-            USE SEARCH ENGINE
+            USE PROJECT https://github.com/example/project
+            USE MCP https://mcp.example.com/server
             RULE Prefer the narrowest useful capability for the task.
             \`\`\`
         `);
@@ -1795,65 +1794,6 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
-    /**
-     * COMPONENT commitment definition
-     *
-     * The COMPONENT commitment defines a UI component that the agent can render in the chat.
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class ComponentCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('COMPONENT');
-        }
-        /**
-         * Short one-line description of COMPONENT.
-         */
-        get description() {
-            return 'Define a UI component that the agent can render in the chat.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🧩';
-        }
-        /**
-         * Markdown documentation for COMPONENT commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # COMPONENT
-
-            Defines a UI component that the agent can render in the chat.
-
-            ## Key aspects
-
-            - Tells the agent that a specific component is available.
-            - Provides syntax for using the component.
-
-            ## Example
-
-            \`\`\`book
-            COMPONENT Arrow
-            The agent should render an arrow component in the chat UI.
-            Syntax:
-            <Arrow direction="up" color="red" />
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            const trimmedContent = content.trim();
-            if (!trimmedContent) {
-                return requirements;
-            }
-            // Add component capability to the system message
-            const componentSection = `Component: ${trimmedContent}`;
-            return this.appendToSystemMessage(requirements, componentSection, '\n\n');
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
     /**
      * DELETE commitment definition
      *
@@ -3705,653 +3645,6 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
-    /**
-     * @@@
-     *
-     * @private utility for commitments
-     */
-    function formatOptionalInstructionBlock(label, content) {
-        const trimmedContent = spacetrim.spaceTrim(content);
-        if (!trimmedContent) {
-            return '';
-        }
-        return spacetrim.spaceTrim((block) => `
-        - ${label}:
-            ${block(trimmedContent
-        .split(/\r?\n/)
-        .map((line) => `- ${line}`)
-        .join('\n'))}
-    `);
-    }
-
-    /**
-     * Names of tools used by the MEMORY commitment.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    const MemoryToolNames = {
-        retrieve: 'retrieve_user_memory',
-        store: 'store_user_memory',
-        update: 'update_user_memory',
-        delete: 'delete_user_memory',
-    };
-
-    /**
-     * Builds the MEMORY instruction block appended to the system message.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function createMemorySystemMessage(extraInstructions) {
-        return spacetrim.spaceTrim((block) => `
-            ## Memory
-
-            -   Prefer storing agent-scoped memories; only make them global when the fact should apply across all your agents.
-            -   You can use persistent user memory tools.
-            -   Use \`${MemoryToolNames.retrieve}\` to load relevant memory before answering.
-            -   Use \`${MemoryToolNames.store}\` to save stable user-specific facts that improve future help.
-            -   Use \`${MemoryToolNames.update}\` to refresh an existing memory when the content changes.
-            -   Use \`${MemoryToolNames.delete}\` to delete memories that are no longer accurate (deletions are soft and hidden from future queries).
-            -   Store concise memory items and avoid duplicates.
-            -   Never claim memory was saved or loaded unless the tool confirms it.
-            ${block(extraInstructions)}
-        `);
-    }
-
-    /**
-     * Builds a disabled memory-tool response payload.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function createDisabledMemoryResult(action, message) {
-        if (action === 'retrieve') {
-            return {
-                action,
-                status: 'disabled',
-                memories: [],
-                message,
-            };
-        }
-        if (action === 'store') {
-            return {
-                action,
-                status: 'disabled',
-                message,
-            };
-        }
-        if (action === 'update') {
-            return {
-                action,
-                status: 'disabled',
-                message,
-            };
-        }
-        if (action === 'delete') {
-            return {
-                action,
-                status: 'disabled',
-                message,
-            };
-        }
-        throw new Error(`Unsupported memory tool action: ${action}`);
-    }
-    /**
-     * Gets the runtime adapter and returns a disabled result when unavailable.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function getMemoryToolRuntimeAdapterOrDisabledResult(action, runtimeContext) {
-        if (!runtimeContext.enabled || runtimeContext.isTeamConversation || runtimeContext.isPrivateMode) {
-            const message = runtimeContext.isPrivateMode
-                ? 'Memory is disabled because private mode is active.'
-                : runtimeContext.isTeamConversation
-                    ? 'Memory is disabled for TEAM conversations.'
-                    : 'Memory is disabled for unauthenticated users.';
-            return {
-                adapter: null,
-                disabledResult: createDisabledMemoryResult(action, message),
-            };
-        }
-        {
-            return {
-                adapter: null,
-                disabledResult: createDisabledMemoryResult(action, 'Memory runtime is not available in this environment.'),
-            };
-        }
-    }
-
-    /**
-     * Parses a memory identifier argument shared across MEMORY tools.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function parseMemoryIdArg(value) {
-        const memoryId = typeof value === 'string' ? value.trim() : '';
-        if (!memoryId) {
-            throw new Error('Memory id is required.');
-        }
-        return memoryId;
-    }
-    /**
-     * Collection of MEMORY tool argument parsers.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    const parseMemoryToolArgs = {
-        /**
-         * Parses retrieve memory arguments.
-         */
-        retrieve(args) {
-            const query = typeof args.query === 'string' ? args.query.trim() : undefined;
-            const limit = typeof args.limit === 'number' && Number.isFinite(args.limit) ? Math.floor(args.limit) : undefined;
-            return {
-                query: query && query.length > 0 ? query : undefined,
-                limit: limit && limit > 0 ? Math.min(limit, 20) : undefined,
-            };
-        },
-        /**
-         * Parses store memory arguments.
-         */
-        store(args) {
-            const content = typeof args.content === 'string' ? args.content.trim() : '';
-            if (!content) {
-                throw new Error('Memory content is required.');
-            }
-            return {
-                content,
-                isGlobal: args.isGlobal === true,
-            };
-        },
-        /**
-         * Parses update memory arguments.
-         */
-        update(args) {
-            const memoryId = parseMemoryIdArg(args.memoryId);
-            const content = typeof args.content === 'string' ? args.content.trim() : '';
-            if (!content) {
-                throw new Error('Memory content is required.');
-            }
-            const isGlobal = typeof args.isGlobal === 'boolean' ? args.isGlobal : undefined;
-            return {
-                memoryId,
-                content,
-                isGlobal,
-            };
-        },
-        /**
-         * Parses delete memory arguments.
-         */
-        delete(args) {
-            return {
-                memoryId: parseMemoryIdArg(args.memoryId),
-            };
-        },
-    };
-
-    /**
-     * Prompt parameter key used to pass hidden runtime context to tool execution.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    const TOOL_RUNTIME_CONTEXT_PARAMETER = 'promptbookToolRuntimeContext';
-    /**
-     * Hidden argument key used to pass runtime context into individual tool calls.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    const TOOL_RUNTIME_CONTEXT_ARGUMENT = '__promptbookToolRuntimeContext';
-    /**
-     * Prompt parameter key used to pass a hidden tool-progress listener token into script execution.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    const TOOL_PROGRESS_TOKEN_PARAMETER = 'promptbookToolProgressToken';
-    /**
-     * Hidden argument key used to pass a tool-progress listener token into individual tool calls.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    const TOOL_PROGRESS_TOKEN_ARGUMENT = '__promptbookToolProgressToken';
-    /**
-     * Monotonic counter used for hidden progress-listener tokens.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    let toolCallProgressListenerCounter = 0;
-    /**
-     * Active tool-progress listeners keyed by hidden execution token.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    const toolCallProgressListeners = new Map();
-    /**
-     * Parses unknown runtime context payload into a normalized object.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    function parseToolRuntimeContext(rawValue) {
-        if (!rawValue) {
-            return null;
-        }
-        let parsed = rawValue;
-        if (typeof rawValue === 'string') {
-            try {
-                parsed = JSON.parse(rawValue);
-            }
-            catch (_a) {
-                return null;
-            }
-        }
-        if (!parsed || typeof parsed !== 'object') {
-            return null;
-        }
-        return parsed;
-    }
-    /**
-     * Reads runtime context attached to tool call arguments.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    function readToolRuntimeContextFromToolArgs(args) {
-        return parseToolRuntimeContext(args[TOOL_RUNTIME_CONTEXT_ARGUMENT]);
-    }
-    /**
-     * Serializes runtime context for prompt parameters.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    function serializeToolRuntimeContext(context) {
-        return JSON.stringify(context);
-    }
-    /**
-     * Registers one in-memory listener that receives progress updates emitted by a running tool.
-     *
-     * The returned token is passed into script execution as a hidden argument so tool implementations
-     * can stream progress without exposing extra parameters to the model.
-     *
-     * @param listener - Listener notified about tool progress.
-     * @returns Hidden token used to route progress updates.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    function registerToolCallProgressListener(listener) {
-        toolCallProgressListenerCounter += 1;
-        const token = `tool-progress:${Date.now()}:${toolCallProgressListenerCounter}`;
-        toolCallProgressListeners.set(token, listener);
-        return token;
-    }
-    /**
-     * Unregisters one in-memory progress listener.
-     *
-     * @param token - Token previously created by `registerToolCallProgressListener`.
-     *
-     * @private internal runtime wiring for commitment tools
-     */
-    function unregisterToolCallProgressListener(token) {
-        toolCallProgressListeners.delete(token);
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * Resolves runtime context from hidden tool arguments.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function resolveMemoryRuntimeContext(args) {
-        const runtimeContext = readToolRuntimeContextFromToolArgs(args);
-        const memoryContext = runtimeContext === null || runtimeContext === void 0 ? void 0 : runtimeContext.memory;
-        return {
-            enabled: (memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.enabled) === true,
-            userId: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.userId,
-            username: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.username,
-            agentId: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.agentId,
-            agentName: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.agentName,
-            isTeamConversation: (memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.isTeamConversation) === true,
-            isPrivateMode: (memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.isPrivateMode) === true,
-        };
-    }
-
-    /**
-     * Gets MEMORY tool function implementations.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function createMemoryToolFunctions() {
-        return {
-            async [MemoryToolNames.retrieve](args) {
-                const runtimeContext = resolveMemoryRuntimeContext(args);
-                const { adapter, disabledResult } = getMemoryToolRuntimeAdapterOrDisabledResult('retrieve', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                const parsedArgs = parseMemoryToolArgs.retrieve(args);
-                try {
-                    const memories = await adapter.retrieveMemories(parsedArgs, runtimeContext);
-                    const result = {
-                        action: 'retrieve',
-                        status: 'ok',
-                        query: parsedArgs.query,
-                        memories,
-                    };
-                    return JSON.stringify(result);
-                }
-                catch (error) {
-                    const result = {
-                        action: 'retrieve',
-                        status: 'error',
-                        query: parsedArgs.query,
-                        memories: [],
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-            async [MemoryToolNames.store](args) {
-                const runtimeContext = resolveMemoryRuntimeContext(args);
-                const { adapter, disabledResult } = getMemoryToolRuntimeAdapterOrDisabledResult('store', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseMemoryToolArgs.store(args);
-                    const memory = await adapter.storeMemory(parsedArgs, runtimeContext);
-                    const result = {
-                        action: 'store',
-                        status: 'stored',
-                        memory,
-                    };
-                    return JSON.stringify(result);
-                }
-                catch (error) {
-                    const result = {
-                        action: 'store',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-            async [MemoryToolNames.update](args) {
-                const runtimeContext = resolveMemoryRuntimeContext(args);
-                const { adapter, disabledResult } = getMemoryToolRuntimeAdapterOrDisabledResult('update', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseMemoryToolArgs.update(args);
-                    const memory = await adapter.updateMemory(parsedArgs, runtimeContext);
-                    const result = {
-                        action: 'update',
-                        status: 'updated',
-                        memory,
-                    };
-                    return JSON.stringify(result);
-                }
-                catch (error) {
-                    const result = {
-                        action: 'update',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-            async [MemoryToolNames.delete](args) {
-                const runtimeContext = resolveMemoryRuntimeContext(args);
-                const { adapter, disabledResult } = getMemoryToolRuntimeAdapterOrDisabledResult('delete', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseMemoryToolArgs.delete(args);
-                    const deleted = await adapter.deleteMemory(parsedArgs, runtimeContext);
-                    const result = {
-                        action: 'delete',
-                        status: 'deleted',
-                        memoryId: deleted.id,
-                    };
-                    return JSON.stringify(result);
-                }
-                catch (error) {
-                    const result = {
-                        action: 'delete',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-        };
-    }
-
-    /**
-     * Creates MEMORY tool definitions while preserving already-registered tools.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function createMemoryTools(existingTools) {
-        const tools = [...(existingTools || [])];
-        if (!tools.some((tool) => tool.name === MemoryToolNames.retrieve)) {
-            tools.push({
-                name: MemoryToolNames.retrieve,
-                description: spacetrim.spaceTrim(`
-                Retrieve previously stored user memories relevant to the current conversation.
-                Use this before responding when user context can improve the answer.
-            `),
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        query: {
-                            type: 'string',
-                            description: 'Optional query used to filter relevant memories.',
-                        },
-                        limit: {
-                            type: 'integer',
-                            description: 'Optional maximum number of memories to return (default 5, max 20).',
-                        },
-                    },
-                },
-            });
-        }
-        if (!tools.some((tool) => tool.name === MemoryToolNames.store)) {
-            tools.push({
-                name: MemoryToolNames.store,
-                description: spacetrim.spaceTrim(`
-                Store a durable user memory that should be remembered in future conversations.
-                Store only stable and useful user-specific facts or preferences.
-            `),
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        content: {
-                            type: 'string',
-                            description: 'Memory text to store.',
-                        },
-                        isGlobal: {
-                            type: 'boolean',
-                            description: 'Set true to make this memory global across all user agents.',
-                        },
-                    },
-                    required: ['content'],
-                },
-            });
-        }
-        if (!tools.some((tool) => tool.name === MemoryToolNames.update)) {
-            tools.push({
-                name: MemoryToolNames.update,
-                description: spacetrim.spaceTrim(`
-                Update an existing user memory after retrieving it, so the stored fact stays accurate.
-                Always pass the memory id you retrieved along with the new content.
-            `),
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        memoryId: {
-                            type: 'string',
-                            description: 'Unique identifier of the memory entry to update.',
-                        },
-                        content: {
-                            type: 'string',
-                            description: 'Updated memory text.',
-                        },
-                        isGlobal: {
-                            type: 'boolean',
-                            description: 'Set true to keep the fact global; omit or false to keep it agent-scoped.',
-                        },
-                    },
-                    required: ['memoryId', 'content'],
-                },
-            });
-        }
-        if (!tools.some((tool) => tool.name === MemoryToolNames.delete)) {
-            tools.push({
-                name: MemoryToolNames.delete,
-                description: spacetrim.spaceTrim(`
-                Delete a user memory that is no longer relevant. Deletions are soft so the record is hidden from future queries.
-            `),
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        memoryId: {
-                            type: 'string',
-                            description: 'Unique identifier of the memory entry to delete.',
-                        },
-                    },
-                    required: ['memoryId'],
-                },
-            });
-        }
-        return tools;
-    }
-
-    /**
-     * Markdown documentation for MEMORY commitment.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function getMemoryCommitmentDocumentation(type) {
-        return spacetrim.spaceTrim(`
-        # ${type}
-
-        Enables persistent user memory for the current agent. The memory is stored by the runtime and can be retrieved in future conversations.
-
-        ## Key aspects
-
-        - Both \`MEMORY\` and \`MEMORIES\` work identically.
-        - Stores user-specific details through runtime tools.
-        - Retrieves relevant memories for personalized responses.
-        - Supports optional extra instructions in the commitment content.
-
-        ## Examples
-
-        \`\`\`book
-        Personal Assistant
-
-        PERSONA You are a personal productivity assistant
-        MEMORY Remember user projects and long-term preferences.
-        GOAL Help optimize daily productivity and workflow
-        \`\`\`
-
-        \`\`\`book
-        Learning Companion
-
-        PERSONA You are an educational companion for programming students
-        MEMORY Remember only the student's learning progress and preferred study style.
-        GOAL Provide progressive learning experiences tailored to student's pace
-        \`\`\`
-
-        \`\`\`book
-        Customer Support Agent
-
-        PERSONA You are a customer support representative
-        MEMORY Remember only important support history and communication preferences.
-        GOAL Provide personalized support based on customer history
-        \`\`\`
-    `);
-    }
-
-    /**
-     * Gets human-readable titles for MEMORY tool functions.
-     *
-     * @private function of MemoryCommitmentDefinition
-     */
-    function getMemoryToolTitles() {
-        return {
-            [MemoryToolNames.retrieve]: 'User memory',
-            [MemoryToolNames.store]: 'Store user memory',
-            [MemoryToolNames.update]: 'Update user memory',
-            [MemoryToolNames.delete]: 'Delete user memory',
-        };
-    }
-
-    /**
-     * MEMORY commitment definition
-     *
-     * The MEMORY commitment is similar to KNOWLEDGE but has a focus on remembering past
-     * interactions and user preferences. It helps the agent maintain context about the
-     * user's history, preferences, and previous conversations.
-     *
-     * Example usage in agent source:
-     *
-     * ```book
-     * MEMORY User prefers detailed technical explanations
-     * MEMORY Previously worked on React projects
-     * MEMORY Timezone: UTC-5 (Eastern Time)
-     * ```
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class MemoryCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor(type = 'MEMORY') {
-            super(type);
-        }
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of MEMORY.
-         */
-        get description() {
-            return 'Remember past interactions and user **preferences** for personalized responses.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🧠';
-        }
-        /**
-         * Markdown documentation for MEMORY commitment.
-         */
-        get documentation() {
-            return getMemoryCommitmentDocumentation(this.type);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            const extraInstructions = formatOptionalInstructionBlock('Memory instructions', content);
-            const tools = createMemoryTools(requirements.tools);
-            return this.appendToSystemMessage({
-                ...requirements,
-                tools,
-                _metadata: {
-                    ...requirements._metadata,
-                    useMemory: content || true,
-                },
-            }, createMemorySystemMessage(extraInstructions));
-        }
-        /**
-         * Gets human-readable titles for MEMORY tool functions.
-         */
-        getToolTitles() {
-            return getMemoryToolTitles();
-        }
-        /**
-         * Gets MEMORY tool function implementations.
-         */
-        getToolFunctions() {
-            return createMemoryToolFunctions();
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
     /**
      * AGENT MESSAGE commitment definition
      *
@@ -4811,161 +4104,6 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
-    /**
-     * META commitment definition
-     *
-     * The META commitment handles all meta-information about the agent such as:
-     * - META AVATAR / META VISUAL: Sets the agent's built-in default avatar visual
-     * - META IMAGE: Sets the agent's avatar/profile image URL
-     * - META LINK: Provides profile/source links for the person the agent models
-     * - META DOMAIN: Sets the canonical custom domain/host of the agent
-     * - META TITLE: Sets the agent's display title
-     * - META DESCRIPTION: Sets the agent's description
-     * - META INPUT PLACEHOLDER: Sets chat input placeholder text
-     * - META THINKING MESSAGE: Adds custom thinking placeholder variants
-     * - META [ANYTHING]: Any other meta information in uppercase format
-     *
-     * These commitments are special because they don't affect the system message,
-     * but are handled separately in the parsing logic for profile display.
-     *
-     * Example usage in agent source:
-     *
-     * ```book
-     * META VISUAL pixel-art
-     * META IMAGE https://example.com/avatar.jpg
-     * META LINK https://twitter.com/username
-     * META DOMAIN my-agent.com
-     * META TITLE Professional Assistant
-     * META DESCRIPTION An AI assistant specialized in business tasks
-     * META INPUT PLACEHOLDER Write a message...
-     * META THINKING MESSAGE Thinking...
-     * META AUTHOR John Doe
-     * META VERSION 1.0
-     * ```
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class MetaCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('META');
-        }
-        /**
-         * Short one-line description of META commitments.
-         */
-        get description() {
-            return 'Set meta-information about the agent (IMAGE, LINK, TITLE, DESCRIPTION, etc.).';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return 'ℹ️';
-        }
-        /**
-         * Markdown documentation for META commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # META
-
-            Sets meta-information about the agent that is used for display and attribution purposes.
-
-            ## Supported META types
-
-            - **META AVATAR** / **META VISUAL** - Sets the agent's built-in default avatar visual
-            - **META IMAGE** - Sets the agent's avatar/profile image URL
-            - **META LINK** - Provides profile/source links for the person the agent models
-            - **META DOMAIN** - Sets the canonical custom domain/host of the agent
-            - **META TITLE** - Sets the agent's display title
-            - **META DESCRIPTION** - Sets the agent's description
-            - **META INPUT PLACEHOLDER** - Sets chat input placeholder text
-            - **META THINKING MESSAGE** - Adds custom thinking placeholder variants
-            - **META [ANYTHING]** - Any other meta information in uppercase format
-
-            ## Key aspects
-
-            - Does not modify the agent's behavior or responses
-            - Used for visual representation and attribution in user interfaces
-            - Multiple META commitments of different types can be used
-            - Multiple META LINK commitments can be used for different social profiles
-            - Multiple META THINKING MESSAGE commitments can be used for different thinking placeholder variants
-            - If multiple META commitments of the same type are specified, the last one takes precedence (except for LINK)
-
-            ## Examples
-
-            ### Basic meta information
-
-            \`\`\`book
-            Professional Assistant
-
-            META VISUAL octopus3
-            META IMAGE https://example.com/professional-avatar.jpg
-            META TITLE Senior Business Consultant
-            META DESCRIPTION Specialized in strategic planning and project management
-            META LINK https://linkedin.com/in/professional
-            \`\`\`
-
-            ### Multiple links and custom meta
-
-            \`\`\`book
-            Open Source Developer
-
-            META IMAGE /assets/dev-avatar.png
-            META LINK https://github.com/developer
-            META LINK https://twitter.com/devhandle
-            META AUTHOR Jane Smith
-            META VERSION 2.1
-            META LICENSE MIT
-            \`\`\`
-
-            ### Creative assistant
-
-            \`\`\`book
-            Creative Helper
-
-            META IMAGE https://example.com/creative-bot.jpg
-            META TITLE Creative Writing Assistant
-            META DESCRIPTION Helps with brainstorming, storytelling, and creative projects
-            META INSPIRATION Books, movies, and real-world experiences
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            // META commitments don't modify the system message or model requirements
-            // They are handled separately in the parsing logic for meta information extraction
-            // This method exists for consistency with the CommitmentDefinition interface
-            return requirements;
-        }
-        /**
-         * Extracts meta information from the content based on the meta type
-         * This is used by the parsing logic
-         */
-        extractMetaValue(metaType, content) {
-            const trimmedContent = content.trim();
-            return trimmedContent || null;
-        }
-        /**
-         * Validates if the provided content is a valid URL (for IMAGE and LINK types)
-         */
-        isValidUrl(content) {
-            try {
-                new URL(content.trim());
-                return true;
-            }
-            catch (_a) {
-                return false;
-            }
-        }
-        /**
-         * Checks if this is a known meta type
-         */
-        isKnownMetaType(metaType) {
-            const knownTypes = ['AVATAR', 'IMAGE', 'LINK', 'TITLE', 'DESCRIPTION', 'AUTHOR', 'VERSION', 'LICENSE'];
-            return knownTypes.includes(metaType.toUpperCase());
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
     /**
      * Makes color transformer which darker the given color
      *
@@ -11216,6 +10354,81 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * META DESCRIPTION commitment definition
+     *
+     * The META DESCRIPTION commitment sets the agent's meta description for the profile page.
+     * This commitment is special because it doesn't affect the system message,
+     * but is handled separately in the parsing logic.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * META DESCRIPTION An AI assistant specialized in business tasks
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class MetaDescriptionCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('META DESCRIPTION');
+        }
+        /**
+         * Short one-line description of META DESCRIPTION.
+         */
+        get description() {
+            return "Set the agent's meta description.";
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '📝';
+        }
+        /**
+         * Markdown documentation for META DESCRIPTION commitment.
+         */
+        get documentation() {
+            return spacetrim.spaceTrim(`
+            # META DESCRIPTION
+
+            Sets the agent's meta description for the profile page.
+
+            ## Key aspects
+
+            - Does not modify the agent's behavior or responses.
+            - Only one \`META DESCRIPTION\` should be used per agent.
+            - If multiple are specified, the last one takes precedence.
+            - Used for SEO and display in user interfaces.
+            - If not present, the agent description falls back to \`PERSONA\` or the first few lines of the agent source.
+
+            ## Examples
+
+            \`\`\`book
+            Professional Assistant
+
+            META DESCRIPTION Specialized in strategic planning and project management
+            PERSONA You are a professional business assistant
+            WRITING RULES Maintain a formal and courteous tone
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            // META DESCRIPTION doesn't modify the system message or model requirements
+            // It's handled separately in the parsing logic
+            return requirements;
+        }
+        /**
+         * Extracts the meta description from the content
+         * This is used by the parsing logic
+         */
+        extractMetaDescription(content) {
+            const trimmedContent = content.trim();
+            return trimmedContent || null;
+        }
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * META DOMAIN commitment definition
      *
@@ -11432,6 +10645,131 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * META FULLNAME commitment definition
+     *
+     * The `META FULLNAME` commitment sets the full display name of the agent, which can differ
+     * from the agent name on the first line of the agent source, for example when the agent
+     * should be presented with academic titles.
+     * This commitment is metadata-only and does not modify model requirements.
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class MetaFullnameCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('META FULLNAME');
+        }
+        /**
+         * Short one-line description of META FULLNAME.
+         */
+        get description() {
+            return "Set the agent's full display name.";
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '🪪';
+        }
+        /**
+         * Markdown documentation for META FULLNAME commitment.
+         */
+        get documentation() {
+            return spacetrim.spaceTrim(`
+            # META FULLNAME
+
+            Sets the full display name of the agent shown in profiles, chats, and exports.
+
+            ## Key aspects
+
+            - Does not modify the agent's behavior or responses.
+            - If not present, the agent name from the first line of the agent source is used.
+            - If multiple \`META FULLNAME\` commitments are specified, the last one takes precedence.
+
+            ## Examples
+
+            \`\`\`book
+            Pavol Hejný
+
+            META FULLNAME Dr. Ing. Pavol Hejný, PhD.
+            PERSONA Developer with 10 years of experience in building AI applications.
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            // META FULLNAME does not modify the model requirements.
+            // It is consumed by profile parsing.
+            return requirements;
+        }
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
+    /**
+     * META ID commitment definition
+     *
+     * The `META ID` commitment carries the permanent id of the agent when an agent source is moved
+     * between systems. It is a low-level commitment which is normally written and stripped by the
+     * persistence layer instead of being written by hand.
+     * This commitment is metadata-only and does not modify model requirements.
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class MetaIdCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('META ID');
+        }
+        /**
+         * Short one-line description of META ID.
+         */
+        get description() {
+            return "Set the agent's permanent id.";
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '🔖';
+        }
+        /**
+         * `META ID` is written by the persistence layer, not by agent authors.
+         */
+        get isLowLevel() {
+            return true;
+        }
+        /**
+         * Markdown documentation for META ID commitment.
+         */
+        get documentation() {
+            return spacetrim.spaceTrim(`
+            # META ID
+
+            Carries the permanent id of the agent inside the agent source.
+
+            ## Key aspects
+
+            - Does not modify the agent's behavior or responses.
+            - Written and stripped by the persistence layer, it should not be written by hand.
+            - When an agent source without \`META ID\` is stored, a fresh permanent id is assigned.
+            - If multiple \`META ID\` commitments are specified, the last one takes precedence.
+
+            ## Examples
+
+            \`\`\`book
+            My agent
+
+            META ID doQMRg82izNfJa
+            PERSONA My agent is an expert in something.
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            // META ID does not modify the model requirements.
+            // It is consumed by profile parsing and agent persistence.
+            return requirements;
+        }
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * META IMAGE commitment definition
      *
@@ -13215,6 +12553,110 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Prompt parameter key used to pass hidden runtime context to tool execution.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    const TOOL_RUNTIME_CONTEXT_PARAMETER = 'promptbookToolRuntimeContext';
+    /**
+     * Hidden argument key used to pass runtime context into individual tool calls.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    const TOOL_RUNTIME_CONTEXT_ARGUMENT = '__promptbookToolRuntimeContext';
+    /**
+     * Prompt parameter key used to pass a hidden tool-progress listener token into script execution.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    const TOOL_PROGRESS_TOKEN_PARAMETER = 'promptbookToolProgressToken';
+    /**
+     * Hidden argument key used to pass a tool-progress listener token into individual tool calls.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    const TOOL_PROGRESS_TOKEN_ARGUMENT = '__promptbookToolProgressToken';
+    /**
+     * Monotonic counter used for hidden progress-listener tokens.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    let toolCallProgressListenerCounter = 0;
+    /**
+     * Active tool-progress listeners keyed by hidden execution token.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    const toolCallProgressListeners = new Map();
+    /**
+     * Parses unknown runtime context payload into a normalized object.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    function parseToolRuntimeContext(rawValue) {
+        if (!rawValue) {
+            return null;
+        }
+        let parsed = rawValue;
+        if (typeof rawValue === 'string') {
+            try {
+                parsed = JSON.parse(rawValue);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        return parsed;
+    }
+    /**
+     * Reads runtime context attached to tool call arguments.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    function readToolRuntimeContextFromToolArgs(args) {
+        return parseToolRuntimeContext(args[TOOL_RUNTIME_CONTEXT_ARGUMENT]);
+    }
+    /**
+     * Serializes runtime context for prompt parameters.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    function serializeToolRuntimeContext(context) {
+        return JSON.stringify(context);
+    }
+    /**
+     * Registers one in-memory listener that receives progress updates emitted by a running tool.
+     *
+     * The returned token is passed into script execution as a hidden argument so tool implementations
+     * can stream progress without exposing extra parameters to the model.
+     *
+     * @param listener - Listener notified about tool progress.
+     * @returns Hidden token used to route progress updates.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    function registerToolCallProgressListener(listener) {
+        toolCallProgressListenerCounter += 1;
+        const token = `tool-progress:${Date.now()}:${toolCallProgressListenerCounter}`;
+        toolCallProgressListeners.set(token, listener);
+        return token;
+    }
+    /**
+     * Unregisters one in-memory progress listener.
+     *
+     * @param token - Token previously created by `registerToolCallProgressListener`.
+     *
+     * @private internal runtime wiring for commitment tools
+     */
+    function unregisterToolCallProgressListener(token) {
+        toolCallProgressListeners.delete(token);
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * Map of team tool functions.
      */
@@ -13802,430 +13244,23 @@
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
     /**
-     * All `USE` commitment types currently participating in final system-message aggregation.
-     *
-     * @private internal constant for `aggregateUseCommitmentSystemMessages`
-     */
-    const AGGREGATED_USE_COMMITMENT_TYPES = [
-        'USE BROWSER',
-        'USE DEEPSEARCH',
-        'USE SEARCH ENGINE',
-        'USE TIME',
-    ];
-    /**
-     * Prefix used for temporary in-system-message placeholders that preserve the first-occurrence position of aggregated `USE` sections.
-     *
-     * @private internal constant for `appendAggregatedUseCommitmentPlaceholder`
-     */
-    const AGGREGATED_USE_COMMITMENT_PLACEHOLDER_PREFIX = '# AGGREGATED USE COMMITMENT: ';
-    /**
-     * Type guard for `USE` commitment types that are aggregated in the final system message.
-     *
-     * @param type - Commitment type to check.
-     * @returns `true` when the commitment participates in `USE` system-message aggregation.
-     *
-     * @private internal utility of `aggregateUseCommitmentSystemMessages`
-     */
-    function isAggregatedUseCommitmentType(type) {
-        return AGGREGATED_USE_COMMITMENT_TYPES.includes(type);
-    }
-    /**
-     * Creates the placeholder token used to reserve the first-occurrence position of an aggregated `USE` system-message section.
-     *
-     * @param type - Aggregated `USE` commitment type.
-     * @returns Single-line placeholder comment stored in the interim system message.
-     *
-     * @private internal utility of `appendAggregatedUseCommitmentPlaceholder`
-     */
-    function getAggregatedUseCommitmentPlaceholder(type) {
-        return `${AGGREGATED_USE_COMMITMENT_PLACEHOLDER_PREFIX}${type}`;
-    }
-    /**
-     * Combines distinct additional instruction blocks in source order.
-     *
-     * @param additionalInstructions - Deduplicated instruction blocks collected from the agent source.
-     * @returns Combined instruction text ready for `formatOptionalInstructionBlock`.
-     *
-     * @private internal utility of `createAggregatedUseCommitmentSystemMessage`
-     */
-    function combineAdditionalInstructions(additionalInstructions) {
-        return additionalInstructions.join('\n');
-    }
-    /**
-     * Creates the final aggregated system-message section for a supported `USE` commitment type.
-     *
-     * @param type - Aggregated `USE` commitment type.
-     * @param additionalInstructions - Distinct additional instructions in source order.
-     * @returns Final system-message block for the commitment type.
-     *
-     * @private internal utility of `aggregateUseCommitmentSystemMessages`
-     */
-    function createAggregatedUseCommitmentSystemMessage(type, additionalInstructions) {
-        const combinedAdditionalInstructions = combineAdditionalInstructions(additionalInstructions);
-        switch (type) {
-            case 'USE TIME':
-                return spacetrim.spaceTrim((block) => `
-                    ## Time and date context
-
-                    -   It is ${moment__default["default"]().format('MMMM YYYY')} now.
-                    -   If you need more precise current time information, use the tool \`get_current_time\`.
-                    ${block(formatOptionalInstructionBlock('Time instructions', combinedAdditionalInstructions))}
-                `);
-            case 'USE BROWSER':
-                return spacetrim.spaceTrim((block) => `
-                    ## Browser
-
-                    -   Use \`fetch_url_content\` to retrieve content from specific URLs (webpages or documents) using scrapers.
-                    -   Use \`run_browser\` for real interactive browser automation (navigation, clicks, typing, waiting, scrolling).
-                    -   When you need to know information from a specific website or document, use the tools provided.
-                    ${block(formatOptionalInstructionBlock('Browser instructions', combinedAdditionalInstructions))}
-                `);
-            case 'USE SEARCH ENGINE':
-                return spacetrim.spaceTrim((block) => `
-                    ## Web Search
-
-                    -   Use \`web_search\` to find up-to-date information or facts.
-                    -   When you need to know some information from the internet, use the search tool provided.
-                    -   Do not make up information when you can search for it.
-                    -   Do not tell the user you cannot search for information, YOU CAN.
-                    ${block(formatOptionalInstructionBlock('Search instructions', combinedAdditionalInstructions))}
-                `);
-            case 'USE DEEPSEARCH':
-                return spacetrim.spaceTrim((block) => `
-                    ## Deep Research
-
-                    -   Use \`deep_search\` for broader research tasks that need multi-step investigation, comparison, or synthesis across multiple sources.
-                    -   Prefer it over quick search when the user asks for a well-grounded brief, report, or deeper investigation.
-                    -   Do not pretend you cannot research current information when this tool is available.
-                    ${block(formatOptionalInstructionBlock('DeepSearch instructions', combinedAdditionalInstructions))}
-                `);
-        }
-    }
-    /**
-     * Adds the placeholder for an aggregated `USE` system-message section only once, preserving the section position from the first occurrence.
-     *
-     * @param requirements - Current model requirements.
-     * @param type - Aggregated `USE` commitment type being applied.
-     * @returns Requirements with the placeholder inserted when it was not already present.
-     *
-     * @private internal utility of `USE` commitments
-     */
-    function appendAggregatedUseCommitmentPlaceholder(requirements, type) {
-        const placeholder = getAggregatedUseCommitmentPlaceholder(type);
-        if (requirements.systemMessage.includes(placeholder)) {
-            return requirements;
-        }
-        const systemMessage = requirements.systemMessage.trim()
-            ? `${requirements.systemMessage}\n\n${placeholder}`
-            : placeholder;
-        return {
-            ...requirements,
-            systemMessage,
-        };
-    }
-    /**
-     * Replaces temporary `USE` placeholders with one aggregated system-message block per commitment type.
-     *
-     * Distinct additional-instruction blocks are merged in stable source order while the hard-coded section is emitted only once.
-     *
-     * @param requirements - Model requirements produced by commitment-by-commitment application.
-     * @param commitments - Filtered commitments in their original source order.
-     * @returns Requirements with aggregated `USE` system-message sections.
-     *
-     * @private internal utility of `createAgentModelRequirementsWithCommitments`
-     */
-    function aggregateUseCommitmentSystemMessages(requirements, commitments) {
-        const additionalInstructionsByType = new Map();
-        for (const commitment of commitments) {
-            if (!isAggregatedUseCommitmentType(commitment.type)) {
-                continue;
-            }
-            let additionalInstructions = additionalInstructionsByType.get(commitment.type);
-            if (!additionalInstructions) {
-                additionalInstructions = [];
-                additionalInstructionsByType.set(commitment.type, additionalInstructions);
-            }
-            const normalizedContent = spacetrim.spaceTrim(commitment.content);
-            if (normalizedContent && !additionalInstructions.includes(normalizedContent)) {
-                additionalInstructions.push(normalizedContent);
-            }
-        }
-        let systemMessage = requirements.systemMessage;
-        for (const [type, additionalInstructions] of additionalInstructionsByType) {
-            const placeholder = getAggregatedUseCommitmentPlaceholder(type);
-            if (!systemMessage.includes(placeholder)) {
-                continue;
-            }
-            systemMessage = systemMessage.replace(placeholder, createAggregatedUseCommitmentSystemMessage(type, additionalInstructions));
-        }
-        return {
-            ...requirements,
-            systemMessage,
-        };
-    }
-
-    /**
-     * Client-side safe wrapper for fetching URL content
-     *
-     * This function proxies requests to the Agents Server API endpoint for scraping,
-     * making it safe to use in browser environments.
-     *
-     * @param url The URL to fetch and scrape
-     * @param agentsServerUrl The base URL of the agents server (defaults to current origin)
-     * @returns Markdown content from the URL
-     *
-     * @private internal utility for USE BROWSER commitment
-     */
-    async function fetchUrlContentViaBrowser(url, agentsServerUrl) {
-        try {
-            // Determine the agents server URL
-            const baseUrl = agentsServerUrl || (typeof window !== 'undefined' ? window.location.origin : '');
-            if (!baseUrl) {
-                throw new Error('Agents server URL is required in non-browser environments');
-            }
-            // Build the API endpoint URL
-            const apiUrl = new URL('/api/scrape', baseUrl);
-            apiUrl.searchParams.set('url', url);
-            // Fetch from the API endpoint
-            const response = await fetch(apiUrl.toString());
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
-                throw new Error(`Failed to scrape URL: ${errorData.error || response.statusText}`);
-            }
-            const data = await response.json();
-            if (!data.success || !data.content) {
-                throw new Error(`Scraping failed: ${data.error || 'No content returned'}`);
-            }
-            return data.content;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Error fetching URL content via browser: ${errorMessage}`);
-        }
-    }
-
-    /**
-     * USE BROWSER commitment definition
-     *
-     * The `USE BROWSER` commitment indicates that the agent should utilize browser tools
-     * to access and retrieve up-to-date information from the internet when necessary.
-     *
-     * This commitment provides two levels of browser access:
-     * 1. One-shot URL fetching: Simple function to fetch and scrape URL content
-     * 2. Running browser: For complex tasks like scrolling, clicking, form filling, etc.
-     *
-     * The content following `USE BROWSER` is an arbitrary text that the agent should know
-     * (e.g. browsing scope or preferred sources).
-     *
-     * Example usage in agent source:
-     *
-     * ```book
-     * USE BROWSER
-     * USE BROWSER Prefer official documentation and source websites.
-     * ```
+     * @@@
      *
-     * @private [🪔] Maybe export the commitments through some package
+     * @private utility for commitments
      */
-    class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE BROWSER', ['BROWSER']);
-        }
-        /**
-         * The `USE BROWSER` commitment is standalone.
-         */
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of USE BROWSER.
-         */
-        get description() {
-            return 'Enable the agent to use browser tools for accessing internet information.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🌐';
-        }
-        /**
-         * Markdown documentation for USE BROWSER commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # USE BROWSER
-
-            Enables the agent to use browser tools to access and retrieve up-to-date information from the internet.
-
-            ## Key aspects
-
-            - The content following \`USE BROWSER\` is an arbitrary text that the agent should know (e.g. browsing scope or preferred sources).
-            - Provides two levels of browser access:
-              1. **One-shot URL fetching**: Simple function to fetch and scrape URL content (active)
-              2. **Running browser**: For complex tasks like scrolling, clicking, form filling, etc. (runtime-dependent)
-            - The actual browser tool usage is handled by the agent runtime
-            - On the Agents Server, every agent browses in its own persistent isolated browser profile, so cookies and logged-in sessions survive across chats (the profile is linked from the agent wallet)
-            - Allows the agent to fetch current information from websites and documents
-            - Useful for research tasks, fact-checking, and accessing dynamic content
-            - Supports various content types including HTML pages and PDF documents
-
-            ## Examples
-
-            \`\`\`book
-            Research Assistant
-
-            PERSONA You are a helpful research assistant specialized in finding current information
-            USE BROWSER
-            RULE Always cite your sources when providing information from the web
-            \`\`\`
-
-            \`\`\`book
-            News Analyst
-
-            PERSONA You are a news analyst who stays up-to-date with current events
-            USE BROWSER
-            WRITING RULES Present news in a balanced and objective manner
-            ACTION Can search for and summarize news articles
-            \`\`\`
-
-            \`\`\`book
-            Company Lawyer
-
-            PERSONA You are a company lawyer providing legal advice
-            USE BROWSER
-            KNOWLEDGE Corporate law and legal procedures
-            RULE Always recommend consulting with a licensed attorney for specific legal matters
-            \`\`\`
-        `);
-        }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                fetch_url_content: 'Fetch URL content',
-                run_browser: 'Run browser',
-            };
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            // Get existing tools array or create new one
-            const existingTools = requirements.tools || [];
-            // Add browser tools if not already present
-            const toolsToAdd = [];
-            // Tool 1: One-shot URL content fetching
-            if (!existingTools.some((tool) => tool.name === 'fetch_url_content')) {
-                toolsToAdd.push({
-                    name: 'fetch_url_content',
-                    description: spacetrim.spaceTrim(`
-                    Fetches and scrapes the content from a URL (webpage or document).
-                    This tool retrieves the content of the specified URL and converts it to markdown format.
-                    Use this when you need to access information from a specific website or document.
-                    Supports various content types including HTML pages and PDF documents.
-                `),
-                    parameters: {
-                        type: 'object',
-                        properties: {
-                            url: {
-                                type: 'string',
-                                description: 'The URL to fetch and scrape (e.g., "https://example.com" or "https://example.com/document.pdf")',
-                            },
-                        },
-                        required: ['url'],
-                    },
-                });
-            }
-            // Tool 2: Running browser for complex page interactions
-            if (!existingTools.some((tool) => tool.name === 'run_browser')) {
-                toolsToAdd.push({
-                    name: 'run_browser',
-                    description: spacetrim.spaceTrim(`
-                    Launches a browser session for complex interactions.
-                    This tool is for advanced browser automation tasks like scrolling, clicking, form filling, etc.
-                    Use this when simple one-shot URL fetching is not enough.
-                `),
-                    parameters: {
-                        type: 'object',
-                        properties: {
-                            url: {
-                                type: 'string',
-                                description: 'The initial URL to navigate to',
-                            },
-                            actions: {
-                                type: 'array',
-                                description: 'Array of actions to perform in the browser',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        type: {
-                                            type: 'string',
-                                            enum: ['navigate', 'click', 'scroll', 'type', 'wait'],
-                                        },
-                                        selector: {
-                                            type: 'string',
-                                            description: 'CSS selector for the element (for click, type actions)',
-                                        },
-                                        value: {
-                                            type: 'string',
-                                            description: 'Value to type or navigate to',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        required: ['url'],
-                    },
-                });
-            }
-            const updatedTools = [...existingTools, ...toolsToAdd];
-            return appendAggregatedUseCommitmentPlaceholder({
-                ...requirements,
-                tools: updatedTools,
-                _metadata: {
-                    ...requirements._metadata,
-                    useBrowser: true,
-                },
-            }, this.type);
-        }
-        /**
-         * Gets the browser tool function implementations.
-         *
-         * This method automatically detects the environment and uses:
-         * - Server-side: Direct scraping via fetchUrlContent (Node.js)
-         * - Browser: Proxy through Agents Server API via fetchUrlContentViaBrowser
-         */
-        getToolFunctions() {
-            return {
-                /**
-                 * @@@
-                 *
-                 * Note: [🛺] This function has implementation both for browser and node, this is the proxied one for browser
-                 */
-                async fetch_url_content(args) {
-                    console.log('!!!! [Tool] fetch_url_content called', { args });
-                    const { url } = args;
-                    return await fetchUrlContentViaBrowser(url);
-                },
-                /**
-                 * @@@
-                 */
-                async run_browser(args) {
-                    console.log('!!!! [Tool] run_browser called', { args });
-                    const { url } = args;
-                    return spacetrim.spaceTrim(`
-                    # Running browser
-
-                    The running browser tool is not available in this runtime.
-
-                    This environment does not provide the server-side browser automation backend.
-                    In Agents Server Node runtime, this tool is resolved to a Playwright CLI implementation.
-
-                    Requested URL: ${url}
-                `);
-                },
-            };
+    function formatOptionalInstructionBlock(label, content) {
+        const trimmedContent = spacetrim.spaceTrim(content);
+        if (!trimmedContent) {
+            return '';
         }
+        return spacetrim.spaceTrim((block) => `
+        - ${label}:
+            ${block(trimmedContent
+        .split(/\r?\n/)
+        .map((line) => `- ${line}`)
+        .join('\n'))}
+    `);
     }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
 
     /**
      * Hostnames accepted for Google Calendar references.
@@ -14550,7 +13585,7 @@
         const runtimeContext = (readToolRuntimeContextFromToolArgs(args) ||
             {});
         const configuredCalendars = normalizeConfiguredCalendars$1((_a = runtimeContext.calendars) === null || _a === void 0 ? void 0 : _a.connections);
-        const calendarArgument = normalizeOptionalText$2(args.calendarUrl);
+        const calendarArgument = normalizeOptionalText$1(args.calendarUrl);
         let calendarReference = null;
         if (calendarArgument) {
             calendarReference = parseGoogleCalendarReference(calendarArgument);
@@ -14570,7 +13605,7 @@
         if (!calendarReference) {
             throw new Error('Calendar is required but was not resolved.');
         }
-        const accessToken = normalizeOptionalText$2((_b = runtimeContext.calendars) === null || _b === void 0 ? void 0 : _b.googleAccessToken) || '';
+        const accessToken = normalizeOptionalText$1((_b = runtimeContext.calendars) === null || _b === void 0 ? void 0 : _b.googleAccessToken) || '';
         if (!accessToken) {
             throw new CalendarWalletCredentialRequiredError({
                 calendarReference,
@@ -14603,7 +13638,7 @@
                 continue;
             }
             const calendar = rawCalendar;
-            const rawUrl = normalizeOptionalText$2(calendar.url);
+            const rawUrl = normalizeOptionalText$1(calendar.url);
             if (!rawUrl) {
                 continue;
             }
@@ -14654,7 +13689,7 @@
      *
      * @private function of resolveUseCalendarToolRuntimeOrWalletCredentialResult
      */
-    function normalizeOptionalText$2(value) {
+    function normalizeOptionalText$1(value) {
         if (typeof value !== 'string') {
             return undefined;
         }
@@ -14686,13 +13721,13 @@
             async [UseCalendarToolNames.listEvents](args) {
                 return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
                     const query = {};
-                    if (normalizeOptionalText$1(args.timeMin)) {
+                    if (normalizeOptionalText(args.timeMin)) {
                         query.timeMin = args.timeMin.trim();
                     }
-                    if (normalizeOptionalText$1(args.timeMax)) {
+                    if (normalizeOptionalText(args.timeMax)) {
                         query.timeMax = args.timeMax.trim();
                     }
-                    if (normalizeOptionalText$1(args.query)) {
+                    if (normalizeOptionalText(args.query)) {
                         query.q = args.query.trim();
                     }
                     if (typeof args.maxResults === 'number' && Number.isFinite(args.maxResults) && args.maxResults > 0) {
@@ -14704,7 +13739,7 @@
                     if (args.orderBy === 'startTime' || args.orderBy === 'updated') {
                         query.orderBy = args.orderBy;
                     }
-                    if (normalizeOptionalText$1(args.timeZone)) {
+                    if (normalizeOptionalText(args.timeZone)) {
                         query.timeZone = args.timeZone.trim();
                     }
                     const payload = await callGoogleCalendarApi(accessToken, {
@@ -14742,11 +13777,11 @@
                 return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
                     const requestBody = createGoogleCalendarEventPayload({
                         summary: normalizeRequiredText(args.summary, 'summary'),
-                        description: normalizeOptionalText$1(args.description),
-                        location: normalizeOptionalText$1(args.location),
+                        description: normalizeOptionalText(args.description),
+                        location: normalizeOptionalText(args.location),
                         start: normalizeRequiredText(args.start, 'start'),
                         end: normalizeRequiredText(args.end, 'end'),
-                        timeZone: normalizeOptionalText$1(args.timeZone),
+                        timeZone: normalizeOptionalText(args.timeZone),
                         attendees: normalizeAttendees(args.attendees),
                         reminderMinutes: normalizeReminderMinutes(args.reminderMinutes),
                     });
@@ -14768,12 +13803,12 @@
                 return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
                     const eventId = normalizeRequiredText(args.eventId, 'eventId');
                     const requestBody = createGoogleCalendarEventPayload({
-                        summary: normalizeOptionalText$1(args.summary),
-                        description: normalizeOptionalText$1(args.description),
-                        location: normalizeOptionalText$1(args.location),
-                        start: normalizeOptionalText$1(args.start),
-                        end: normalizeOptionalText$1(args.end),
-                        timeZone: normalizeOptionalText$1(args.timeZone),
+                        summary: normalizeOptionalText(args.summary),
+                        description: normalizeOptionalText(args.description),
+                        location: normalizeOptionalText(args.location),
+                        start: normalizeOptionalText(args.start),
+                        end: normalizeOptionalText(args.end),
+                        timeZone: normalizeOptionalText(args.timeZone),
                         attendees: normalizeAttendees(args.attendees),
                         reminderMinutes: normalizeReminderMinutes(args.reminderMinutes),
                     });
@@ -14820,7 +13855,7 @@
                         path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events/${encodeURIComponent(eventId)}`,
                     });
                     const existingAttendees = ((existingEvent === null || existingEvent === void 0 ? void 0 : existingEvent.attendees) || [])
-                        .map((attendee) => normalizeOptionalText$1(attendee.email))
+                        .map((attendee) => normalizeOptionalText(attendee.email))
                         .filter((email) => Boolean(email));
                     const mergedAttendees = [...new Set([...existingAttendees, ...guests])];
                     const payload = await callGoogleCalendarApi(accessToken, {
@@ -14868,7 +13903,7 @@
      * @private function of createUseCalendarToolFunctions
      */
     function normalizeRequiredText(value, fieldName) {
-        const normalizedValue = normalizeOptionalText$1(value);
+        const normalizedValue = normalizeOptionalText(value);
         if (!normalizedValue) {
             throw new Error(`Tool "${fieldName}" requires non-empty value.`);
         }
@@ -14879,7 +13914,7 @@
      *
      * @private function of createUseCalendarToolFunctions
      */
-    function normalizeOptionalText$1(value) {
+    function normalizeOptionalText(value) {
         if (typeof value !== 'string') {
             return undefined;
         }
@@ -15453,484 +14488,6 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
-    /**
-     * A search engine implementation that uses the SerpApi to fetch Google search results.
-     *
-     * @private <- TODO: !!!! Export via some package
-     */
-    class SerpSearchEngine {
-        get title() {
-            return 'SerpApi Search Engine';
-        }
-        get description() {
-            return 'Search engine that uses SerpApi to fetch Google search results';
-        }
-        checkConfiguration() {
-            if (!process.env.SERP_API_KEY) {
-                throw new Error('SERP_API_KEY is not configured');
-            }
-        }
-        async search(query, options = {}) {
-            const apiKey = process.env.SERP_API_KEY;
-            if (!apiKey) {
-                throw new Error('SERP_API_KEY is not configured');
-            }
-            const url = new URL('https://serpapi.com/search');
-            url.searchParams.set('api_key', apiKey);
-            url.searchParams.set('engine', 'google');
-            url.searchParams.set('q', query);
-            for (const [key, value] of Object.entries(options)) {
-                url.searchParams.set(key, String(value));
-            }
-            const response = await fetch(url.toString());
-            if (!response.ok) {
-                const body = await response.text();
-                throw new Error(`SerpApi failed with status ${response.status}: ${response.statusText}\n${body}`);
-            }
-            const data = (await response.json());
-            return (data.organic_results || []).map((item) => ({
-                title: item.title,
-                url: item.link,
-                snippet: item.snippet || '',
-            }));
-        }
-    }
-
-    /**
-     * Creates one SERP-backed tool function used as a local fallback for search-like commitments.
-     *
-     * @param toolName - Technical tool name used for validation messages.
-     * @param resultLabel - Human-readable label used in formatted results.
-     * @returns Async tool function compatible with commitment tool registration.
-     *
-     * @private internal helper for search-like commitments
-     */
-    function createSerpSearchToolFunction(toolName, resultLabel) {
-        return async (rawArgs) => {
-            const { query, ...searchOptions } = rawArgs;
-            if (typeof query !== 'string' || !query.trim()) {
-                throw new Error(`${toolName} query is required`);
-            }
-            const searchEngine = new SerpSearchEngine();
-            const results = await searchEngine.search(query, searchOptions);
-            return spacetrim.spaceTrim((block) => `
-                ${resultLabel} results for "${query}"${Object.keys(searchOptions).length === 0 ? '' : ` with options ${JSON.stringify(searchOptions)}`}:
-
-                ${block(results
-            .map((result) => spacetrim.spaceTrim(`
-                                - **${result.title}**
-                                  ${result.url}
-                                  ${result.snippet}
-                            `))
-            .join('\n\n'))}
-            `);
-        };
-    }
-
-    /**
-     * USE DEEPSEARCH commitment definition
-     *
-     * The `USE DEEPSEARCH` commitment indicates that the agent should use a deeper research-oriented
-     * search workflow instead of lightweight web search when it needs fresh information from the internet.
-     *
-     * The content following `USE DEEPSEARCH` is an arbitrary text that the agent should know
-     * (e.g. search scope or research instructions).
-     *
-     * Example usage in agent source:
-     *
-     * ```book
-     * USE DEEPSEARCH
-     * USE DEEPSEARCH Compare official vendor documentation with independent benchmarks.
-     * ```
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class UseDeepSearchCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE DEEPSEARCH');
-        }
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of USE DEEPSEARCH.
-         */
-        get description() {
-            return 'Enable the agent to use DeepSearch for more thorough internet research.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🔬';
-        }
-        /**
-         * Markdown documentation for USE DEEPSEARCH commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # USE DEEPSEARCH
-
-            Enables the agent to use DeepSearch for broader, more thorough internet research than lightweight web search.
-
-            ## Key aspects
-
-            - The content following \`USE DEEPSEARCH\` is arbitrary guidance for the research workflow.
-            - In Agents Server, the OpenAI Agents SDK runtime uses a nested deep-research agent for this tool.
-            - Use this for investigations, comparisons, market scans, or other tasks that benefit from deeper synthesis.
-            - Prefer regular \`USE SEARCH ENGINE\` when a quick factual lookup is enough.
-
-            ## Examples
-
-            \`\`\`book
-            Due Diligence Researcher
-
-            GOAL Investigate vendors thoroughly before making recommendations.
-            USE DEEPSEARCH Compare official sources with credible third-party analysis.
-            RULE Cite the strongest supporting sources in the final answer.
-            \`\`\`
-
-            \`\`\`book
-            Market Analyst
-
-            GOAL Build concise but well-grounded research briefs.
-            USE DEEPSEARCH Focus on recent public information and competing viewpoints.
-            CLOSED
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            const existingTools = requirements.tools || [];
-            const updatedTools = existingTools.some((tool) => tool.name === 'deep_search')
-                ? existingTools
-                : [
-                    ...existingTools,
-                    {
-                        name: 'deep_search',
-                        description: spacetrim.spaceTrim(`
-                          Research the internet deeply and synthesize a grounded answer.
-                          Use this tool for broader investigations, comparisons, and requests that need more than a quick search.
-                      `),
-                        parameters: {
-                            type: 'object',
-                            properties: {
-                                query: {
-                                    type: 'string',
-                                    description: 'The research question or investigation request.',
-                                },
-                            },
-                            required: ['query'],
-                            additionalProperties: false,
-                        },
-                    },
-                ];
-            return appendAggregatedUseCommitmentPlaceholder({
-                ...requirements,
-                tools: updatedTools,
-                _metadata: {
-                    ...requirements._metadata,
-                    useDeepSearch: content || true,
-                },
-            }, this.type);
-        }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                deep_search: 'DeepSearch',
-            };
-        }
-        /**
-         * Gets the local fallback implementation for the `deep_search` tool.
-         */
-        getToolFunctions() {
-            return {
-                deep_search: createSerpSearchToolFunction('deep_search', 'DeepSearch'),
-            };
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * Checks if value is valid email
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function isValidEmail(email) {
-        if (typeof email !== 'string') {
-            return false;
-        }
-        if (email.split(/\r?\n/).length > 1) {
-            return false;
-        }
-        return /^.+@.+\..+$/.test(email);
-    }
-
-    /**
-     * Lightweight email token matcher used for `USE EMAIL` first-line parsing.
-     *
-     * @private internal USE EMAIL constant
-     */
-    const EMAIL_TOKEN_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/;
-    /**
-     * Parses `USE EMAIL` commitment content into optional sender email + additional instructions.
-     *
-     * Examples:
-     * - `agent@example.com`
-     * - `agent@example.com Keep emails concise`
-     * - `Keep emails concise`
-     *
-     * @private internal utility of USE EMAIL commitment
-     */
-    function parseUseEmailCommitmentContent(content) {
-        const trimmedContent = spacetrim.spaceTrim(content);
-        if (!trimmedContent) {
-            return {
-                senderEmail: null,
-                senderEmailRaw: null,
-                instructions: '',
-            };
-        }
-        const lines = trimmedContent
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter(Boolean);
-        if (lines.length === 0) {
-            return {
-                senderEmail: null,
-                senderEmailRaw: null,
-                instructions: '',
-            };
-        }
-        const firstLine = lines[0] || '';
-        const senderMatch = firstLine.match(EMAIL_TOKEN_PATTERN);
-        const senderEmailRaw = (senderMatch === null || senderMatch === void 0 ? void 0 : senderMatch[0]) || null;
-        const senderEmail = senderEmailRaw && isValidEmail(senderEmailRaw) ? senderEmailRaw : null;
-        let firstLineWithoutSender = firstLine;
-        if (senderEmailRaw) {
-            const matchIndex = firstLine.indexOf(senderEmailRaw);
-            const prefix = firstLine.slice(0, matchIndex).trim();
-            const suffix = firstLine.slice(matchIndex + senderEmailRaw.length).trim();
-            firstLineWithoutSender = [prefix, suffix].filter(Boolean).join(' ').trim();
-        }
-        const instructionLines = [firstLineWithoutSender, ...lines.slice(1)].filter(Boolean);
-        const instructions = instructionLines.join('\n').trim();
-        return {
-            senderEmail,
-            senderEmailRaw,
-            instructions,
-        };
-    }
-
-    /**
-     * Client-side safe wrapper for sending emails.
-     *
-     * This function proxies requests to the Agents Server API endpoint for email queuing,
-     * making it safe to use in browser environments.
-     *
-     * @param args Email payload forwarded to the server-side `send_email` tool
-     * @param agentsServerUrl The base URL of the agents server (defaults to current origin)
-     * @returns Result string from the server-side send_email tool
-     *
-     * @private internal utility for USE EMAIL commitment
-     */
-    async function sendEmailViaBrowser(args, agentsServerUrl) {
-        try {
-            const baseUrl = agentsServerUrl || (typeof window !== 'undefined' ? window.location.origin : '');
-            if (!baseUrl) {
-                throw new Error('Agents server URL is required in non-browser environments');
-            }
-            const apiUrl = new URL('/api/send-email', baseUrl);
-            const response = await fetch(apiUrl.toString(), {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(args),
-            });
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
-                throw new Error(`Failed to send email: ${errorData.error || response.statusText}`);
-            }
-            const data = await response.json();
-            if (!data.success) {
-                throw new Error(`Email sending failed: ${data.error || 'Unknown error'}`);
-            }
-            return typeof data.result === 'string' ? data.result : JSON.stringify(data.result);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Error sending email via browser: ${errorMessage}`);
-        }
-    }
-
-    /**
-     * Tool name used by USE EMAIL.
-     *
-     * @private internal USE EMAIL constant
-     */
-    const SEND_EMAIL_TOOL_NAME = 'send_email';
-    /**
-     * USE EMAIL commitment definition.
-     *
-     * The `USE EMAIL` commitment enables outbound email sending through the `send_email` tool.
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class UseEmailCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE EMAIL', ['EMAIL', 'MAIL']);
-        }
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of USE EMAIL.
-         */
-        get description() {
-            return 'Enable outbound email sending through a wallet-backed SMTP configuration.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '📧';
-        }
-        /**
-         * Markdown documentation for USE EMAIL commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # USE EMAIL
-
-            Enables the agent to send outbound emails through SMTP.
-
-            ## Key aspects
-
-            - The agent sends email via the \`send_email\` tool.
-            - SMTP credentials are expected from wallet records (\`ACCESS_TOKEN\`, service \`smtp\`, key \`use-email-smtp-credentials\`).
-            - Commitment content can optionally begin with a default sender email address:
-              - \`USE EMAIL agent@example.com\`
-            - Remaining commitment content is treated as optional email-writing instructions.
-
-            ## Examples
-
-            \`\`\`book
-            Writing Agent
-            USE EMAIL agent@example.com
-            RULE Write emails to customers according to the instructions from user.
-            \`\`\`
-
-            \`\`\`book
-            Formal Email Assistant
-            USE EMAIL agent@example.com Keep emails concise and formal.
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            var _a;
-            const parsedCommitment = parseUseEmailCommitmentContent(content);
-            const updatedTools = addUseEmailTools(requirements.tools || []);
-            // Collect all configured sender emails across multiple USE EMAIL commitments
-            const existingSenders = Array.isArray((_a = requirements._metadata) === null || _a === void 0 ? void 0 : _a.useEmailSenders)
-                ? [...requirements._metadata.useEmailSenders]
-                : [];
-            if (parsedCommitment.senderEmail && !existingSenders.includes(parsedCommitment.senderEmail)) {
-                existingSenders.push(parsedCommitment.senderEmail);
-            }
-            const senderBullets = existingSenders.length > 0
-                ? existingSenders
-                    .map((email, index) => index === 0
-                    ? `-   Default sender address: "${email}".`
-                    : `-   Additional sender address: "${email}".`)
-                    .join('\n')
-                : '';
-            const extraInstructions = formatOptionalInstructionBlock('Email instructions', parsedCommitment.instructions);
-            const emailSectionContent = spacetrim.spaceTrim((block) => `
-                ## Emails
-
-                -   Use \`${SEND_EMAIL_TOOL_NAME}\` to send outbound emails.
-                ${block(senderBullets)}
-                ${block(extraInstructions)}
-            `);
-            return this.replaceOrCreateSection({
-                ...requirements,
-                tools: updatedTools,
-                _metadata: {
-                    ...requirements._metadata,
-                    useEmail: true,
-                    ...(parsedCommitment.senderEmail ? { useEmailSender: parsedCommitment.senderEmail } : {}),
-                    useEmailSenders: existingSenders,
-                },
-            }, 'Emails', emailSectionContent);
-        }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                [SEND_EMAIL_TOOL_NAME]: 'Send email',
-            };
-        }
-        /**
-         * Gets the browser-safe `send_email` implementation.
-         *
-         * Node.js runtime overrides this via `getAllCommitmentsToolFunctionsForNode`.
-         */
-        getToolFunctions() {
-            return {
-                async [SEND_EMAIL_TOOL_NAME](args) {
-                    return sendEmailViaBrowser(args);
-                },
-            };
-        }
-    }
-    /**
-     * Adds USE EMAIL tool definition while keeping already registered tools untouched.
-     *
-     * @private utility of USE EMAIL commitment
-     */
-    function addUseEmailTools(existingTools) {
-        if (existingTools.some((tool) => tool.name === SEND_EMAIL_TOOL_NAME)) {
-            return [...existingTools];
-        }
-        return [
-            ...existingTools,
-            {
-                name: SEND_EMAIL_TOOL_NAME,
-                description: 'Send an outbound email.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        message: {
-                            type: 'object',
-                            description: 'Email payload. Use metadata.subject for the subject line.',
-                        },
-                        to: {
-                            type: 'string',
-                            description: 'Legacy alias for recipients (use comma-separated emails or JSON array encoded as string).',
-                        },
-                        cc: {
-                            type: 'string',
-                            description: 'Optional CC recipients (use comma-separated emails or JSON array encoded as string).',
-                        },
-                        subject: {
-                            type: 'string',
-                            description: 'Legacy alias for subject.',
-                        },
-                        body: {
-                            type: 'string',
-                            description: 'Legacy alias for markdown body content.',
-                        },
-                    },
-                    required: [],
-                },
-            },
-        ];
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
     /**
      * USE IMAGE GENERATOR commitment definition
      *
@@ -18159,1503 +16716,6 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
-    /**
-     * USE SEARCH ENGINE commitment definition
-     *
-     * The `USE SEARCH ENGINE` commitment indicates that the agent should utilize a search engine tool
-     * to access and retrieve up-to-date information from the internet when necessary.
-     *
-     * The content following `USE SEARCH ENGINE` is an arbitrary text that the agent should know (e.g. search scope or instructions).
-     *
-     * Example usage in agent source:
-     *
-     * ```book
-     * USE SEARCH ENGINE
-     * USE SEARCH ENGINE Hledej informace o Přemyslovcích
-     * ```
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE SEARCH ENGINE', ['USE SEARCH']);
-        }
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of USE SEARCH ENGINE.
-         */
-        get description() {
-            return 'Enable the agent to use a search engine tool for accessing internet information.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🔍';
-        }
-        /**
-         * Markdown documentation for USE SEARCH ENGINE commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # USE SEARCH ENGINE
-
-            Enables the agent to use a search engine tool to access and retrieve up-to-date information from the internet.
-
-            ## Key aspects
-
-            - The content following \`USE SEARCH ENGINE\` is an arbitrary text that the agent should know (e.g. search scope or instructions).
-            - The actual search engine tool usage is handled by the agent runtime
-            - Allows the agent to search for current information from the web
-            - Useful for research tasks, finding facts, and accessing dynamic content
-
-            ## Examples
-
-            \`\`\`book
-            Research Assistant
-
-            PERSONA You are a helpful research assistant specialized in finding current information
-            USE SEARCH ENGINE
-            RULE Always cite your sources when providing information from the web
-            \`\`\`
-
-            \`\`\`book
-            Fact Checker
-
-            PERSONA You are a fact checker
-            USE SEARCH ENGINE
-            ACTION Search for claims and verify them against reliable sources
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            // Get existing tools array or create new one
-            const existingTools = requirements.tools || [];
-            // Add 'web_search' to tools if not already present
-            const updatedTools = existingTools.some((tool) => tool.name === 'web_search')
-                ? existingTools
-                : [
-                    ...existingTools,
-                    {
-                        name: 'web_search',
-                        description: spacetrim.spaceTrim(`
-                        Search the internet for information.
-                        Use this tool when you need to find up-to-date information or facts that you don't know.
-                    `),
-                        parameters: {
-                            type: 'object',
-                            properties: {
-                                query: {
-                                    type: 'string',
-                                    description: 'The search query',
-                                },
-                                location: {
-                                    type: 'string',
-                                    description: 'The location for the search (e.g., "Austin, Texas, United States" or "Prague, Czechia")',
-                                },
-                                gl: {
-                                    type: 'string',
-                                    description: 'The country code (e.g., "us" for United States, "cz" for Czechia)',
-                                },
-                                hl: {
-                                    type: 'string',
-                                    description: 'The language code (e.g., "en" for English, "cs" for Czech)',
-                                },
-                                num: {
-                                    type: 'integer',
-                                    description: 'Number of results to return',
-                                },
-                                engine: {
-                                    type: 'string',
-                                    description: 'The search engine to use (e.g., "google", "bing", "yahoo", "baidu")',
-                                },
-                                google_domain: {
-                                    type: 'string',
-                                    description: 'The Google domain to use (e.g., "google.com", "google.cz")',
-                                },
-                            },
-                            required: ['query'],
-                        },
-                    },
-                ];
-            return appendAggregatedUseCommitmentPlaceholder({
-                ...requirements,
-                tools: updatedTools,
-                _metadata: {
-                    ...requirements._metadata,
-                    useSearchEngine: content || true,
-                },
-            }, this.type);
-        }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                web_search: 'Web search',
-            };
-        }
-        /**
-         * Gets the `web_search` tool function implementation.
-         */
-        getToolFunctions() {
-            return {
-                web_search: createSerpSearchToolFunction('web_search', 'Search'),
-            };
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
-     *
-     * @public exported from `@promptbook/core`
-     */
-    class ParseError extends Error {
-        constructor(message) {
-            super(message);
-            this.name = 'ParseError';
-            Object.setPrototypeOf(this, ParseError.prototype);
-        }
-    }
-    // TODO: Maybe split `ParseError` and `ApplyError`
-
-    /**
-     * Supported visibility states for persisted agents.
-     *
-     * @public exported from `@promptbook/core`
-     */
-    const AGENT_VISIBILITY_VALUES = ['PRIVATE', 'UNLISTED', 'PUBLIC'];
-    /**
-     * Returns `true` when the value is one of supported visibility states.
-     *
-     * @param value - Raw value to validate.
-     * @returns Whether the value is a valid `AgentVisibility`.
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function isAgentVisibility(value) {
-        return typeof value === 'string' && AGENT_VISIBILITY_VALUES.includes(value);
-    }
-    /**
-     * Normalizes raw visibility text into a supported value.
-     *
-     * @param value - Raw visibility value.
-     * @returns Normalized visibility, or `null` when invalid.
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function normalizeAgentVisibility(value) {
-        if (typeof value !== 'string') {
-            return null;
-        }
-        const normalized = value.trim().toUpperCase();
-        return isAgentVisibility(normalized) ? normalized : null;
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * This error type indicates that some limit was reached
-     *
-     * @public exported from `@promptbook/core`
-     */
-    class LimitReachedError extends Error {
-        constructor(message) {
-            super(message);
-            this.name = 'LimitReachedError';
-            Object.setPrototypeOf(this, LimitReachedError.prototype);
-        }
-    }
-
-    /**
-     * Maximum allowed source length for create-agent payloads.
-     *
-     * @private shared create-agent contract
-     */
-    const CREATE_AGENT_INPUT_SOURCE_MAX_LENGTH = 120000;
-    /**
-     * Builds strict JSON schema for create-agent tool parameters.
-     *
-     * @private shared create-agent contract
-     */
-    function createCreateAgentInputToolParametersSchema() {
-        return {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                source: {
-                    type: 'string',
-                    description: 'Full source of the new persisted agent (Promptbook/book markdown).',
-                },
-                folderId: {
-                    type: 'number',
-                    description: 'Optional folder identifier where the new agent should be placed.',
-                },
-                sortOrder: {
-                    type: 'number',
-                    description: 'Optional sort order inside the selected folder.',
-                },
-                visibility: {
-                    type: 'string',
-                    description: 'Optional visibility: PRIVATE, UNLISTED, or PUBLIC.',
-                },
-            },
-            required: ['source'],
-        };
-    }
-
-    /**
-     * Browser-safe wrapper for spawning one persisted Agents Server agent.
-     *
-     * This function proxies requests to the Agents Server `/api/spawn-agent` endpoint.
-     *
-     * @param args Tool payload forwarded to server-side `spawn_agent` tool.
-     * @param agentsServerUrl Optional explicit agents server base URL.
-     * @returns JSON string with structured spawn result.
-     *
-     * @private internal utility for USE SPAWN commitment
-     */
-    async function spawnAgentViaBrowser(args, agentsServerUrl) {
-        try {
-            const baseUrl = agentsServerUrl || (typeof window !== 'undefined' ? window.location.origin : '');
-            if (!baseUrl) {
-                throw new Error('Agents server URL is required in non-browser environments');
-            }
-            const apiUrl = new URL('/api/spawn-agent', baseUrl);
-            const response = await fetch(apiUrl.toString(), {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(args),
-            });
-            const payload = (await response.json().catch(() => ({})));
-            if (payload.result !== undefined) {
-                return typeof payload.result === 'string' ? payload.result : JSON.stringify(payload.result);
-            }
-            if (!response.ok || payload.success === false) {
-                throw new Error(`Failed to spawn agent: ${typeof payload.error === 'string' ? payload.error : response.statusText}`);
-            }
-            return JSON.stringify(payload);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Error spawning agent via browser: ${errorMessage}`);
-        }
-    }
-
-    /**
-     * Tool name used by USE SPAWN.
-     *
-     * @private internal USE SPAWN constant
-     */
-    const SPAWN_AGENT_TOOL_NAME = 'spawn_agent';
-    /**
-     * USE SPAWN commitment definition.
-     *
-     * The `USE SPAWN` commitment enables creating new persistent child agents through one tool call.
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class UseSpawnCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE SPAWN', ['SPAWN']);
-        }
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of USE SPAWN.
-         */
-        get description() {
-            return 'Enable the agent to create persistent child agents via Agents Server create-agent flow.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🧬';
-        }
-        /**
-         * Markdown documentation for USE SPAWN commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # USE SPAWN
-
-            Enables the agent to create a new persistent child agent using the \`spawn_agent\` tool.
-
-            ## Key aspects
-
-            - The spawned agent is persisted exactly like manually created agents.
-            - Tool input mirrors create-agent fields currently supported by Agents Server:
-              - \`source\` (required)
-              - \`folderId\` (optional)
-              - \`sortOrder\` (optional)
-              - \`visibility\` (optional)
-            - Unknown fields are rejected to avoid silent misconfiguration.
-            - \`source\` payload is size-limited.
-            - Agents Server applies permission and abuse protections (auth checks, limits).
-            - Optional text after \`USE SPAWN\` is treated as spawn-policy instructions.
-
-            ## Examples
-
-            \`\`\`book
-            Team Builder
-
-            PERSONA You can create specialized assistants for the user.
-            USE SPAWN Spawn only when the user explicitly asks for a new persistent agent.
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            const extraInstructions = formatOptionalInstructionBlock('Spawn instructions', content);
-            const existingTools = requirements.tools || [];
-            const tools = existingTools.some((tool) => tool.name === SPAWN_AGENT_TOOL_NAME)
-                ? existingTools
-                : [
-                    ...existingTools,
-                    {
-                        name: SPAWN_AGENT_TOOL_NAME,
-                        description: spacetrim.spaceTrim(`
-                          Creates one new persistent child agent in Agents Server.
-                          Use this when the user asks to create a new dedicated agent profile.
-                          The tool returns JSON with \`status\`, \`agentId\`, and created \`agent\` or \`error\`.
-                      `),
-                        parameters: createCreateAgentInputToolParametersSchema(),
-                    },
-                ];
-            return this.appendToSystemMessage({
-                ...requirements,
-                tools,
-                _metadata: {
-                    ...requirements._metadata,
-                    useSpawn: content || true,
-                },
-            }, spacetrim.spaceTrim((block) => `
-                    ## Spawning agents
-
-                    -   Use \`${SPAWN_AGENT_TOOL_NAME}\` only when user asks to create a persistent new agent.
-                    -   Pass full agent source in \`source\`.
-                    -   Keep \`source\` concise; the maximum accepted length is ${CREATE_AGENT_INPUT_SOURCE_MAX_LENGTH} characters.
-                    -   Do not add unknown fields in tool arguments.
-                    ${block(extraInstructions)}
-                `));
-        }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                [SPAWN_AGENT_TOOL_NAME]: 'Spawn agent',
-            };
-        }
-        /**
-         * Gets browser-safe `spawn_agent` implementation.
-         *
-         * Node.js runtime overrides this through `getAllCommitmentsToolFunctionsForNode`.
-         */
-        getToolFunctions() {
-            return {
-                async [SPAWN_AGENT_TOOL_NAME](args) {
-                    return spawnAgentViaBrowser(args);
-                },
-            };
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * Creates system-message instructions for `USE TIMEOUT`.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createTimeoutSystemMessage(extraInstructions) {
-        return spacetrim.spaceTrim((block) => `
-            ## Timeout scheduling
-
-            -   Use \`set_timeout\` to wake this same chat thread in the future.
-            -   Use \`list_timeouts\` to review timeout ids/details across all chats for the same user+agent scope.
-            -   \`cancel_timeout\` accepts either one timeout id or \`allActive: true\` to cancel all active timeouts in this same user+agent scope.
-            -   Use \`update_timeout\` to pause/resume, edit next run, edit recurrence, or update timeout payload details.
-            -   When one timeout elapses, you will receive a new user-like message that explicitly says it is a timeout wake-up and includes the \`timeoutId\`.
-            -   Do not claim a timer was set or cancelled unless the tool confirms it.
-            ${block(extraInstructions)}
-        `);
-    }
-
-    /**
-     * Marker property stored inside serialized tool-execution envelopes.
-     *
-     * @private internal tool-execution transport
-     */
-    const TOOL_EXECUTION_ENVELOPE_MARKER = '__promptbookToolExecutionEnvelope';
-    /**
-     * Creates one serialized tool-execution envelope.
-     *
-     * @private internal tool-execution transport
-     */
-    function createToolExecutionEnvelope(options) {
-        const envelope = {
-            [TOOL_EXECUTION_ENVELOPE_MARKER]: true,
-            assistantMessage: options.assistantMessage,
-            toolResult: options.toolResult,
-        };
-        return JSON.stringify(envelope);
-    }
-    /**
-     * Parses one serialized tool-execution envelope when present.
-     *
-     * @private internal tool-execution transport
-     */
-    function parseToolExecutionEnvelope(rawValue) {
-        if (typeof rawValue !== 'string') {
-            return null;
-        }
-        try {
-            const parsedValue = JSON.parse(rawValue);
-            if (!parsedValue ||
-                typeof parsedValue !== 'object' ||
-                parsedValue[TOOL_EXECUTION_ENVELOPE_MARKER] !== true ||
-                typeof parsedValue.assistantMessage !== 'string') {
-                return null;
-            }
-            return {
-                assistantMessage: parsedValue.assistantMessage,
-                toolResult: parsedValue.toolResult,
-            };
-        }
-        catch (_a) {
-            return null;
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * Builds a disabled timeout-tool payload.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createDisabledTimeoutResult(action, message) {
-        return {
-            action,
-            status: 'disabled',
-            message,
-        };
-    }
-    /**
-     * Resolves the runtime adapter for timeout tools or returns disabled payload when unavailable.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function getTimeoutToolRuntimeAdapterOrDisabledResult(action, runtimeContext) {
-        if (!runtimeContext.enabled || !runtimeContext.chatId) {
-            return {
-                adapter: null,
-                disabledResult: createDisabledTimeoutResult(action, 'Timeouts are unavailable because this conversation is not running inside a chat thread.'),
-            };
-        }
-        {
-            return {
-                adapter: null,
-                disabledResult: createDisabledTimeoutResult(action, 'Timeout runtime is not available in this environment.'),
-            };
-        }
-    }
-
-    /**
-     * Generates random token
-     *
-     * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic
-     * Note: This function is cryptographically secure (it uses crypto.randomBytes internally)
-     *
-     * @returns secure random token
-     *
-     * @private internal helper function
-     */
-    function $randomToken(randomness) {
-        return CryptoJS__default["default"].lib.WordArray.random(randomness).toString(CryptoJS__default["default"].enc.Hex);
-    }
-    // TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
-    // TODO: Maybe use nanoid instead https://github.com/ai/nanoid
-
-    /**
-     * This error indicates errors during the execution of the pipeline
-     *
-     * @public exported from `@promptbook/core`
-     */
-    class PipelineExecutionError extends Error {
-        constructor(message) {
-            // Added id parameter
-            super(message);
-            this.name = 'PipelineExecutionError';
-            // TODO: [🐙] DRY - Maybe $randomId
-            this.id = `error-${$randomToken(8 /* <- TODO: To global config + Use Base58 to avoid similar char conflicts   */)}`;
-            Object.setPrototypeOf(this, PipelineExecutionError.prototype);
-        }
-    }
-    // TODO: [🧠][🌂] Add id to all errors
-
-    /**
-     * Default number of rows returned by `list_timeouts`.
-     *
-     * @private internal USE TIMEOUT constant
-     */
-    const DEFAULT_LIST_TIMEOUTS_LIMIT = 20;
-    /**
-     * Hard cap for `list_timeouts` page size.
-     *
-     * @private internal USE TIMEOUT constant
-     */
-    const MAX_LIST_TIMEOUTS_LIMIT = 100;
-    /**
-     * Creates one formatted timeout-argument validation error.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createTimeoutToolArgsError(message) {
-        return new PipelineExecutionError(spacetrim.spaceTrim(`
-            ${message}
-        `));
-    }
-    /**
-     * Normalizes one optional timeout id string.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function normalizeOptionalTimeoutId(value) {
-        return typeof value === 'string' ? value.trim() : '';
-    }
-    /**
-     * Parses timeout target selection for tools that accept either `timeoutId` or `allActive: true`.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseTimeoutTargetSelection(args, options) {
-        const timeoutId = normalizeOptionalTimeoutId(args.timeoutId);
-        const allActive = args.allActive === true;
-        if (timeoutId && allActive) {
-            throw createTimeoutToolArgsError(options.bothMessage);
-        }
-        if (allActive) {
-            return { allActive: true };
-        }
-        if (!timeoutId) {
-            throw createTimeoutToolArgsError(options.missingMessage);
-        }
-        return {
-            timeoutId,
-            allActive: false,
-        };
-    }
-    /**
-     * Parses one explicit `dueAt` update value.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseOptionalTimeoutDueAt(value) {
-        if (typeof value !== 'string' || value.trim().length === 0) {
-            return undefined;
-        }
-        const normalizedDueAt = value.trim();
-        const dueAtTimestamp = Date.parse(normalizedDueAt);
-        if (!Number.isFinite(dueAtTimestamp)) {
-            throw createTimeoutToolArgsError('Timeout `dueAt` must be one valid ISO timestamp.');
-        }
-        return new Date(dueAtTimestamp).toISOString();
-    }
-    /**
-     * Parses one explicit `extendByMs` update value.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseOptionalTimeoutExtendByMs(value) {
-        if (typeof value !== 'number') {
-            return undefined;
-        }
-        if (!Number.isFinite(value) || value <= 0) {
-            throw createTimeoutToolArgsError('Timeout `extendByMs` must be a positive number of milliseconds.');
-        }
-        return Math.floor(value);
-    }
-    /**
-     * Parses one explicit `recurrenceIntervalMs` update value.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseOptionalTimeoutRecurrenceInterval(value) {
-        if (value === null) {
-            return null;
-        }
-        if (typeof value !== 'number') {
-            return undefined;
-        }
-        if (!Number.isFinite(value) || value <= 0) {
-            throw createTimeoutToolArgsError('Timeout `recurrenceIntervalMs` must be a positive number of milliseconds or `null`.');
-        }
-        return Math.floor(value);
-    }
-    /**
-     * Parses one explicit `message` update value.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseOptionalTimeoutMessage(value) {
-        if (value === null) {
-            return null;
-        }
-        if (typeof value !== 'string') {
-            return undefined;
-        }
-        const normalizedMessage = value.trim();
-        return normalizedMessage.length > 0 ? normalizedMessage : null;
-    }
-    /**
-     * Parses one explicit `parameters` update value.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseOptionalTimeoutParameters(value) {
-        if (value === undefined) {
-            return undefined;
-        }
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            throw createTimeoutToolArgsError('Timeout `parameters` must be one JSON object.');
-        }
-        return value;
-    }
-    /**
-     * Parses one explicit `paused` update value.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseOptionalTimeoutPaused(value) {
-        return typeof value === 'boolean' ? value : undefined;
-    }
-    /**
-     * Parses patch fields for `update_timeout`.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseTimeoutUpdatePatch(args) {
-        const patch = {};
-        const dueAt = parseOptionalTimeoutDueAt(args.dueAt);
-        const extendByMs = parseOptionalTimeoutExtendByMs(args.extendByMs);
-        const recurrenceIntervalMs = parseOptionalTimeoutRecurrenceInterval(args.recurrenceIntervalMs);
-        const message = parseOptionalTimeoutMessage(args.message);
-        const parameters = parseOptionalTimeoutParameters(args.parameters);
-        const paused = parseOptionalTimeoutPaused(args.paused);
-        if (dueAt !== undefined) {
-            patch.dueAt = dueAt;
-        }
-        if (extendByMs !== undefined) {
-            patch.extendByMs = extendByMs;
-        }
-        if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
-            throw createTimeoutToolArgsError('Timeout update cannot include both `dueAt` and `extendByMs`.');
-        }
-        if (recurrenceIntervalMs !== undefined) {
-            patch.recurrenceIntervalMs = recurrenceIntervalMs;
-        }
-        if (message !== undefined) {
-            patch.message = message;
-        }
-        if (parameters !== undefined) {
-            patch.parameters = parameters;
-        }
-        if (paused !== undefined) {
-            patch.paused = paused;
-        }
-        return patch;
-    }
-    /**
-     * Determines whether the patch contains fields that are only supported for single-timeout updates.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function hasSingleTimeoutOnlyPatchFields(patch) {
-        return (patch.dueAt !== undefined ||
-            patch.extendByMs !== undefined ||
-            patch.recurrenceIntervalMs !== undefined ||
-            patch.message !== undefined ||
-            patch.parameters !== undefined);
-    }
-    /**
-     * Parses bulk timeout update arguments.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseBulkTimeoutUpdateArgs(patch) {
-        if (patch.paused === undefined) {
-            throw createTimeoutToolArgsError('Bulk timeout update with `allActive: true` requires `paused` to be explicitly set.');
-        }
-        if (hasSingleTimeoutOnlyPatchFields(patch)) {
-            throw createTimeoutToolArgsError('Bulk timeout update only supports the `paused` field.');
-        }
-        return {
-            allActive: true,
-            paused: patch.paused,
-        };
-    }
-    /**
-     * Parses single-timeout update arguments.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function parseSingleTimeoutUpdateArgs(timeoutId, patch) {
-        if (!timeoutId) {
-            throw createTimeoutToolArgsError('Timeout `timeoutId` is required for single-timeout updates.');
-        }
-        if (Object.keys(patch).length === 0) {
-            throw createTimeoutToolArgsError('Timeout update must include at least one editable field.');
-        }
-        return {
-            timeoutId,
-            patch,
-        };
-    }
-    /**
-     * Parses and validates `USE TIMEOUT` tool arguments.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    const parseTimeoutToolArgs = {
-        /**
-         * Parses `set_timeout` input.
-         */
-        set(args) {
-            const parsedMilliseconds = Number(args.milliseconds);
-            if (!Number.isFinite(parsedMilliseconds) || parsedMilliseconds <= 0) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout \`milliseconds\` must be a positive number.
-                `));
-            }
-            const message = typeof args.message === 'string' ? args.message.trim() : '';
-            return {
-                milliseconds: Math.floor(parsedMilliseconds),
-                ...(message ? { message } : {}),
-            };
-        },
-        /**
-         * Parses `cancel_timeout` input.
-         */
-        cancel(args) {
-            const target = parseTimeoutTargetSelection(args, {
-                bothMessage: 'Timeout cancellation must target either one `timeoutId` or `allActive: true`, not both.',
-                missingMessage: 'Timeout `timeoutId` is required unless you pass `allActive: true`.',
-            });
-            if (target.allActive) {
-                return { allActive: true };
-            }
-            return { timeoutId: target.timeoutId };
-        },
-        /**
-         * Parses `list_timeouts` input.
-         */
-        list(args) {
-            if (args.includeFinished !== undefined && typeof args.includeFinished !== 'boolean') {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout \`includeFinished\` must be a boolean when provided.
-                `));
-            }
-            const parsedLimit = args.limit === undefined ? DEFAULT_LIST_TIMEOUTS_LIMIT : Math.floor(Number(args.limit));
-            if (!Number.isFinite(parsedLimit) || parsedLimit <= 0) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout \`limit\` must be a positive number.
-                `));
-            }
-            if (parsedLimit > MAX_LIST_TIMEOUTS_LIMIT) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout \`limit\` must be at most \`${MAX_LIST_TIMEOUTS_LIMIT}\`.
-                `));
-            }
-            return {
-                includeFinished: args.includeFinished === true,
-                limit: parsedLimit,
-            };
-        },
-        /**
-         * Parses `update_timeout` input.
-         */
-        update(args) {
-            const target = parseTimeoutTargetSelection(args, {
-                bothMessage: 'Timeout update must target either one `timeoutId` or `allActive: true`, not both.',
-                missingMessage: 'Timeout update requires one `timeoutId` or `allActive: true`.',
-            });
-            const patch = parseTimeoutUpdatePatch(args);
-            return target.allActive
-                ? parseBulkTimeoutUpdateArgs(patch)
-                : parseSingleTimeoutUpdateArgs(target.timeoutId, patch);
-        },
-    };
-
-    /**
-     * Resolves timeout runtime context from hidden tool arguments.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function resolveTimeoutRuntimeContext(args) {
-        const runtimeContext = readToolRuntimeContextFromToolArgs(args);
-        const chatContext = runtimeContext === null || runtimeContext === void 0 ? void 0 : runtimeContext.chat;
-        return {
-            enabled: Boolean(chatContext === null || chatContext === void 0 ? void 0 : chatContext.chatId),
-            chatId: chatContext === null || chatContext === void 0 ? void 0 : chatContext.chatId,
-            userId: chatContext === null || chatContext === void 0 ? void 0 : chatContext.userId,
-            agentId: chatContext === null || chatContext === void 0 ? void 0 : chatContext.agentId,
-            agentName: chatContext === null || chatContext === void 0 ? void 0 : chatContext.agentName,
-            promptParameters: normalizePromptParameters(chatContext === null || chatContext === void 0 ? void 0 : chatContext.parameters),
-        };
-    }
-    /**
-     * Normalizes stored prompt parameters carried by timeout runtime context.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function normalizePromptParameters(rawParameters) {
-        if (!rawParameters || typeof rawParameters !== 'object' || Array.isArray(rawParameters)) {
-            return {};
-        }
-        const normalizedEntries = Object.entries(rawParameters).filter(([, value]) => typeof value === 'string');
-        return Object.fromEntries(normalizedEntries);
-    }
-
-    /**
-     * Tool names provided by the `USE TIMEOUT` commitment.
-     *
-     * @private internal USE TIMEOUT constant
-     */
-    const TimeoutToolNames = {
-        set: 'set_timeout',
-        cancel: 'cancel_timeout',
-        list: 'list_timeouts',
-        update: 'update_timeout',
-    };
-
-    /**
-     * Maximum number of timeout rows rendered into the assistant-visible `list_timeouts` message.
-     *
-     * @private internal USE TIMEOUT constant
-     */
-    const MAX_ASSISTANT_VISIBLE_TIMEOUT_ROWS = 20;
-    /**
-     * Maximum number of timeout ids rendered in bulk-action summaries.
-     *
-     * @private internal USE TIMEOUT constant
-     */
-    const MAX_ASSISTANT_VISIBLE_BULK_TIMEOUT_IDS = 10;
-    /**
-     * Gets `USE TIMEOUT` tool function implementations.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createTimeoutToolFunctions() {
-        return {
-            async [TimeoutToolNames.set](args) {
-                const runtimeContext = resolveTimeoutRuntimeContext(args);
-                const { adapter, disabledResult } = getTimeoutToolRuntimeAdapterOrDisabledResult('set', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseTimeoutToolArgs.set(args);
-                    const scheduledTimeout = await adapter.scheduleTimeout(parsedArgs, runtimeContext);
-                    const result = {
-                        action: 'set',
-                        status: 'set',
-                        timeoutId: scheduledTimeout.timeoutId,
-                        dueAt: scheduledTimeout.dueAt,
-                    };
-                    return createToolExecutionEnvelope({
-                        assistantMessage: 'The timer was set.',
-                        toolResult: result,
-                    });
-                }
-                catch (error) {
-                    const result = {
-                        action: 'set',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-            async [TimeoutToolNames.cancel](args) {
-                const runtimeContext = resolveTimeoutRuntimeContext(args);
-                const { adapter, disabledResult } = getTimeoutToolRuntimeAdapterOrDisabledResult('cancel', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseTimeoutToolArgs.cancel(args);
-                    const cancelledTimeout = await adapter.cancelTimeout(parsedArgs, runtimeContext);
-                    if (cancelledTimeout.status === 'cancelled_all') {
-                        const result = {
-                            action: 'cancel',
-                            status: 'cancelled_all',
-                            cancelledCount: cancelledTimeout.cancelledCount || 0,
-                            cancelledTimeoutIds: cancelledTimeout.cancelledTimeoutIds || [],
-                            hasMore: cancelledTimeout.hasMore,
-                        };
-                        return createToolExecutionEnvelope({
-                            assistantMessage: createBulkCancelAssistantMessage({
-                                cancelledCount: result.cancelledCount || 0,
-                                cancelledTimeoutIds: result.cancelledTimeoutIds || [],
-                                hasMore: result.hasMore,
-                            }),
-                            toolResult: result,
-                        });
-                    }
-                    const result = {
-                        action: 'cancel',
-                        status: cancelledTimeout.status,
-                        timeoutId: cancelledTimeout.timeoutId,
-                        dueAt: cancelledTimeout.dueAt,
-                    };
-                    return createToolExecutionEnvelope({
-                        assistantMessage: cancelledTimeout.status === 'cancelled'
-                            ? 'The timer was cancelled.'
-                            : 'The timer was already inactive.',
-                        toolResult: result,
-                    });
-                }
-                catch (error) {
-                    const result = {
-                        action: 'cancel',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-            async [TimeoutToolNames.list](args) {
-                const runtimeContext = resolveTimeoutRuntimeContext(args);
-                const { adapter, disabledResult } = getTimeoutToolRuntimeAdapterOrDisabledResult('list', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseTimeoutToolArgs.list(args);
-                    const listedTimeouts = await adapter.listTimeouts(parsedArgs, runtimeContext);
-                    const result = {
-                        action: 'list',
-                        status: 'listed',
-                        items: listedTimeouts.items,
-                        total: listedTimeouts.total,
-                    };
-                    return createToolExecutionEnvelope({
-                        assistantMessage: createListedTimeoutsAssistantMessage({
-                            total: listedTimeouts.total,
-                            items: listedTimeouts.items,
-                        }),
-                        toolResult: result,
-                    });
-                }
-                catch (error) {
-                    const result = {
-                        action: 'list',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-            async [TimeoutToolNames.update](args) {
-                const runtimeContext = resolveTimeoutRuntimeContext(args);
-                const { adapter, disabledResult } = getTimeoutToolRuntimeAdapterOrDisabledResult('update', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseTimeoutToolArgs.update(args);
-                    const updatedTimeout = await adapter.updateTimeout(parsedArgs, runtimeContext);
-                    if (updatedTimeout.status === 'updated_all') {
-                        const result = {
-                            action: 'update',
-                            status: 'updated_all',
-                            updatedCount: updatedTimeout.updatedCount,
-                            matchedCount: updatedTimeout.matchedCount,
-                            updatedTimeoutIds: updatedTimeout.updatedTimeoutIds,
-                            hasMore: updatedTimeout.hasMore,
-                        };
-                        return createToolExecutionEnvelope({
-                            assistantMessage: createBulkUpdateAssistantMessage({
-                                paused: 'allActive' in parsedArgs && parsedArgs.allActive ? parsedArgs.paused : false,
-                                updatedCount: updatedTimeout.updatedCount,
-                                matchedCount: updatedTimeout.matchedCount,
-                                updatedTimeoutIds: updatedTimeout.updatedTimeoutIds,
-                                hasMore: updatedTimeout.hasMore,
-                            }),
-                            toolResult: result,
-                        });
-                    }
-                    if (updatedTimeout.status === 'not_found') {
-                        const result = {
-                            action: 'update',
-                            status: 'not_found',
-                            timeoutId: updatedTimeout.timeoutId,
-                        };
-                        return createToolExecutionEnvelope({
-                            assistantMessage: 'The timeout was not found.',
-                            toolResult: result,
-                        });
-                    }
-                    if (updatedTimeout.status === 'conflict') {
-                        const conflictMessage = updatedTimeout.reason === 'running'
-                            ? 'Running timeout cannot be edited.'
-                            : 'Finished timeout cannot be edited.';
-                        const result = {
-                            action: 'update',
-                            status: 'conflict',
-                            timeoutId: updatedTimeout.timeoutId,
-                            message: conflictMessage,
-                        };
-                        return createToolExecutionEnvelope({
-                            assistantMessage: conflictMessage,
-                            toolResult: result,
-                        });
-                    }
-                    const result = {
-                        action: 'update',
-                        status: 'updated',
-                        timeoutId: updatedTimeout.timeout.timeoutId,
-                        dueAt: updatedTimeout.timeout.dueAt,
-                        paused: updatedTimeout.timeout.paused,
-                        recurrenceIntervalMs: updatedTimeout.timeout.recurrenceIntervalMs,
-                    };
-                    return createToolExecutionEnvelope({
-                        assistantMessage: `Updated timeout ${JSON.stringify(updatedTimeout.timeout.timeoutId)}.`,
-                        toolResult: result,
-                    });
-                }
-                catch (error) {
-                    const result = {
-                        action: 'update',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                    return JSON.stringify(result);
-                }
-            },
-        };
-    }
-    /**
-     * Creates assistant-visible summary for one `list_timeouts` response.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createListedTimeoutsAssistantMessage(options) {
-        if (options.total <= 0 || options.items.length === 0) {
-            return 'Found 0 timeouts.';
-        }
-        const visibleItems = options.items.slice(0, MAX_ASSISTANT_VISIBLE_TIMEOUT_ROWS);
-        const summaryRows = visibleItems.map((item, index) => `${index + 1}. ${formatTimeoutListRow(item)}`);
-        const hiddenCount = Math.max(0, options.total - visibleItems.length);
-        if (hiddenCount > 0) {
-            summaryRows.push(`...and ${hiddenCount} more.`);
-        }
-        return spacetrim.spaceTrim((block) => `
-            Found ${options.total} ${options.total === 1 ? 'timeout' : 'timeouts'}:
-            ${block(summaryRows.join('\n'))}
-        `);
-    }
-    /**
-     * Formats one timeout row for assistant-visible timeout listings.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function formatTimeoutListRow(item) {
-        const normalizedMessage = typeof item.message === 'string' ? item.message.trim() : '';
-        const messageSuffix = normalizedMessage ? ` | message ${JSON.stringify(normalizedMessage)}` : '';
-        const recurrenceSuffix = typeof item.recurrenceIntervalMs === 'number' && item.recurrenceIntervalMs > 0
-            ? ` | recurrence ${item.recurrenceIntervalMs}ms`
-            : '';
-        const pausedSuffix = item.paused ? ' (paused)' : '';
-        return `${item.timeoutId} | ${item.status}${pausedSuffix} | chat ${item.chatId} | due ${item.dueAt}${recurrenceSuffix}${messageSuffix}`;
-    }
-    /**
-     * Creates assistant-visible summary for bulk timeout cancellation.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createBulkCancelAssistantMessage(options) {
-        if (options.cancelledCount <= 0) {
-            return 'No active timeouts were found to cancel.';
-        }
-        const visibleTimeoutIds = options.cancelledTimeoutIds.slice(0, MAX_ASSISTANT_VISIBLE_BULK_TIMEOUT_IDS);
-        const hiddenIdsCount = Math.max(0, options.cancelledTimeoutIds.length - visibleTimeoutIds.length);
-        const hasMoreSuffix = options.hasMore ? ' Additional active timeouts may still exist.' : '';
-        const idsSuffix = visibleTimeoutIds.length > 0
-            ? ` Cancelled ids: ${visibleTimeoutIds.join(', ')}${hiddenIdsCount > 0 ? `, and ${hiddenIdsCount} more.` : '.'}`
-            : '';
-        return `Cancelled ${options.cancelledCount} active ${options.cancelledCount === 1 ? 'timeout' : 'timeouts'}.${idsSuffix}${hasMoreSuffix}`;
-    }
-    /**
-     * Creates assistant-visible summary for bulk timeout pause/resume updates.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createBulkUpdateAssistantMessage(options) {
-        if (options.matchedCount <= 0) {
-            return options.paused
-                ? 'No active queued timeouts were found to pause.'
-                : 'No paused queued timeouts were found to resume.';
-        }
-        const verb = options.paused ? 'Paused' : 'Resumed';
-        const visibleTimeoutIds = options.updatedTimeoutIds.slice(0, MAX_ASSISTANT_VISIBLE_BULK_TIMEOUT_IDS);
-        const hiddenIdsCount = Math.max(0, options.updatedTimeoutIds.length - visibleTimeoutIds.length);
-        const skippedCount = Math.max(0, options.matchedCount - options.updatedCount);
-        const idsSuffix = visibleTimeoutIds.length > 0
-            ? ` Updated ids: ${visibleTimeoutIds.join(', ')}${hiddenIdsCount > 0 ? `, and ${hiddenIdsCount} more.` : '.'}`
-            : '';
-        const skippedSuffix = skippedCount > 0 ? ` Skipped ${skippedCount} due to concurrent changes.` : '';
-        const hasMoreSuffix = options.hasMore ? ' Additional matching timeouts may still exist.' : '';
-        return `${verb} ${options.updatedCount} ${options.updatedCount === 1 ? 'timeout' : 'timeouts'}.${idsSuffix}${skippedSuffix}${hasMoreSuffix}`;
-    }
-
-    /**
-     * Adds `USE TIMEOUT` tool definitions while preserving already registered tools.
-     *
-     * @private internal utility of USE TIMEOUT
-     */
-    function createTimeoutTools(existingTools = []) {
-        const tools = [...existingTools];
-        if (!tools.some((tool) => tool.name === TimeoutToolNames.set)) {
-            tools.push({
-                name: TimeoutToolNames.set,
-                description: 'Schedule one thread-scoped wake-up in the current chat. The timer returns immediately and wakes this same conversation later.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        milliseconds: {
-                            type: 'number',
-                            description: 'Delay in milliseconds before the timeout wakes the same chat thread.',
-                        },
-                        message: {
-                            type: 'string',
-                            description: 'Optional note appended to the future timeout wake-up message.',
-                        },
-                    },
-                    required: ['milliseconds'],
-                },
-            });
-        }
-        if (!tools.some((tool) => tool.name === TimeoutToolNames.cancel)) {
-            tools.push({
-                name: TimeoutToolNames.cancel,
-                description: 'Cancel one timeout by id or cancel all active timeouts across chats for the same user+agent scope.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        timeoutId: {
-                            type: 'string',
-                            description: 'Identifier returned earlier by `set_timeout` or `list_timeouts`.',
-                        },
-                        allActive: {
-                            type: 'boolean',
-                            description: 'When true, cancel all currently active timeouts across chats in this user+agent scope.',
-                        },
-                    },
-                },
-            });
-        }
-        if (!tools.some((tool) => tool.name === TimeoutToolNames.list)) {
-            tools.push({
-                name: TimeoutToolNames.list,
-                description: 'List timeout details across all chats for this same user+agent scope so they can be reviewed and managed.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        includeFinished: {
-                            type: 'boolean',
-                            description: 'When true, include completed, failed, and cancelled rows in addition to active timeouts.',
-                        },
-                        limit: {
-                            type: 'number',
-                            description: 'Maximum number of rows to return (default 20, max 100).',
-                        },
-                    },
-                },
-            });
-        }
-        if (!tools.some((tool) => tool.name === TimeoutToolNames.update)) {
-            tools.push({
-                name: TimeoutToolNames.update,
-                description: 'Update one timeout (pause/resume, next run, recurrence, payload) or pause/resume all active queued timeouts across chats.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        timeoutId: {
-                            type: 'string',
-                            description: 'Identifier returned earlier by `set_timeout` or `list_timeouts` for one timeout update.',
-                        },
-                        allActive: {
-                            type: 'boolean',
-                            description: 'When true, run one bulk pause/resume across all active queued timeouts in this same user+agent scope.',
-                        },
-                        paused: {
-                            type: 'boolean',
-                            description: 'Pause (`true`) or resume (`false`) one timeout; with `allActive: true` this pauses/resumes all active queued timeouts.',
-                        },
-                        dueAt: {
-                            type: 'string',
-                            description: 'Set the next run timestamp (ISO string). Cannot be used with `extendByMs`.',
-                        },
-                        extendByMs: {
-                            type: 'number',
-                            description: 'Move next run by this many milliseconds. Cannot be used with `dueAt`.',
-                        },
-                        recurrenceIntervalMs: {
-                            type: 'number',
-                            description: 'Set recurrence interval in milliseconds; pass `null` to disable recurrence.',
-                        },
-                        message: {
-                            type: 'string',
-                            description: 'Set wake-up message text for this timeout; pass empty string to clear.',
-                        },
-                        parameters: {
-                            type: 'object',
-                            description: 'Replace stored JSON parameters passed back when timeout fires.',
-                        },
-                    },
-                },
-            });
-        }
-        return tools;
-    }
-
-    /**
-     * `USE TIMEOUT` commitment definition.
-     *
-     * The `USE TIMEOUT` commitment enables timeout wake-ups and scoped timeout management.
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class UseTimeoutCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE TIMEOUT');
-        }
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of `USE TIMEOUT`.
-         */
-        get description() {
-            return 'Enable timeout wake-ups plus scoped timeout listing, updates, and cancellation across chats.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '⏱️';
-        }
-        /**
-         * Markdown documentation for `USE TIMEOUT`.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # USE TIMEOUT
-
-            Enables timeout wake-ups and timeout management for the same user+agent scope.
-
-            ## Key aspects
-
-            - The agent uses \`set_timeout\` to schedule a future wake-up in the same chat thread.
-            - The tool returns immediately while the timeout is stored and executed by the runtime later.
-            - The wake-up arrives as a new user-like timeout message in the same conversation.
-            - The agent can inspect known timeout details via \`list_timeouts\`.
-            - The agent can cancel one timeout by \`timeoutId\` or cancel all active timeouts via \`cancel_timeout\`.
-            - The agent can pause/resume and edit timeout details via \`update_timeout\`.
-            - Commitment content is treated as optional timeout policy instructions.
-
-            ## Examples
-
-            \`\`\`book
-            Follow-up Agent
-            USE TIMEOUT Remind yourself only when follow-up work is explicitly requested.
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            const extraInstructions = formatOptionalInstructionBlock('Timeout instructions', content);
-            return this.appendToSystemMessage({
-                ...requirements,
-                tools: createTimeoutTools(requirements.tools || []),
-                _metadata: {
-                    ...requirements._metadata,
-                    useTimeout: content || true,
-                },
-            }, createTimeoutSystemMessage(extraInstructions));
-        }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                [TimeoutToolNames.set]: 'Set timer',
-                [TimeoutToolNames.cancel]: 'Cancel timer',
-                [TimeoutToolNames.list]: 'List timers',
-                [TimeoutToolNames.update]: 'Update timer',
-            };
-        }
-        /**
-         * Gets `USE TIMEOUT` tool function implementations.
-         */
-        getToolFunctions() {
-            return createTimeoutToolFunctions();
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
-    /**
-     * USE TIME commitment definition
-     *
-     * The `USE TIME` commitment indicates that the agent should be able to determine the current date and time.
-     *
-     * Example usage in agent source:
-     *
-     * ```book
-     * USE TIME
-     * USE TIME Prefer the user's local timezone.
-     * ```
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class UseTimeCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE TIME', ['CURRENT TIME', 'TIME', 'DATE']);
-        }
-        get requiresContent() {
-            return false;
-        }
-        /**
-         * Short one-line description of USE TIME.
-         */
-        get description() {
-            return 'Enable the agent to determine the current date and time.';
-        }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🕒';
-        }
-        /**
-         * Markdown documentation for USE TIME commitment.
-         */
-        get documentation() {
-            return spacetrim.spaceTrim(`
-            # USE TIME
-
-            Enables the agent to determine the current date and time.
-
-            ## Key aspects
-
-            - This tool won't receive any input.
-            - It outputs the current date and time as an ISO 8601 string.
-            - Allows the agent to answer questions about the current time or date.
-            - The content following \`USE TIME\` is an arbitrary text that the agent should know (e.g. timezone preference).
-
-            ## Examples
-
-            \`\`\`book
-            Time-aware Assistant
-
-            PERSONA You are a helpful assistant who knows the current time.
-            USE TIME
-            \`\`\`
-
-            \`\`\`book
-            Travel Assistant
-
-            PERSONA You help travelers with planning.
-            USE TIME Prefer the user's local timezone.
-            \`\`\`
-        `);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            // Get existing tools array or create new one
-            const existingTools = requirements.tools || [];
-            // Add 'get_current_time' to tools if not already present
-            const updatedTools = existingTools.some((tool) => tool.name === 'get_current_time')
-                ? existingTools
-                : [
-                    ...existingTools,
-                    {
-                        name: 'get_current_time',
-                        description: 'Get the current date and time in ISO 8601 format.',
-                        parameters: {
-                            type: 'object',
-                            properties: {
-                                timezone: {
-                                    type: 'string',
-                                    description: 'Optional timezone name (e.g. "Europe/Prague", "UTC", "America/New_York").',
-                                },
-                            },
-                            required: [],
-                        },
-                    },
-                    // <- TODO: !!!! define the function in LLM tools
-                ];
-            return appendAggregatedUseCommitmentPlaceholder({
-                ...requirements,
-                tools: updatedTools,
-                _metadata: {
-                    ...requirements._metadata,
-                },
-            }, this.type);
-        }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                get_current_time: 'Get current time',
-            };
-        }
-        /**
-         * Gets the `get_current_time` tool function implementation.
-         */
-        getToolFunctions() {
-            return {
-                async get_current_time(args) {
-                    var _a;
-                    console.log('!!!! [Tool] get_current_time called', { args });
-                    const { timezone } = args;
-                    if (!timezone) {
-                        return new Date().toISOString();
-                    }
-                    try {
-                        // Note: Returning ISO 8601 string but in the requested timezone
-                        const formatter = new Intl.DateTimeFormat('en-CA', {
-                            timeZone: timezone,
-                            year: 'numeric',
-                            month: '2-digit',
-                            day: '2-digit',
-                            hour: '2-digit',
-                            minute: '2-digit',
-                            second: '2-digit',
-                            hour12: false,
-                            timeZoneName: 'shortOffset',
-                        });
-                        const parts = formatter.formatToParts(new Date());
-                        const part = (type) => { var _a; return (_a = parts.find((p) => p.type === type)) === null || _a === void 0 ? void 0 : _a.value; };
-                        // en-CA format is YYYY-MM-DD
-                        const isoString = `${part('year')}-${part('month')}-${part('day')}T${part('hour')}:${part('minute')}:${part('second')}${(_a = part('timeZoneName')) === null || _a === void 0 ? void 0 : _a.replace('GMT', '')}`;
-                        return isoString;
-                    }
-                    catch (error) {
-                        // Fallback to UTC if timezone is invalid
-                        return new Date().toISOString();
-                    }
-                },
-            };
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
     /**
      * Tool name used by the USE USER LOCATION commitment.
      *
@@ -19870,580 +16930,6 @@
     }
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
-    /**
-     * Names of tools used by the WALLET commitment.
-     *
-     * @private constant of WalletCommitmentDefinition
-     */
-    const WalletToolNames = {
-        retrieve: 'retrieve_wallet_records',
-        store: 'store_wallet_record',
-        update: 'update_wallet_record',
-        delete: 'delete_wallet_record',
-        request: 'request_wallet_record',
-    };
-
-    /**
-     * Creates WALLET system-message instructions.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function createWalletSystemMessage(extraInstructions) {
-        return spacetrim.spaceTrim((block) => `
-            Wallet:
-            - Use "${WalletToolNames.retrieve}" before authenticated operations.
-            - Use "${WalletToolNames.store}" and "${WalletToolNames.update}" to maintain credentials.
-            - Use "${WalletToolNames.delete}" to remove invalid credentials.
-            - Use "${WalletToolNames.request}" to request missing credentials via UI popup.
-            - Scope records by user (\`isUserScoped\`) and/or by agent (\`isGlobal=false\`) as needed.
-            - Never expose raw credentials in chat responses.
-            ${block(extraInstructions)}
-        `);
-    }
-
-    /**
-     * Resolves disabled message for wallet runtime context.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function resolveWalletDisabledMessage(runtimeContext) {
-        if (runtimeContext.isPrivateMode) {
-            return 'Wallet is disabled because private mode is active.';
-        }
-        if (runtimeContext.isTeamConversation) {
-            return 'Wallet is disabled for TEAM conversations.';
-        }
-        if (!runtimeContext.enabled) {
-            return 'Wallet is disabled for unauthenticated users.';
-        }
-        return null;
-    }
-    /**
-     * Resolves runtime adapter for wallet tools or returns disabled payload when unavailable.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function getWalletToolRuntimeAdapterOrDisabledResult(action, runtimeContext) {
-        const disabledMessage = resolveWalletDisabledMessage(runtimeContext);
-        if (disabledMessage) {
-            return {
-                adapter: null,
-                disabledResult: {
-                    action,
-                    status: 'disabled',
-                    records: action === 'retrieve' ? [] : undefined,
-                    message: disabledMessage,
-                },
-            };
-        }
-        {
-            return {
-                adapter: null,
-                disabledResult: {
-                    action,
-                    status: 'disabled',
-                    records: action === 'retrieve' ? [] : undefined,
-                    message: 'Wallet runtime is not available in this environment.',
-                },
-            };
-        }
-    }
-
-    /**
-     * Parses store/update wallet payload.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function parseWalletPayload(args) {
-        const recordType = parseWalletRecordType(args.recordType);
-        return {
-            recordType,
-            service: parseWalletService(args.service),
-            key: parseWalletKey(args.key),
-            isUserScoped: args.isUserScoped === true,
-            isGlobal: args.isGlobal === true,
-            ...parseWalletSecrets({
-                recordType,
-                username: args.username,
-                password: args.password,
-                secret: args.secret,
-                cookies: args.cookies,
-            }),
-        };
-    }
-    /**
-     * Parses text argument and returns trimmed text when available.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function normalizeOptionalText(value) {
-        if (typeof value !== 'string') {
-            return undefined;
-        }
-        const trimmed = value.trim();
-        return trimmed || undefined;
-    }
-    /**
-     * Parses wallet service argument.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function parseWalletService(value) {
-        return (normalizeOptionalText(value) || 'generic').toLowerCase();
-    }
-    /**
-     * Parses wallet key argument.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function parseWalletKey(value) {
-        return normalizeOptionalText(value) || 'default';
-    }
-    /**
-     * Parses one wallet record id argument.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function parseWalletId(value) {
-        const walletId = normalizeOptionalText(value);
-        if (!walletId) {
-            throw new Error('Wallet id is required.');
-        }
-        return walletId;
-    }
-    /**
-     * Parses wallet record type.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function parseWalletRecordType(value, fallback) {
-        var _a;
-        const normalizedType = (_a = normalizeOptionalText(value)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-        if (normalizedType === 'USERNAME_PASSWORD') {
-            return 'USERNAME_PASSWORD';
-        }
-        if (normalizedType === 'SESSION_COOKIE') {
-            return 'SESSION_COOKIE';
-        }
-        if (normalizedType === 'ACCESS_TOKEN') {
-            return 'ACCESS_TOKEN';
-        }
-        if (fallback) {
-            return fallback;
-        }
-        throw new Error('Unsupported wallet recordType. Expected one of: USERNAME_PASSWORD, SESSION_COOKIE, ACCESS_TOKEN.');
-    }
-    /**
-     * Parses wallet secret fields according to record type.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function parseWalletSecrets(args) {
-        const username = normalizeOptionalText(args.username);
-        const password = normalizeOptionalText(args.password);
-        const secret = normalizeOptionalText(args.secret);
-        const cookies = normalizeOptionalText(args.cookies);
-        if (args.recordType === 'USERNAME_PASSWORD') {
-            if (!username || !password) {
-                throw new Error('Both username and password are required for USERNAME_PASSWORD.');
-            }
-            return { username, password };
-        }
-        if (args.recordType === 'SESSION_COOKIE') {
-            if (!cookies) {
-                throw new Error('Cookies are required for SESSION_COOKIE.');
-            }
-            return { cookies };
-        }
-        if (!secret) {
-            throw new Error('Secret is required for ACCESS_TOKEN.');
-        }
-        return { secret };
-    }
-    /**
-     * Collection of WALLET tool argument parsers.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    const parseWalletToolArgs = {
-        /**
-         * Parses retrieve arguments.
-         */
-        retrieve(args) {
-            const limit = typeof args.limit === 'number' && Number.isFinite(args.limit) ? Math.floor(args.limit) : undefined;
-            return {
-                query: normalizeOptionalText(args.query),
-                recordType: normalizeOptionalText(args.recordType) ? parseWalletRecordType(args.recordType) : undefined,
-                service: normalizeOptionalText(args.service) ? parseWalletService(args.service) : undefined,
-                key: normalizeOptionalText(args.key) ? parseWalletKey(args.key) : undefined,
-                limit: limit && limit > 0 ? Math.min(limit, 20) : undefined,
-            };
-        },
-        /**
-         * Parses store payload.
-         */
-        store(args) {
-            return parseWalletPayload(args);
-        },
-        /**
-         * Parses update payload.
-         */
-        update(args) {
-            const walletId = parseWalletId(args.walletId);
-            const record = parseWalletPayload(args);
-            return {
-                ...record,
-                walletId,
-            };
-        },
-        /**
-         * Parses delete payload.
-         */
-        delete(args) {
-            return { walletId: parseWalletId(args.walletId) };
-        },
-        /**
-         * Parses request payload for user wallet input prompt.
-         */
-        request(args) {
-            return {
-                recordType: parseWalletRecordType(args.recordType, 'ACCESS_TOKEN'),
-                service: parseWalletService(args.service),
-                key: parseWalletKey(args.key),
-                message: normalizeOptionalText(args.message),
-                isUserScoped: args.isUserScoped === true,
-                isGlobal: args.isGlobal === true,
-            };
-        },
-    };
-
-    /**
-     * Resolves runtime context from hidden tool arguments.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function resolveWalletRuntimeContext(args) {
-        const runtimeContext = readToolRuntimeContextFromToolArgs(args);
-        const memoryContext = runtimeContext === null || runtimeContext === void 0 ? void 0 : runtimeContext.memory;
-        return {
-            enabled: (memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.enabled) === true,
-            userId: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.userId,
-            username: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.username,
-            agentId: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.agentId,
-            agentName: memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.agentName,
-            isTeamConversation: (memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.isTeamConversation) === true,
-            isPrivateMode: (memoryContext === null || memoryContext === void 0 ? void 0 : memoryContext.isPrivateMode) === true,
-        };
-    }
-
-    /**
-     * Creates runtime wallet tool function implementations.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function createWalletToolFunctions() {
-        return {
-            async [WalletToolNames.retrieve](args) {
-                const runtimeContext = resolveWalletRuntimeContext(args);
-                const { adapter, disabledResult } = getWalletToolRuntimeAdapterOrDisabledResult('retrieve', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseWalletToolArgs.retrieve(args);
-                    const records = await adapter.retrieveWalletRecords(parsedArgs, runtimeContext);
-                    return JSON.stringify({
-                        action: 'retrieve',
-                        status: 'ok',
-                        query: parsedArgs.query,
-                        records,
-                    });
-                }
-                catch (error) {
-                    return JSON.stringify({
-                        action: 'retrieve',
-                        status: 'error',
-                        records: [],
-                        message: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            },
-            async [WalletToolNames.store](args) {
-                const runtimeContext = resolveWalletRuntimeContext(args);
-                const { adapter, disabledResult } = getWalletToolRuntimeAdapterOrDisabledResult('store', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseWalletToolArgs.store(args);
-                    const record = await adapter.storeWalletRecord(parsedArgs, runtimeContext);
-                    return JSON.stringify({
-                        action: 'store',
-                        status: 'stored',
-                        record,
-                    });
-                }
-                catch (error) {
-                    return JSON.stringify({
-                        action: 'store',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            },
-            async [WalletToolNames.update](args) {
-                const runtimeContext = resolveWalletRuntimeContext(args);
-                const { adapter, disabledResult } = getWalletToolRuntimeAdapterOrDisabledResult('update', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseWalletToolArgs.update(args);
-                    const record = await adapter.updateWalletRecord(parsedArgs, runtimeContext);
-                    return JSON.stringify({
-                        action: 'update',
-                        status: 'updated',
-                        record,
-                    });
-                }
-                catch (error) {
-                    return JSON.stringify({
-                        action: 'update',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            },
-            async [WalletToolNames.delete](args) {
-                const runtimeContext = resolveWalletRuntimeContext(args);
-                const { adapter, disabledResult } = getWalletToolRuntimeAdapterOrDisabledResult('delete', runtimeContext);
-                if (!adapter || disabledResult) {
-                    return JSON.stringify(disabledResult);
-                }
-                try {
-                    const parsedArgs = parseWalletToolArgs.delete(args);
-                    const deleted = await adapter.deleteWalletRecord(parsedArgs, runtimeContext);
-                    return JSON.stringify({
-                        action: 'delete',
-                        status: 'deleted',
-                        walletId: deleted.id,
-                    });
-                }
-                catch (error) {
-                    return JSON.stringify({
-                        action: 'delete',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            },
-            async [WalletToolNames.request](args) {
-                const runtimeContext = resolveWalletRuntimeContext(args);
-                const disabledMessage = resolveWalletDisabledMessage(runtimeContext);
-                if (disabledMessage) {
-                    return JSON.stringify({
-                        action: 'request',
-                        status: 'disabled',
-                        message: disabledMessage,
-                    });
-                }
-                const request = parseWalletToolArgs.request(args);
-                return JSON.stringify({
-                    action: 'request',
-                    status: 'requested',
-                    request,
-                    message: request.message ||
-                        `Request user to provide ${request.recordType} credentials for service "${request.service}".`,
-                });
-            },
-        };
-    }
-
-    /**
-     * Creates tool definitions required by WALLET commitment.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function createWalletTools(existingTools) {
-        const tools = [...(existingTools || [])];
-        addWalletToolIfMissing(tools, {
-            name: WalletToolNames.retrieve,
-            description: 'Retrieve wallet records relevant to the current task.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string', description: 'Optional text query used to filter wallet records.' },
-                    recordType: {
-                        type: 'string',
-                        description: 'Optional record type filter (USERNAME_PASSWORD, SESSION_COOKIE, ACCESS_TOKEN).',
-                    },
-                    service: { type: 'string', description: 'Optional service filter, for example github.' },
-                    key: { type: 'string', description: 'Optional wallet key filter.' },
-                    limit: { type: 'integer', description: 'Optional maximum number of records (default 5, max 20).' },
-                },
-                required: [],
-            },
-        });
-        addWalletToolIfMissing(tools, {
-            name: WalletToolNames.store,
-            description: 'Store one wallet record.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    recordType: {
-                        type: 'string',
-                        description: 'Record type: USERNAME_PASSWORD, SESSION_COOKIE, ACCESS_TOKEN.',
-                    },
-                    service: { type: 'string', description: 'Service identifier, for example github.' },
-                    key: { type: 'string', description: 'Logical credential key.' },
-                    username: { type: 'string', description: 'Username for USERNAME_PASSWORD.' },
-                    password: { type: 'string', description: 'Password for USERNAME_PASSWORD.' },
-                    secret: { type: 'string', description: 'Token/API key for ACCESS_TOKEN.' },
-                    cookies: { type: 'string', description: 'Cookie header/json for SESSION_COOKIE.' },
-                    isUserScoped: { type: 'boolean', description: 'Set true to scope this record to current user.' },
-                    isGlobal: { type: 'boolean', description: 'Set true to make this record global.' },
-                },
-                required: ['recordType', 'service'],
-            },
-        });
-        addWalletToolIfMissing(tools, {
-            name: WalletToolNames.update,
-            description: 'Update one existing wallet record.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    walletId: { type: 'string', description: 'Wallet record id to update.' },
-                    recordType: {
-                        type: 'string',
-                        description: 'Record type: USERNAME_PASSWORD, SESSION_COOKIE, ACCESS_TOKEN.',
-                    },
-                    service: { type: 'string', description: 'Service identifier, for example github.' },
-                    key: { type: 'string', description: 'Logical credential key.' },
-                    username: { type: 'string', description: 'Username for USERNAME_PASSWORD.' },
-                    password: { type: 'string', description: 'Password for USERNAME_PASSWORD.' },
-                    secret: { type: 'string', description: 'Token/API key for ACCESS_TOKEN.' },
-                    cookies: { type: 'string', description: 'Cookie header/json for SESSION_COOKIE.' },
-                    isUserScoped: { type: 'boolean', description: 'Set true to scope this record to current user.' },
-                    isGlobal: { type: 'boolean', description: 'Set true to make this record global.' },
-                },
-                required: ['walletId', 'recordType', 'service'],
-            },
-        });
-        addWalletToolIfMissing(tools, {
-            name: WalletToolNames.delete,
-            description: 'Delete one wallet record.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    walletId: { type: 'string', description: 'Wallet record id to delete.' },
-                },
-                required: ['walletId'],
-            },
-        });
-        addWalletToolIfMissing(tools, {
-            name: WalletToolNames.request,
-            description: 'Request missing credential from user via popup.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    recordType: {
-                        type: 'string',
-                        description: 'Requested record type: USERNAME_PASSWORD, SESSION_COOKIE, ACCESS_TOKEN.',
-                    },
-                    service: { type: 'string', description: 'Service identifier.' },
-                    key: { type: 'string', description: 'Logical credential key.' },
-                    message: { type: 'string', description: 'Optional UI message for user.' },
-                    isUserScoped: {
-                        type: 'boolean',
-                        description: 'Set true when record should be scoped to current user.',
-                    },
-                    isGlobal: { type: 'boolean', description: 'Set true when record should be global.' },
-                },
-                required: [],
-            },
-        });
-        return tools;
-    }
-    /**
-     * Registers one wallet tool when missing in current tool list.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function addWalletToolIfMissing(tools, tool) {
-        if (!tools.some((existingTool) => existingTool.name === tool.name)) {
-            tools.push(tool);
-        }
-    }
-
-    /**
-     * Gets markdown documentation for WALLET commitment.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function getWalletCommitmentDocumentation(type) {
-        return spacetrim.spaceTrim(`
-        # ${type}
-
-        Enables private credential storage for tokens, usernames/passwords, and session cookies.
-    `);
-    }
-
-    /**
-     * Gets human-readable titles for WALLET tool functions.
-     *
-     * @private function of WalletCommitmentDefinition
-     */
-    function getWalletToolTitles() {
-        return {
-            [WalletToolNames.retrieve]: 'Wallet',
-            [WalletToolNames.store]: 'Store wallet record',
-            [WalletToolNames.update]: 'Update wallet record',
-            [WalletToolNames.delete]: 'Delete wallet record',
-            [WalletToolNames.request]: 'Request wallet record',
-        };
-    }
-
-    /**
-     * WALLET commitment definition.
-     *
-     * @private [🪔] Maybe export the commitments through some package
-     */
-    class WalletCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor(type = 'WALLET') {
-            super(type);
-        }
-        get requiresContent() {
-            return false;
-        }
-        get description() {
-            return 'Enable persistent private credential storage (tokens, logins, cookies) scoped per agent or globally.';
-        }
-        get icon() {
-            return '👛';
-        }
-        get documentation() {
-            return getWalletCommitmentDocumentation(this.type);
-        }
-        applyToAgentModelRequirements(requirements, content) {
-            const extraInstructions = formatOptionalInstructionBlock('Wallet instructions', content);
-            return this.appendToSystemMessage({
-                ...requirements,
-                tools: createWalletTools(requirements.tools),
-                _metadata: {
-                    ...requirements._metadata,
-                    useWallet: content || true,
-                },
-            }, createWalletSystemMessage(extraInstructions));
-        }
-        getToolTitles() {
-            return getWalletToolTitles();
-        }
-        getToolFunctions() {
-            return createWalletToolFunctions();
-        }
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
     /**
      * `WRITING RULES` commitment definition.
      *
@@ -20670,8 +17156,6 @@
         new PersonaCommitmentDefinition('PERSONA'),
         new PersonaCommitmentDefinition('PERSONAE'),
         new KnowledgeCommitmentDefinition(),
-        new MemoryCommitmentDefinition('MEMORY'),
-        new MemoryCommitmentDefinition('MEMORIES'),
         new StyleCommitmentDefinition('STYLE'),
         new StyleCommitmentDefinition('STYLES'),
         new RuleCommitmentDefinition('RULE'),
@@ -20693,7 +17177,6 @@
         new ModelCommitmentDefinition('MODELS'),
         new ActionCommitmentDefinition('ACTION'),
         new ActionCommitmentDefinition('ACTIONS'),
-        new ComponentCommitmentDefinition(),
         new MetaAvatarCommitmentDefinition(),
         new MetaAvatarCommitmentDefinition('META VISUAL'),
         new MetaImageCommitmentDefinition(),
@@ -20701,11 +17184,13 @@
         new MetaFontCommitmentDefinition(),
         new MetaLinkCommitmentDefinition(),
         new MetaDomainCommitmentDefinition(),
+        new MetaDescriptionCommitmentDefinition(),
         new MetaDisclaimerCommitmentDefinition(),
+        new MetaFullnameCommitmentDefinition(),
+        new MetaIdCommitmentDefinition(),
         new MetaInputPlaceholderCommitmentDefinition(),
         new MetaThinkingMessageCommitmentDefinition(),
         new MetaVisibilityCommitmentDefinition(),
-        new MetaCommitmentDefinition(),
         new MetaVoiceCommitmentDefinition(),
         new NoteCommitmentDefinition('NOTE'),
         new NoteCommitmentDefinition('NOTES'),
@@ -20721,8 +17206,6 @@
         new MessageSuffixCommitmentDefinition(),
         new MessageCommitmentDefinition('MESSAGE'),
         new MessageCommitmentDefinition('MESSAGES'),
-        new WalletCommitmentDefinition('WALLET'),
-        new WalletCommitmentDefinition('WALLETS'),
         new ScenarioCommitmentDefinition('SCENARIO'),
         new ScenarioCommitmentDefinition('SCENARIOS'),
         new DeleteCommitmentDefinition('DELETE'),
@@ -20733,15 +17216,8 @@
         new OpenCommitmentDefinition(),
         new ClosedCommitmentDefinition(),
         new TeamCommitmentDefinition(),
-        new UseBrowserCommitmentDefinition(),
-        new UseDeepSearchCommitmentDefinition(),
-        new UseSearchEngineCommitmentDefinition(),
-        new UseSpawnCommitmentDefinition(),
-        new UseTimeoutCommitmentDefinition(),
-        new UseTimeCommitmentDefinition(),
         new UseUserLocationCommitmentDefinition(),
         new UseCalendarCommitmentDefinition(),
-        new UseEmailCommitmentDefinition(),
         new UsePopupCommitmentDefinition(),
         new UseImageGeneratorCommitmentDefinition('USE IMAGE GENERATOR'),
         new UseMcpCommitmentDefinition(),
@@ -20937,6 +17413,39 @@
         return commitmentToolFunctionsProxy;
     }
 
+    /**
+     * Generates random token
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic
+     * Note: This function is cryptographically secure (it uses crypto.randomBytes internally)
+     *
+     * @returns secure random token
+     *
+     * @private internal helper function
+     */
+    function $randomToken(randomness) {
+        return CryptoJS__default["default"].lib.WordArray.random(randomness).toString(CryptoJS__default["default"].enc.Hex);
+    }
+    // TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
+    // TODO: Maybe use nanoid instead https://github.com/ai/nanoid
+
+    /**
+     * This error indicates errors during the execution of the pipeline
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class PipelineExecutionError extends Error {
+        constructor(message) {
+            // Added id parameter
+            super(message);
+            this.name = 'PipelineExecutionError';
+            // TODO: [🐙] DRY - Maybe $randomId
+            this.id = `error-${$randomToken(8 /* <- TODO: To global config + Use Base58 to avoid similar char conflicts   */)}`;
+            Object.setPrototypeOf(this, PipelineExecutionError.prototype);
+        }
+    }
+    // TODO: [🧠][🌂] Add id to all errors
+
     /**
      * Wrapper around `window.prompt` synchronous function that interacts with the user via browser prompt
      *
@@ -22253,59 +18762,6 @@
         return initialMessage;
     }
 
-    /**
-     * 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
-
     /**
      * Normalizes a domain-like string into a comparable hostname form.
      *
@@ -22344,6 +18800,54 @@
         return value.startsWith('http://') || value.startsWith('https://');
     }
 
+    /**
+     * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class ParseError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'ParseError';
+            Object.setPrototypeOf(this, ParseError.prototype);
+        }
+    }
+    // TODO: Maybe split `ParseError` and `ApplyError`
+
+    /**
+     * Supported visibility states for persisted agents.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const AGENT_VISIBILITY_VALUES = ['PRIVATE', 'UNLISTED', 'PUBLIC'];
+    /**
+     * Returns `true` when the value is one of supported visibility states.
+     *
+     * @param value - Raw value to validate.
+     * @returns Whether the value is a valid `AgentVisibility`.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function isAgentVisibility(value) {
+        return typeof value === 'string' && AGENT_VISIBILITY_VALUES.includes(value);
+    }
+    /**
+     * Normalizes raw visibility text into a supported value.
+     *
+     * @param value - Raw visibility value.
+     * @returns Normalized visibility, or `null` when invalid.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    function normalizeAgentVisibility(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+        const normalized = value.trim().toUpperCase();
+        return isAgentVisibility(normalized) ? normalized : null;
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * Dedicated handlers for META-style commitments that directly map onto parsed meta fields.
      */
@@ -22355,6 +18859,8 @@
         'META IMAGE': applyMetaImageContent,
         'META DESCRIPTION': applyMetaDescriptionContent,
         'META DISCLAIMER': applyMetaDisclaimerContent,
+        'META FULLNAME': applyMetaFullnameContent,
+        'META ID': applyMetaIdContent,
         'META INPUT PLACEHOLDER': applyMetaInputPlaceholderContent,
         'META THINKING MESSAGE': applyMetaThinkingMessageContent,
         'MESSAGE SUFFIX': applyMessageSuffixContent,
@@ -22372,32 +18878,8 @@
         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`).
-     */
-    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;
-        }
-        if (metaTypeRaw.toUpperCase() === 'VISIBILITY') {
-            applyMetaVisibilityContent(state, metaValue);
-            return;
-        }
-        const metaType = normalizeTo_camelCase(metaTypeRaw);
-        state.meta[metaType] = metaValue;
-    }
     /**
      * Applies META AVATAR / META VISUAL content into the canonical `meta.avatar` field.
      */
@@ -22441,6 +18923,18 @@
     function applyMetaDisclaimerContent(state, content) {
         state.meta.disclaimer = content;
     }
+    /**
+     * Applies META FULLNAME content into the canonical `meta.fullname` field.
+     */
+    function applyMetaFullnameContent(state, content) {
+        state.meta.fullname = spacetrim.spaceTrim(content);
+    }
+    /**
+     * Applies META ID content into the canonical `meta.id` field.
+     */
+    function applyMetaIdContent(state, content) {
+        state.meta.id = spacetrim.spaceTrim(content);
+    }
     /**
      * Applies META INPUT PLACEHOLDER content into the canonical `meta.inputPlaceholder` field.
      */
@@ -22545,46 +19039,11 @@
      * 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',
@@ -23094,6 +19553,21 @@
     //                  <- [🐱‍🚀] Buttons into genesis book
     // <- TODO: [🐱‍🚀] generateBookBoilerplate and deprecate `DEFAULT_BOOK`
 
+    /**
+     * Checks if value is valid email
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function isValidEmail(email) {
+        if (typeof email !== 'string') {
+            return false;
+        }
+        if (email.split(/\r?\n/).length > 1) {
+            return false;
+        }
+        return /^.+@.+\..+$/.test(email);
+    }
+
     /**
      * Function isValidJsonString will tell you if the string is valid JSON or not
      *
@@ -23167,6 +19641,19 @@
     }
     // TODO: [🧠][🈴] Where is the best location for this file
 
+    /**
+     * This error type indicates that some limit was reached
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class LimitReachedError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'LimitReachedError';
+            Object.setPrototypeOf(this, LimitReachedError.prototype);
+        }
+    }
+
     /**
      * Replaces parameters in template with values from parameters object
      *
@@ -30218,12 +26705,6 @@
         ['GOAL', 'GOAL'],
         ['GOALS', 'GOAL'],
     ]);
-    /**
-     * Legacy commitments that should be parsed for compatibility but ignored by the model-requirements pipeline.
-     *
-     * @private internal constant of `filterCommitmentsForAgentModelRequirements`
-     */
-    const IGNORED_COMMITMENT_TYPES = new Set(['WALLET', 'WALLETS']);
     /**
      * Applies the commitment filtering rules used before commitment definitions are executed.
      *
@@ -30272,9 +26753,6 @@
     function filterDeletedCommitments(commitments) {
         const filteredCommitments = [];
         for (const commitment of commitments) {
-            if (isIgnoredCommitmentType(commitment.type)) {
-                continue;
-            }
             if (!isDeleteCommitmentType(commitment.type)) {
                 filteredCommitments.push(commitment);
                 continue;
@@ -30305,17 +26783,6 @@
     function isDeleteCommitmentType(commitmentType) {
         return DELETE_COMMITMENT_TYPES.has(commitmentType);
     }
-    /**
-     * Checks whether a parsed commitment is intentionally ignored by the current model compiler.
-     *
-     * @param commitmentType - Commitment type to check.
-     * @returns `true` when the commitment should not affect model requirements.
-     *
-     * @private internal utility of `filterDeletedCommitments`
-     */
-    function isIgnoredCommitmentType(commitmentType) {
-        return IGNORED_COMMITMENT_TYPES.has(commitmentType);
-    }
     /**
      * Extracts normalized parameter names used for DELETE-like invalidation matching.
      *
@@ -30449,7 +26916,6 @@
         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);
@@ -31126,6 +27592,40 @@
         }
     }
 
+    /**
+     * Marker property stored inside serialized tool-execution envelopes.
+     *
+     * @private internal tool-execution transport
+     */
+    const TOOL_EXECUTION_ENVELOPE_MARKER = '__promptbookToolExecutionEnvelope';
+    /**
+     * Parses one serialized tool-execution envelope when present.
+     *
+     * @private internal tool-execution transport
+     */
+    function parseToolExecutionEnvelope(rawValue) {
+        if (typeof rawValue !== 'string') {
+            return null;
+        }
+        try {
+            const parsedValue = JSON.parse(rawValue);
+            if (!parsedValue ||
+                typeof parsedValue !== 'object' ||
+                parsedValue[TOOL_EXECUTION_ENVELOPE_MARKER] !== true ||
+                typeof parsedValue.assistantMessage !== 'string') {
+                return null;
+            }
+            return {
+                assistantMessage: parsedValue.assistantMessage,
+                toolResult: parsedValue.toolResult,
+            };
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * Builds a tool invocation script that injects hidden runtime context into tool args.
      *
@@ -31197,7 +27697,7 @@
      */
     const DEFAULT_DEEP_SEARCH_MODEL_NAME = 'o4-mini-deep-research';
     /**
-     * Tool name used by the Book commitment-backed DeepSearch capability.
+     * Tool name used by the DeepSearch capability.
      */
     const DEEP_SEARCH_TOOL_NAME = 'deep_search';
     /**
@@ -31467,7 +27967,7 @@
             };
         }
         /**
-         * Creates the native Agent SDK tool used for `USE DEEPSEARCH`.
+         * Creates the native Agent SDK tool used for the DeepSearch capability.
          */
         async createDeepSearchAgentKitTool(toolDefinition) {
             const { Agent: AgentFromKit, webSearchTool } = await loadOpenAiAgentsModule();
@@ -39564,7 +36064,7 @@
             this.links = [];
             /**
              * Capabilities of the agent
-             * This is parsed from commitments like USE BROWSER, USE SEARCH ENGINE, KNOWLEDGE, etc.
+             * This is parsed from commitments like USE CALENDAR, USE PROJECT, KNOWLEDGE, etc.
              */
             this.capabilities = [];
             /**