@promptbook/node 0.112.0-11 → 0.112.0-12

package/esm/index.es.js

@@ -11,7 +11,6 @@ import { JSDOM } from 'jsdom';
 import { Converter } from 'showdown';
 import { tmpdir } from 'os';
 import { ConfigChecker } from 'configchecker';
-import { locateChrome } from 'locate-app';
 import { chromium } from 'playwright';
 import { spawn } from 'child_process';
 import { forTime } from 'waitasecond';
@@ -39,7 +38,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -14804,117 +14803,449 @@ const runBrowserResultFormatting = {
 };
 
 /**
- * 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()
+            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.yellow(cwd) + ' ' + colors.green(command) + ' ' + colors.blue(args.join(' ')));
+        }
+        try {
+            const commandProcess = 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(output.join('\n')));
+                    }
+                }
+                else {
+                    resolve(spaceTrim$1(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(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 = join(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,
+            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 = join(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;
 /**
@@ -21357,27 +21688,154 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
  */
 
 /**
- * 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(`
+                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(content);
     if (!trimmedContent) {
         return {
-            senderEmail: null,
-            senderEmailRaw: null,
+            calendar: null,
+            calendarUrlRaw: null,
             instructions: '',
         };
     }
@@ -21387,718 +21845,1505 @@ function parseUseEmailCommitmentContent(content) {
         .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(`
-            # 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((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(`
-            # 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((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(`
-            # 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((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(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(`
-            # 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(`
-                        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((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(`
-                    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(`
-            # 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(`
-                          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((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(`
+            # 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],
         };
     }
 }
@@ -22106,135 +23351,447 @@ class UsePrivacyCommitmentDefinition extends BaseCommitmentDefinition {
  * 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(`
+            # 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(`
+                        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((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(`
+                    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(`
+            # 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(`
+                          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((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') ||
@@ -25198,503 +26755,186 @@ const COMMITMENT_REGISTRY = [
     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()
-            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.yellow(cwd) + ' ' + colors.green(command) + ' ' + colors.blue(args.join(' ')));
-        }
-        try {
-            const commandProcess = 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(output.join('\n')));
-                    }
-                }
-                else {
-                    resolve(spaceTrim$1(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(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,
-            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
  */
 
 /**
@@ -27759,6 +28999,14 @@ function parseAgentSource(agentSource) {
             });
             continue;
         }
+        if (commitment.type === 'USE CALENDAR') {
+            capabilities.push({
+                type: 'calendar',
+                label: 'Calendar',
+                iconName: 'Calendar',
+            });
+            continue;
+        }
         if (commitment.type === 'FROM') {
             const content = spaceTrim$2(commitment.content).split(/\r?\n/)[0] || '';
             if (content === 'Adam' || content === '' /* <- Note: Adam is implicit */) {