@promptbook/node 0.112.0-11 → 0.112.0-12

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('fs/promises'), require('path'), require('spacetrim'), require('jszip'), require('crypto'), require('crypto-js'), require('crypto-js/enc-hex'), require('@mozilla/readability'), require('jsdom'), require('showdown'), require('os'), require('configchecker'), require('locate-app'), require('playwright'), require('child_process'), require('waitasecond'), require('dotenv'), require('crypto-js/sha256'), require('rxjs'), require('mime-types'), require('moment'), require('papaparse'), require('@openai/agents'), require('bottleneck'), require('openai')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'fs/promises', 'path', 'spacetrim', 'jszip', 'crypto', 'crypto-js', 'crypto-js/enc-hex', '@mozilla/readability', 'jsdom', 'showdown', 'os', 'configchecker', 'locate-app', 'playwright', 'child_process', 'waitasecond', 'dotenv', 'crypto-js/sha256', 'rxjs', 'mime-types', 'moment', 'papaparse', '@openai/agents', 'bottleneck', 'openai'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-node"] = {}, global.colors, global.promises, global.path, global.spaceTrim$1, global.JSZip, global.crypto, global.cryptoJs, global.hexEncoder, global.readability, global.jsdom, global.showdown, global.os, global.configchecker, global.locateApp$1, global.playwright, global.child_process, global.waitasecond, global.dotenv, global.sha256, global.rxjs, global.mimeTypes, global.moment, global.papaparse, global.agents, global.Bottleneck, global.OpenAI));
-})(this, (function (exports, colors, promises, path, spaceTrim$1, JSZip, crypto, cryptoJs, hexEncoder, readability, jsdom, showdown, os, configchecker, locateApp$1, playwright, child_process, waitasecond, dotenv, sha256, rxjs, mimeTypes, moment, papaparse, agents, Bottleneck, OpenAI) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('fs/promises'), require('path'), require('spacetrim'), require('jszip'), require('crypto'), require('crypto-js'), require('crypto-js/enc-hex'), require('@mozilla/readability'), require('jsdom'), require('showdown'), require('os'), require('configchecker'), require('playwright'), require('child_process'), require('waitasecond'), require('dotenv'), require('crypto-js/sha256'), require('rxjs'), require('mime-types'), require('moment'), require('papaparse'), require('@openai/agents'), require('bottleneck'), require('openai')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'fs/promises', 'path', 'spacetrim', 'jszip', 'crypto', 'crypto-js', 'crypto-js/enc-hex', '@mozilla/readability', 'jsdom', 'showdown', 'os', 'configchecker', 'playwright', 'child_process', 'waitasecond', 'dotenv', 'crypto-js/sha256', 'rxjs', 'mime-types', 'moment', 'papaparse', '@openai/agents', 'bottleneck', 'openai'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-node"] = {}, global.colors, global.promises, global.path, global.spaceTrim$1, global.JSZip, global.crypto, global.cryptoJs, global.hexEncoder, global.readability, global.jsdom, global.showdown, global.os, global.configchecker, global.playwright, global.child_process, global.waitasecond, global.dotenv, global.sha256, global.rxjs, global.mimeTypes, global.moment, global.papaparse, global.agents, global.Bottleneck, global.OpenAI));
+})(this, (function (exports, colors, promises, path, spaceTrim$1, JSZip, crypto, cryptoJs, hexEncoder, readability, jsdom, showdown, os, configchecker, playwright, child_process, waitasecond, dotenv, sha256, rxjs, mimeTypes, moment, papaparse, agents, Bottleneck, OpenAI) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -48,7 +48,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-11';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-12';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -14813,117 +14813,449 @@
     };
 
     /**
-     * Creates one standard abort error for cancelled retry loops.
+     * Normalize options for `execCommand` and `execCommands`
      *
-     * @private utility for Agents Server runtime retries
-     */
-    function createAbortError$1() {
-        const error = new Error('Operation was aborted.');
-        error.name = 'AbortError';
-        return error;
-    }
-    /**
-     * Throws when the supplied signal is already aborted.
+     * Note: `$` is used to indicate that this function behaves differently according to `process.platform`
      *
-     * @private utility for Agents Server runtime retries
+     * @private internal utility of `execCommand` and `execCommands`
      */
-    function assertNotAborted(signal) {
-        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-            throw createAbortError$1();
+    function $execCommandNormalizeOptions(options) {
+        var _a, _b, _c, _d;
+        let command;
+        let cwd;
+        let crashOnError;
+        let args = [];
+        let timeout;
+        let isVerbose;
+        let env;
+        if (typeof options === 'string') {
+            // TODO: [1] DRY default values
+            command = options;
+            cwd = process.cwd();
+            crashOnError = true;
+            timeout = Infinity; // <- TODO: [⏳]
+            isVerbose = DEFAULT_IS_VERBOSE;
+            env = undefined;
         }
-    }
-    /**
-     * Waits for a duration while respecting cancellation.
-     *
-     * @private utility for Agents Server runtime retries
-     */
-    async function sleepWithAbort(delayMs, signal) {
-        if (delayMs <= 0) {
-            assertNotAborted(signal);
-            return;
+        else {
+            /*
+            TODO:
+            if ((options as any).commands !== undefined) {
+                commands = (options as any).commands;
+            } else {
+                commands = [(options as any).command];
+            }
+            */
+            // TODO: [1] DRY default values
+            command = options.command;
+            cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+            crashOnError = (_b = options.crashOnError) !== null && _b !== void 0 ? _b : true;
+            timeout = (_c = options.timeout) !== null && _c !== void 0 ? _c : Infinity;
+            isVerbose = (_d = options.isVerbose) !== null && _d !== void 0 ? _d : DEFAULT_IS_VERBOSE;
+            env = options.env;
         }
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
-                resolve();
-            }, delayMs);
-            const onAbort = () => {
-                clearTimeout(timeout);
-                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
-                reject(createAbortError$1());
-            };
-            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
-        });
+        // TODO: /(-[a-zA-Z0-9-]+\s+[^\s]*)|[^\s]*/g
+        const _ = Array.from(command.matchAll(/(".*")|([^\s]*)/g))
+            .map(([match]) => match)
+            .filter((arg) => arg !== '');
+        if (_.length > 1) {
+            [command, ...args] = _;
+        }
+        if (options.args) {
+            args = [...args, ...options.args];
+        }
+        let humanReadableCommand = !['npx', 'npm'].includes(command) ? command : args[0];
+        if (['ts-node'].includes(humanReadableCommand)) {
+            humanReadableCommand += ` ${args[1]}`;
+        }
+        if (/^win/.test(process.platform) && ['npm', 'npx'].includes(command)) {
+            command = `${command}.cmd`;
+        }
+        return { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose, env };
     }
+    // TODO: This should show type error> execCommandNormalizeOptions({ command: '', commands: [''] });
+
     /**
-     * Resolves the retry wait duration for one failed attempt.
+     * Run one command in a shell
      *
-     * @private utility for Agents Server runtime retries
-     */
-    function resolveBackoffDelayMs(options) {
-        const exponentialDelay = options.initialDelayMs * Math.pow(options.backoffFactor, Math.max(0, options.attempt - 1));
-        const boundedDelay = Math.min(exponentialDelay, options.maxDelayMs);
-        const jitterDelay = boundedDelay * options.jitterRatio * Math.max(0, options.random());
-        return Math.max(0, Math.round(boundedDelay + jitterDelay));
-    }
-    /**
-     * Retries one async operation with exponential backoff and jitter.
      *
-     * @private utility for Agents Server runtime retries
+     * Note: There are 2 similar functions in the codebase:
+     * - `$execCommand` which runs a single command
+     * - `$execCommands` which runs multiple commands
+     * Note: `$` is used to indicate that this function is not a pure function - it runs a command in a shell
+     *
+     * @public exported from `@promptbook/node`
      */
-    async function retryWithBackoff(operation, options) {
-        var _a, _b, _c;
-        const startedAt = Date.now();
-        const totalAttempts = Math.max(1, options.retries + 1);
-        const random = (_a = options.random) !== null && _a !== void 0 ? _a : Math.random;
-        const sleep = (_b = options.sleep) !== null && _b !== void 0 ? _b : sleepWithAbort;
-        for (let attempt = 1; attempt <= totalAttempts; attempt++) {
-            assertNotAborted(options.signal);
-            try {
-                const value = await operation(attempt);
-                return {
-                    value,
-                    attempts: attempt,
-                    durationMs: Date.now() - startedAt,
-                };
+    function $execCommand(options) {
+        if (!$isRunningInNode()) {
+            throw new EnvironmentMismatchError('Function `$execCommand` can run only in Node environment.js');
+        }
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const
+            const { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose = DEFAULT_IS_VERBOSE, env, } = $execCommandNormalizeOptions(options);
+            if (timeout !== Infinity) {
+                // TODO: In waitasecond forTime(Infinity) should be equivalent to forEver()
+                waitasecond.forTime(timeout).then(() => {
+                    if (crashOnError) {
+                        reject(new Error(`Command "${humanReadableCommand}" exceeded time limit of ${timeout}ms`));
+                    }
+                    else {
+                        console.warn(`Command "${humanReadableCommand}" exceeded time limit of ${timeout}ms but continues running`);
+                        // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
+                        resolve('Command exceeded time limit');
+                    }
+                });
             }
-            catch (error) {
-                const isLastAttempt = attempt >= totalAttempts;
-                const isRetryable = options.shouldRetry ? options.shouldRetry(error, attempt) : true;
-                if (isLastAttempt || !isRetryable) {
-                    throw error;
+            if (isVerbose) {
+                console.info(colors__default["default"].yellow(cwd) + ' ' + colors__default["default"].green(command) + ' ' + colors__default["default"].blue(args.join(' ')));
+            }
+            try {
+                const commandProcess = child_process.spawn(command, args, {
+                    cwd,
+                    shell: true,
+                    env: env ? { ...process.env, ...env } : process.env,
+                });
+                if (isVerbose) {
+                    commandProcess.on('message', (message) => {
+                        console.info({ message });
+                    });
                 }
-                const delayMs = resolveBackoffDelayMs({
-                    attempt,
-                    initialDelayMs: options.initialDelayMs,
-                    maxDelayMs: options.maxDelayMs,
-                    backoffFactor: options.backoffFactor,
-                    jitterRatio: options.jitterRatio,
-                    random,
+                const output = [];
+                commandProcess.stdout.on('data', (stdout) => {
+                    output.push(stdout.toString());
+                    if (isVerbose) {
+                        console.info(stdout.toString());
+                    }
                 });
-                (_c = options.onRetry) === null || _c === void 0 ? void 0 : _c.call(options, {
-                    attempt,
-                    retries: options.retries,
-                    delayMs,
-                    error,
+                commandProcess.stderr.on('data', (stderr) => {
+                    output.push(stderr.toString());
+                    if (isVerbose && stderr.toString().trim()) {
+                        console.warn(stderr.toString());
+                        // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
+                    }
+                });
+                const finishWithCode = (code) => {
+                    if (code !== 0) {
+                        if (crashOnError) {
+                            reject(new Error(output.join('\n').trim() ||
+                                `Command "${humanReadableCommand}" exited with code ${code}`));
+                        }
+                        else {
+                            if (isVerbose) {
+                                console.warn(`Command "${humanReadableCommand}" exited with code ${code}`);
+                                // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
+                            }
+                            resolve(spaceTrim$1.spaceTrim(output.join('\n')));
+                        }
+                    }
+                    else {
+                        resolve(spaceTrim$1.spaceTrim(output.join('\n')));
+                    }
+                };
+                commandProcess.on('close', finishWithCode);
+                commandProcess.on('exit', finishWithCode);
+                commandProcess.on('disconnect', () => {
+                    // Note: Unexpected disconnection should always result in rejection
+                    reject(new Error(`Command "${humanReadableCommand}" disconnected`));
+                });
+                commandProcess.on('error', (error) => {
+                    if (crashOnError) {
+                        reject(new Error(`Command "${humanReadableCommand}" failed: \n${error.message}`));
+                    }
+                    else {
+                        if (isVerbose) {
+                            console.warn(error);
+                            // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
+                        }
+                        resolve(spaceTrim$1.spaceTrim(output.join('\n')));
+                    }
                 });
-                await sleep(delayMs, options.signal);
             }
-        }
-        throw new Error('Retry loop exited unexpectedly.');
+            catch (error) {
+                // Note: Unexpected error in sync code should always result in rejection
+                reject(error);
+            }
+        });
     }
-
-    const DEFAULT_BROWSER_USER_DATA_DIR = path.join(os.tmpdir(), 'promptbook', 'browser', 'user-data');
     /**
-     * Default remote browser connect timeout in milliseconds.
+     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
      */
-    const DEFAULT_REMOTE_CONNECT_TIMEOUT_MS = 10000;
+
     /**
-     * Default retry count for remote browser connection establishment.
+     * Attempts to locate the specified application on a Linux system using the 'which' command.
+     * Returns the path to the executable if found, or null otherwise.
+     *
+     * @private within the repository
      */
-    const DEFAULT_REMOTE_CONNECT_RETRIES = 2;
+    async function locateAppOnLinux({ linuxWhich, }) {
+        try {
+            const result = await $execCommand({ crashOnError: true, command: `which ${linuxWhich}` });
+            return result.trim();
+        }
+        catch (error) {
+            assertsError(error);
+            return null;
+        }
+    }
     /**
-     * Default initial retry delay for remote browser connection.
+     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
+     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     */
+
+    /**
+     * Checks if the file is executable
+     *
+     * @private within the repository
+     */
+    async function isExecutable(path, fs) {
+        try {
+            await fs.access(path, fs.constants.X_OK);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Note: Not [~🟢~] because it is not directly dependent on `fs
+     * TODO: [🖇] What about symlinks?
+     */
+
+    // Note: Module `userhome` has no types available, so it is imported using `require`
+    //       @see https://stackoverflow.com/questions/37000981/how-to-import-node-module-in-typescript-without-type-definitions
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const userhome = require('userhome');
+    /**
+     * Attempts to locate the specified application on a macOS system by checking standard application paths and using mdfind.
+     * Returns the path to the executable if found, or null otherwise.
+     *
+     * @private within the repository
+     */
+    async function locateAppOnMacOs({ macOsName, }) {
+        try {
+            const toExec = `/Contents/MacOS/${macOsName}`;
+            const regPath = `/Applications/${macOsName}.app` + toExec;
+            const altPath = userhome(regPath.slice(1));
+            if (await isExecutable(regPath, $provideFilesystemForNode())) {
+                return regPath;
+            }
+            else if (await isExecutable(altPath, $provideFilesystemForNode())) {
+                return altPath;
+            }
+            const result = await $execCommand({
+                crashOnError: true,
+                command: `mdfind 'kMDItemDisplayName == "${macOsName}" && kMDItemKind == Application'`,
+            });
+            return result.trim() + toExec;
+        }
+        catch (error) {
+            assertsError(error);
+            return null;
+        }
+    }
+    /**
+     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
+     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     */
+
+    /**
+     * Attempts to locate the specified application on a Windows system by searching common installation directories.
+     * Returns the path to the executable if found, or null otherwise.
+     *
+     * @private within the repository
+     */
+    async function locateAppOnWindows({ appName, windowsSuffix, }) {
+        try {
+            const prefixes = [
+                process.env.LOCALAPPDATA,
+                path.join(process.env.LOCALAPPDATA || '', 'Programs'),
+                process.env.PROGRAMFILES,
+                process.env['PROGRAMFILES(X86)'],
+            ];
+            for (const prefix of prefixes) {
+                const path = prefix + windowsSuffix;
+                if (await isExecutable(path, $provideFilesystemForNode())) {
+                    return path;
+                }
+            }
+            throw new Error(`Can not locate app ${appName} on Windows.`);
+        }
+        catch (error) {
+            assertsError(error);
+            return null;
+        }
+    }
+    /**
+     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
+     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     */
+
+    /**
+     * Locates an application on the system
+     *
+     * @private within the repository
+     */
+    function locateApp(options) {
+        if (!$isRunningInNode()) {
+            throw new EnvironmentMismatchError('Locating apps works only in Node.js environment');
+        }
+        const { appName, linuxWhich, windowsSuffix, macOsName } = options;
+        if (process.platform === 'win32') {
+            if (windowsSuffix) {
+                return locateAppOnWindows({ appName, windowsSuffix });
+            }
+            else {
+                throw new Error(`${appName} is not available on Windows.`);
+            }
+        }
+        else if (process.platform === 'darwin') {
+            if (macOsName) {
+                return locateAppOnMacOs({ macOsName });
+            }
+            else {
+                throw new Error(`${appName} is not available on macOS.`);
+            }
+        }
+        else {
+            if (linuxWhich) {
+                return locateAppOnLinux({ linuxWhich });
+            }
+            else {
+                throw new Error(`${appName} is not available on Linux.`);
+            }
+        }
+    }
+    /**
+     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
+     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     */
+
+    /**
+     * @@@
+     *
+     * @private within the repository
+     */
+    function locateChrome() {
+        return locateApp({
+            appName: 'Chrome',
+            linuxWhich: 'google-chrome',
+            windowsSuffix: '\\Google\\Chrome\\Application\\chrome.exe',
+            macOsName: 'Google Chrome',
+        });
+    }
+
+    /**
+     * Creates one standard abort error for cancelled retry loops.
+     *
+     * @private utility for Agents Server runtime retries
+     */
+    function createAbortError$1() {
+        const error = new Error('Operation was aborted.');
+        error.name = 'AbortError';
+        return error;
+    }
+    /**
+     * Throws when the supplied signal is already aborted.
+     *
+     * @private utility for Agents Server runtime retries
+     */
+    function assertNotAborted(signal) {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw createAbortError$1();
+        }
+    }
+    /**
+     * Waits for a duration while respecting cancellation.
+     *
+     * @private utility for Agents Server runtime retries
+     */
+    async function sleepWithAbort(delayMs, signal) {
+        if (delayMs <= 0) {
+            assertNotAborted(signal);
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+                resolve();
+            }, delayMs);
+            const onAbort = () => {
+                clearTimeout(timeout);
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+                reject(createAbortError$1());
+            };
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    /**
+     * Resolves the retry wait duration for one failed attempt.
+     *
+     * @private utility for Agents Server runtime retries
+     */
+    function resolveBackoffDelayMs(options) {
+        const exponentialDelay = options.initialDelayMs * Math.pow(options.backoffFactor, Math.max(0, options.attempt - 1));
+        const boundedDelay = Math.min(exponentialDelay, options.maxDelayMs);
+        const jitterDelay = boundedDelay * options.jitterRatio * Math.max(0, options.random());
+        return Math.max(0, Math.round(boundedDelay + jitterDelay));
+    }
+    /**
+     * Retries one async operation with exponential backoff and jitter.
+     *
+     * @private utility for Agents Server runtime retries
+     */
+    async function retryWithBackoff(operation, options) {
+        var _a, _b, _c;
+        const startedAt = Date.now();
+        const totalAttempts = Math.max(1, options.retries + 1);
+        const random = (_a = options.random) !== null && _a !== void 0 ? _a : Math.random;
+        const sleep = (_b = options.sleep) !== null && _b !== void 0 ? _b : sleepWithAbort;
+        for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+            assertNotAborted(options.signal);
+            try {
+                const value = await operation(attempt);
+                return {
+                    value,
+                    attempts: attempt,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                const isLastAttempt = attempt >= totalAttempts;
+                const isRetryable = options.shouldRetry ? options.shouldRetry(error, attempt) : true;
+                if (isLastAttempt || !isRetryable) {
+                    throw error;
+                }
+                const delayMs = resolveBackoffDelayMs({
+                    attempt,
+                    initialDelayMs: options.initialDelayMs,
+                    maxDelayMs: options.maxDelayMs,
+                    backoffFactor: options.backoffFactor,
+                    jitterRatio: options.jitterRatio,
+                    random,
+                });
+                (_c = options.onRetry) === null || _c === void 0 ? void 0 : _c.call(options, {
+                    attempt,
+                    retries: options.retries,
+                    delayMs,
+                    error,
+                });
+                await sleep(delayMs, options.signal);
+            }
+        }
+        throw new Error('Retry loop exited unexpectedly.');
+    }
+
+    const DEFAULT_BROWSER_USER_DATA_DIR = path.join(os.tmpdir(), 'promptbook', 'browser', 'user-data');
+    /**
+     * Default remote browser connect timeout in milliseconds.
+     */
+    const DEFAULT_REMOTE_CONNECT_TIMEOUT_MS = 10000;
+    /**
+     * Default retry count for remote browser connection establishment.
+     */
+    const DEFAULT_REMOTE_CONNECT_RETRIES = 2;
+    /**
+     * Default initial retry delay for remote browser connection.
      */
     const DEFAULT_REMOTE_CONNECT_BACKOFF_INITIAL_MS = 250;
     /**
@@ -15183,7 +15515,7 @@
                 args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
             };
             try {
-                const chromePath = await locateApp$1.locateChrome();
+                const chromePath = await locateChrome();
                 launchOptions.executablePath = chromePath;
             }
             catch (error) {
@@ -21366,27 +21698,154 @@
      */
 
     /**
-     * Lightweight email token matcher used for `USE EMAIL` first-line parsing.
+     * Base Google Calendar API URL.
      *
-     * @private internal USE EMAIL constant
+     * @private constant of callGoogleCalendarApi
      */
-    const EMAIL_TOKEN_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/;
+    const GOOGLE_CALENDAR_API_BASE_URL = 'https://www.googleapis.com/calendar/v3';
     /**
-     * Parses `USE EMAIL` commitment content into optional sender email + additional instructions.
+     * Runs one Google Calendar API request and parses JSON response payload.
      *
-     * Examples:
-     * - `agent@example.com`
-     * - `agent@example.com Keep emails concise`
-     * - `Keep emails concise`
+     * @private function of UseCalendarCommitmentDefinition
+     */
+    async function callGoogleCalendarApi(accessToken, options) {
+        const url = new URL(options.path, GOOGLE_CALENDAR_API_BASE_URL);
+        if (options.query) {
+            for (const [key, value] of Object.entries(options.query)) {
+                if (value && value.trim()) {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        const response = await fetch(url.toString(), {
+            method: options.method,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+        const textPayload = await response.text();
+        const parsedPayload = tryParseJson$2(textPayload);
+        if (options.allowNotFound && response.status === 404) {
+            return null;
+        }
+        if (!response.ok) {
+            throw new Error(spaceTrim$1.spaceTrim(`
+                Google Calendar API request failed (${response.status} ${response.statusText}):
+                ${extractGoogleCalendarApiErrorMessage(parsedPayload, textPayload)}
+            `));
+        }
+        return parsedPayload;
+    }
+    /**
+     * Parses raw text into JSON when possible.
      *
-     * @private internal utility of USE EMAIL commitment
+     * @private function of callGoogleCalendarApi
      */
-    function parseUseEmailCommitmentContent(content) {
+    function tryParseJson$2(rawText) {
+        if (!rawText.trim()) {
+            return {};
+        }
+        try {
+            return JSON.parse(rawText);
+        }
+        catch (_a) {
+            return rawText;
+        }
+    }
+    /**
+     * Extracts a user-friendly Google Calendar API error message.
+     *
+     * @private function of callGoogleCalendarApi
+     */
+    function extractGoogleCalendarApiErrorMessage(parsedPayload, fallbackText) {
+        if (parsedPayload && typeof parsedPayload === 'object') {
+            const payload = parsedPayload;
+            const errorPayload = payload.error;
+            if (errorPayload && typeof errorPayload === 'object') {
+                const normalizedErrorPayload = errorPayload;
+                const message = typeof normalizedErrorPayload.message === 'string' ? normalizedErrorPayload.message : '';
+                const errors = Array.isArray(normalizedErrorPayload.errors) ? normalizedErrorPayload.errors : [];
+                const flattenedErrors = errors
+                    .map((errorEntry) => {
+                    if (!errorEntry || typeof errorEntry !== 'object') {
+                        return '';
+                    }
+                    const normalizedErrorEntry = errorEntry;
+                    const detailMessage = typeof normalizedErrorEntry.message === 'string' ? normalizedErrorEntry.message : '';
+                    const reason = typeof normalizedErrorEntry.reason === 'string' ? normalizedErrorEntry.reason : '';
+                    return [detailMessage, reason].filter(Boolean).join(' | ');
+                })
+                    .filter(Boolean);
+                if (message || flattenedErrors.length > 0) {
+                    return [message, ...flattenedErrors].filter(Boolean).join(' | ');
+                }
+            }
+        }
+        return fallbackText || 'Unknown Google Calendar API error';
+    }
+
+    /**
+     * Hostnames accepted for Google Calendar references.
+     *
+     * @private internal USE CALENDAR constant
+     */
+    const GOOGLE_CALENDAR_HOSTNAMES = new Set(['calendar.google.com', 'www.calendar.google.com']);
+    /**
+     * Default Google Calendar OAuth scopes when commitment content does not list any.
+     *
+     * @private internal USE CALENDAR constant
+     */
+    const DEFAULT_GOOGLE_CALENDAR_SCOPES = ['https://www.googleapis.com/auth/calendar'];
+    /**
+     * Parses one Google Calendar URL/reference into canonical details.
+     *
+     * Supported input forms:
+     * - `https://calendar.google.com/...`
+     * - `calendar.google.com/...`
+     *
+     * @private internal utility of USE CALENDAR commitment
+     */
+    function parseGoogleCalendarReference(rawReference) {
+        const trimmedReference = rawReference.trim();
+        if (!trimmedReference) {
+            return null;
+        }
+        const normalizedReference = trimmedReference.startsWith('calendar.google.com/')
+            ? `https://${trimmedReference}`
+            : trimmedReference;
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(normalizedReference);
+        }
+        catch (_a) {
+            return null;
+        }
+        if (!GOOGLE_CALENDAR_HOSTNAMES.has(parsedUrl.hostname.toLowerCase())) {
+            return null;
+        }
+        parsedUrl.protocol = 'https:';
+        parsedUrl.hash = '';
+        return {
+            provider: 'google',
+            url: parsedUrl.toString(),
+            calendarId: parseGoogleCalendarIdFromUrl(parsedUrl) || 'primary',
+            scopes: [...DEFAULT_GOOGLE_CALENDAR_SCOPES],
+        };
+    }
+    /**
+     * Parses `USE CALENDAR` commitment content into calendar reference + optional instructions.
+     *
+     * @private internal utility of USE CALENDAR commitment
+     */
+    function parseUseCalendarCommitmentContent(content) {
         const trimmedContent = spaceTrim$1.spaceTrim(content);
         if (!trimmedContent) {
             return {
-                senderEmail: null,
-                senderEmailRaw: null,
+                calendar: null,
+                calendarUrlRaw: null,
                 instructions: '',
             };
         }
@@ -21396,718 +21855,1505 @@
             .filter(Boolean);
         if (lines.length === 0) {
             return {
-                senderEmail: null,
-                senderEmailRaw: null,
+                calendar: null,
+                calendarUrlRaw: null,
                 instructions: '',
             };
         }
+        let calendarReferenceRaw = null;
+        let calendarReference = null;
         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 firstLineTokens = firstLine.split(/\s+/).filter(Boolean);
+        for (const token of firstLineTokens) {
+            const cleanedToken = token.replace(/[),.;:!?]+$/g, '');
+            const parsedReference = parseGoogleCalendarReference(cleanedToken);
+            if (!parsedReference) {
+                continue;
+            }
+            calendarReferenceRaw = cleanedToken;
+            calendarReference = parsedReference;
+            break;
         }
-        const instructionLines = [firstLineWithoutSender, ...lines.slice(1)].filter(Boolean);
-        const instructions = instructionLines.join('\n').trim();
+        if (!calendarReference) {
+            const firstUrl = findFirstUrlToken(trimmedContent);
+            if (firstUrl) {
+                calendarReferenceRaw = firstUrl;
+                calendarReference = parseGoogleCalendarReference(firstUrl);
+            }
+        }
+        const scopes = extractGoogleCalendarScopes(trimmedContent);
+        if (calendarReference) {
+            calendarReference = {
+                ...calendarReference,
+                scopes: scopes.length > 0 ? scopes : [...DEFAULT_GOOGLE_CALENDAR_SCOPES],
+                tokenRef: extractTokenRef(trimmedContent),
+            };
+        }
+        const instructionLines = [...lines];
+        if (instructionLines.length > 0 && calendarReferenceRaw) {
+            instructionLines[0] = removeTokenFromLine(instructionLines[0] || '', calendarReferenceRaw);
+        }
+        const filteredInstructionLines = instructionLines.filter((line) => !/^\s*SCOPES?\s+/i.test(line) && !line.trim().startsWith('https://www.googleapis.com/auth/'));
         return {
-            senderEmail,
-            senderEmailRaw,
-            instructions,
+            calendar: calendarReference,
+            calendarUrlRaw: calendarReferenceRaw,
+            instructions: filteredInstructionLines.join('\n').trim(),
         };
     }
-
     /**
-     * Client-side safe wrapper for sending emails.
+     * Attempts to resolve one concrete Google Calendar id from URL.
      *
-     * This function proxies requests to the Agents Server API endpoint for email queuing,
-     * making it safe to use in browser environments.
+     * @private internal utility of USE CALENDAR commitment
+     */
+    function parseGoogleCalendarIdFromUrl(url) {
+        const rawCalendarId = url.searchParams.get('cid') || url.searchParams.get('src') || url.searchParams.get('calendarId');
+        if (!rawCalendarId) {
+            return null;
+        }
+        const decodedCalendarId = decodeURIComponent(rawCalendarId).trim();
+        return decodedCalendarId || null;
+    }
+    /**
+     * Finds the first URL-looking token in text.
      *
-     * @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 utility of USE CALENDAR commitment
+     */
+    function findFirstUrlToken(text) {
+        const match = text.match(/https?:\/\/[^\s)]+/i);
+        return match ? match[0] || null : null;
+    }
+    /**
+     * Extracts Google Calendar OAuth scopes declared in commitment text.
      *
-     * @private internal utility for USE EMAIL commitment
+     * @private utility of USE CALENDAR 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}`);
+    function extractGoogleCalendarScopes(content) {
+        const scopesFromUrls = content.match(/https:\/\/www\.googleapis\.com\/auth\/[A-Za-z0-9._/-]+/gim) || [];
+        const scopesFromKeywordLines = content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => /^\s*SCOPES?\s+/i.test(line))
+            .flatMap((line) => line
+            .replace(/^\s*SCOPES?\s+/i, '')
+            .split(/[,\s]+/)
+            .map((scope) => scope.trim())
+            .filter(Boolean))
+            .filter((scope) => scope.startsWith('https://www.googleapis.com/auth/'));
+        const uniqueScopes = new Set();
+        for (const scope of [...scopesFromUrls, ...scopesFromKeywordLines]) {
+            uniqueScopes.add(scope);
         }
+        return [...uniqueScopes];
     }
-
     /**
-     * Tool name used by USE EMAIL.
+     * Extracts optional token reference marker from commitment text.
      *
-     * @private internal USE EMAIL constant
+     * @private utility of USE CALENDAR commitment
      */
-    const SEND_EMAIL_TOOL_NAME = 'send_email';
+    function extractTokenRef(content) {
+        var _a;
+        const tokenRefMatch = content.match(/@[\w.-]+/);
+        const tokenRef = (_a = tokenRefMatch === null || tokenRefMatch === void 0 ? void 0 : tokenRefMatch[0]) === null || _a === void 0 ? void 0 : _a.trim();
+        return tokenRef || undefined;
+    }
     /**
-     * Wallet service used for SMTP credentials required by USE EMAIL.
+     * Removes one specific token from one instruction line.
      *
-     * @private internal USE EMAIL constant
+     * @private utility of USE CALENDAR commitment
      */
-    const USE_EMAIL_SMTP_WALLET_SERVICE = 'smtp';
+    function removeTokenFromLine(line, token) {
+        const tokens = line.split(/\s+/).filter(Boolean);
+        const filteredTokens = tokens.filter((lineToken) => lineToken.replace(/[),.;:!?]+$/g, '') !== token);
+        return filteredTokens.join(' ').trim();
+    }
     /**
-     * Wallet key used for SMTP credentials required by USE EMAIL.
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * Wallet metadata used by USE CALENDAR when resolving Google Calendar credentials.
      *
-     * @private internal USE EMAIL constant
+     * @private constant of UseCalendarCommitmentDefinition
      */
-    const USE_EMAIL_SMTP_WALLET_KEY = 'use-email-smtp-credentials';
+    const UseCalendarWallet = {
+        service: 'google_calendar',
+        key: 'use-calendar-google-token',
+    };
+
     /**
-     * USE EMAIL commitment definition.
+     * Internal error used to signal missing wallet credentials.
      *
-     * The `USE EMAIL` commitment enables outbound email sending through the `send_email` tool.
+     * @private class of resolveUseCalendarToolRuntimeOrWalletCredentialResult
+     */
+    class CalendarWalletCredentialRequiredError extends Error {
+        constructor(options) {
+            super('Google Calendar token is missing in wallet. Request it from user and store as ACCESS_TOKEN (service google_calendar, key use-calendar-google-token).');
+            this.name = 'CalendarWalletCredentialRequiredError';
+            this.service = UseCalendarWallet.service;
+            this.key = UseCalendarWallet.key;
+            this.calendarReference = options.calendarReference;
+        }
+    }
+    /**
+     * Resolves calendar runtime or returns a wallet-credential-required payload when missing.
      *
-     * @private [🪔] Maybe export the commitments through some package
+     * @private function of UseCalendarCommitmentDefinition
      */
-    class UseEmailCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE EMAIL', ['EMAIL', 'MAIL']);
+    function resolveUseCalendarToolRuntimeOrWalletCredentialResult(args) {
+        try {
+            return resolveUseCalendarToolRuntime(args);
         }
-        get requiresContent() {
-            return false;
+        catch (error) {
+            if (error instanceof CalendarWalletCredentialRequiredError) {
+                return {
+                    walletResult: JSON.stringify(createCalendarWalletCredentialRequiredResult(error)),
+                };
+            }
+            throw error;
         }
-        /**
-         * Short one-line description of USE EMAIL.
-         */
-        get description() {
-            return 'Enable outbound email sending through a wallet-backed SMTP configuration.';
+    }
+    /**
+     * Resolves runtime calendar + token for a USE CALENDAR tool call.
+     *
+     * @private function of resolveUseCalendarToolRuntimeOrWalletCredentialResult
+     */
+    function resolveUseCalendarToolRuntime(args) {
+        var _a, _b;
+        const runtimeContext = (readToolRuntimeContextFromToolArgs(args) ||
+            {});
+        const configuredCalendars = normalizeConfiguredCalendars$1((_a = runtimeContext.calendars) === null || _a === void 0 ? void 0 : _a.connections);
+        const calendarArgument = normalizeOptionalText$1(args.calendarUrl);
+        let calendarReference = null;
+        if (calendarArgument) {
+            calendarReference = parseGoogleCalendarReference(calendarArgument);
+            if (!calendarReference) {
+                throw new Error(`Calendar URL "${calendarArgument}" is invalid.`);
+            }
         }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '📧';
+        else if (configuredCalendars.length === 1) {
+            calendarReference = configuredCalendars[0] || null;
         }
-        /**
-         * Markdown documentation for USE EMAIL commitment.
-         */
-        get documentation() {
-            return spaceTrim$1.spaceTrim(`
-            # USE EMAIL
-
-            Enables the agent to send outbound emails through SMTP.
-
-            ## Key aspects
-
-            - The agent sends email via the \`send_email\` tool.
-            - SMTP credentials are expected from wallet records (\`ACCESS_TOKEN\`, service \`smtp\`, key \`use-email-smtp-credentials\`).
-            - Commitment content can optionally begin with a default sender email address:
-              - \`USE EMAIL agent@example.com\`
-            - Remaining commitment content is treated as optional email-writing instructions.
-
-            ## Examples
-
-            \`\`\`book
-            Writing Agent
-            USE EMAIL agent@example.com
-            RULE Write emails to customers according to the instructions from user.
-            \`\`\`
-
-            \`\`\`book
-            Formal Email Assistant
-            USE EMAIL agent@example.com Keep emails concise and formal.
-            \`\`\`
-        `);
+        else if (configuredCalendars.length > 1) {
+            throw new Error('Calendar is ambiguous. Provide "calendarUrl" argument with one calendar from USE CALENDAR commitments.');
         }
-        applyToAgentModelRequirements(requirements, content) {
-            const parsedCommitment = parseUseEmailCommitmentContent(content);
-            const extraInstructions = formatOptionalInstructionBlock('Email instructions', parsedCommitment.instructions);
-            const senderInstruction = parsedCommitment.senderEmail
-                ? `- Default sender address from commitment: "${parsedCommitment.senderEmail}".`
-                : '';
-            const updatedTools = addUseEmailTools(requirements.tools || []);
-            return this.appendToSystemMessage({
-                ...requirements,
-                tools: updatedTools,
-                _metadata: {
-                    ...requirements._metadata,
-                    useEmail: true,
-                    ...(parsedCommitment.senderEmail ? { useEmailSender: parsedCommitment.senderEmail } : {}),
-                },
-            }, spaceTrim$1.spaceTrim((block) => `
-                    Email tool:
-                    - Use "${SEND_EMAIL_TOOL_NAME}" to send outbound emails.
-                    - Prefer \`message\` argument compatible with Promptbook \`Message\` type.
-                    - Include subject in \`message.metadata.subject\` (or use legacy \`subject\` argument).
-                    - USE EMAIL credentials are read from wallet records (ACCESS_TOKEN, service "${USE_EMAIL_SMTP_WALLET_SERVICE}", key "${USE_EMAIL_SMTP_WALLET_KEY}").
-                    - Wallet secret must contain SMTP credentials in JSON format with fields \`host\`, \`port\`, \`secure\`, \`username\`, \`password\`.
-                    - If credentials are missing, ask user to add wallet credentials.
-                    ${block(senderInstruction)}
-                    ${block(extraInstructions)}
-                `));
+        else {
+            throw new Error('Calendar is required. Provide "calendarUrl" argument in the tool call.');
         }
-        /**
-         * Gets human-readable titles for tool functions provided by this commitment.
-         */
-        getToolTitles() {
-            return {
-                [SEND_EMAIL_TOOL_NAME]: 'Send email',
-            };
+        if (!calendarReference) {
+            throw new Error('Calendar is required but was not resolved.');
         }
-        /**
-         * 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);
-                },
-            };
+        const accessToken = normalizeOptionalText$1((_b = runtimeContext.calendars) === null || _b === void 0 ? void 0 : _b.googleAccessToken) || '';
+        if (!accessToken) {
+            throw new CalendarWalletCredentialRequiredError({
+                calendarReference,
+            });
+        }
+        if (configuredCalendars.length > 0) {
+            const allowedCalendarUrls = new Set(configuredCalendars.map((configuredCalendar) => configuredCalendar.url));
+            if (!allowedCalendarUrls.has(calendarReference.url)) {
+                throw new Error(`Calendar "${calendarReference.url}" is not configured by USE CALENDAR for this agent.`);
+            }
         }
+        return {
+            calendarReference,
+            accessToken,
+        };
     }
     /**
-     * Adds USE EMAIL tool definition while keeping already registered tools untouched.
+     * Normalizes optional calendar list from runtime context.
      *
-     * @private utility of USE EMAIL commitment
+     * @private function of resolveUseCalendarToolRuntimeOrWalletCredentialResult
      */
-    function addUseEmailTools(existingTools) {
-        if (existingTools.some((tool) => tool.name === SEND_EMAIL_TOOL_NAME)) {
-            return [...existingTools];
+    function normalizeConfiguredCalendars$1(rawCalendars) {
+        if (!Array.isArray(rawCalendars)) {
+            return [];
         }
-        return [
-            ...existingTools,
-            {
-                name: SEND_EMAIL_TOOL_NAME,
-                description: 'Send an outbound email through configured SMTP credentials. Prefer providing Message-like payload in `message`.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        message: {
-                            type: 'object',
-                            description: 'Preferred input payload compatible with Promptbook Message type. Use metadata.subject for 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.',
-                        },
+        const calendars = [];
+        const knownCalendars = new Set();
+        for (const rawCalendar of rawCalendars) {
+            if (!rawCalendar || typeof rawCalendar !== 'object') {
+                continue;
+            }
+            const calendar = rawCalendar;
+            const rawUrl = normalizeOptionalText$1(calendar.url);
+            if (!rawUrl) {
+                continue;
+            }
+            const parsedReference = parseGoogleCalendarReference(rawUrl);
+            if (!parsedReference) {
+                continue;
+            }
+            const key = `${parsedReference.provider}|${parsedReference.url}`;
+            if (knownCalendars.has(key)) {
+                continue;
+            }
+            knownCalendars.add(key);
+            const scopes = Array.isArray(calendar.scopes)
+                ? calendar.scopes
+                    .filter((scope) => typeof scope === 'string')
+                    .map((scope) => scope.trim())
+                    .filter(Boolean)
+                : [];
+            calendars.push({
+                ...parsedReference,
+                scopes: scopes.length > 0 ? scopes : parsedReference.scopes,
+            });
+        }
+        return calendars;
+    }
+    /**
+     * Converts missing-wallet errors into structured tool result payloads.
+     *
+     * @private function of resolveUseCalendarToolRuntimeOrWalletCredentialResult
+     */
+    function createCalendarWalletCredentialRequiredResult(error) {
+        return {
+            action: 'calendar-auth',
+            status: 'wallet-credential-required',
+            recordType: 'ACCESS_TOKEN',
+            service: error.service,
+            key: error.key,
+            isUserScoped: false,
+            isGlobal: false,
+            provider: 'google',
+            calendarUrl: error.calendarReference.url,
+            scopes: error.calendarReference.scopes,
+            message: error.message,
+        };
+    }
+    /**
+     * Normalizes unknown text input to trimmed non-empty string.
+     *
+     * @private function of resolveUseCalendarToolRuntimeOrWalletCredentialResult
+     */
+    function normalizeOptionalText$1(value) {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const trimmedValue = value.trim();
+        return trimmedValue || undefined;
+    }
+
+    /**
+     * Names of tools used by the USE CALENDAR commitment.
+     *
+     * @private constant of UseCalendarCommitmentDefinition
+     */
+    const UseCalendarToolNames = {
+        listEvents: 'calendar_list_events',
+        getEvent: 'calendar_get_event',
+        createEvent: 'calendar_create_event',
+        updateEvent: 'calendar_update_event',
+        deleteEvent: 'calendar_delete_event',
+        inviteGuests: 'calendar_invite_guests',
+    };
+
+    /**
+     * Gets Google Calendar tool function implementations.
+     *
+     * @private function of UseCalendarCommitmentDefinition
+     */
+    function createUseCalendarToolFunctions() {
+        return {
+            async [UseCalendarToolNames.listEvents](args) {
+                return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
+                    const query = {};
+                    if (normalizeOptionalText(args.timeMin)) {
+                        query.timeMin = args.timeMin.trim();
+                    }
+                    if (normalizeOptionalText(args.timeMax)) {
+                        query.timeMax = args.timeMax.trim();
+                    }
+                    if (normalizeOptionalText(args.query)) {
+                        query.q = args.query.trim();
+                    }
+                    if (typeof args.maxResults === 'number' && Number.isFinite(args.maxResults) && args.maxResults > 0) {
+                        query.maxResults = String(Math.floor(args.maxResults));
+                    }
+                    if (args.singleEvents !== undefined) {
+                        query.singleEvents = args.singleEvents ? 'true' : 'false';
+                    }
+                    if (args.orderBy === 'startTime' || args.orderBy === 'updated') {
+                        query.orderBy = args.orderBy;
+                    }
+                    if (normalizeOptionalText(args.timeZone)) {
+                        query.timeZone = args.timeZone.trim();
+                    }
+                    const payload = await callGoogleCalendarApi(accessToken, {
+                        method: 'GET',
+                        path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events`,
+                        query,
+                    });
+                    const events = ((payload === null || payload === void 0 ? void 0 : payload.items) || []).map((event) => mapGoogleCalendarEvent(event));
+                    return JSON.stringify({
+                        provider: calendarReference.provider,
+                        calendarUrl: calendarReference.url,
+                        calendarId: calendarReference.calendarId,
+                        events,
+                        nextPageToken: (payload === null || payload === void 0 ? void 0 : payload.nextPageToken) || null,
+                        nextSyncToken: (payload === null || payload === void 0 ? void 0 : payload.nextSyncToken) || null,
+                    });
+                });
+            },
+            async [UseCalendarToolNames.getEvent](args) {
+                return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
+                    const eventId = normalizeRequiredText(args.eventId, 'eventId');
+                    const payload = await callGoogleCalendarApi(accessToken, {
+                        method: 'GET',
+                        path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events/${encodeURIComponent(eventId)}`,
+                    });
+                    return JSON.stringify({
+                        provider: calendarReference.provider,
+                        calendarUrl: calendarReference.url,
+                        calendarId: calendarReference.calendarId,
+                        event: mapGoogleCalendarEvent(payload || {}),
+                    });
+                });
+            },
+            async [UseCalendarToolNames.createEvent](args) {
+                return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
+                    const requestBody = createGoogleCalendarEventPayload({
+                        summary: normalizeRequiredText(args.summary, 'summary'),
+                        description: normalizeOptionalText(args.description),
+                        location: normalizeOptionalText(args.location),
+                        start: normalizeRequiredText(args.start, 'start'),
+                        end: normalizeRequiredText(args.end, 'end'),
+                        timeZone: normalizeOptionalText(args.timeZone),
+                        attendees: normalizeAttendees(args.attendees),
+                        reminderMinutes: normalizeReminderMinutes(args.reminderMinutes),
+                    });
+                    const payload = await callGoogleCalendarApi(accessToken, {
+                        method: 'POST',
+                        path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events`,
+                        query: createSendUpdatesQuery(args.sendUpdates),
+                        body: requestBody,
+                    });
+                    return JSON.stringify({
+                        provider: calendarReference.provider,
+                        calendarUrl: calendarReference.url,
+                        calendarId: calendarReference.calendarId,
+                        event: mapGoogleCalendarEvent(payload || {}),
+                    });
+                });
+            },
+            async [UseCalendarToolNames.updateEvent](args) {
+                return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
+                    const eventId = normalizeRequiredText(args.eventId, 'eventId');
+                    const requestBody = createGoogleCalendarEventPayload({
+                        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),
+                    });
+                    const payload = await callGoogleCalendarApi(accessToken, {
+                        method: 'PATCH',
+                        path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events/${encodeURIComponent(eventId)}`,
+                        query: createSendUpdatesQuery(args.sendUpdates),
+                        body: requestBody,
+                    });
+                    return JSON.stringify({
+                        provider: calendarReference.provider,
+                        calendarUrl: calendarReference.url,
+                        calendarId: calendarReference.calendarId,
+                        event: mapGoogleCalendarEvent(payload || {}),
+                    });
+                });
+            },
+            async [UseCalendarToolNames.deleteEvent](args) {
+                return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
+                    const eventId = normalizeRequiredText(args.eventId, 'eventId');
+                    await callGoogleCalendarApi(accessToken, {
+                        method: 'DELETE',
+                        path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events/${encodeURIComponent(eventId)}`,
+                        query: createSendUpdatesQuery(args.sendUpdates),
+                    });
+                    return JSON.stringify({
+                        provider: calendarReference.provider,
+                        calendarUrl: calendarReference.url,
+                        calendarId: calendarReference.calendarId,
+                        eventId,
+                        status: 'deleted',
+                    });
+                });
+            },
+            async [UseCalendarToolNames.inviteGuests](args) {
+                return withUseCalendarRuntime(args, async ({ calendarReference, accessToken }) => {
+                    const eventId = normalizeRequiredText(args.eventId, 'eventId');
+                    const guests = normalizeAttendees(args.guests);
+                    if (guests.length === 0) {
+                        throw new Error('Tool "calendar_invite_guests" requires non-empty "guests".');
+                    }
+                    const existingEvent = await callGoogleCalendarApi(accessToken, {
+                        method: 'GET',
+                        path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events/${encodeURIComponent(eventId)}`,
+                    });
+                    const existingAttendees = ((existingEvent === null || existingEvent === void 0 ? void 0 : existingEvent.attendees) || [])
+                        .map((attendee) => normalizeOptionalText(attendee.email))
+                        .filter((email) => Boolean(email));
+                    const mergedAttendees = [...new Set([...existingAttendees, ...guests])];
+                    const payload = await callGoogleCalendarApi(accessToken, {
+                        method: 'PATCH',
+                        path: `/calendars/${encodeGoogleCalendarId(calendarReference.calendarId)}/events/${encodeURIComponent(eventId)}`,
+                        query: createSendUpdatesQuery(args.sendUpdates),
                         body: {
-                            type: 'string',
-                            description: 'Legacy alias for markdown body content.',
+                            attendees: mergedAttendees.map((email) => ({ email })),
                         },
-                    },
-                    required: [],
-                },
+                    });
+                    return JSON.stringify({
+                        provider: calendarReference.provider,
+                        calendarUrl: calendarReference.url,
+                        calendarId: calendarReference.calendarId,
+                        event: mapGoogleCalendarEvent(payload || {}),
+                        invitedGuests: guests,
+                    });
+                });
             },
-        ];
+        };
     }
     /**
-     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * Executes one tool operation with resolved USE CALENDAR runtime.
+     *
+     * @private function of createUseCalendarToolFunctions
      */
-
+    async function withUseCalendarRuntime(args, operation) {
+        const runtime = resolveUseCalendarToolRuntimeOrWalletCredentialResult(args);
+        if ('walletResult' in runtime) {
+            return runtime.walletResult;
+        }
+        return operation(runtime);
+    }
     /**
-     * USE IMAGE GENERATOR commitment definition
+     * Encodes one Google calendar id for URL path usage.
      *
-     * The `USE IMAGE GENERATOR` commitment indicates that the agent can output
-     * markdown placeholders for UI-driven image generation.
+     * @private function of createUseCalendarToolFunctions
+     */
+    function encodeGoogleCalendarId(calendarId) {
+        return encodeURIComponent(calendarId);
+    }
+    /**
+     * Normalizes one required textual input.
      *
-     * Example usage in agent source:
+     * @private function of createUseCalendarToolFunctions
+     */
+    function normalizeRequiredText(value, fieldName) {
+        const normalizedValue = normalizeOptionalText(value);
+        if (!normalizedValue) {
+            throw new Error(`Tool "${fieldName}" requires non-empty value.`);
+        }
+        return normalizedValue;
+    }
+    /**
+     * Normalizes unknown text input to trimmed non-empty string.
      *
-     * ```book
-     * USE IMAGE GENERATOR
-     * USE IMAGE GENERATOR Create realistic images of nature
-     * ```
+     * @private function of createUseCalendarToolFunctions
+     */
+    function normalizeOptionalText(value) {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const trimmedValue = value.trim();
+        return trimmedValue || undefined;
+    }
+    /**
+     * Normalizes optional attendee list from tool input.
      *
-     * @private [🪔] Maybe export the commitments through some package
+     * @private function of createUseCalendarToolFunctions
      */
-    class UseImageGeneratorCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor(type = 'USE IMAGE GENERATOR') {
-            super(type);
+    function normalizeAttendees(value) {
+        if (!Array.isArray(value)) {
+            return [];
         }
-        get requiresContent() {
-            return false;
+        const normalizedAttendees = value
+            .filter((attendee) => typeof attendee === 'string')
+            .map((attendee) => attendee.trim())
+            .filter(Boolean);
+        return [...new Set(normalizedAttendees)];
+    }
+    /**
+     * Normalizes optional reminder-minute offsets from tool input.
+     *
+     * @private function of createUseCalendarToolFunctions
+     */
+    function normalizeReminderMinutes(value) {
+        if (!Array.isArray(value)) {
+            return [];
         }
-        /**
-         * Short one-line description of USE IMAGE GENERATOR.
-         */
-        get description() {
-            return 'Enable the agent to output markdown image placeholders that the UI turns into generated images.';
+        const reminderMinutes = value
+            .filter((minute) => typeof minute === 'number' && Number.isFinite(minute))
+            .map((minute) => Math.max(0, Math.floor(minute)));
+        return [...new Set(reminderMinutes)];
+    }
+    /**
+     * Builds optional `sendUpdates` query for mutating Google Calendar requests.
+     *
+     * @private function of createUseCalendarToolFunctions
+     */
+    function createSendUpdatesQuery(sendUpdates) {
+        if (sendUpdates === 'all' || sendUpdates === 'externalOnly' || sendUpdates === 'none') {
+            return { sendUpdates };
         }
-        /**
-         * Icon for this commitment.
-         */
-        get icon() {
-            return '🖼️';
+        return {};
+    }
+    /**
+     * Creates one Google Calendar event payload from normalized tool arguments.
+     *
+     * @private function of createUseCalendarToolFunctions
+     */
+    function createGoogleCalendarEventPayload(options) {
+        const payload = {};
+        if (options.summary) {
+            payload.summary = options.summary;
         }
-        /**
-         * Markdown documentation for USE IMAGE GENERATOR commitment.
-         */
-        get documentation() {
-            return spaceTrim$1.spaceTrim(`
-            # USE IMAGE GENERATOR
-
-            Enables the agent to output markdown image placeholders that trigger image generation in the user interface.
-
-            ## Key aspects
-
-            - The content following \`USE IMAGE GENERATOR\` is an arbitrary text that the agent should know (e.g. style instructions or safety guidelines).
-            - The agent does **not** call an image-generation tool directly.
-            - The agent inserts markdown notation: \`![alt](?image-prompt=...)\`.
-            - The user interface detects the notation and generates the image asynchronously.
-
-            ## Examples
-
-            \`\`\`book
-            Visual Artist
-
-            PERSONA You are a creative visual artist.
-            USE IMAGE GENERATOR
-            RULE Always describe the generated image to the user.
-            \`\`\`
-
-            \`\`\`book
-            Interior Designer
-
-            PERSONA You are an interior designer who helps users visualize their space.
-            USE IMAGE GENERATOR Professional interior design renders.
-            ACTION Add one generated image placeholder whenever a user asks for a visual.
-            \`\`\`
-        `);
+        if (options.description) {
+            payload.description = options.description;
         }
-        applyToAgentModelRequirements(requirements, content) {
-            const extraInstructions = formatOptionalInstructionBlock('Image instructions', content);
-            return this.appendToSystemMessage({
-                ...requirements,
-                _metadata: {
-                    ...requirements._metadata,
-                    useImageGenerator: content || true,
-                },
-            }, spaceTrim$1.spaceTrim((block) => `
-                    Image generation:
-                    - You do not generate images directly and you do not call any image tool.
-                    - When the user asks for an image, include markdown notation in your message:
-                      \`![<alt text>](?image-prompt=<prompt>)\`
-                    - Keep \`<alt text>\` short and descriptive.
-                    - Keep \`<prompt>\` detailed so the generated image matches the request.
-                    - You can include normal explanatory text before and after the notation.
-                    ${block(extraInstructions)}
-                `));
+        if (options.location) {
+            payload.location = options.location;
+        }
+        if (options.start) {
+            payload.start = createGoogleCalendarDateValue(options.start, options.timeZone);
+        }
+        if (options.end) {
+            payload.end = createGoogleCalendarDateValue(options.end, options.timeZone);
+        }
+        if (options.attendees && options.attendees.length > 0) {
+            payload.attendees = options.attendees.map((email) => ({ email }));
         }
+        if (options.reminderMinutes && options.reminderMinutes.length > 0) {
+            payload.reminders = {
+                useDefault: false,
+                overrides: options.reminderMinutes.map((minutes) => ({
+                    method: 'popup',
+                    minutes,
+                })),
+            };
+        }
+        return payload;
     }
     /**
-     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * Converts date/dateTime input into a Google Calendar-compatible date object.
+     *
+     * @private function of createUseCalendarToolFunctions
      */
+    function createGoogleCalendarDateValue(value, timeZone) {
+        const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(value);
+        if (isDateOnly) {
+            return {
+                date: value,
+            };
+        }
+        return {
+            dateTime: value,
+            ...(timeZone ? { timeZone } : {}),
+        };
+    }
+    /**
+     * Maps raw Google Calendar event payload to a compact tool result object.
+     *
+     * @private function of createUseCalendarToolFunctions
+     */
+    function mapGoogleCalendarEvent(event) {
+        return {
+            id: event.id || null,
+            summary: event.summary || null,
+            description: event.description || null,
+            location: event.location || null,
+            status: event.status || null,
+            htmlLink: event.htmlLink || null,
+            start: event.start || null,
+            end: event.end || null,
+            organizer: event.organizer || null,
+            attendees: (event.attendees || []).map((attendee) => ({
+                email: attendee.email || null,
+                responseStatus: attendee.responseStatus || null,
+            })),
+        };
+    }
 
     /**
-     * USE MCP commitment definition
+     * Shared calendar URL argument description used in USE CALENDAR tool schemas.
      *
-     * The `USE MCP` commitment allows to specify an MCP server URL which the agent will connect to
-     * for retrieving additional instructions and actions.
+     * @private constant of createUseCalendarTools
+     */
+    const CALENDAR_URL_PARAMETER_DESCRIPTION = 'Google Calendar URL configured by USE CALENDAR (for example "https://calendar.google.com/...").';
+    /**
+     * Adds USE CALENDAR tool definitions while keeping already registered tools untouched.
      *
-     * The content following `USE MCP` is the URL of the MCP server.
+     * @private function of UseCalendarCommitmentDefinition
+     */
+    function createUseCalendarTools(existingTools) {
+        const updatedTools = [...existingTools];
+        const addToolIfMissing = (tool) => {
+            if (!updatedTools.some((existingTool) => existingTool.name === tool.name)) {
+                updatedTools.push(tool);
+            }
+        };
+        addToolIfMissing({
+            name: UseCalendarToolNames.listEvents,
+            description: 'List events from a configured calendar for a time range.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    calendarUrl: {
+                        type: 'string',
+                        description: CALENDAR_URL_PARAMETER_DESCRIPTION,
+                    },
+                    timeMin: {
+                        type: 'string',
+                        description: 'Inclusive event start bound in ISO datetime.',
+                    },
+                    timeMax: {
+                        type: 'string',
+                        description: 'Exclusive event end bound in ISO datetime.',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Optional free-text event search query.',
+                    },
+                    maxResults: {
+                        type: 'integer',
+                        description: 'Maximum number of events to return.',
+                    },
+                    singleEvents: {
+                        type: 'boolean',
+                        description: 'Expand recurring events into individual instances.',
+                    },
+                    orderBy: {
+                        type: 'string',
+                        description: 'Optional ordering ("startTime" or "updated").',
+                    },
+                    timeZone: {
+                        type: 'string',
+                        description: 'Optional IANA timezone for response rendering.',
+                    },
+                },
+                required: [],
+            },
+        });
+        addToolIfMissing({
+            name: UseCalendarToolNames.getEvent,
+            description: 'Get one event by id from a configured calendar.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    calendarUrl: {
+                        type: 'string',
+                        description: CALENDAR_URL_PARAMETER_DESCRIPTION,
+                    },
+                    eventId: {
+                        type: 'string',
+                        description: 'Google Calendar event id.',
+                    },
+                },
+                required: ['eventId'],
+            },
+        });
+        addToolIfMissing({
+            name: UseCalendarToolNames.createEvent,
+            description: 'Create one event in a configured calendar.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    calendarUrl: {
+                        type: 'string',
+                        description: CALENDAR_URL_PARAMETER_DESCRIPTION,
+                    },
+                    summary: {
+                        type: 'string',
+                        description: 'Event title/summary.',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Optional event description.',
+                    },
+                    location: {
+                        type: 'string',
+                        description: 'Optional event location.',
+                    },
+                    start: {
+                        type: 'string',
+                        description: 'Event start as ISO datetime or date.',
+                    },
+                    end: {
+                        type: 'string',
+                        description: 'Event end as ISO datetime or date.',
+                    },
+                    timeZone: {
+                        type: 'string',
+                        description: 'Optional timezone for datetime values.',
+                    },
+                    attendees: {
+                        type: 'array',
+                        description: 'Optional guest email list.',
+                    },
+                    reminderMinutes: {
+                        type: 'array',
+                        description: 'Optional popup reminder minute offsets.',
+                    },
+                    sendUpdates: {
+                        type: 'string',
+                        description: 'Guest update policy ("all", "externalOnly", "none").',
+                    },
+                },
+                required: ['summary', 'start', 'end'],
+            },
+        });
+        addToolIfMissing({
+            name: UseCalendarToolNames.updateEvent,
+            description: 'Update one existing event in a configured calendar.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    calendarUrl: {
+                        type: 'string',
+                        description: CALENDAR_URL_PARAMETER_DESCRIPTION,
+                    },
+                    eventId: {
+                        type: 'string',
+                        description: 'Google Calendar event id.',
+                    },
+                    summary: {
+                        type: 'string',
+                        description: 'Updated event summary.',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Updated event description.',
+                    },
+                    location: {
+                        type: 'string',
+                        description: 'Updated event location.',
+                    },
+                    start: {
+                        type: 'string',
+                        description: 'Updated event start as ISO datetime or date.',
+                    },
+                    end: {
+                        type: 'string',
+                        description: 'Updated event end as ISO datetime or date.',
+                    },
+                    timeZone: {
+                        type: 'string',
+                        description: 'Optional timezone for datetime values.',
+                    },
+                    attendees: {
+                        type: 'array',
+                        description: 'Optional replacement guest email list.',
+                    },
+                    reminderMinutes: {
+                        type: 'array',
+                        description: 'Optional replacement popup reminder minute offsets.',
+                    },
+                    sendUpdates: {
+                        type: 'string',
+                        description: 'Guest update policy ("all", "externalOnly", "none").',
+                    },
+                },
+                required: ['eventId'],
+            },
+        });
+        addToolIfMissing({
+            name: UseCalendarToolNames.deleteEvent,
+            description: 'Delete one event from a configured calendar.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    calendarUrl: {
+                        type: 'string',
+                        description: CALENDAR_URL_PARAMETER_DESCRIPTION,
+                    },
+                    eventId: {
+                        type: 'string',
+                        description: 'Google Calendar event id.',
+                    },
+                    sendUpdates: {
+                        type: 'string',
+                        description: 'Guest update policy ("all", "externalOnly", "none").',
+                    },
+                },
+                required: ['eventId'],
+            },
+        });
+        addToolIfMissing({
+            name: UseCalendarToolNames.inviteGuests,
+            description: 'Add guests to an existing event in a configured calendar.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    calendarUrl: {
+                        type: 'string',
+                        description: CALENDAR_URL_PARAMETER_DESCRIPTION,
+                    },
+                    eventId: {
+                        type: 'string',
+                        description: 'Google Calendar event id.',
+                    },
+                    guests: {
+                        type: 'array',
+                        description: 'Guest email list to add to the event.',
+                    },
+                    sendUpdates: {
+                        type: 'string',
+                        description: 'Guest update policy ("all", "externalOnly", "none").',
+                    },
+                },
+                required: ['eventId', 'guests'],
+            },
+        });
+        return updatedTools;
+    }
+
+    /**
+     * Gets human-readable tool labels for USE CALENDAR functions.
      *
-     * Example usage in agent source:
+     * @private function of UseCalendarCommitmentDefinition
+     */
+    function getUseCalendarToolTitles() {
+        return {
+            [UseCalendarToolNames.listEvents]: 'List calendar events',
+            [UseCalendarToolNames.getEvent]: 'Get calendar event',
+            [UseCalendarToolNames.createEvent]: 'Create calendar event',
+            [UseCalendarToolNames.updateEvent]: 'Update calendar event',
+            [UseCalendarToolNames.deleteEvent]: 'Delete calendar event',
+            [UseCalendarToolNames.inviteGuests]: 'Invite calendar guests',
+        };
+    }
+
+    /**
+     * Normalizes unknown metadata payload into a typed list of configured calendars.
      *
-     * ```book
-     * USE MCP http://mcp-server-url.com
-     * ```
+     * @private internal utility of USE CALENDAR commitment
+     */
+    function normalizeConfiguredCalendars(rawCalendars) {
+        if (!Array.isArray(rawCalendars)) {
+            return [];
+        }
+        const uniqueCalendars = new Set();
+        const calendars = [];
+        for (const rawCalendar of rawCalendars) {
+            if (!rawCalendar || typeof rawCalendar !== 'object') {
+                continue;
+            }
+            const calendar = rawCalendar;
+            const provider = normalizeProvider(calendar.provider);
+            const url = normalizeText(calendar.url);
+            const calendarId = normalizeText(calendar.calendarId);
+            if (!provider || !url || !calendarId) {
+                continue;
+            }
+            const uniqueKey = `${provider}|${url}`;
+            if (uniqueCalendars.has(uniqueKey)) {
+                continue;
+            }
+            uniqueCalendars.add(uniqueKey);
+            const scopes = Array.isArray(calendar.scopes)
+                ? calendar.scopes
+                    .filter((scope) => typeof scope === 'string')
+                    .map((scope) => scope.trim())
+                    .filter(Boolean)
+                : [];
+            calendars.push({
+                provider,
+                url,
+                calendarId,
+                scopes,
+                ...(normalizeText(calendar.tokenRef) ? { tokenRef: normalizeText(calendar.tokenRef) } : {}),
+            });
+        }
+        return calendars;
+    }
+    /**
+     * Normalizes optional provider text to one supported value.
+     *
+     * @private function of normalizeConfiguredCalendars
+     */
+    function normalizeProvider(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+        const normalizedProvider = value.trim().toLowerCase();
+        if (normalizedProvider === 'google') {
+            return 'google';
+        }
+        return null;
+    }
+    /**
+     * Normalizes unknown text input to trimmed non-empty string.
+     *
+     * @private function of normalizeConfiguredCalendars
+     */
+    function normalizeText(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
+
+    /**
+     * USE CALENDAR commitment definition.
+     *
+     * `USE CALENDAR` enables calendar tooling so the agent can read and manage events
+     * in one configured Google Calendar.
+     *
+     * Authentication is expected through runtime context provided by the host app UI.
+     * Hosts can provide manual wallet tokens or host-managed OAuth tokens.
      *
      * @private [🪔] Maybe export the commitments through some package
      */
-    class UseMcpCommitmentDefinition extends BaseCommitmentDefinition {
+    class UseCalendarCommitmentDefinition extends BaseCommitmentDefinition {
         constructor() {
-            super('USE MCP', ['MCP']);
+            super('USE CALENDAR', ['CALENDAR']);
         }
         /**
-         * Short one-line description of USE MCP.
+         * Short one-line description of USE CALENDAR.
          */
         get description() {
-            return 'Connects the agent to an external MCP server for additional capabilities.';
+            return 'Enable calendar tools for reading and managing events through Google Calendar.';
         }
         /**
          * Icon for this commitment.
          */
         get icon() {
-            return '🔌';
+            return '📅';
         }
         /**
-         * Markdown documentation for USE MCP commitment.
+         * Markdown documentation for USE CALENDAR commitment.
          */
         get documentation() {
             return spaceTrim$1.spaceTrim(`
-            # USE MCP
+            # USE CALENDAR
 
-            Connects the agent to an external Model Context Protocol (MCP) server.
+            Enables the agent to access and manage one Google Calendar.
 
             ## Key aspects
 
-            - The content following \`USE MCP\` must be a valid URL
-            - Multiple MCP servers can be connected by using multiple \`USE MCP\` commitments
-            - The agent will have access to tools and resources provided by the MCP server
+            - The first URL in the commitment should point to a Google Calendar URL.
+            - Optional \`SCOPES\` lines can provide explicit OAuth scopes.
+            - Optional extra instructions can follow calendar reference lines.
+            - Runtime provides Google Calendar OAuth token (manual wallet token or host-managed OAuth token).
+            - Tools support listing events, reading one event, creating events, updating events, deleting events, and inviting guests.
 
-            ## Example
+            ## Examples
 
             \`\`\`book
-            Company Lawyer
+            Scheduling Assistant
 
-            PERSONA You are a company lawyer.
-            USE MCP http://legal-db.example.com
+            PERSONA You coordinate meetings and schedules.
+            USE CALENDAR https://calendar.google.com/calendar/u/0/r
+            \`\`\`
+
+            \`\`\`book
+            Executive Assistant
+
+            USE CALENDAR https://calendar.google.com/calendar/u/0/r
+            SCOPES https://www.googleapis.com/auth/calendar.readonly
+            RULE Ask for confirmation before deleting events.
             \`\`\`
         `);
         }
         applyToAgentModelRequirements(requirements, content) {
-            const mcpServerUrl = content.trim();
-            if (!mcpServerUrl) {
-                return requirements;
-            }
-            const existingMcpServers = requirements.mcpServers || [];
-            // Avoid duplicates
-            if (existingMcpServers.includes(mcpServerUrl)) {
-                return requirements;
-            }
-            return {
+            var _a;
+            const parsedCommitment = parseUseCalendarCommitmentContent(content);
+            const existingConfiguredCalendars = normalizeConfiguredCalendars((_a = requirements._metadata) === null || _a === void 0 ? void 0 : _a.useCalendars);
+            if (parsedCommitment.calendar) {
+                addConfiguredCalendarIfMissing(existingConfiguredCalendars, parsedCommitment.calendar);
+            }
+            const calendarsList = existingConfiguredCalendars.length > 0
+                ? existingConfiguredCalendars
+                    .map((calendar) => [
+                    `- ${calendar.provider}: ${calendar.url}`,
+                    calendar.scopes.length > 0 ? `  scopes: ${calendar.scopes.join(', ')}` : '',
+                ]
+                    .filter(Boolean)
+                    .join('\n'))
+                    .join('\n')
+                : '- Calendar is resolved from runtime context';
+            const extraInstructions = formatOptionalInstructionBlock('Calendar instructions', parsedCommitment.instructions);
+            return this.appendToSystemMessage({
                 ...requirements,
-                mcpServers: [...existingMcpServers, mcpServerUrl],
-            };
+                tools: createUseCalendarTools(requirements.tools || []),
+                _metadata: {
+                    ...requirements._metadata,
+                    useCalendar: true,
+                    useCalendars: existingConfiguredCalendars,
+                },
+            }, spaceTrim$1.spaceTrim((block) => `
+                    Calendar tools:
+                    - You can inspect and manage events in configured calendars.
+                    - Supported operations include read, create, update, delete, invite guests, and reminders.
+                    - Configured calendars:
+                      ${block(calendarsList)}
+                    - USE CALENDAR credentials are read from wallet records (ACCESS_TOKEN, service "${UseCalendarWallet.service}", key "${UseCalendarWallet.key}").
+                    - If credentials are missing, ask user to connect calendar credentials in host UI and/or add them to wallet.
+                    ${block(extraInstructions)}
+                `));
         }
+        /**
+         * Gets human-readable titles for tool functions provided by this commitment.
+         */
+        getToolTitles() {
+            return getUseCalendarToolTitles();
+        }
+        /**
+         * Gets calendar tool function implementations.
+         */
+        getToolFunctions() {
+            return createUseCalendarToolFunctions();
+        }
+    }
+    /**
+     * Adds calendar into configured calendars list if it is not already present.
+     *
+     * @private function of UseCalendarCommitmentDefinition
+     */
+    function addConfiguredCalendarIfMissing(configuredCalendars, calendarReference) {
+        if (configuredCalendars.some((calendar) => calendar.provider === calendarReference.provider && calendar.url === calendarReference.url)) {
+            return;
+        }
+        configuredCalendars.push({
+            provider: calendarReference.provider,
+            url: calendarReference.url,
+            calendarId: calendarReference.calendarId,
+            scopes: [...calendarReference.scopes],
+            ...(calendarReference.tokenRef ? { tokenRef: calendarReference.tokenRef } : {}),
+        });
     }
     /**
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
     /**
-     * USE POPUP commitment definition
+     * Lightweight email token matcher used for `USE EMAIL` first-line parsing.
      *
-     * The `USE POPUP` commitment indicates that the agent can open a popup window with a specific website.
-     * This is useful, for example, when the agent writes a post on Facebook but wants the user to post it on Facebook.
+     * @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.
      *
-     * Example usage in agent source:
+     * Examples:
+     * - `agent@example.com`
+     * - `agent@example.com Keep emails concise`
+     * - `Keep emails concise`
      *
-     * ```book
-     * USE POPUP Allow to open Facebook and Linkedin
-     * ```
+     * @private internal utility of USE EMAIL commitment
+     */
+    function parseUseEmailCommitmentContent(content) {
+        const trimmedContent = spaceTrim$1.spaceTrim(content);
+        if (!trimmedContent) {
+            return {
+                senderEmail: null,
+                senderEmailRaw: null,
+                instructions: '',
+            };
+        }
+        const lines = trimmedContent
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        if (lines.length === 0) {
+            return {
+                senderEmail: null,
+                senderEmailRaw: null,
+                instructions: '',
+            };
+        }
+        const firstLine = lines[0] || '';
+        const senderMatch = firstLine.match(EMAIL_TOKEN_PATTERN);
+        const senderEmailRaw = (senderMatch === null || senderMatch === void 0 ? void 0 : senderMatch[0]) || null;
+        const senderEmail = senderEmailRaw && isValidEmail(senderEmailRaw) ? senderEmailRaw : null;
+        let firstLineWithoutSender = firstLine;
+        if (senderEmailRaw) {
+            const matchIndex = firstLine.indexOf(senderEmailRaw);
+            const prefix = firstLine.slice(0, matchIndex).trim();
+            const suffix = firstLine.slice(matchIndex + senderEmailRaw.length).trim();
+            firstLineWithoutSender = [prefix, suffix].filter(Boolean).join(' ').trim();
+        }
+        const instructionLines = [firstLineWithoutSender, ...lines.slice(1)].filter(Boolean);
+        const instructions = instructionLines.join('\n').trim();
+        return {
+            senderEmail,
+            senderEmailRaw,
+            instructions,
+        };
+    }
+
+    /**
+     * Client-side safe wrapper for sending emails.
+     *
+     * This function proxies requests to the Agents Server API endpoint for email queuing,
+     * making it safe to use in browser environments.
+     *
+     * @param args Email payload forwarded to the server-side `send_email` tool
+     * @param agentsServerUrl The base URL of the agents server (defaults to current origin)
+     * @returns Result string from the server-side send_email tool
+     *
+     * @private internal utility for USE EMAIL commitment
+     */
+    async function sendEmailViaBrowser(args, agentsServerUrl) {
+        try {
+            const baseUrl = agentsServerUrl || (typeof window !== 'undefined' ? window.location.origin : '');
+            if (!baseUrl) {
+                throw new Error('Agents server URL is required in non-browser environments');
+            }
+            const apiUrl = new URL('/api/send-email', baseUrl);
+            const response = await fetch(apiUrl.toString(), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(args),
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+                throw new Error(`Failed to send email: ${errorData.error || response.statusText}`);
+            }
+            const data = await response.json();
+            if (!data.success) {
+                throw new Error(`Email sending failed: ${data.error || 'Unknown error'}`);
+            }
+            return typeof data.result === 'string' ? data.result : JSON.stringify(data.result);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Error sending email via browser: ${errorMessage}`);
+        }
+    }
+
+    /**
+     * Tool name used by USE EMAIL.
+     *
+     * @private internal USE EMAIL constant
+     */
+    const SEND_EMAIL_TOOL_NAME = 'send_email';
+    /**
+     * Wallet service used for SMTP credentials required by USE EMAIL.
+     *
+     * @private internal USE EMAIL constant
+     */
+    const USE_EMAIL_SMTP_WALLET_SERVICE = 'smtp';
+    /**
+     * Wallet key used for SMTP credentials required by USE EMAIL.
+     *
+     * @private internal USE EMAIL constant
+     */
+    const USE_EMAIL_SMTP_WALLET_KEY = 'use-email-smtp-credentials';
+    /**
+     * 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 UsePopupCommitmentDefinition extends BaseCommitmentDefinition {
+    class UseEmailCommitmentDefinition extends BaseCommitmentDefinition {
         constructor() {
-            super('USE POPUP', ['POPUP']);
+            super('USE EMAIL', ['EMAIL', 'MAIL']);
         }
-        /**
-         * The `USE POPUP` commitment is standalone or with instructions.
-         */
         get requiresContent() {
             return false;
         }
         /**
-         * Short one-line description of USE POPUP.
+         * Short one-line description of USE EMAIL.
          */
         get description() {
-            return 'Enable the agent to open a popup window with a specific website.';
+            return 'Enable outbound email sending through a wallet-backed SMTP configuration.';
         }
         /**
          * Icon for this commitment.
          */
         get icon() {
-            return '🪟';
+            return '📧';
         }
         /**
-         * Markdown documentation for USE POPUP commitment.
+         * Markdown documentation for USE EMAIL commitment.
          */
         get documentation() {
             return spaceTrim$1.spaceTrim(`
-            # USE POPUP
+            # USE EMAIL
 
-            Enables the agent to open a popup window with a specific website.
+            Enables the agent to send outbound emails through SMTP.
 
             ## Key aspects
 
-            - The content following \`USE POPUP\` is an arbitrary text that the agent should know (e.g. constraints or instructions).
-            - The actual popup opening is handled by the agent runtime (usually in the browser)
-            - Allows the agent to open websites for the user to interact with (e.g. social media posts)
+            - 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
-            John the Copywriter
+            Writing Agent
+            USE EMAIL agent@example.com
+            RULE Write emails to customers according to the instructions from user.
+            \`\`\`
 
-            PERSONA You are a professional copywriter writing about CNC machines.
-            USE POPUP Allow to open Facebook and Linkedin
+            \`\`\`book
+            Formal Email Assistant
+            USE EMAIL agent@example.com Keep emails concise and formal.
             \`\`\`
         `);
         }
         applyToAgentModelRequirements(requirements, content) {
-            const extraInstructions = formatOptionalInstructionBlock('Popup instructions', content);
-            // Get existing tools array or create new one
-            const existingTools = requirements.tools || [];
-            // Add 'open_popup' to tools if not already present
-            const updatedTools = existingTools.some((tool) => tool.name === 'open_popup')
-                ? existingTools
-                : [
-                    ...existingTools,
-                    {
-                        name: 'open_popup',
-                        description: spaceTrim$1.spaceTrim(`
-                        Opens a popup window with a specific URL.
-                        Use this when you want to show a specific website to the user in a new window.
-                        ${!content ? '' : `Constraints / instructions: ${content}`}
-                    `),
-                        parameters: {
-                            type: 'object',
-                            properties: {
-                                url: {
-                                    type: 'string',
-                                    description: 'The URL to open in the popup window',
-                                },
-                            },
-                            required: ['url'],
-                        },
-                    },
-                ];
-            // Return requirements with updated tools and metadata
+            const parsedCommitment = parseUseEmailCommitmentContent(content);
+            const extraInstructions = formatOptionalInstructionBlock('Email instructions', parsedCommitment.instructions);
+            const senderInstruction = parsedCommitment.senderEmail
+                ? `- Default sender address from commitment: "${parsedCommitment.senderEmail}".`
+                : '';
+            const updatedTools = addUseEmailTools(requirements.tools || []);
             return this.appendToSystemMessage({
                 ...requirements,
                 tools: updatedTools,
                 _metadata: {
                     ...requirements._metadata,
-                    usePopup: content || true,
+                    useEmail: true,
+                    ...(parsedCommitment.senderEmail ? { useEmailSender: parsedCommitment.senderEmail } : {}),
                 },
             }, spaceTrim$1.spaceTrim((block) => `
-                    Tool:
-                    - You can open a popup window with a specific URL using the tool "open_popup".
-                    - Use this when you want the user to see or interact with a specific website.
+                    Email tool:
+                    - Use "${SEND_EMAIL_TOOL_NAME}" to send outbound emails.
+                    - Prefer \`message\` argument compatible with Promptbook \`Message\` type.
+                    - Include subject in \`message.metadata.subject\` (or use legacy \`subject\` argument).
+                    - USE EMAIL credentials are read from wallet records (ACCESS_TOKEN, service "${USE_EMAIL_SMTP_WALLET_SERVICE}", key "${USE_EMAIL_SMTP_WALLET_KEY}").
+                    - Wallet secret must contain SMTP credentials in JSON format with fields \`host\`, \`port\`, \`secure\`, \`username\`, \`password\`.
+                    - If credentials are missing, ask user to add wallet credentials.
+                    ${block(senderInstruction)}
                     ${block(extraInstructions)}
-            `));
+                `));
         }
         /**
          * Gets human-readable titles for tool functions provided by this commitment.
          */
         getToolTitles() {
             return {
-                open_popup: 'Open popup',
+                [SEND_EMAIL_TOOL_NAME]: 'Send email',
             };
         }
         /**
-         * Gets the `open_popup` tool function implementation.
+         * Gets the browser-safe `send_email` implementation.
+         *
+         * Node.js runtime overrides this via `getAllCommitmentsToolFunctionsForNode`.
          */
         getToolFunctions() {
             return {
-                async open_popup(args) {
-                    console.log('!!!! [Tool] open_popup called', { args });
-                    const { url } = args;
-                    if (typeof window !== 'undefined') {
-                        window.open(url, '_blank');
-                        return `Popup window with URL "${url}" was opened.`;
-                    }
-                    return spaceTrim$1.spaceTrim(`
-                    Popup window with URL "${url}" was requested.
-                    
-                    Note: The agent is currently running on the server, so the popup cannot be opened automatically.
-                    The user can open it manually from the tool call details in the chat.
-                `);
+                async [SEND_EMAIL_TOOL_NAME](args) {
+                    return sendEmailViaBrowser(args);
                 },
             };
         }
     }
     /**
-     * Note: [💞] Ignore a discrepancy between file name and entity name
-     */
-
-    /**
-     * Tool name used by the USE PRIVACY commitment.
+     * Adds USE EMAIL tool definition while keeping already registered tools untouched.
      *
-     * @private internal USE PRIVACY constant
+     * @private utility of USE EMAIL commitment
      */
-    const TURN_PRIVACY_ON_TOOL_NAME = 'turn_privacy_on';
-    /**
-     * Status returned when the UI should ask the user to confirm private mode.
-     *
-     * @private internal USE PRIVACY constant
-     */
-    const PRIVACY_CONFIRMATION_REQUIRED_STATUS = 'confirmation-required';
-    /**
-     * Status returned when private mode is already enabled.
-     *
-     * @private internal USE PRIVACY constant
-     */
-    const PRIVACY_ALREADY_ENABLED_STATUS = 'already-enabled';
-    /**
-     * Checks whether private mode is already enabled in runtime context.
-     *
-     * @private utility of USE PRIVACY commitment
-     */
-    function isPrivateModeEnabledInRuntimeContext(args) {
-        var _a;
-        const runtimeContext = readToolRuntimeContextFromToolArgs(args);
-        return ((_a = runtimeContext === null || runtimeContext === void 0 ? void 0 : runtimeContext.memory) === null || _a === void 0 ? void 0 : _a.isPrivateMode) === true;
+    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 through configured SMTP credentials. Prefer providing Message-like payload in `message`.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        message: {
+                            type: 'object',
+                            description: 'Preferred input payload compatible with Promptbook Message type. Use metadata.subject for 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: [],
+                },
+            },
+        ];
     }
     /**
-     * Creates a standard "confirmation required" result payload.
-     *
-     * @private utility of USE PRIVACY commitment
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
-    function createPrivacyConfirmationRequiredResult() {
-        return {
-            status: PRIVACY_CONFIRMATION_REQUIRED_STATUS,
-            message: 'Private mode requires explicit user confirmation in the UI. Ask the user to confirm the privacy prompt.',
-        };
-    }
+
     /**
-     * Creates a standard "already enabled" result payload.
+     * USE IMAGE GENERATOR commitment definition
      *
-     * @private utility of USE PRIVACY commitment
-     */
-    function createPrivacyAlreadyEnabledResult() {
-        return {
-            status: PRIVACY_ALREADY_ENABLED_STATUS,
-            message: 'Private mode is already enabled for this chat session.',
-        };
-    }
-    /**
-     * USE PRIVACY commitment definition.
+     * The `USE IMAGE GENERATOR` commitment indicates that the agent can output
+     * markdown placeholders for UI-driven image generation.
      *
-     * The `USE PRIVACY` commitment enables an agent to request enabling private mode.
+     * Example usage in agent source:
+     *
+     * ```book
+     * USE IMAGE GENERATOR
+     * USE IMAGE GENERATOR Create realistic images of nature
+     * ```
      *
      * @private [🪔] Maybe export the commitments through some package
      */
-    class UsePrivacyCommitmentDefinition extends BaseCommitmentDefinition {
-        constructor() {
-            super('USE PRIVACY', ['PRIVACY']);
+    class UseImageGeneratorCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor(type = 'USE IMAGE GENERATOR') {
+            super(type);
         }
         get requiresContent() {
             return false;
         }
         /**
-         * Short one-line description of USE PRIVACY.
+         * Short one-line description of USE IMAGE GENERATOR.
          */
         get description() {
-            return 'Enable the agent to request turning private mode on for sensitive conversations.';
+            return 'Enable the agent to output markdown image placeholders that the UI turns into generated images.';
         }
         /**
          * Icon for this commitment.
          */
         get icon() {
-            return '🔒';
+            return '🖼️';
         }
         /**
-         * Markdown documentation for USE PRIVACY commitment.
+         * Markdown documentation for USE IMAGE GENERATOR commitment.
          */
         get documentation() {
             return spaceTrim$1.spaceTrim(`
-            # USE PRIVACY
+            # USE IMAGE GENERATOR
 
-            Enables the agent to request turning on private mode in chat.
+            Enables the agent to output markdown image placeholders that trigger image generation in the user interface.
 
             ## Key aspects
 
-            - The tool \`turn_privacy_on\` asks the UI to show a confirmation dialog to the user.
-            - Private mode is enabled only after explicit user confirmation in the UI.
-            - In the current implementation, this reuses existing private mode behavior in chat.
-            - While private mode is active, chat persistence, memory persistence, and self-learning are disabled.
-            - Proper encryption is planned for future updates, but not implemented by this commitment yet.
-            - Optional content after \`USE PRIVACY\` can provide additional privacy instructions.
+            - The content following \`USE IMAGE GENERATOR\` is an arbitrary text that the agent should know (e.g. style instructions or safety guidelines).
+            - The agent does **not** call an image-generation tool directly.
+            - The agent inserts markdown notation: \`![alt](?image-prompt=...)\`.
+            - The user interface detects the notation and generates the image asynchronously.
 
             ## Examples
 
             \`\`\`book
-            Sensitive Assistant
+            Visual Artist
 
-            PERSONA You help with sensitive topics where privacy is important.
-            USE PRIVACY
+            PERSONA You are a creative visual artist.
+            USE IMAGE GENERATOR
+            RULE Always describe the generated image to the user.
             \`\`\`
 
             \`\`\`book
-            Compliance Assistant
+            Interior Designer
 
-            PERSONA You assist with legal and HR conversations.
-            USE PRIVACY Offer private mode when user asks to avoid storing data.
+            PERSONA You are an interior designer who helps users visualize their space.
+            USE IMAGE GENERATOR Professional interior design renders.
+            ACTION Add one generated image placeholder whenever a user asks for a visual.
             \`\`\`
         `);
         }
         applyToAgentModelRequirements(requirements, content) {
-            const extraInstructions = formatOptionalInstructionBlock('Privacy instructions', content);
-            const existingTools = requirements.tools || [];
-            const tools = existingTools.some((tool) => tool.name === TURN_PRIVACY_ON_TOOL_NAME)
-                ? existingTools
-                : [
-                    ...existingTools,
-                    {
-                        name: TURN_PRIVACY_ON_TOOL_NAME,
-                        description: spaceTrim$1.spaceTrim(`
-                          Requests turning private mode on in the chat UI.
-                          The user must explicitly confirm the action in a dialog before private mode is enabled.
-                          Use this for sensitive topics or when the user asks not to store conversation data.
-                      `),
-                        parameters: {
-                            type: 'object',
-                            properties: {},
-                            required: [],
-                        },
-                    },
-                ];
+            const extraInstructions = formatOptionalInstructionBlock('Image instructions', content);
             return this.appendToSystemMessage({
                 ...requirements,
-                tools,
                 _metadata: {
                     ...requirements._metadata,
-                    usePrivacy: content || true,
+                    useImageGenerator: content || true,
                 },
             }, spaceTrim$1.spaceTrim((block) => `
-                    Privacy mode:
-                    - Use "${TURN_PRIVACY_ON_TOOL_NAME}" when the user asks for a private/sensitive conversation.
-                    - This tool requests a UI confirmation dialog. Private mode is enabled only after user confirms.
-                    - Current implementation uses the existing chat private mode (no chat persistence, memory persistence, or self-learning while active).
-                    - Do not claim that end-to-end encryption is implemented yet.
+                    Image generation:
+                    - You do not generate images directly and you do not call any image tool.
+                    - When the user asks for an image, include markdown notation in your message:
+                      \`![<alt text>](?image-prompt=<prompt>)\`
+                    - Keep \`<alt text>\` short and descriptive.
+                    - Keep \`<prompt>\` detailed so the generated image matches the request.
+                    - You can include normal explanatory text before and after the notation.
                     ${block(extraInstructions)}
                 `));
         }
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * USE MCP commitment definition
+     *
+     * The `USE MCP` commitment allows to specify an MCP server URL which the agent will connect to
+     * for retrieving additional instructions and actions.
+     *
+     * The content following `USE MCP` is the URL of the MCP server.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * USE MCP http://mcp-server-url.com
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
+     */
+    class UseMcpCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('USE MCP', ['MCP']);
+        }
         /**
-         * Gets human-readable titles for tool functions provided by this commitment.
+         * Short one-line description of USE MCP.
          */
-        getToolTitles() {
-            return {
-                [TURN_PRIVACY_ON_TOOL_NAME]: 'Turn privacy mode on',
-            };
+        get description() {
+            return 'Connects the agent to an external MCP server for additional capabilities.';
         }
         /**
-         * Gets the `turn_privacy_on` tool function implementation.
+         * Icon for this commitment.
          */
-        getToolFunctions() {
+        get icon() {
+            return '🔌';
+        }
+        /**
+         * Markdown documentation for USE MCP commitment.
+         */
+        get documentation() {
+            return spaceTrim$1.spaceTrim(`
+            # USE MCP
+
+            Connects the agent to an external Model Context Protocol (MCP) server.
+
+            ## Key aspects
+
+            - The content following \`USE MCP\` must be a valid URL
+            - Multiple MCP servers can be connected by using multiple \`USE MCP\` commitments
+            - The agent will have access to tools and resources provided by the MCP server
+
+            ## Example
+
+            \`\`\`book
+            Company Lawyer
+
+            PERSONA You are a company lawyer.
+            USE MCP http://legal-db.example.com
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const mcpServerUrl = content.trim();
+            if (!mcpServerUrl) {
+                return requirements;
+            }
+            const existingMcpServers = requirements.mcpServers || [];
+            // Avoid duplicates
+            if (existingMcpServers.includes(mcpServerUrl)) {
+                return requirements;
+            }
             return {
-                async [TURN_PRIVACY_ON_TOOL_NAME](args) {
-                    const result = isPrivateModeEnabledInRuntimeContext(args)
-                        ? createPrivacyAlreadyEnabledResult()
-                        : createPrivacyConfirmationRequiredResult();
-                    return JSON.stringify(result);
-                },
+                ...requirements,
+                mcpServers: [...existingMcpServers, mcpServerUrl],
             };
         }
     }
@@ -22115,135 +23361,447 @@
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
-    /* eslint-disable no-magic-numbers */
     /**
-     * Default byte limit for one best-effort text decode.
+     * USE POPUP commitment definition
      *
-     * @private constant of decodeAttachmentAsText
-     */
-    const DEFAULT_ATTACHMENT_TEXT_DECODE_BYTES = 512 * 1024;
-    /**
-     * Marker appended when only a prefix of the payload is decoded.
+     * The `USE POPUP` commitment indicates that the agent can open a popup window with a specific website.
+     * This is useful, for example, when the agent writes a post on Facebook but wants the user to post it on Facebook.
      *
-     * @private constant of decodeAttachmentAsText
-     */
-    const TRUNCATED_MARKER = '…[TRUNCATED]…';
-    /**
-     * MIME types that are trustworthy indicators of textual content.
+     * Example usage in agent source:
      *
-     * @private constant of decodeAttachmentAsText
+     * ```book
+     * USE POPUP Allow to open Facebook and Linkedin
+     * ```
+     *
+     * @private [🪔] Maybe export the commitments through some package
      */
-    const TRUSTED_TEXT_MIME_TYPES = new Set([
-        'application/json',
-        'application/ld+json',
-        'application/javascript',
-        'application/x-javascript',
-        'application/xml',
-        'application/xhtml+xml',
-        'application/x-www-form-urlencoded',
-        'application/yaml',
-        'application/x-yaml',
-        'application/toml',
-        'application/sql',
-        'application/rtf',
-        'application/x-subrip',
-    ]);
+    class UsePopupCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('USE POPUP', ['POPUP']);
+        }
+        /**
+         * The `USE POPUP` commitment is standalone or with instructions.
+         */
+        get requiresContent() {
+            return false;
+        }
+        /**
+         * Short one-line description of USE POPUP.
+         */
+        get description() {
+            return 'Enable the agent to open a popup window with a specific website.';
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '🪟';
+        }
+        /**
+         * Markdown documentation for USE POPUP commitment.
+         */
+        get documentation() {
+            return spaceTrim$1.spaceTrim(`
+            # USE POPUP
+
+            Enables the agent to open a popup window with a specific website.
+
+            ## Key aspects
+
+            - The content following \`USE POPUP\` is an arbitrary text that the agent should know (e.g. constraints or instructions).
+            - The actual popup opening is handled by the agent runtime (usually in the browser)
+            - Allows the agent to open websites for the user to interact with (e.g. social media posts)
+
+            ## Examples
+
+            \`\`\`book
+            John the Copywriter
+
+            PERSONA You are a professional copywriter writing about CNC machines.
+            USE POPUP Allow to open Facebook and Linkedin
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const extraInstructions = formatOptionalInstructionBlock('Popup instructions', content);
+            // Get existing tools array or create new one
+            const existingTools = requirements.tools || [];
+            // Add 'open_popup' to tools if not already present
+            const updatedTools = existingTools.some((tool) => tool.name === 'open_popup')
+                ? existingTools
+                : [
+                    ...existingTools,
+                    {
+                        name: 'open_popup',
+                        description: spaceTrim$1.spaceTrim(`
+                        Opens a popup window with a specific URL.
+                        Use this when you want to show a specific website to the user in a new window.
+                        ${!content ? '' : `Constraints / instructions: ${content}`}
+                    `),
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                url: {
+                                    type: 'string',
+                                    description: 'The URL to open in the popup window',
+                                },
+                            },
+                            required: ['url'],
+                        },
+                    },
+                ];
+            // Return requirements with updated tools and metadata
+            return this.appendToSystemMessage({
+                ...requirements,
+                tools: updatedTools,
+                _metadata: {
+                    ...requirements._metadata,
+                    usePopup: content || true,
+                },
+            }, spaceTrim$1.spaceTrim((block) => `
+                    Tool:
+                    - You can open a popup window with a specific URL using the tool "open_popup".
+                    - Use this when you want the user to see or interact with a specific website.
+                    ${block(extraInstructions)}
+            `));
+        }
+        /**
+         * Gets human-readable titles for tool functions provided by this commitment.
+         */
+        getToolTitles() {
+            return {
+                open_popup: 'Open popup',
+            };
+        }
+        /**
+         * Gets the `open_popup` tool function implementation.
+         */
+        getToolFunctions() {
+            return {
+                async open_popup(args) {
+                    console.log('!!!! [Tool] open_popup called', { args });
+                    const { url } = args;
+                    if (typeof window !== 'undefined') {
+                        window.open(url, '_blank');
+                        return `Popup window with URL "${url}" was opened.`;
+                    }
+                    return spaceTrim$1.spaceTrim(`
+                    Popup window with URL "${url}" was requested.
+                    
+                    Note: The agent is currently running on the server, so the popup cannot be opened automatically.
+                    The user can open it manually from the tool call details in the chat.
+                `);
+                },
+            };
+        }
+    }
     /**
-     * MIME types that are trustworthy indicators of binary content.
-     *
-     * @private constant of decodeAttachmentAsText
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
-    const TRUSTED_BINARY_MIME_TYPES = new Set([
-        'application/pdf',
-        'application/zip',
-        'application/gzip',
-        'application/x-gzip',
-        'application/x-7z-compressed',
-        'application/vnd.rar',
-        'application/x-rar-compressed',
-    ]);
+
     /**
-     * MIME prefixes that strongly indicate binary content.
+     * Tool name used by the USE PRIVACY commitment.
      *
-     * @private constant of decodeAttachmentAsText
+     * @private internal USE PRIVACY constant
      */
-    const TRUSTED_BINARY_MIME_PREFIXES = ['image/', 'audio/', 'video/', 'font/', 'model/'];
+    const TURN_PRIVACY_ON_TOOL_NAME = 'turn_privacy_on';
     /**
-     * Suspicious characters that often appear when `windows-1250` text is decoded as `windows-1252`.
+     * Status returned when the UI should ask the user to confirm private mode.
      *
-     * @private constant of decodeAttachmentAsText
+     * @private internal USE PRIVACY constant
      */
-    const SUSPICIOUS_SINGLE_BYTE_ARTIFACTS = new Set([
-        'ˇ',
-        '˘',
-        '˙',
-        '˛',
-        '˝',
-        '¸',
-        '¤',
-        '¦',
-        '¨',
-        '¯',
-        '²',
-        '³',
-        '¹',
-    ]);
+    const PRIVACY_CONFIRMATION_REQUIRED_STATUS = 'confirmation-required';
     /**
-     * Supported fallback encodings tried when UTF-8 is not convincing.
+     * Status returned when private mode is already enabled.
      *
-     * @private constant of decodeAttachmentAsText
+     * @private internal USE PRIVACY constant
      */
-    const FALLBACK_ENCODINGS = ['windows-1250', 'windows-1252', 'iso-8859-1'];
+    const PRIVACY_ALREADY_ENABLED_STATUS = 'already-enabled';
     /**
-     * Converts unknown byte containers into `Uint8Array`.
+     * Checks whether private mode is already enabled in runtime context.
      *
-     * @private function of decodeAttachmentAsText
+     * @private utility of USE PRIVACY commitment
      */
-    function toUint8Array(bytes) {
-        if (bytes instanceof Uint8Array) {
-            return bytes;
-        }
-        if (ArrayBuffer.isView(bytes)) {
-            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        }
-        return new Uint8Array(bytes);
+    function isPrivateModeEnabledInRuntimeContext(args) {
+        var _a;
+        const runtimeContext = readToolRuntimeContextFromToolArgs(args);
+        return ((_a = runtimeContext === null || runtimeContext === void 0 ? void 0 : runtimeContext.memory) === null || _a === void 0 ? void 0 : _a.isPrivateMode) === true;
     }
     /**
-     * Removes MIME parameters and normalizes casing.
+     * Creates a standard "confirmation required" result payload.
      *
-     * @private function of decodeAttachmentAsText
+     * @private utility of USE PRIVACY commitment
      */
-    function normalizeMimeType(mimeType) {
-        if (!mimeType) {
-            return null;
-        }
-        const normalized = mimeType.split(';')[0].trim().toLowerCase();
-        return normalized || null;
+    function createPrivacyConfirmationRequiredResult() {
+        return {
+            status: PRIVACY_CONFIRMATION_REQUIRED_STATUS,
+            message: 'Private mode requires explicit user confirmation in the UI. Ask the user to confirm the privacy prompt.',
+        };
     }
     /**
-     * Extracts optional `charset=...` information from a MIME type value.
+     * Creates a standard "already enabled" result payload.
      *
-     * @private function of decodeAttachmentAsText
+     * @private utility of USE PRIVACY commitment
      */
-    function extractCharset(mimeType) {
-        if (!mimeType) {
-            return null;
-        }
-        const match = mimeType.match(/charset\s*=\s*("?)([^";\s]+)\1/i);
-        if (!match) {
-            return null;
-        }
-        return match[2].trim().toLowerCase();
+    function createPrivacyAlreadyEnabledResult() {
+        return {
+            status: PRIVACY_ALREADY_ENABLED_STATUS,
+            message: 'Private mode is already enabled for this chat session.',
+        };
     }
     /**
-     * Returns true when the MIME type is a strong textual hint.
+     * USE PRIVACY commitment definition.
      *
-     * @private function of decodeAttachmentAsText
+     * The `USE PRIVACY` commitment enables an agent to request enabling private mode.
+     *
+     * @private [🪔] Maybe export the commitments through some package
      */
-    function isTrustedTextMimeType(mimeType) {
-        if (!mimeType) {
-            return false;
-        }
+    class UsePrivacyCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('USE PRIVACY', ['PRIVACY']);
+        }
+        get requiresContent() {
+            return false;
+        }
+        /**
+         * Short one-line description of USE PRIVACY.
+         */
+        get description() {
+            return 'Enable the agent to request turning private mode on for sensitive conversations.';
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '🔒';
+        }
+        /**
+         * Markdown documentation for USE PRIVACY commitment.
+         */
+        get documentation() {
+            return spaceTrim$1.spaceTrim(`
+            # USE PRIVACY
+
+            Enables the agent to request turning on private mode in chat.
+
+            ## Key aspects
+
+            - The tool \`turn_privacy_on\` asks the UI to show a confirmation dialog to the user.
+            - Private mode is enabled only after explicit user confirmation in the UI.
+            - In the current implementation, this reuses existing private mode behavior in chat.
+            - While private mode is active, chat persistence, memory persistence, and self-learning are disabled.
+            - Proper encryption is planned for future updates, but not implemented by this commitment yet.
+            - Optional content after \`USE PRIVACY\` can provide additional privacy instructions.
+
+            ## Examples
+
+            \`\`\`book
+            Sensitive Assistant
+
+            PERSONA You help with sensitive topics where privacy is important.
+            USE PRIVACY
+            \`\`\`
+
+            \`\`\`book
+            Compliance Assistant
+
+            PERSONA You assist with legal and HR conversations.
+            USE PRIVACY Offer private mode when user asks to avoid storing data.
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const extraInstructions = formatOptionalInstructionBlock('Privacy instructions', content);
+            const existingTools = requirements.tools || [];
+            const tools = existingTools.some((tool) => tool.name === TURN_PRIVACY_ON_TOOL_NAME)
+                ? existingTools
+                : [
+                    ...existingTools,
+                    {
+                        name: TURN_PRIVACY_ON_TOOL_NAME,
+                        description: spaceTrim$1.spaceTrim(`
+                          Requests turning private mode on in the chat UI.
+                          The user must explicitly confirm the action in a dialog before private mode is enabled.
+                          Use this for sensitive topics or when the user asks not to store conversation data.
+                      `),
+                        parameters: {
+                            type: 'object',
+                            properties: {},
+                            required: [],
+                        },
+                    },
+                ];
+            return this.appendToSystemMessage({
+                ...requirements,
+                tools,
+                _metadata: {
+                    ...requirements._metadata,
+                    usePrivacy: content || true,
+                },
+            }, spaceTrim$1.spaceTrim((block) => `
+                    Privacy mode:
+                    - Use "${TURN_PRIVACY_ON_TOOL_NAME}" when the user asks for a private/sensitive conversation.
+                    - This tool requests a UI confirmation dialog. Private mode is enabled only after user confirms.
+                    - Current implementation uses the existing chat private mode (no chat persistence, memory persistence, or self-learning while active).
+                    - Do not claim that end-to-end encryption is implemented yet.
+                    ${block(extraInstructions)}
+                `));
+        }
+        /**
+         * Gets human-readable titles for tool functions provided by this commitment.
+         */
+        getToolTitles() {
+            return {
+                [TURN_PRIVACY_ON_TOOL_NAME]: 'Turn privacy mode on',
+            };
+        }
+        /**
+         * Gets the `turn_privacy_on` tool function implementation.
+         */
+        getToolFunctions() {
+            return {
+                async [TURN_PRIVACY_ON_TOOL_NAME](args) {
+                    const result = isPrivateModeEnabledInRuntimeContext(args)
+                        ? createPrivacyAlreadyEnabledResult()
+                        : createPrivacyConfirmationRequiredResult();
+                    return JSON.stringify(result);
+                },
+            };
+        }
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /* eslint-disable no-magic-numbers */
+    /**
+     * Default byte limit for one best-effort text decode.
+     *
+     * @private constant of decodeAttachmentAsText
+     */
+    const DEFAULT_ATTACHMENT_TEXT_DECODE_BYTES = 512 * 1024;
+    /**
+     * Marker appended when only a prefix of the payload is decoded.
+     *
+     * @private constant of decodeAttachmentAsText
+     */
+    const TRUNCATED_MARKER = '…[TRUNCATED]…';
+    /**
+     * MIME types that are trustworthy indicators of textual content.
+     *
+     * @private constant of decodeAttachmentAsText
+     */
+    const TRUSTED_TEXT_MIME_TYPES = new Set([
+        'application/json',
+        'application/ld+json',
+        'application/javascript',
+        'application/x-javascript',
+        'application/xml',
+        'application/xhtml+xml',
+        'application/x-www-form-urlencoded',
+        'application/yaml',
+        'application/x-yaml',
+        'application/toml',
+        'application/sql',
+        'application/rtf',
+        'application/x-subrip',
+    ]);
+    /**
+     * MIME types that are trustworthy indicators of binary content.
+     *
+     * @private constant of decodeAttachmentAsText
+     */
+    const TRUSTED_BINARY_MIME_TYPES = new Set([
+        'application/pdf',
+        'application/zip',
+        'application/gzip',
+        'application/x-gzip',
+        'application/x-7z-compressed',
+        'application/vnd.rar',
+        'application/x-rar-compressed',
+    ]);
+    /**
+     * MIME prefixes that strongly indicate binary content.
+     *
+     * @private constant of decodeAttachmentAsText
+     */
+    const TRUSTED_BINARY_MIME_PREFIXES = ['image/', 'audio/', 'video/', 'font/', 'model/'];
+    /**
+     * Suspicious characters that often appear when `windows-1250` text is decoded as `windows-1252`.
+     *
+     * @private constant of decodeAttachmentAsText
+     */
+    const SUSPICIOUS_SINGLE_BYTE_ARTIFACTS = new Set([
+        'ˇ',
+        '˘',
+        '˙',
+        '˛',
+        '˝',
+        '¸',
+        '¤',
+        '¦',
+        '¨',
+        '¯',
+        '²',
+        '³',
+        '¹',
+    ]);
+    /**
+     * Supported fallback encodings tried when UTF-8 is not convincing.
+     *
+     * @private constant of decodeAttachmentAsText
+     */
+    const FALLBACK_ENCODINGS = ['windows-1250', 'windows-1252', 'iso-8859-1'];
+    /**
+     * Converts unknown byte containers into `Uint8Array`.
+     *
+     * @private function of decodeAttachmentAsText
+     */
+    function toUint8Array(bytes) {
+        if (bytes instanceof Uint8Array) {
+            return bytes;
+        }
+        if (ArrayBuffer.isView(bytes)) {
+            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        }
+        return new Uint8Array(bytes);
+    }
+    /**
+     * Removes MIME parameters and normalizes casing.
+     *
+     * @private function of decodeAttachmentAsText
+     */
+    function normalizeMimeType(mimeType) {
+        if (!mimeType) {
+            return null;
+        }
+        const normalized = mimeType.split(';')[0].trim().toLowerCase();
+        return normalized || null;
+    }
+    /**
+     * Extracts optional `charset=...` information from a MIME type value.
+     *
+     * @private function of decodeAttachmentAsText
+     */
+    function extractCharset(mimeType) {
+        if (!mimeType) {
+            return null;
+        }
+        const match = mimeType.match(/charset\s*=\s*("?)([^";\s]+)\1/i);
+        if (!match) {
+            return null;
+        }
+        return match[2].trim().toLowerCase();
+    }
+    /**
+     * Returns true when the MIME type is a strong textual hint.
+     *
+     * @private function of decodeAttachmentAsText
+     */
+    function isTrustedTextMimeType(mimeType) {
+        if (!mimeType) {
+            return false;
+        }
         return (mimeType.startsWith('text/') ||
             mimeType.endsWith('+json') ||
             mimeType.endsWith('+xml') ||
@@ -25207,503 +26765,186 @@
         new NoteCommitmentDefinition('COMMENT'),
         new NoteCommitmentDefinition('NONCE'),
         new NoteCommitmentDefinition('TODO'),
-        new GoalCommitmentDefinition('GOAL'),
-        new GoalCommitmentDefinition('GOALS'),
-        new InitialMessageCommitmentDefinition(),
-        new UserMessageCommitmentDefinition(),
-        new InternalMessageCommitmentDefinition(),
-        new AgentMessageCommitmentDefinition(),
-        new MessageSuffixCommitmentDefinition(),
-        new MessageCommitmentDefinition('MESSAGE'),
-        new MessageCommitmentDefinition('MESSAGES'),
-        new ScenarioCommitmentDefinition('SCENARIO'),
-        new ScenarioCommitmentDefinition('SCENARIOS'),
-        new DeleteCommitmentDefinition('DELETE'),
-        new DeleteCommitmentDefinition('CANCEL'),
-        new DeleteCommitmentDefinition('DISCARD'),
-        new DeleteCommitmentDefinition('REMOVE'),
-        new DictionaryCommitmentDefinition(),
-        new OpenCommitmentDefinition(),
-        new ClosedCommitmentDefinition(),
-        new TeamCommitmentDefinition(),
-        new UseBrowserCommitmentDefinition(),
-        new UseSearchEngineCommitmentDefinition(),
-        new UseSpawnCommitmentDefinition(),
-        new UseTimeoutCommitmentDefinition(),
-        new UseTimeCommitmentDefinition(),
-        new UseUserLocationCommitmentDefinition(),
-        new UseEmailCommitmentDefinition(),
-        new UsePopupCommitmentDefinition(),
-        new UseImageGeneratorCommitmentDefinition('USE IMAGE GENERATOR'),
-        new UseMcpCommitmentDefinition(),
-        new UsePrivacyCommitmentDefinition(),
-        new UseProjectCommitmentDefinition(),
-        new UseCommitmentDefinition(),
-        // Not yet implemented commitments (using placeholder)
-        new NotYetImplementedCommitmentDefinition('EXPECT'),
-        new NotYetImplementedCommitmentDefinition('BEHAVIOUR'),
-        new NotYetImplementedCommitmentDefinition('BEHAVIOURS'),
-        new NotYetImplementedCommitmentDefinition('AVOID'),
-        new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
-        new NotYetImplementedCommitmentDefinition('CONTEXT'),
-        // <- TODO: Prompt: Leverage aliases instead of duplicating commitment definitions
-    ];
-    /**
-     * TODO: [🧠] Maybe create through standardized $register
-     * Note: [💞] Ignore a discrepancy between file name and entity name
-     */
-
-    /**
-     * Gets all available commitment definitions
-     * @returns Array of all commitment definitions
-     *
-     * @public exported from `@promptbook/core`
-     */
-    function getAllCommitmentDefinitions() {
-        return $deepFreeze([...COMMITMENT_REGISTRY]);
-    }
-
-    /**
-     * Collects tool functions from all commitment definitions.
-     *
-     * @returns Map of tool function implementations.
-     * @private internal helper for commitment tool registry
-     */
-    function collectCommitmentToolFunctions() {
-        const allToolFunctions = {};
-        for (const commitmentDefinition of getAllCommitmentDefinitions()) {
-            const toolFunctions = commitmentDefinition.getToolFunctions();
-            for (const [funcName, funcImpl] of Object.entries(toolFunctions)) {
-                if (allToolFunctions[funcName] !== undefined &&
-                    just(false) /* <- Note: [??] How to deal with commitment aliases */) {
-                    throw new UnexpectedError(`Duplicate tool function name detected: \`${funcName}\` provided by commitment \`${commitmentDefinition.type}\``);
-                }
-                allToolFunctions[funcName] = funcImpl;
-            }
-        }
-        return allToolFunctions;
-    }
-    /**
-     * Creates a proxy that resolves tool functions on demand.
-     *
-     * @param getFunctions - Provider of current tool functions.
-     * @returns Proxy exposing tool functions as properties.
-     * @private internal helper for commitment tool registry
-     */
-    function createToolFunctionsProxy(getFunctions) {
-        const resolveFunctions = () => getFunctions();
-        return new Proxy({}, {
-            get(_target, prop) {
-                if (typeof prop !== 'string') {
-                    return undefined;
-                }
-                return resolveFunctions()[prop];
-            },
-            has(_target, prop) {
-                if (typeof prop !== 'string') {
-                    return false;
-                }
-                return prop in resolveFunctions();
-            },
-            ownKeys() {
-                return Object.keys(resolveFunctions());
-            },
-            getOwnPropertyDescriptor(_target, prop) {
-                if (typeof prop !== 'string') {
-                    return undefined;
-                }
-                const value = resolveFunctions()[prop];
-                if (value === undefined) {
-                    return undefined;
-                }
-                return {
-                    enumerable: true,
-                    configurable: true,
-                    writable: false,
-                    value,
-                };
-            },
-        });
-    }
-    /**
-     * Note: [💞] Ignore a discrepancy between file name and entity name
-     */
-
-    const nodeToolFunctions = {
-        /**
-         * @@@
-         *
-         * Note: [??] This function has implementation both for browser and node, this is the full one for node
-         */
-        async fetch_url_content(args) {
-            console.log('!!!! [Tool] fetch_url_content called', { args });
-            const { url } = args;
-            return await fetchUrlContent(url);
-        },
-        /**
-         * @@@
-         *
-         * Note: [??] This function has implementation both for browser and node, this is the server one for node
-         */
-        run_browser: resolveRunBrowserToolForNode(),
-        /**
-         * @@@
-         *
-         * Note: [??] This function has implementation both for browser and node, this is the server one for node
-         */
-        send_email: resolveSendEmailToolForNode(),
-        /**
-         * @@@
-         *
-         * Note: [??] This function has implementation both for browser and node, this is the server one for node
-         */
-        spawn_agent: resolveSpawnAgentToolForNode(),
-        // TODO: !!!! Unhardcode, make proper server function register from definitions
-    };
-    const nodeToolFunctionsProxy = createToolFunctionsProxy(() => ({
-        ...collectCommitmentToolFunctions(),
-        ...nodeToolFunctions,
-    }));
-    /**
-     * Gets all function implementations provided by all commitments
-     *
-     * Note: This function is intended for server use, there is also equivalent `getAllCommitmentsToolFunctionsForBrowser` for browser use
-     *
-     * @public exported from `@promptbook/node`
-     */
-    function getAllCommitmentsToolFunctionsForNode() {
-        if (!$isRunningInNode()) {
-            throw new EnvironmentMismatchError(spaceTrim(`
-                Function getAllCommitmentsToolFunctionsForNode should be run in Node.js environment.
-
-                - In browser use getAllCommitmentsToolFunctionsForBrowser instead.
-                - This function can include server-only tools which cannot run in browser environment.
-
-            `));
-        }
-        return nodeToolFunctionsProxy;
-    }
-    /**
-     * Note: [??] Code in this file should never be never released in packages that could be imported into browser environment
-     * TODO: [??] Unite `xxxForServer` and `xxxForNode` naming
-     */
-
-    /**
-     * Normalize options for `execCommand` and `execCommands`
-     *
-     * Note: `$` is used to indicate that this function behaves differently according to `process.platform`
-     *
-     * @private internal utility of `execCommand` and `execCommands`
-     */
-    function $execCommandNormalizeOptions(options) {
-        var _a, _b, _c, _d;
-        let command;
-        let cwd;
-        let crashOnError;
-        let args = [];
-        let timeout;
-        let isVerbose;
-        let env;
-        if (typeof options === 'string') {
-            // TODO: [1] DRY default values
-            command = options;
-            cwd = process.cwd();
-            crashOnError = true;
-            timeout = Infinity; // <- TODO: [⏳]
-            isVerbose = DEFAULT_IS_VERBOSE;
-            env = undefined;
-        }
-        else {
-            /*
-            TODO:
-            if ((options as any).commands !== undefined) {
-                commands = (options as any).commands;
-            } else {
-                commands = [(options as any).command];
-            }
-            */
-            // TODO: [1] DRY default values
-            command = options.command;
-            cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
-            crashOnError = (_b = options.crashOnError) !== null && _b !== void 0 ? _b : true;
-            timeout = (_c = options.timeout) !== null && _c !== void 0 ? _c : Infinity;
-            isVerbose = (_d = options.isVerbose) !== null && _d !== void 0 ? _d : DEFAULT_IS_VERBOSE;
-            env = options.env;
-        }
-        // TODO: /(-[a-zA-Z0-9-]+\s+[^\s]*)|[^\s]*/g
-        const _ = Array.from(command.matchAll(/(".*")|([^\s]*)/g))
-            .map(([match]) => match)
-            .filter((arg) => arg !== '');
-        if (_.length > 1) {
-            [command, ...args] = _;
-        }
-        if (options.args) {
-            args = [...args, ...options.args];
-        }
-        let humanReadableCommand = !['npx', 'npm'].includes(command) ? command : args[0];
-        if (['ts-node'].includes(humanReadableCommand)) {
-            humanReadableCommand += ` ${args[1]}`;
-        }
-        if (/^win/.test(process.platform) && ['npm', 'npx'].includes(command)) {
-            command = `${command}.cmd`;
-        }
-        return { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose, env };
-    }
-    // TODO: This should show type error> execCommandNormalizeOptions({ command: '', commands: [''] });
-
-    /**
-     * Run one command in a shell
-     *
-     *
-     * Note: There are 2 similar functions in the codebase:
-     * - `$execCommand` which runs a single command
-     * - `$execCommands` which runs multiple commands
-     * Note: `$` is used to indicate that this function is not a pure function - it runs a command in a shell
-     *
-     * @public exported from `@promptbook/node`
-     */
-    function $execCommand(options) {
-        if (!$isRunningInNode()) {
-            throw new EnvironmentMismatchError('Function `$execCommand` can run only in Node environment.js');
-        }
-        return new Promise((resolve, reject) => {
-            // eslint-disable-next-line prefer-const
-            const { command, humanReadableCommand, args, cwd, crashOnError, timeout, isVerbose = DEFAULT_IS_VERBOSE, env, } = $execCommandNormalizeOptions(options);
-            if (timeout !== Infinity) {
-                // TODO: In waitasecond forTime(Infinity) should be equivalent to forEver()
-                waitasecond.forTime(timeout).then(() => {
-                    if (crashOnError) {
-                        reject(new Error(`Command "${humanReadableCommand}" exceeded time limit of ${timeout}ms`));
-                    }
-                    else {
-                        console.warn(`Command "${humanReadableCommand}" exceeded time limit of ${timeout}ms but continues running`);
-                        // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
-                        resolve('Command exceeded time limit');
-                    }
-                });
-            }
-            if (isVerbose) {
-                console.info(colors__default["default"].yellow(cwd) + ' ' + colors__default["default"].green(command) + ' ' + colors__default["default"].blue(args.join(' ')));
-            }
-            try {
-                const commandProcess = child_process.spawn(command, args, {
-                    cwd,
-                    shell: true,
-                    env: env ? { ...process.env, ...env } : process.env,
-                });
-                if (isVerbose) {
-                    commandProcess.on('message', (message) => {
-                        console.info({ message });
-                    });
-                }
-                const output = [];
-                commandProcess.stdout.on('data', (stdout) => {
-                    output.push(stdout.toString());
-                    if (isVerbose) {
-                        console.info(stdout.toString());
-                    }
-                });
-                commandProcess.stderr.on('data', (stderr) => {
-                    output.push(stderr.toString());
-                    if (isVerbose && stderr.toString().trim()) {
-                        console.warn(stderr.toString());
-                        // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
-                    }
-                });
-                const finishWithCode = (code) => {
-                    if (code !== 0) {
-                        if (crashOnError) {
-                            reject(new Error(output.join('\n').trim() ||
-                                `Command "${humanReadableCommand}" exited with code ${code}`));
-                        }
-                        else {
-                            if (isVerbose) {
-                                console.warn(`Command "${humanReadableCommand}" exited with code ${code}`);
-                                // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
-                            }
-                            resolve(spaceTrim$1.spaceTrim(output.join('\n')));
-                        }
-                    }
-                    else {
-                        resolve(spaceTrim$1.spaceTrim(output.join('\n')));
-                    }
-                };
-                commandProcess.on('close', finishWithCode);
-                commandProcess.on('exit', finishWithCode);
-                commandProcess.on('disconnect', () => {
-                    // Note: Unexpected disconnection should always result in rejection
-                    reject(new Error(`Command "${humanReadableCommand}" disconnected`));
-                });
-                commandProcess.on('error', (error) => {
-                    if (crashOnError) {
-                        reject(new Error(`Command "${humanReadableCommand}" failed: \n${error.message}`));
-                    }
-                    else {
-                        if (isVerbose) {
-                            console.warn(error);
-                            // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
-                        }
-                        resolve(spaceTrim$1.spaceTrim(output.join('\n')));
-                    }
-                });
-            }
-            catch (error) {
-                // Note: Unexpected error in sync code should always result in rejection
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
-     */
-
-    /**
-     * Attempts to locate the specified application on a Linux system using the 'which' command.
-     * Returns the path to the executable if found, or null otherwise.
-     *
-     * @private within the repository
-     */
-    async function locateAppOnLinux({ linuxWhich, }) {
-        try {
-            const result = await $execCommand({ crashOnError: true, command: `which ${linuxWhich}` });
-            return result.trim();
-        }
-        catch (error) {
-            assertsError(error);
-            return null;
-        }
-    }
+        new GoalCommitmentDefinition('GOAL'),
+        new GoalCommitmentDefinition('GOALS'),
+        new InitialMessageCommitmentDefinition(),
+        new UserMessageCommitmentDefinition(),
+        new InternalMessageCommitmentDefinition(),
+        new AgentMessageCommitmentDefinition(),
+        new MessageSuffixCommitmentDefinition(),
+        new MessageCommitmentDefinition('MESSAGE'),
+        new MessageCommitmentDefinition('MESSAGES'),
+        new ScenarioCommitmentDefinition('SCENARIO'),
+        new ScenarioCommitmentDefinition('SCENARIOS'),
+        new DeleteCommitmentDefinition('DELETE'),
+        new DeleteCommitmentDefinition('CANCEL'),
+        new DeleteCommitmentDefinition('DISCARD'),
+        new DeleteCommitmentDefinition('REMOVE'),
+        new DictionaryCommitmentDefinition(),
+        new OpenCommitmentDefinition(),
+        new ClosedCommitmentDefinition(),
+        new TeamCommitmentDefinition(),
+        new UseBrowserCommitmentDefinition(),
+        new UseSearchEngineCommitmentDefinition(),
+        new UseSpawnCommitmentDefinition(),
+        new UseTimeoutCommitmentDefinition(),
+        new UseTimeCommitmentDefinition(),
+        new UseUserLocationCommitmentDefinition(),
+        new UseCalendarCommitmentDefinition(),
+        new UseEmailCommitmentDefinition(),
+        new UsePopupCommitmentDefinition(),
+        new UseImageGeneratorCommitmentDefinition('USE IMAGE GENERATOR'),
+        new UseMcpCommitmentDefinition(),
+        new UsePrivacyCommitmentDefinition(),
+        new UseProjectCommitmentDefinition(),
+        new UseCommitmentDefinition(),
+        // Not yet implemented commitments (using placeholder)
+        new NotYetImplementedCommitmentDefinition('EXPECT'),
+        new NotYetImplementedCommitmentDefinition('BEHAVIOUR'),
+        new NotYetImplementedCommitmentDefinition('BEHAVIOURS'),
+        new NotYetImplementedCommitmentDefinition('AVOID'),
+        new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
+        new NotYetImplementedCommitmentDefinition('CONTEXT'),
+        // <- TODO: Prompt: Leverage aliases instead of duplicating commitment definitions
+    ];
     /**
-     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
-     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     * TODO: [🧠] Maybe create through standardized $register
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
     /**
-     * Checks if the file is executable
+     * Gets all available commitment definitions
+     * @returns Array of all commitment definitions
      *
-     * @private within the repository
+     * @public exported from `@promptbook/core`
      */
-    async function isExecutable(path, fs) {
-        try {
-            await fs.access(path, fs.constants.X_OK);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
+    function getAllCommitmentDefinitions() {
+        return $deepFreeze([...COMMITMENT_REGISTRY]);
     }
-    /**
-     * Note: Not [~🟢~] because it is not directly dependent on `fs
-     * TODO: [🖇] What about symlinks?
-     */
 
-    // Note: Module `userhome` has no types available, so it is imported using `require`
-    //       @see https://stackoverflow.com/questions/37000981/how-to-import-node-module-in-typescript-without-type-definitions
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const userhome = require('userhome');
     /**
-     * Attempts to locate the specified application on a macOS system by checking standard application paths and using mdfind.
-     * Returns the path to the executable if found, or null otherwise.
+     * Collects tool functions from all commitment definitions.
      *
-     * @private within the repository
+     * @returns Map of tool function implementations.
+     * @private internal helper for commitment tool registry
      */
-    async function locateAppOnMacOs({ macOsName, }) {
-        try {
-            const toExec = `/Contents/MacOS/${macOsName}`;
-            const regPath = `/Applications/${macOsName}.app` + toExec;
-            const altPath = userhome(regPath.slice(1));
-            if (await isExecutable(regPath, $provideFilesystemForNode())) {
-                return regPath;
-            }
-            else if (await isExecutable(altPath, $provideFilesystemForNode())) {
-                return altPath;
+    function collectCommitmentToolFunctions() {
+        const allToolFunctions = {};
+        for (const commitmentDefinition of getAllCommitmentDefinitions()) {
+            const toolFunctions = commitmentDefinition.getToolFunctions();
+            for (const [funcName, funcImpl] of Object.entries(toolFunctions)) {
+                if (allToolFunctions[funcName] !== undefined &&
+                    just(false) /* <- Note: [??] How to deal with commitment aliases */) {
+                    throw new UnexpectedError(`Duplicate tool function name detected: \`${funcName}\` provided by commitment \`${commitmentDefinition.type}\``);
+                }
+                allToolFunctions[funcName] = funcImpl;
             }
-            const result = await $execCommand({
-                crashOnError: true,
-                command: `mdfind 'kMDItemDisplayName == "${macOsName}" && kMDItemKind == Application'`,
-            });
-            return result.trim() + toExec;
-        }
-        catch (error) {
-            assertsError(error);
-            return null;
         }
+        return allToolFunctions;
     }
     /**
-     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
-     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
-     */
-
-    /**
-     * Attempts to locate the specified application on a Windows system by searching common installation directories.
-     * Returns the path to the executable if found, or null otherwise.
+     * Creates a proxy that resolves tool functions on demand.
      *
-     * @private within the repository
+     * @param getFunctions - Provider of current tool functions.
+     * @returns Proxy exposing tool functions as properties.
+     * @private internal helper for commitment tool registry
      */
-    async function locateAppOnWindows({ appName, windowsSuffix, }) {
-        try {
-            const prefixes = [
-                process.env.LOCALAPPDATA,
-                path.join(process.env.LOCALAPPDATA || '', 'Programs'),
-                process.env.PROGRAMFILES,
-                process.env['PROGRAMFILES(X86)'],
-            ];
-            for (const prefix of prefixes) {
-                const path = prefix + windowsSuffix;
-                if (await isExecutable(path, $provideFilesystemForNode())) {
-                    return path;
+    function createToolFunctionsProxy(getFunctions) {
+        const resolveFunctions = () => getFunctions();
+        return new Proxy({}, {
+            get(_target, prop) {
+                if (typeof prop !== 'string') {
+                    return undefined;
                 }
-            }
-            throw new Error(`Can not locate app ${appName} on Windows.`);
-        }
-        catch (error) {
-            assertsError(error);
-            return null;
-        }
+                return resolveFunctions()[prop];
+            },
+            has(_target, prop) {
+                if (typeof prop !== 'string') {
+                    return false;
+                }
+                return prop in resolveFunctions();
+            },
+            ownKeys() {
+                return Object.keys(resolveFunctions());
+            },
+            getOwnPropertyDescriptor(_target, prop) {
+                if (typeof prop !== 'string') {
+                    return undefined;
+                }
+                const value = resolveFunctions()[prop];
+                if (value === undefined) {
+                    return undefined;
+                }
+                return {
+                    enumerable: true,
+                    configurable: true,
+                    writable: false,
+                    value,
+                };
+            },
+        });
     }
     /**
-     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
-     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
+    const nodeToolFunctions = {
+        /**
+         * @@@
+         *
+         * Note: [??] This function has implementation both for browser and node, this is the full one for node
+         */
+        async fetch_url_content(args) {
+            console.log('!!!! [Tool] fetch_url_content called', { args });
+            const { url } = args;
+            return await fetchUrlContent(url);
+        },
+        /**
+         * @@@
+         *
+         * Note: [??] This function has implementation both for browser and node, this is the server one for node
+         */
+        run_browser: resolveRunBrowserToolForNode(),
+        /**
+         * @@@
+         *
+         * Note: [??] This function has implementation both for browser and node, this is the server one for node
+         */
+        send_email: resolveSendEmailToolForNode(),
+        /**
+         * @@@
+         *
+         * Note: [??] This function has implementation both for browser and node, this is the server one for node
+         */
+        spawn_agent: resolveSpawnAgentToolForNode(),
+        // TODO: !!!! Unhardcode, make proper server function register from definitions
+    };
+    const nodeToolFunctionsProxy = createToolFunctionsProxy(() => ({
+        ...collectCommitmentToolFunctions(),
+        ...nodeToolFunctions,
+    }));
     /**
-     * Locates an application on the system
+     * Gets all function implementations provided by all commitments
      *
-     * @private within the repository
+     * Note: This function is intended for server use, there is also equivalent `getAllCommitmentsToolFunctionsForBrowser` for browser use
+     *
+     * @public exported from `@promptbook/node`
      */
-    function locateApp(options) {
+    function getAllCommitmentsToolFunctionsForNode() {
         if (!$isRunningInNode()) {
-            throw new EnvironmentMismatchError('Locating apps works only in Node.js environment');
-        }
-        const { appName, linuxWhich, windowsSuffix, macOsName } = options;
-        if (process.platform === 'win32') {
-            if (windowsSuffix) {
-                return locateAppOnWindows({ appName, windowsSuffix });
-            }
-            else {
-                throw new Error(`${appName} is not available on Windows.`);
-            }
-        }
-        else if (process.platform === 'darwin') {
-            if (macOsName) {
-                return locateAppOnMacOs({ macOsName });
-            }
-            else {
-                throw new Error(`${appName} is not available on macOS.`);
-            }
-        }
-        else {
-            if (linuxWhich) {
-                return locateAppOnLinux({ linuxWhich });
-            }
-            else {
-                throw new Error(`${appName} is not available on Linux.`);
-            }
+            throw new EnvironmentMismatchError(spaceTrim(`
+                Function getAllCommitmentsToolFunctionsForNode should be run in Node.js environment.
+
+                - In browser use getAllCommitmentsToolFunctionsForBrowser instead.
+                - This function can include server-only tools which cannot run in browser environment.
+
+            `));
         }
+        return nodeToolFunctionsProxy;
     }
     /**
-     * TODO: [🧠][♿] Maybe export through `@promptbook/node`
-     * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+     * Note: [??] Code in this file should never be never released in packages that could be imported into browser environment
+     * TODO: [??] Unite `xxxForServer` and `xxxForNode` naming
      */
 
     /**
@@ -27768,6 +29009,14 @@
                 });
                 continue;
             }
+            if (commitment.type === 'USE CALENDAR') {
+                capabilities.push({
+                    type: 'calendar',
+                    label: 'Calendar',
+                    iconName: 'Calendar',
+                });
+                continue;
+            }
             if (commitment.type === 'FROM') {
                 const content = spaceTrim__default["default"](commitment.content).split(/\r?\n/)[0] || '';
                 if (content === 'Adam' || content === '' /* <- Note: Adam is implicit */) {