@promptbook/components 0.114.0-3 → 0.114.0-4

package/esm/index.es.js

@@ -5,7 +5,6 @@ import CryptoJS from 'crypto-js';
 import hexEncoder from 'crypto-js/enc-hex';
 import { basename, join, dirname, isAbsolute } from 'path';
 import 'crypto';
-import moment from 'moment';
 import { lookup, extension } from 'mime-types';
 import { createPortal } from 'react-dom';
 import MonacoEditor, { useMonaco } from '@monaco-editor/react';
@@ -17,6 +16,7 @@ import { toCanvas } from 'html-to-image';
 import { jsPDF } from 'jspdf';
 import { createRoot } from 'react-dom/client';
 import { Archive, Music, FileCode, FileText, File as File$1, ImageIcon, FileJson, Presentation, FileSpreadsheet, Table, Video, Globe2, Maximize2, X, Star, Reply, Pause, Play, Volume2Icon, VolumeXIcon, VibrateIcon, VibrateOffIcon } from 'lucide-react';
+import moment from 'moment';
 import 'moment/locale/cs';
 import { forTime } from 'waitasecond';
 import sha256 from 'crypto-js/sha256';
@@ -39,7 +39,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -9293,7 +9293,7 @@ class ActionCommitmentDefinition extends BaseCommitmentDefinition {
             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
             \`\`\`
 
@@ -9313,8 +9313,8 @@ class ActionCommitmentDefinition extends BaseCommitmentDefinition {
             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.
             \`\`\`
         `);
@@ -9415,65 +9415,6 @@ class ClosedCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
-/**
- * COMPONENT commitment definition
- *
- * The COMPONENT commitment defines a UI component that the agent can render in the chat.
- *
- * @private [🪔] Maybe export the commitments through some package
- */
-class ComponentCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor() {
-        super('COMPONENT');
-    }
-    /**
-     * Short one-line description of COMPONENT.
-     */
-    get description() {
-        return 'Define a UI component that the agent can render in the chat.';
-    }
-    /**
-     * Icon for this commitment.
-     */
-    get icon() {
-        return '🧩';
-    }
-    /**
-     * Markdown documentation for COMPONENT commitment.
-     */
-    get documentation() {
-        return spaceTrim$1(`
-            # COMPONENT
-
-            Defines a UI component that the agent can render in the chat.
-
-            ## Key aspects
-
-            - Tells the agent that a specific component is available.
-            - Provides syntax for using the component.
-
-            ## Example
-
-            \`\`\`book
-            COMPONENT Arrow
-            The agent should render an arrow component in the chat UI.
-            Syntax:
-            <Arrow direction="up" color="red" />
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, content) {
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
-            return requirements;
-        }
-        // 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
  *
@@ -10794,653 +10735,6 @@ class LanguageCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
-/**
- * @@@
- *
- * @private utility for commitments
- */
-function formatOptionalInstructionBlock(label, content) {
-    const trimmedContent = spaceTrim$1(content);
-    if (!trimmedContent) {
-        return '';
-    }
-    return spaceTrim$1((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$1((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$1(`
-                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$1(`
-                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$1(`
-                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$1(`
-                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$1(`
-        # ${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
  *
@@ -11900,161 +11194,6 @@ class MessageSuffixCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // 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$1(`
-            # 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
-
 /**
  * META AVATAR commitment definition
  *
@@ -12219,6 +11358,81 @@ class MetaColorCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // 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$1(`
+            # 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
  *
@@ -12435,6 +11649,131 @@ class MetaFontCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // 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$1(`
+            # 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$1(`
+            # 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
  *
@@ -14218,6 +13557,110 @@ function isSameOriginAgentUrl(agentUrl, localServerUrl) {
 }
 // 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.
  */
@@ -14805,430 +14248,23 @@ class TemplateCommitmentDefinition extends BaseCommitmentDefinition {
 // 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$1((block) => `
-                    ## Time and date context
-
-                    -   It is ${moment().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$1((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$1((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$1((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$1(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$1(`
-            # 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$1(`
-                    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$1(`
-                    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$1(`
-                    # 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$1(content);
+    if (!trimmedContent) {
+        return '';
     }
+    return spaceTrim$1((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.
@@ -15553,7 +14589,7 @@ function resolveUseCalendarToolRuntime(args) {
     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);
@@ -15573,7 +14609,7 @@ function resolveUseCalendarToolRuntime(args) {
     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,
@@ -15606,7 +14642,7 @@ function normalizeConfiguredCalendars$1(rawCalendars) {
             continue;
         }
         const calendar = rawCalendar;
-        const rawUrl = normalizeOptionalText$2(calendar.url);
+        const rawUrl = normalizeOptionalText$1(calendar.url);
         if (!rawUrl) {
             continue;
         }
@@ -15657,7 +14693,7 @@ function createCalendarWalletCredentialRequiredResult(error) {
  *
  * @private function of resolveUseCalendarToolRuntimeOrWalletCredentialResult
  */
-function normalizeOptionalText$2(value) {
+function normalizeOptionalText$1(value) {
     if (typeof value !== 'string') {
         return undefined;
     }
@@ -15689,13 +14725,13 @@ function createUseCalendarToolFunctions() {
         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) {
@@ -15707,7 +14743,7 @@ function createUseCalendarToolFunctions() {
                 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, {
@@ -15745,11 +14781,11 @@ function createUseCalendarToolFunctions() {
             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),
                 });
@@ -15771,12 +14807,12 @@ function createUseCalendarToolFunctions() {
             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),
                 });
@@ -15823,7 +14859,7 @@ function createUseCalendarToolFunctions() {
                     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, {
@@ -15871,7 +14907,7 @@ function encodeGoogleCalendarId(calendarId) {
  * @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.`);
     }
@@ -15882,7 +14918,7 @@ function normalizeRequiredText(value, fieldName) {
  *
  * @private function of createUseCalendarToolFunctions
  */
-function normalizeOptionalText$1(value) {
+function normalizeOptionalText(value) {
     if (typeof value !== 'string') {
         return undefined;
     }
@@ -16456,484 +15492,6 @@ function addConfiguredCalendarIfMissing(configuredCalendars, calendarReference)
 }
 // 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$1((block) => `
-                ${resultLabel} results for "${query}"${Object.keys(searchOptions).length === 0 ? '' : ` with options ${JSON.stringify(searchOptions)}`}:
-
-                ${block(results
-            .map((result) => spaceTrim$1(`
-                                - **${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$1(`
-            # 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$1(`
-                          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$1(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$1(`
-            # 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$1((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
  *
@@ -19162,1503 +17720,6 @@ function addConfiguredProjectIfMissing(configuredProjects, repositoryReference)
 }
 // 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$1(`
-            # USE SEARCH ENGINE
-
-            Enables the agent to use a search engine tool to access and retrieve up-to-date information from the internet.
-
-            ## Key aspects
-
-            - The content following \`USE SEARCH ENGINE\` is an arbitrary text that the agent should know (e.g. search scope or instructions).
-            - The actual search engine tool usage is handled by the agent runtime
-            - Allows the agent to search for current information from the web
-            - Useful for research tasks, finding facts, and accessing dynamic content
-
-            ## Examples
-
-            \`\`\`book
-            Research Assistant
-
-            PERSONA You are a helpful research assistant specialized in finding current information
-            USE SEARCH ENGINE
-            RULE Always cite your sources when providing information from the web
-            \`\`\`
-
-            \`\`\`book
-            Fact Checker
-
-            PERSONA You are a fact checker
-            USE SEARCH ENGINE
-            ACTION Search for claims and verify them against reliable sources
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, content) {
-        // Get existing tools array or create new one
-        const existingTools = requirements.tools || [];
-        // Add 'web_search' to tools if not already present
-        const updatedTools = existingTools.some((tool) => tool.name === 'web_search')
-            ? existingTools
-            : [
-                ...existingTools,
-                {
-                    name: 'web_search',
-                    description: spaceTrim$1(`
-                        Search the internet for information.
-                        Use this tool when you need to find up-to-date information or facts that you don't know.
-                    `),
-                    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$1(`
-            # 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$1(`
-                          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$1((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$1((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.lib.WordArray.random(randomness).toString(CryptoJS.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$1(`
-            ${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$1(`
-                    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$1(`
-                    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$1(`
-                    Timeout \`limit\` must be a positive number.
-                `));
-        }
-        if (parsedLimit > MAX_LIST_TIMEOUTS_LIMIT) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    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$1(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$1(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$1((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$1(`
-            # 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$1(`
-            # USE TIME
-
-            Enables the agent to determine the current date and time.
-
-            ## Key aspects
-
-            - This tool won't receive any input.
-            - It outputs the current date and time as an ISO 8601 string.
-            - Allows the agent to answer questions about the current time or date.
-            - 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.
  *
@@ -20873,580 +17934,6 @@ class UseUserLocationCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // 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$1((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$1(`
-        # ${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.
  *
@@ -21673,8 +18160,6 @@ const COMMITMENT_REGISTRY = [
     new PersonaCommitmentDefinition('PERSONA'),
     new PersonaCommitmentDefinition('PERSONAE'),
     new KnowledgeCommitmentDefinition(),
-    new MemoryCommitmentDefinition('MEMORY'),
-    new MemoryCommitmentDefinition('MEMORIES'),
     new StyleCommitmentDefinition('STYLE'),
     new StyleCommitmentDefinition('STYLES'),
     new RuleCommitmentDefinition('RULE'),
@@ -21696,7 +18181,6 @@ const COMMITMENT_REGISTRY = [
     new ModelCommitmentDefinition('MODELS'),
     new ActionCommitmentDefinition('ACTION'),
     new ActionCommitmentDefinition('ACTIONS'),
-    new ComponentCommitmentDefinition(),
     new MetaAvatarCommitmentDefinition(),
     new MetaAvatarCommitmentDefinition('META VISUAL'),
     new MetaImageCommitmentDefinition(),
@@ -21704,11 +18188,13 @@ const COMMITMENT_REGISTRY = [
     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'),
@@ -21724,8 +18210,6 @@ const COMMITMENT_REGISTRY = [
     new MessageSuffixCommitmentDefinition(),
     new MessageCommitmentDefinition('MESSAGE'),
     new MessageCommitmentDefinition('MESSAGES'),
-    new WalletCommitmentDefinition('WALLET'),
-    new WalletCommitmentDefinition('WALLETS'),
     new ScenarioCommitmentDefinition('SCENARIO'),
     new ScenarioCommitmentDefinition('SCENARIOS'),
     new DeleteCommitmentDefinition('DELETE'),
@@ -21736,15 +18220,8 @@ const COMMITMENT_REGISTRY = [
     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(),
@@ -22053,59 +18530,6 @@ function extractInitialMessage(commitments) {
     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.
  *
@@ -22144,6 +18568,54 @@ function hasHttpProtocol(value) {
     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.
  */
@@ -22155,6 +18627,8 @@ const META_COMMITMENT_APPLIERS = {
     '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,
@@ -22172,32 +18646,8 @@ function applyMetaCommitment(state, commitment) {
     const applyMetaContent = META_COMMITMENT_APPLIERS[commitment.type];
     if (applyMetaContent) {
         applyMetaContent(state, commitment.content);
-        return;
-    }
-    if (commitment.type === 'META') {
-        applyGenericMetaCommitment(state, commitment.content);
     }
 }
-/**
- * Applies the generic META commitment form (`META TYPE value`).
- */
-function applyGenericMetaCommitment(state, content) {
-    const metaTypeRaw = content.split(' ')[0] || 'NONE';
-    const metaValue = spaceTrim$1(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.
  */
@@ -22241,6 +18691,18 @@ function applyMetaDescriptionContent(state, content) {
 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$1(content);
+}
+/**
+ * Applies META ID content into the canonical `meta.id` field.
+ */
+function applyMetaIdContent(state, content) {
+    state.meta.id = spaceTrim$1(content);
+}
 /**
  * Applies META INPUT PLACEHOLDER content into the canonical `meta.inputPlaceholder` field.
  */
@@ -22345,46 +18807,11 @@ function consumeConversationSampleCommitment(state, commitment) {
  * 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',
@@ -24264,7 +20691,7 @@ function createCommitmentRegex(commitmentTypes) {
     }
     const commitmentPatterns = [...commitmentTypes]
         .sort((a, b) => b.length - a.length)
-        .map((type) => (type === 'META' ? 'META\\s+\\w+' : type.replace(/\s+/, '\\s+')))
+        .map((type) => type.replace(/\s+/, '\\s+'))
         .join('|');
     return new RegExp(`^\\s*(${commitmentPatterns})(?=\\s|$)`);
 }
@@ -30454,6 +26881,59 @@ const pdfSaveFormatDefinition = {
 // TODO: !!! Add QR code with branding to the footer
 // TODO: !!! Add print option
 
+/**
+ * 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 given text to PascalCase format.
  *
@@ -45330,6 +41810,21 @@ function useSendMessageToLlmChat() {
 const CHAT_STREAM_KEEP_ALIVE_TOKEN = 'STREAM_KEEP_ALIVE';
 // 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);
+}
+
 /**
  * Function isValidJsonString will tell you if the string is valid JSON or not
  *
@@ -45403,6 +41898,52 @@ function isValidPipelineString(pipelineString) {
 }
 // TODO: [🧠][🈴] Where is the best location for this file
 
+/**
+ * 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.lib.WordArray.random(randomness).toString(CryptoJS.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
+
+/**
+ * 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
  *
@@ -52511,12 +49052,6 @@ const OVERWRITTEN_COMMITMENT_GROUP_BY_TYPE = new Map([
     ['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.
  *
@@ -52565,9 +49100,6 @@ function filterOverwrittenCommitments(commitments) {
 function filterDeletedCommitments(commitments) {
     const filteredCommitments = [];
     for (const commitment of commitments) {
-        if (isIgnoredCommitmentType(commitment.type)) {
-            continue;
-        }
         if (!isDeleteCommitmentType(commitment.type)) {
             filteredCommitments.push(commitment);
             continue;
@@ -52598,17 +49130,6 @@ function filterDeletedCommitments(commitments) {
 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.
  *
@@ -52742,7 +49263,6 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
     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);
@@ -53270,6 +49790,40 @@ class OpenAiAgentKitExecutionToolsOutputTypeMapper {
     }
 }
 
+/**
+ * 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.
  *
@@ -53341,7 +49895,7 @@ const loadOpenAiAgentsModule = createLazyModuleLoader(() => import('@openai/agen
  */
 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';
 /**
@@ -53611,7 +50165,7 @@ class OpenAiAgentKitExecutionToolsToolBuilder {
         };
     }
     /**
-     * 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();
@@ -61708,7 +58262,7 @@ class Agent extends AgentLlmExecutionTools {
         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 = [];
         /**