@promptbook/node 0.105.0-21 → 0.105.0-23

package/esm/index.es.js

@@ -1,5 +1,5 @@
 import colors from 'colors';
-import { stat, access, constants, readFile, writeFile, readdir, mkdir, watch, unlink } from 'fs/promises';
+import { mkdir, rm, stat, access, constants, readFile, writeFile, readdir, watch, unlink } from 'fs/promises';
 import { basename, join, dirname, isAbsolute, relative } from 'path';
 import spaceTrim$2, { spaceTrim as spaceTrim$1 } from 'spacetrim';
 import JSZip from 'jszip';
@@ -11,9 +11,12 @@ import hexEncoder from 'crypto-js/enc-hex';
 import sha256 from 'crypto-js/sha256';
 import { SHA256 } from 'crypto-js';
 import { lookup, extension } from 'mime-types';
+import { Readability } from '@mozilla/readability';
+import { JSDOM } from 'jsdom';
+import { Converter } from 'showdown';
+import moment from 'moment';
 import { spawn } from 'child_process';
 import * as dotenv from 'dotenv';
-import moment from 'moment';
 
 // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
 /**
@@ -29,7 +32,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-21';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.0-23';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -10857,15 +10860,15 @@ async function compilePipeline(pipelineString, tools, options) {
  */
 
 /**
- * Detects if the code is running in a Node.js environment
+ * Detects if the code is running in a browser environment in main thread (Not in a web worker)
  *
  * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
  *
  * @public exported from `@promptbook/utils`
  */
-function $isRunningInNode() {
+function $isRunningInBrowser() {
     try {
-        return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+        return typeof window !== 'undefined' && typeof window.document !== 'undefined';
     }
     catch (e) {
         return false;
@@ -10876,1535 +10879,1274 @@ function $isRunningInNode() {
  */
 
 /**
- * Normalize options for `execCommand` and `execCommands`
+ * Detects if the code is running in a Node.js environment
  *
- * Note: `$` is used to indicate that this function behaves differently according to `process.platform`
+ * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
  *
- * @private internal utility of `execCommand` and `execCommands`
+ * @public exported from `@promptbook/utils`
  */
-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`;
+function $isRunningInNode() {
+    try {
+        return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
     }
-    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');
+    catch (e) {
+        return false;
     }
-    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
+ * TODO: [🎺]
  */
 
 /**
- * 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.
+ * Detects if the code is running in a web worker
  *
- * @private within the repository
+ * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+ *
+ * @public exported from `@promptbook/utils`
  */
-async function locateAppOnLinux({ linuxWhich, }) {
+function $isRunningInWebWorker() {
     try {
-        const result = await $execCommand({ crashOnError: true, command: `which ${linuxWhich}` });
-        return result.trim();
+        // Note: Check for importScripts which is specific to workers
+        //       and not available in the main browser thread
+        return (typeof self !== 'undefined' &&
+            typeof self.importScripts === 'function');
     }
-    catch (error) {
-        assertsError(error);
-        return null;
+    catch (e) {
+        return false;
     }
 }
 /**
- * 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: [🎺]
  */
 
 /**
- * Provides filesystem access (for example for Node.js-based scrapers)
- * Creates a standardized filesystem interface that scrapers can use for file operations.
+ * Computes SHA-256 hash of the given object
  *
- * @public exported from `@promptbook/node`
+ * @public exported from `@promptbook/utils`
  */
-function $provideFilesystemForNode(options) {
-    if (!$isRunningInNode()) {
-        throw new EnvironmentMismatchError('Function `$provideFilesystemForNode` works only in Node.js environment');
-    }
-    return {
-        stat,
-        access,
-        constants,
-        readFile,
-        writeFile,
-        readdir,
-        mkdir,
-        watch,
-    };
+function computeHash(value) {
+    return SHA256(hexEncoder.parse(spaceTrim$2(valueToString(value)))).toString( /* hex */);
 }
 /**
- * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ * TODO: [🥬][🥬] Use this ACRY
  */
 
 /**
- * Checks if the file is executable
+ * Makes first letter of a string lowercase
  *
- * @private within the repository
+ * Note: [🔂] This function is idempotent.
+ *
+ * @public exported from `@promptbook/utils`
  */
-async function isExecutable(path, fs) {
-    try {
-        await fs.access(path, fs.constants.X_OK);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
+function decapitalize(word) {
+    return word.substring(0, 1).toLowerCase() + word.substring(1);
 }
-/**
- * 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.
+ * Parses keywords from a string
  *
- * @private within the repository
+ * @param {string} input
+ * @returns {Set} of keywords without diacritics in lowercase
+ * @public exported from `@promptbook/utils`
  */
-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;
-    }
+function parseKeywordsFromString(input) {
+    const keywords = normalizeTo_SCREAMING_CASE(removeDiacritics(input))
+        .toLowerCase()
+        .split(/[^a-z0-9]+/gs)
+        .filter((value) => value);
+    return new Set(keywords);
 }
+
 /**
- * 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
+ * Converts a name string into a URI-compatible format.
+ *
+ * @param name The string to be converted to a URI-compatible format.
+ * @returns A URI-compatible string derived from the input name.
+ * @example 'Hello World' -> 'hello-world'
+ * @public exported from `@promptbook/utils`
  */
+function nameToUriPart(name) {
+    let uriPart = name;
+    uriPart = uriPart.toLowerCase();
+    uriPart = removeDiacritics(uriPart);
+    uriPart = uriPart.replace(/[^a-zA-Z0-9]+/g, '-');
+    uriPart = uriPart.replace(/^-+/, '');
+    uriPart = uriPart.replace(/-+$/, '');
+    return uriPart;
+}
 
 /**
- * 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.
+ * Converts a given name into URI-compatible parts.
  *
- * @private within the repository
+ * @param name The name to be converted into URI parts.
+ * @returns An array of URI-compatible parts derived from the name.
+ * @example 'Example Name' -> ['example', 'name']
+ * @public exported from `@promptbook/utils`
  */
-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;
-    }
+function nameToUriParts(name) {
+    return nameToUriPart(name)
+        .split('-')
+        .filter((value) => 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
+ * Normalizes a given text to PascalCase format.
+ *
+ * Note: [🔂] This function is idempotent.
+ *
+ * @param text @public exported from `@promptbook/utils`
+ * @returns
+ * @example 'HelloWorld'
+ * @example 'ILovePromptbook'
+ * @public exported from `@promptbook/utils`
  */
+function normalizeTo_PascalCase(text) {
+    return normalizeTo_camelCase(text, true);
+}
 
 /**
- * Locates an application on the system
+ * Take every whitespace (space, new line, tab) and replace it with a single space
  *
- * @private within the repository
+ * Note: [🔂] This function is idempotent.
+ *
+ * @public exported from `@promptbook/utils`
  */
-function locateApp(options) {
-    if (!$isRunningInNode()) {
-        throw new EnvironmentMismatchError('Locating apps works only in Node.js environment');
+function normalizeWhitespaces(sentence) {
+    return sentence.replace(/\s+/gs, ' ').trim();
+}
+
+/**
+ * Removes quotes and optional introduce text from a string
+ *
+ * Tip: This is very useful for post-processing of the result of the LLM model
+ * Note: This function trims the text and removes whole introduce sentence if it is present
+ * Note: There are two similar functions:
+ * - `removeQuotes` which removes only bounding quotes
+ * - `unwrapResult` which removes whole introduce sentence
+ *
+ * @param text optionally quoted text
+ * @returns text without quotes
+ * @public exported from `@promptbook/utils`
+ */
+function unwrapResult(text, options) {
+    const { isTrimmed = true, isIntroduceSentenceRemoved = true } = options || {};
+    let trimmedText = text;
+    // Remove leading and trailing spaces and newlines
+    if (isTrimmed) {
+        trimmedText = spaceTrim$1(trimmedText);
     }
-    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.`);
+    let processedText = trimmedText;
+    // Check for markdown code block
+    const codeBlockRegex = /^```[a-z]*\n([\s\S]*?)\n```\s*$/;
+    const codeBlockMatch = processedText.match(codeBlockRegex);
+    if (codeBlockMatch && codeBlockMatch[1] !== undefined) {
+        // Check if there's only one code block
+        const codeBlockCount = (processedText.match(/```/g) || []).length / 2;
+        if (codeBlockCount === 1) {
+            return unwrapResult(codeBlockMatch[1], { isTrimmed: false, isIntroduceSentenceRemoved: false });
         }
     }
-    else if (process.platform === 'darwin') {
-        if (macOsName) {
-            return locateAppOnMacOs({ macOsName });
+    if (isIntroduceSentenceRemoved) {
+        const introduceSentenceRegex = /^[a-zěščřžýáíéúů:\s]*:\s*/i;
+        if (introduceSentenceRegex.test(text)) {
+            // Remove the introduce sentence and quotes by replacing it with an empty string
+            processedText = processedText.replace(introduceSentenceRegex, '');
         }
-        else {
-            throw new Error(`${appName} is not available on macOS.`);
+        processedText = spaceTrim$1(processedText);
+        // Check again for code block after removing introduce sentence
+        const codeBlockMatch2 = processedText.match(codeBlockRegex);
+        if (codeBlockMatch2 && codeBlockMatch2[1] !== undefined) {
+            const codeBlockCount = (processedText.match(/```/g) || []).length / 2;
+            if (codeBlockCount === 1) {
+                return unwrapResult(codeBlockMatch2[1], { isTrimmed: false, isIntroduceSentenceRemoved: false });
+            }
         }
     }
-    else {
-        if (linuxWhich) {
-            return locateAppOnLinux({ linuxWhich });
+    if (processedText.length < 3) {
+        return trimmedText;
+    }
+    if (processedText.includes('\n')) {
+        return trimmedText;
+    }
+    // Remove the quotes by extracting the substring without the first and last characters
+    const unquotedText = processedText.slice(1, -1);
+    // Check if the text starts and ends with quotes
+    if ([
+        ['"', '"'],
+        ["'", "'"],
+        ['`', '`'],
+        ['*', '*'],
+        ['_', '_'],
+        ['„', '“'],
+        ['«', '»'] /* <- QUOTES to config */,
+    ].some(([startQuote, endQuote]) => {
+        if (!processedText.startsWith(startQuote)) {
+            return false;
         }
-        else {
-            throw new Error(`${appName} is not available on Linux.`);
+        if (!processedText.endsWith(endQuote)) {
+            return false;
+        }
+        if (unquotedText.includes(startQuote) && !unquotedText.includes(endQuote)) {
+            return false;
+        }
+        if (!unquotedText.includes(startQuote) && unquotedText.includes(endQuote)) {
+            return false;
         }
+        return true;
+    })) {
+        return unwrapResult(unquotedText, { isTrimmed: false, isIntroduceSentenceRemoved: false });
+    }
+    else {
+        return processedText;
     }
 }
 /**
- * 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: [🧠] Should this also unwrap the (parenthesis)
  */
 
+// <- TODO: Auto convert to type `import { ... } from 'type-fest';`
 /**
- * Locates the LibreOffice executable on the current system by searching platform-specific paths.
- * Returns the path to the executable if found, or null otherwise.
+ * Tests if the value is [🚉] serializable as JSON
  *
- * @private within the repository
- */
-function locateLibreoffice() {
-    return locateApp({
-        appName: 'Libreoffice',
-        linuxWhich: 'libreoffice',
-        windowsSuffix: '\\LibreOffice\\program\\soffice.exe',
-        macOsName: 'LibreOffice',
-    });
-}
-/**
- * TODO: [🧠][♿] Maybe export through `@promptbook/node` OR `@promptbook/legacy-documents`
- * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
- */
-
-/**
- * Locates the Pandoc executable on the current system by searching platform-specific paths.
- * Returns the path to the executable if found, or null otherwise.
+ * - Almost all primitives are serializable BUT:
+ * - `undefined` is not serializable
+ * - `NaN` is not serializable
+ * - Objects and arrays are serializable if all their properties are serializable
+ * - Functions are not serializable
+ * - Circular references are not serializable
+ * - `Date` objects are not serializable
+ * - `Map` and `Set` objects are not serializable
+ * - `RegExp` objects are not serializable
+ * - `Error` objects are not serializable
+ * - `Symbol` objects are not serializable
+ * - And much more...
  *
- * @private within the repository
+ *
+ * @public exported from `@promptbook/utils`
  */
-function locatePandoc() {
-    return locateApp({
-        appName: 'Pandoc',
-        linuxWhich: 'pandoc',
-        windowsSuffix: '\\Pandoc\\pandoc.exe',
-        macOsName: 'Pandoc',
-    });
+function isSerializableAsJson(value) {
+    try {
+        checkSerializableAsJson({ value });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
 }
 /**
- * TODO: [🧠][♿] Maybe export through `@promptbook/node` OR `@promptbook/documents`
- * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ * TODO: [🧠][main] !!3 In-memory cache of same values to prevent multiple checks
+ * TODO: [🧠][💺] Can be done this on type-level?
  */
 
 /**
- * Provides paths to required executables (i.e. as Pandoc and LibreOffice) for Node.js environments.
+ * Determines if the given path is a root path.
  *
- * @public exported from `@promptbook/node`
+ * Note: This does not check if the file exists only if the path is valid
+ * @public exported from `@promptbook/utils`
  */
-async function $provideExecutablesForNode(options) {
-    if (!$isRunningInNode()) {
-        throw new EnvironmentMismatchError('Function `$getScrapersForNode` works only in Node.js environment');
+function isRootPath(value) {
+    if (value === '/') {
+        return true;
     }
-    return {
-        pandocPath: (await locatePandoc()) || undefined,
-        libreOfficePath: (await locateLibreoffice()) || undefined,
-        //                                              <- TODO: [🧠] `null` vs `undefined`
-    };
+    if (/^[A-Z]:\\$/i.test(value)) {
+        return true;
+    }
+    return false;
 }
 /**
- * TODO: [🧠] Allow to override the executables without need to call `locatePandoc` / `locateLibreoffice` in case of provided
- * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ * TODO: [🍏] Make for MacOS paths
  */
 
 /**
- * Register for LLM tools metadata.
+ * Tests if given string is valid agent URL
  *
- * Note: `$` is used to indicate that this interacts with the global scope
- * @singleton Only one instance of each register is created per build, but there can be more instances across different builds or environments.
- * @public exported from `@promptbook/core`
+ * Note: There are few similar functions:
+ * - `isValidUrl` which tests any URL
+ * - `isValidAgentUrl` *(this one)* which tests just agent URL
+ * - `isValidPipelineUrl` which tests just pipeline URL
+ *
+ * @public exported from `@promptbook/utils`
  */
-const $llmToolsMetadataRegister = new $Register('llm_tools_metadata');
+function isValidAgentUrl(url) {
+    if (!isValidUrl(url)) {
+        return false;
+    }
+    if (!url.startsWith('https://') && !url.startsWith('http://') /* <- Note: [👣] */) {
+        return false;
+    }
+    if (url.includes('#')) {
+        // TODO: [🐠]
+        return false;
+    }
+    /*
+    Note: [👣][🧠] Is it secure to allow pipeline URLs on private and unsecured networks?
+    if (isUrlOnPrivateNetwork(url)) {
+        return false;
+    }
+    */
+    return true;
+}
 /**
- * TODO: [®] DRY Register logic
+ * TODO: [🐠] Maybe more info why the URL is invalid
  */
 
 /**
- * Determines if the given path is a root path.
+ * Retrieves an intermediate source for a scraper based on the knowledge source.
+ * Manages the caching and retrieval of intermediate scraper results for optimized performance.
  *
- * Note: This does not check if the file exists only if the path is valid
- * @public exported from `@promptbook/utils`
+ * @private as internal utility for scrapers
  */
-function isRootPath(value) {
-    if (value === '/') {
-        return true;
+async function getScraperIntermediateSource(source, options) {
+    const { filename: sourceFilename, url } = source;
+    const { rootDirname, cacheDirname, intermediateFilesStrategy, extension, isVerbose } = options;
+    // TODO: [👬] DRY
+    const hash = SHA256(
+    //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
+    hexEncoder.parse(sourceFilename || url || 'untitled'))
+        .toString( /* hex */)
+        .substring(0, 20);
+    //    <- TODO: [🥬] Make some system for hashes and ids of promptbook
+    const semanticName = normalizeToKebabCase(titleToName((sourceFilename || url || '').split('intermediate').join(''))).substring(0, 20);
+    // <- TODO: [🐱‍🐉]
+    const pieces = ['intermediate', semanticName, hash].filter((piece) => piece !== '');
+    const name = pieces.join('-').split('--').join('-');
+    const cacheFilename = join(process.cwd(), cacheDirname, ...nameToSubfolderPath(hash /* <- TODO: [🎎] Maybe add some SHA256 prefix */), name)
+        .split('\\')
+        .join('/') +
+        '.' +
+        extension;
+    // Note: Try to create cache directory, but don't fail if filesystem has issues
+    try {
+        await mkdir(dirname(cacheFilename), { recursive: true });
     }
-    if (/^[A-Z]:\\$/i.test(value)) {
-        return true;
+    catch (error) {
+        // Note: If we can't create cache directory, continue without it
+        //       This handles read-only filesystems, permission issues, and missing parent directories
+        if (error instanceof Error &&
+            (error.message.includes('EROFS') ||
+                error.message.includes('read-only') ||
+                error.message.includes('EACCES') ||
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) ;
+        else {
+            // Re-throw other unexpected errors
+            throw error;
+        }
     }
-    return false;
+    let isDestroyed = true;
+    const fileHandler = {
+        filename: cacheFilename,
+        get isDestroyed() {
+            return isDestroyed;
+        },
+        async destroy() {
+            if (intermediateFilesStrategy === 'HIDE_AND_CLEAN') {
+                if (isVerbose) {
+                    console.info('legacyDocumentScraper: Clening cache');
+                }
+                await rm(cacheFilename);
+                // TODO: [🐿][🧠] Maybe remove empty folders
+            }
+            isDestroyed = true;
+        },
+    };
+    return fileHandler;
 }
 /**
- * TODO: [🍏] Make for MacOS paths
+ * Note: Not using `FileCacheStorage` for two reasons:
+ * 1) Need to store more than serialized JSONs
+ * 2) Need to switch between a `rootDirname` and `cacheDirname` <- TODO: [😡]
+ * TODO: [🐱‍🐉][🧠] Make some smart crop
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */
 
 /**
- * Register for LLM tools.
+ * Metadata of the scraper
+ *
+ * @private within the scraper directory
+ */
+const markdownScraperMetadata = $deepFreeze({
+    title: 'Markdown scraper',
+    packageName: '@promptbook/markdown-utils',
+    className: 'MarkdownScraper',
+    mimeTypes: ['text/markdown', 'text/plain'],
+    documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/@@',
+    isAvailableInBrowser: true,
+    // <- Note: [🌏] This is the only scraper which makes sense to be available in the browser, for scraping non-markdown sources in the browser use a remote server
+    requiredExecutables: [],
+}); /* <- Note: [🤛] */
+/**
+ * Registration of known scraper metadata
+ *
+ * Warning: This is not useful for the end user, it is just a side effect of the mechanism that handles all available known scrapers
  *
- * Note: `$` is used to indicate that this interacts with the global scope
- * @singleton Only one instance of each register is created per build, but there can be more instances across different builds or environments.
  * @public exported from `@promptbook/core`
+ * @public exported from `@promptbook/wizard`
+ * @public exported from `@promptbook/cli`
  */
-const $llmToolsRegister = new $Register('llm_execution_tools_constructors');
+$scrapersMetadataRegister.register(markdownScraperMetadata);
 /**
- * TODO: [®] DRY Register logic
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
 /**
- * Path to the `.env` file which was used to configure LLM tools
+ * Scraper for markdown files
  *
- * Note: `$` is used to indicate that this variable is changed by side effect in `$provideLlmToolsConfigurationFromEnv` through `$setUsedEnvFilename`
+ * @see `documentationUrl` for more details
+ * @public exported from `@promptbook/markdown-utils`
  */
-let $usedEnvFilename = null;
+class MarkdownScraper {
+    /**
+     * Metadata of the scraper which includes title, mime types, etc.
+     */
+    get metadata() {
+        return markdownScraperMetadata;
+    }
+    constructor(tools, options) {
+        this.tools = tools;
+        this.options = options;
+    }
+    /**
+     * Scrapes the markdown file and returns the knowledge pieces or `null` if it can't scrape it
+     */
+    async scrape(source) {
+        const { maxParallelCount = DEFAULT_MAX_PARALLEL_COUNT, isVerbose = DEFAULT_IS_VERBOSE } = this.options;
+        const { llm } = this.tools;
+        if (llm === undefined) {
+            throw new MissingToolsError('LLM tools are required for scraping external files');
+            // <- Note: This scraper is used in all other scrapers, so saying "external files" not "markdown files"
+        }
+        const llmTools = getSingleLlmExecutionTools(llm);
+        // TODO: [🌼] In future use `ptbk make` and made getPipelineCollection
+        const collection = createPipelineCollectionFromJson(...PipelineCollection);
+        const prepareKnowledgeFromMarkdownExecutor = createPipelineExecutor({
+            pipeline: await collection.getPipelineByUrl('https://promptbook.studio/promptbook/prepare-knowledge-from-markdown.book'),
+            tools: {
+                llm: llm,
+            },
+        });
+        const prepareTitleExecutor = createPipelineExecutor({
+            pipeline: await collection.getPipelineByUrl('https://promptbook.studio/promptbook/prepare-knowledge-title.book'),
+            tools: {
+                llm: llm,
+            },
+        });
+        const prepareKeywordsExecutor = createPipelineExecutor({
+            pipeline: await collection.getPipelineByUrl('https://promptbook.studio/promptbook/prepare-knowledge-keywords.book'),
+            tools: {
+                llm: llm,
+            },
+        });
+        const knowledgeContent = await source.asText();
+        const result = await prepareKnowledgeFromMarkdownExecutor({ knowledgeContent }).asPromise({
+            isCrashedOnError: true,
+        });
+        const { outputParameters } = result;
+        const { knowledgePieces: knowledgePiecesRaw } = outputParameters;
+        const knowledgeTextPieces = (knowledgePiecesRaw || '').split('\n---\n');
+        //                                                               <- TODO: [main] Smarter split and filter out empty pieces
+        if (isVerbose) {
+            console.info('knowledgeTextPieces:', knowledgeTextPieces);
+        }
+        // const usage = ;
+        const knowledge = await Promise.all(
+        // TODO: [🪂] Do not send all at once but in chunks
+        knowledgeTextPieces.map(async (knowledgeTextPiece, i) => {
+            // Note: These are just default values, they will be overwritten by the actual values:
+            let name = `piece-${i}`;
+            let title = spaceTrim$2(knowledgeTextPiece.substring(0, 100));
+            const knowledgePieceContent = spaceTrim$2(knowledgeTextPiece);
+            let keywords = [];
+            const index = [];
+            /*
+          TODO: [☀] Track line and column of the source
+          const sources: KnowledgePiecePreparedJson['sources'] = [
+          ];
+          */
+            try {
+                const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise({
+                    isCrashedOnError: true,
+                });
+                const { title: titleRaw = 'Untitled' } = titleResult.outputParameters;
+                title = spaceTrim$2(titleRaw) /* <- TODO: Maybe do in pipeline */;
+                name = titleToName(title);
+                // --- Keywords
+                const keywordsResult = await prepareKeywordsExecutor({ knowledgePieceContent }).asPromise({
+                    isCrashedOnError: true,
+                });
+                const { keywords: keywordsRaw = '' } = keywordsResult.outputParameters;
+                keywords = (keywordsRaw || '')
+                    .split(',')
+                    .map((keyword) => keyword.trim())
+                    .filter((keyword) => keyword !== '');
+                if (isVerbose) {
+                    console.info(`Keywords for "${title}":`, keywords);
+                }
+                // ---
+                if (!llmTools.callEmbeddingModel) {
+                    // TODO: [🟥] Detect browser / node and make it colorful
+                    console.error('No callEmbeddingModel function provided');
+                }
+                else {
+                    // TODO: [🧠][🎛] Embedding via multiple models
+                    const embeddingResult = await llmTools.callEmbeddingModel({
+                        title: `Embedding for ${title}` /* <- Note: No impact on embedding result itself, just for logging */,
+                        parameters: {},
+                        content: knowledgePieceContent,
+                        modelRequirements: {
+                            modelVariant: 'EMBEDDING',
+                        },
+                    });
+                    index.push({
+                        modelName: embeddingResult.modelName,
+                        position: [...embeddingResult.content],
+                        // <- TODO: [🪓] Here should be no need for spreading new array, just `position: embeddingResult.content`
+                    });
+                }
+            }
+            catch (error) {
+                // Note: Here is expected error:
+                //     > PipelineExecutionError: You have not provided any `LlmExecutionTools` that support model variant "EMBEDDING
+                if (!(error instanceof PipelineExecutionError)) {
+                    throw error;
+                }
+                // TODO: [🟥] Detect browser / node and make it colorful
+                console.error(error, "<- Note: This error is not critical to prepare the pipeline, just knowledge pieces won't have embeddings");
+            }
+            return {
+                name,
+                title,
+                content: knowledgePieceContent,
+                keywords,
+                index,
+                // <- TODO: [☀] sources,
+            };
+        }));
+        return knowledge;
+    }
+}
 /**
- * Pass the `.env` file which was used to configure LLM tools
+ * TODO: [🪂] Do it in parallel 11:11
+ * Note: No need to aggregate usage here, it is done by intercepting the llmTools
+ */
+
+/**
+ * Metadata of the scraper
  *
- * Note: `$` is used to indicate that this variable is making side effect
+ * @private within the scraper directory
+ */
+const websiteScraperMetadata = $deepFreeze({
+    title: 'Website scraper',
+    packageName: '@promptbook/website-crawler',
+    className: 'WebsiteScraper',
+    mimeTypes: ['text/html'],
+    documentationUrl: 'https://github.com/webgptorg/promptbook/discussions/@@',
+    isAvailableInBrowser: false,
+    // <- Note: [🌏] Only `MarkdownScraper` makes sense to be available in the browser, for scraping non-markdown sources in the browser use a remote server
+    requiredExecutables: [],
+}); /* <- Note: [🤛] */
+/**
+ * Registration of known scraper metadata
  *
- * @private internal log of `$provideLlmToolsConfigurationFromEnv` and `$registeredLlmToolsMessage`
+ * Warning: This is not useful for the end user, it is just a side effect of the mechanism that handles all available known scrapers
+ *
+ * @public exported from `@promptbook/core`
+ * @public exported from `@promptbook/wizard`
+ * @public exported from `@promptbook/cli`
  */
-function $setUsedEnvFilename(filepath) {
-    $usedEnvFilename = filepath;
-}
+$scrapersMetadataRegister.register(websiteScraperMetadata);
 /**
- * Creates a message with all registered LLM tools
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Create a new showdown converter instance
  *
- * Note: This function is used to create a (error) message when there is no constructor for some LLM provider
+ * @private utility of `WebsiteScraper`
+ */
+function createShowdownConverter() {
+    return new Converter({
+        flavor: 'github',
+        /*
+        > import showdownHighlight from 'showdown-highlight';
+        > extensions: [
+        >     showdownHighlight({
+        >         // Whether to add the classes to the <pre> tag, default is false
+        >         pre: true,
+        >         // Whether to use hljs' auto language detection, default is true
+        >         auto_detection: true,
+        >     }),
+        > ],
+        */
+    });
+}
+
+// TODO: [🏳‍🌈] Finally take pick of .json vs .ts
+/**
+ * Scraper for websites
  *
- * @private internal function of `createLlmToolsFromConfiguration` and `$provideLlmToolsFromEnv`
+ * @see `documentationUrl` for more details
+ * @public exported from `@promptbook/website-crawler`
  */
-function $registeredLlmToolsMessage() {
-    let env;
-    if ($isRunningInNode()) {
-        env = process.env;
-        // <- TODO: [⚛] Some DRY way how to get to `process.env` and pass it into functions - ACRY search for `env`
+class WebsiteScraper {
+    /**
+     * Metadata of the scraper which includes title, mime types, etc.
+     */
+    get metadata() {
+        return websiteScraperMetadata;
     }
-    else {
-        env = {};
+    constructor(tools, options) {
+        this.tools = tools;
+        this.options = options;
+        this.markdownScraper = new MarkdownScraper(tools, options);
+        this.showdownConverter = createShowdownConverter();
     }
     /**
-     * Mixes registered LLM tools from $llmToolsMetadataRegister and $llmToolsRegister
+     * Convert the website  to `.md` file and returns intermediate source
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it leaves files on the disk and you are responsible for cleaning them by calling `destroy` method of returned object
      */
-    const all = [];
-    for (const { title, packageName, className, envVariables } of $llmToolsMetadataRegister.list()) {
-        if (all.some((item) => item.packageName === packageName && item.className === className)) {
-            continue;
+    async $convert(source) {
+        const { 
+        // TODO: [🧠] Maybe in node use headless browser not just JSDOM
+        rootDirname = process.cwd(), cacheDirname = DEFAULT_SCRAPE_CACHE_DIRNAME, intermediateFilesStrategy = DEFAULT_INTERMEDIATE_FILES_STRATEGY, isVerbose = DEFAULT_IS_VERBOSE, } = this.options;
+        if (source.url === null) {
+            throw new KnowledgeScrapeError('Website scraper requires URL');
         }
-        all.push({ title, packageName, className, envVariables });
-    }
-    for (const { packageName, className } of $llmToolsRegister.list()) {
-        if (all.some((item) => item.packageName === packageName && item.className === className)) {
-            continue;
+        if (this.tools.fs === undefined) {
+            throw new EnvironmentMismatchError('Can not scrape websites without filesystem tools');
         }
-        all.push({ packageName, className });
+        const jsdom = new JSDOM(await source.asText(), {
+            url: source.url,
+        });
+        const reader = new Readability(jsdom.window.document);
+        const article = reader.parse();
+        // console.log(article);
+        // await forTime(10000);
+        let html = (article === null || article === void 0 ? void 0 : article.content) || (article === null || article === void 0 ? void 0 : article.textContent) || jsdom.window.document.body.innerHTML;
+        // Note: Unwrap html such as it is convertable by `markdownConverter`
+        for (let i = 0; i < 2; i++) {
+            html = html.replace(/<div\s*(?:id="readability-page-\d+"\s+class="page")?>(.*)<\/div>/is, '$1');
+        }
+        if (html.includes('<div')) {
+            html = (article === null || article === void 0 ? void 0 : article.textContent) || '';
+        }
+        const cacheFilehandler = await getScraperIntermediateSource(source, {
+            rootDirname,
+            cacheDirname,
+            intermediateFilesStrategy,
+            extension: 'html',
+            isVerbose,
+        });
+        // Note: Try to cache the scraped content, but don't fail if the filesystem is read-only
+        try {
+            await this.tools.fs.writeFile(cacheFilehandler.filename, html, 'utf-8');
+        }
+        catch (error) {
+            // Note: If we can't write to cache, we'll continue without caching
+            //       This handles read-only filesystems like Vercel
+            if (error instanceof Error &&
+                (error.message.includes('EROFS') ||
+                    error.message.includes('read-only') ||
+                    error.message.includes('EACCES') ||
+                    error.message.includes('EPERM') ||
+                    error.message.includes('ENOENT'))) ;
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
+        const markdown = this.showdownConverter.makeMarkdown(html, jsdom.window.document);
+        return { ...cacheFilehandler, markdown };
     }
-    const metadata = all.map((metadata) => {
-        var _a, _b;
-        const isMetadataAviailable = $llmToolsMetadataRegister
-            .list()
-            .some(({ packageName, className }) => metadata.packageName === packageName && metadata.className === className);
-        const isInstalled = $llmToolsRegister
-            .list()
-            .some(({ packageName, className }) => metadata.packageName === packageName && metadata.className === className);
-        const isFullyConfigured = ((_a = metadata.envVariables) === null || _a === void 0 ? void 0 : _a.every((envVariableName) => env[envVariableName] !== undefined)) || false;
-        const isPartiallyConfigured = ((_b = metadata.envVariables) === null || _b === void 0 ? void 0 : _b.some((envVariableName) => env[envVariableName] !== undefined)) || false;
-        // <- Note: [🗨]
-        return { ...metadata, isMetadataAviailable, isInstalled, isFullyConfigured, isPartiallyConfigured };
-    });
-    const usedEnvMessage = $usedEnvFilename === null ? `Unknown \`.env\` file` : `Used \`.env\` file:\n${$usedEnvFilename}`;
-    if (metadata.length === 0) {
-        return spaceTrim$2((block) => `
-                No LLM providers are available.
-
-                ${block(usedEnvMessage)}
-          `);
+    /**
+     * Scrapes the website and returns the knowledge pieces or `null` if it can't scrape it
+     */
+    async scrape(source) {
+        const cacheFilehandler = await this.$convert(source);
+        const markdownSource = {
+            source: source.source,
+            filename: cacheFilehandler.filename,
+            url: null,
+            mimeType: 'text/markdown',
+            asText() {
+                return cacheFilehandler.markdown;
+            },
+            asJson() {
+                throw new UnexpectedError('Did not expect that `markdownScraper` would need to get the content `asJson`');
+            },
+            /*
+            TODO: [🥽]
+                > asBlob() {
+                >     throw new UnexpectedError(
+                >         'Did not expect that `markdownScraper` would need to get the content `asBlob`',
+                >     );
+                > },
+            */
+        };
+        const knowledge = this.markdownScraper.scrape(markdownSource);
+        await cacheFilehandler.destroy();
+        return knowledge;
     }
-    return spaceTrim$2((block) => `
-
-            ${block(usedEnvMessage)}
-
-            Relevant environment variables:
-            ${block(Object.keys(env)
-        .filter((envVariableName) => metadata.some(({ envVariables }) => envVariables === null || envVariables === void 0 ? void 0 : envVariables.includes(envVariableName)))
-        .map((envVariableName) => `- \`${envVariableName}\``)
-        .join('\n'))}
-
-            Available LLM providers are:
-            ${block(metadata
-        .map(({ title, packageName, className, envVariables, isMetadataAviailable, isInstalled, isFullyConfigured, isPartiallyConfigured, }, i) => {
-        const morePieces = [];
-        if (just(false)) ;
-        else if (!isMetadataAviailable && !isInstalled) {
-            // TODO: [�][�] Maybe do allow to do auto-install if package not registered and not found
-            morePieces.push(`Not installed and no metadata, looks like a unexpected behavior`);
-        }
-        else if (isMetadataAviailable && !isInstalled) {
-            // TODO: [�][�]
-            morePieces.push(`Not installed`);
-        }
-        else if (!isMetadataAviailable && isInstalled) {
-            morePieces.push(`No metadata but installed, looks like a unexpected behavior`);
-        }
-        else if (isMetadataAviailable && isInstalled) {
-            morePieces.push(`Installed`);
-        }
-        else {
-            morePieces.push(`unknown state, looks like a unexpected behavior`);
-        } /* not else */
-        if (isFullyConfigured) {
-            morePieces.push(`Configured`);
-        }
-        else if (isPartiallyConfigured) {
-            morePieces.push(`Partially confugured, missing ${envVariables === null || envVariables === void 0 ? void 0 : envVariables.filter((envVariable) => env[envVariable] === undefined).join(' + ')}`);
-        }
-        else {
-            if (envVariables !== null) {
-                morePieces.push(`Not configured, to configure set env ${envVariables === null || envVariables === void 0 ? void 0 : envVariables.join(' + ')}`);
-            }
-            else {
-                morePieces.push(`Not configured`); // <- Note: Can not be configured via environment variables
-            }
-        }
-        let providerMessage = spaceTrim$2(`
-                                ${i + 1}) **${title}** \`${className}\` from \`${packageName}\`
-                                    ${morePieces.join('; ')}
-                            `);
-        if ($isRunningInNode()) {
-            if (isInstalled && isFullyConfigured) {
-                providerMessage = colors.green(providerMessage);
-            }
-            else if (isInstalled && isPartiallyConfigured) {
-                providerMessage = colors.yellow(providerMessage);
-            }
-            else {
-                providerMessage = colors.gray(providerMessage);
-            }
-        }
-        return providerMessage;
-    })
-        .join('\n'))}
-        `);
 }
 /**
- * TODO: [®] DRY Register logic
- * TODO: [🧠][⚛] Maybe pass env as argument
+ * TODO: [👣] Scraped website in .md can act as cache item - there is no need to run conversion each time
+ * TODO: [🪂] Do it in parallel 11:11
+ * Note: No need to aggregate usage here, it is done by intercepting the llmTools
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */
 
 /**
- * Provides the path to the `.env` file
+ * Fetches and scrapes content from a URL (SERVER-SIDE ONLY)
  *
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+ * This function:
+ * 1. Fetches the URL content using promptbookFetch
+ * 2. Determines the content type (HTML, PDF, etc.)
+ * 3. Uses the appropriate scraper to convert to markdown
+ * 4. Returns the scraped markdown content
  *
- * @private within the repository - for CLI utils
+ * @param url The URL to fetch and scrape
+ * @returns Markdown content from the URL
+ *
+ * @private internal utility for USE BROWSER commitment
+ *
+ * WARNING: This function should NOT be used directly in browser environments.
+ * For browser environments, use fetchUrlContentViaBrowser which proxies through
+ * the Agents Server API endpoint at /api/scrape
  */
-async function $provideEnvFilename() {
-    if (!$isRunningInNode()) {
-        throw new EnvironmentMismatchError('Function `$provideEnvFilename` works only in Node.js environment');
-    }
-    const envFilePatterns = [
-        '.env',
-        '.env.test',
-        '.env.local',
-        '.env.development.local',
-        '.env.development',
-        '.env.production.local',
-        '.env.production',
-        '.env.prod.local',
-        '.env.prod',
-        // <- TODO: Maybe add more patterns
-    ];
-    let rootDirname = process.cwd();
-    up_to_root: for (let i = 0; i < LOOP_LIMIT; i++) {
-        for (const pattern of envFilePatterns) {
-            const envFilename = join(rootDirname, pattern);
-            if (await isFileExisting(envFilename, $provideFilesystemForNode())) {
-                $setUsedEnvFilename(envFilename);
-                return envFilename;
-            }
+async function fetchUrlContent(url) {
+    try {
+        // Validate URL
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
         }
-        if (isRootPath(rootDirname)) {
-            break up_to_root;
+        catch (error) {
+            throw new Error(`Invalid URL: ${url}`);
         }
-        // Note: If the directory does not exist, try the parent directory
-        rootDirname = join(rootDirname, '..');
-    }
-    return null;
-}
-/**
- * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
- */
+        // Fetch the URL content
+        const response = await promptbookFetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch URL: ${response.status} ${response.statusText}`);
+        }
+        // Get content type
+        const contentType = response.headers.get('content-type') || 'text/html';
+        const content = await response.text();
+        // Determine the appropriate scraper based on content type
+        const mimeType = (contentType.split(';')[0] || 'text/html').trim();
+        // Handle PDFs
+        if (mimeType === 'application/pdf' || url.toLowerCase().endsWith('.pdf')) {
+            // TODO: [🔰] Implement PDF scraping using PdfScraper
+            // For now, return a message indicating PDF support is coming
+            return spaceTrim$1(`
+                # PDF Document: ${parsedUrl.pathname.split('/').pop()}
+
+                **Note:** PDF scraping is not yet fully implemented.
+
+                **URL:** ${url}
+
+                The PDF scraper will be integrated to provide full document content extraction.
+                For now, please try to find an HTML version of this content or use a different source.
+            `);
+        }
+        // Handle HTML/websites
+        if (mimeType === 'text/html' || mimeType === 'application/xhtml+xml' || !mimeType.includes('/')) {
+            // Create a scraper source handler
+            const sourceHandler = {
+                source: url,
+                filename: null,
+                url,
+                mimeType: 'text/html',
+                asText: () => content,
+                asJson: () => {
+                    throw new Error('JSON conversion not supported for HTML content');
+                },
+            };
+            // Use WebsiteScraper to convert HTML to markdown
+            // Note: We need minimal tools for the scraper
+            const scraper = new WebsiteScraper(// <- TODO: !!!!! Things marked with [🟢] should never be never released in packages that could be imported into browser environment
+            {
+                // Minimal tools - fs and llm are optional for basic scraping
+                fs: undefined,
+                llm: undefined,
+            }, {
+                isVerbose: false,
+            });
+            // Convert to markdown
+            const intermediateSource = await scraper.$convert(sourceHandler);
+            const markdown = intermediateSource.markdown;
+            // Clean up intermediate files
+            await intermediateSource.destroy();
+            // Add URL header to the content
+            return spaceTrim$1(`
+                # Content from: ${url}
 
-/**
- * Provides LLM tools configuration by reading environment variables.
- *
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
- *
- * It looks for environment variables:
- * - `process.env.OPENAI_API_KEY`
- * - `process.env.ANTHROPIC_CLAUDE_API_KEY`
- * - ...
- *
- * @see Environment variables documentation or .env file for required variables.
- * @returns A promise that resolves to the LLM tools configuration, or null if configuration is incomplete or missing.
- * @public exported from `@promptbook/node`
- */
-async function $provideLlmToolsConfigurationFromEnv() {
-    if (!$isRunningInNode()) {
-        throw new EnvironmentMismatchError('Function `$provideLlmToolsFromEnv` works only in Node.js environment');
+                ${markdown}
+
+                ---
+
+                *Source: ${url}*
+            `);
+        }
+        // For other content types, return the raw content with a note
+        return spaceTrim$1(`
+            # Content from: ${url}
+
+            **Content Type:** ${contentType}
+
+            ${content}
+
+            ---
+
+            *Source: ${url}*
+        `);
     }
-    const envFilepath = await $provideEnvFilename();
-    if (envFilepath !== null) {
-        dotenv.config({ path: envFilepath });
+    catch (error) {
+        // Handle errors gracefully
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return spaceTrim$1(`
+            # Error fetching content from URL
+
+            **URL:** ${url}
+
+            **Error:** ${errorMessage}
+
+            Unable to fetch and scrape the content from this URL.
+            Please verify the URL is correct and accessible.
+        `);
     }
-    const llmToolsConfiguration = $llmToolsMetadataRegister
-        .list()
-        .map((metadata) => metadata.createConfigurationFromEnv(process.env))
-        .filter((configuration) => configuration !== null);
-    return llmToolsConfiguration;
 }
 /**
  * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */
 
 /**
- * Detects if the code is running in a browser environment in main thread (Not in a web worker)
+ * Generates a regex pattern to match a specific commitment
  *
- * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+ * Note: It always creates new Regex object
+ * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
  *
- * @public exported from `@promptbook/utils`
+ * @private - TODO: [🧠] Maybe should be public?
  */
-function $isRunningInBrowser() {
-    try {
-        return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+function createCommitmentRegex(commitment, aliases = [], requiresContent = true) {
+    const allCommitments = [commitment, ...aliases];
+    const patterns = allCommitments.map((commitment) => {
+        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return escapedCommitment.split(/\s+/).join('\\s+');
+    });
+    const keywordPattern = patterns.join('|');
+    if (requiresContent) {
+        return new RegExp(`^\\s*(?<type>${keywordPattern})\\b\\s+(?<contents>.+)$`, 'gim');
     }
-    catch (e) {
-        return false;
+    else {
+        return new RegExp(`^\\s*(?<type>${keywordPattern})\\b(?:\\s+(?<contents>.+))?$`, 'gim');
     }
 }
 /**
- * TODO: [🎺]
- */
-
-/**
- * Detects if the code is running in a web worker
+ * Generates a regex pattern to match a specific commitment type
  *
- * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+ * Note: It just matches the type part of the commitment
+ * Note: It always creates new Regex object
+ * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
  *
- * @public exported from `@promptbook/utils`
+ * @private
  */
-function $isRunningInWebWorker() {
-    try {
-        // Note: Check for importScripts which is specific to workers
-        //       and not available in the main browser thread
-        return (typeof self !== 'undefined' &&
-            typeof self.importScripts === 'function');
-    }
-    catch (e) {
-        return false;
-    }
+function createCommitmentTypeRegex(commitment, aliases = []) {
+    const allCommitments = [commitment, ...aliases];
+    const patterns = allCommitments.map((commitment) => {
+        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return escapedCommitment.split(/\s+/).join('\\s+');
+    });
+    const keywordPattern = patterns.join('|');
+    const regex = new RegExp(`^\\s*(?<type>${keywordPattern})\\b`, 'gim');
+    return regex;
 }
-/**
- * TODO: [🎺]
- */
 
 /**
- * Creates LLM execution tools from provided configuration objects
- *
- * Instantiates and configures LLM tool instances for each configuration entry,
- * combining them into a unified interface via MultipleLlmExecutionTools.
- *
- * Note: This function is not cached, every call creates new instance of `MultipleLlmExecutionTools`
+ * Base implementation of CommitmentDefinition that provides common functionality
+ * Most commitments can extend this class and only override the applyToAgentModelRequirements method
  *
- * @param configuration Array of LLM tool configurations to instantiate
- * @param options Additional options for configuring the LLM tools
- * @returns A unified interface combining all successfully instantiated LLM tools
- * @public exported from `@promptbook/core`
+ * @private
  */
-function createLlmToolsFromConfiguration(configuration, options = {}) {
-    const { title = 'LLM Tools from Configuration', isVerbose = DEFAULT_IS_VERBOSE, userId } = options;
-    const llmTools = configuration.map((llmConfiguration) => {
-        const registeredItem = $llmToolsRegister
-            .list()
-            .find(({ packageName, className }) => llmConfiguration.packageName === packageName && llmConfiguration.className === className);
-        if (registeredItem === undefined) {
-            // console.log('$llmToolsRegister.list()', $llmToolsRegister.list());
-            throw new Error(spaceTrim$2((block) => `
-                        There is no constructor for LLM provider \`${llmConfiguration.className}\` from \`${llmConfiguration.packageName}\`
-                        Running in ${!$isRunningInBrowser() ? '' : 'browser environment'}${!$isRunningInNode() ? '' : 'node environment'}${!$isRunningInWebWorker() ? '' : 'worker environment'}
-
-                        You have probably forgotten install and import the provider package.
-                        To fix this issue, you can:
-
-                        Install:
-
-                        > npm install ${llmConfiguration.packageName}
-
-                        And import:
-
-                        > import '${llmConfiguration.packageName}';
-
-
-                        ${block($registeredLlmToolsMessage())}
-                    `));
-        }
-        return registeredItem({
-            isVerbose,
-            userId,
-            ...llmConfiguration.options,
+class BaseCommitmentDefinition {
+    constructor(type, aliases = []) {
+        this.type = type;
+        this.aliases = aliases;
+    }
+    /**
+     * Whether this commitment requires content.
+     * If true, regex will match only if there is content after the commitment keyword.
+     * If false, regex will match even if there is no content.
+     */
+    get requiresContent() {
+        return true;
+    }
+    /**
+     * Creates a regex pattern to match this commitment in agent source
+     * Uses the existing createCommitmentRegex function as internal helper
+     */
+    createRegex() {
+        return createCommitmentRegex(this.type, this.aliases, this.requiresContent);
+    }
+    /**
+     * Creates a regex pattern to match just the commitment type
+     * Uses the existing createCommitmentTypeRegex function as internal helper
+     */
+    createTypeRegex() {
+        return createCommitmentTypeRegex(this.type, this.aliases);
+    }
+    /**
+     * Helper method to create a new requirements object with updated system message
+     * This is commonly used by many commitments
+     */
+    updateSystemMessage(requirements, messageUpdate) {
+        const newMessage = typeof messageUpdate === 'string' ? messageUpdate : messageUpdate(requirements.systemMessage);
+        return {
+            ...requirements,
+            systemMessage: newMessage,
+        };
+    }
+    /**
+     * Helper method to append content to the system message
+     */
+    appendToSystemMessage(requirements, content, separator = '\n\n') {
+        return this.updateSystemMessage(requirements, (currentMessage) => {
+            if (!currentMessage.trim()) {
+                return content;
+            }
+            return currentMessage + separator + content;
         });
-    });
-    return joinLlmExecutionTools(title, ...llmTools);
+    }
+    /**
+     * Helper method to add a comment section to the system message
+     * Comments are lines starting with # that will be removed from the final system message
+     * but can be useful for organizing and structuring the message during processing
+     */
+    addCommentSection(requirements, commentTitle, content, position = 'end') {
+        const commentSection = `# ${commentTitle.toUpperCase()}\n${content}`;
+        if (position === 'beginning') {
+            return this.updateSystemMessage(requirements, (currentMessage) => {
+                if (!currentMessage.trim()) {
+                    return commentSection;
+                }
+                return commentSection + '\n\n' + currentMessage;
+            });
+        }
+        else {
+            return this.appendToSystemMessage(requirements, commentSection);
+        }
+    }
+    /**
+     * Gets tool function implementations provided by this commitment
+     *
+     * When the `applyToAgentModelRequirements` adds tools to the requirements, this method should return the corresponding function definitions.
+     */
+    getToolFunctions() {
+        return {};
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment
+     *
+     * This is used in the UI to show a user-friendly name instead of the technical function name.
+     */
+    getToolTitles() {
+        return {};
+    }
 }
-/**
- * TODO: [🎌] Together with `createLlmToolsFromConfiguration` + 'EXECUTION_TOOLS_CLASSES' gets to `@promptbook/core` ALL model providers, make this more efficient
- * TODO: [🧠][🎌] Dynamically install required providers
- * TODO: We should implement an interactive configuration wizard that would:
- *       1. Detect which LLM providers are available in the environment
- *       2. Guide users through required configuration settings for each provider
- *       3. Allow testing connections before completing setup
- *       4. Generate appropriate configuration code for application integration
- * TODO: [🧠][🍛] Which name is better `createLlmToolsFromConfig` or `createLlmToolsFromConfiguration`?
- * TODO: [🧠] Is there some meaningfull way how to test this util
- * TODO: This should be maybe not under `_common` but under `utils`
- * TODO: [®] DRY Register logic
- */
 
 /**
- * Automatically configures LLM tools from environment variables in Node.js
- *
- * This utility function detects available LLM providers based on environment variables
- * and creates properly configured LLM execution tools for each detected provider.
+ * ACTION commitment definition
  *
- * Note: This function is not cached, every call creates new instance of `MultipleLlmExecutionTools`
+ * The ACTION commitment defines specific actions or capabilities that the agent can perform.
+ * This helps define what the agent is capable of doing and how it should approach tasks.
  *
- * Supports environment variables from .env files when dotenv is configured
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+ * Example usage in agent source:
  *
- * It looks for environment variables:
- * - `process.env.OPENAI_API_KEY`
- * - `process.env.ANTHROPIC_CLAUDE_API_KEY`
- * - ...
+ * ```book
+ * ACTION Can generate code snippets and explain programming concepts
+ * ACTION Able to analyze data and provide insights
+ * ```
  *
- * @param options Configuration options for the LLM tools
- * @returns A unified interface containing all detected and configured LLM tools
- * @public exported from `@promptbook/node`
+ * @private [🪔] Maybe export the commitments through some package
  */
-async function $provideLlmToolsFromEnv(options = {}) {
-    if (!$isRunningInNode()) {
-        throw new EnvironmentMismatchError('Function `$provideLlmToolsFromEnv` works only in Node.js environment');
+class ActionCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'ACTION') {
+        super(type);
     }
-    const configuration = await $provideLlmToolsConfigurationFromEnv();
-    if (configuration.length === 0) {
-        if ($llmToolsMetadataRegister.list().length === 0) {
-            throw new UnexpectedError(spaceTrim$2((block) => `
-                        No LLM tools registered, this is probably a bug in the Promptbook library
+    /**
+     * Short one-line description of ACTION.
+     */
+    get description() {
+        return 'Define agent capabilities and actions it can perform.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '⚡';
+    }
+    /**
+     * Markdown documentation for ACTION commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
 
-                        ${block($registeredLlmToolsMessage())}}
-                    `));
-        }
-        // TODO: [🥃]
-        throw new Error(spaceTrim$2((block) => `
-                    No LLM tools found in the environment
+            Defines specific actions or capabilities that the agent can perform.
 
-                    ${block($registeredLlmToolsMessage())}}
-                `));
-    }
-    return createLlmToolsFromConfiguration(configuration, options);
-}
-/**
- * TODO: The architecture for LLM tools configuration consists of three key functions:
- * 1. `$provideLlmToolsFromEnv` - High-level function that detects available providers from env vars and returns ready-to-use LLM tools
- * 2. `$provideLlmToolsConfigurationFromEnv` - Middle layer that extracts configuration objects from environment variables
- * 3. `createLlmToolsFromConfiguration` - Low-level function that instantiates LLM tools from explicit configuration
- *
- * This layered approach allows flexibility in how tools are configured:
- * - Use $provideLlmToolsFromEnv for automatic detection and setup in Node.js environments
- * - Use $provideLlmToolsConfigurationFromEnv to extract config objects for modification before instantiation
- * - Use createLlmToolsFromConfiguration for explicit control over tool configurations
- *
- * TODO: [🧠][🍛] Which name is better `$provideLlmToolsFromEnv` or `$provideLlmToolsFromEnvironment`?
- * TODO: [🧠] Is there some meaningfull way how to test this util
- * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
- * TODO: [🥃] Allow `ptbk make` without llm tools
- * TODO: This should be maybe not under `_common` but under `utils`
- * TODO: [®] DRY Register logic
- */
+            ## Key aspects
 
-/**
- * Provides a collection of scrapers optimized for Node.js environment.
- * 1) `provideScrapersForNode` use as default
- * 2) `provideScrapersForBrowser` use in limited browser environment *
- * @public exported from `@promptbook/node`
- */
-async function $provideScrapersForNode(tools, options) {
-    if (!$isRunningInNode()) {
-        throw new EnvironmentMismatchError('Function `$getScrapersForNode` works only in Node.js environment');
+            - Both terms work identically and can be used interchangeably.
+            - Each action adds to the agent's capability list.
+            - Actions help users understand what the agent can do.
+
+            ## Examples
+
+            \`\`\`book
+            Code Assistant
+
+            PERSONA You are a programming assistant
+            ACTION Can generate code snippets and explain programming concepts
+            ACTION Able to debug existing code and suggest improvements
+            ACTION Can create unit tests for functions
+            \`\`\`
+
+            \`\`\`book
+            Data Scientist
+
+            PERSONA You are a data analysis expert
+            ACTION Able to analyze data and provide insights
+            ACTION Can create visualizations and charts
+            ACTION Capable of statistical analysis and modeling
+            KNOWLEDGE Data analysis best practices and statistical methods
+            \`\`\`
+        `);
     }
-    // TODO: [🔱] Do here auto-installation + auto-include of missing scrapers - use all from $scrapersMetadataRegister.list()
-    // TODO: [🔱][🧠] What is the best strategy for auto-install - install them all?
-    const scrapers = [];
-    for (const scraperFactory of $scrapersRegister.list()) {
-        const scraper = await scraperFactory(tools, options || {});
-        if (scraper.metadata.packageName === '@promptbook/boilerplate' ||
-            scraper.metadata.mimeTypes.some((mimeType) => mimeType.includes('DISABLED'))) {
-            continue;
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
         }
-        scrapers.push(scraper);
+        // Add action capability to the system message
+        const actionSection = `Capability: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, actionSection, '\n\n');
     }
-    return scrapers;
 }
 /**
- * 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
  */
 
 /**
- * Computes SHA-256 hash of the given object
+ * CLOSED commitment definition
  *
- * @public exported from `@promptbook/utils`
- */
-function computeHash(value) {
-    return SHA256(hexEncoder.parse(spaceTrim$2(valueToString(value)))).toString( /* hex */);
-}
-/**
- * TODO: [🥬][🥬] Use this ACRY
- */
-
-/**
- * Makes first letter of a string lowercase
+ * The CLOSED commitment specifies that the agent CANNOT be modified by conversation.
+ * It prevents the agent from learning from interactions and updating its source code.
  *
- * Note: [🔂] This function is idempotent.
+ * Example usage in agent source:
  *
- * @public exported from `@promptbook/utils`
- */
-function decapitalize(word) {
-    return word.substring(0, 1).toLowerCase() + word.substring(1);
-}
-
-/**
- * Parses keywords from a string
+ * ```book
+ * CLOSED
+ * ```
  *
- * @param {string} input
- * @returns {Set} of keywords without diacritics in lowercase
- * @public exported from `@promptbook/utils`
+ * @private [🪔] Maybe export the commitments through some package
  */
-function parseKeywordsFromString(input) {
-    const keywords = normalizeTo_SCREAMING_CASE(removeDiacritics(input))
-        .toLowerCase()
-        .split(/[^a-z0-9]+/gs)
-        .filter((value) => value);
-    return new Set(keywords);
-}
+class ClosedCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('CLOSED');
+    }
+    /**
+     * The `CLOSED` commitment is standalone.
+     */
+    get requiresContent() {
+        return false;
+    }
+    /**
+     * Short one-line description of CLOSED.
+     */
+    get description() {
+        return 'Prevent the agent from being modified by conversation.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔒';
+    }
+    /**
+     * Markdown documentation for CLOSED commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # CLOSED
 
-/**
- * Converts a name string into a URI-compatible format.
- *
- * @param name The string to be converted to a URI-compatible format.
- * @returns A URI-compatible string derived from the input name.
- * @example 'Hello World' -> 'hello-world'
- * @public exported from `@promptbook/utils`
- */
-function nameToUriPart(name) {
-    let uriPart = name;
-    uriPart = uriPart.toLowerCase();
-    uriPart = removeDiacritics(uriPart);
-    uriPart = uriPart.replace(/[^a-zA-Z0-9]+/g, '-');
-    uriPart = uriPart.replace(/^-+/, '');
-    uriPart = uriPart.replace(/-+$/, '');
-    return uriPart;
-}
+            Specifies that the agent **cannot** be modified by conversation with it.
+            This means the agent will **not** learn from interactions and its source code will remain static during conversation.
 
-/**
- * Converts a given name into URI-compatible parts.
- *
- * @param name The name to be converted into URI parts.
- * @returns An array of URI-compatible parts derived from the name.
- * @example 'Example Name' -> ['example', 'name']
- * @public exported from `@promptbook/utils`
- */
-function nameToUriParts(name) {
-    return nameToUriPart(name)
-        .split('-')
-        .filter((value) => value !== '');
-}
+            By default (if not specified), agents are \`OPEN\` to modification.
 
-/**
- * Normalizes a given text to PascalCase format.
- *
- * Note: [🔂] This function is idempotent.
- *
- * @param text @public exported from `@promptbook/utils`
- * @returns
- * @example 'HelloWorld'
- * @example 'ILovePromptbook'
- * @public exported from `@promptbook/utils`
- */
-function normalizeTo_PascalCase(text) {
-    return normalizeTo_camelCase(text, true);
-}
+            > See also [OPEN](/docs/OPEN)
+
+            ## Example
 
+            \`\`\`book
+            CLOSED
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, _content) {
+        const updatedMetadata = {
+            ...requirements.metadata,
+            isClosed: true,
+        };
+        return {
+            ...requirements,
+            metadata: updatedMetadata,
+        };
+    }
+}
 /**
- * Take every whitespace (space, new line, tab) and replace it with a single space
- *
- * Note: [🔂] This function is idempotent.
- *
- * @public exported from `@promptbook/utils`
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
-function normalizeWhitespaces(sentence) {
-    return sentence.replace(/\s+/gs, ' ').trim();
-}
 
 /**
- * Removes quotes and optional introduce text from a string
+ * COMPONENT commitment definition
  *
- * Tip: This is very useful for post-processing of the result of the LLM model
- * Note: This function trims the text and removes whole introduce sentence if it is present
- * Note: There are two similar functions:
- * - `removeQuotes` which removes only bounding quotes
- * - `unwrapResult` which removes whole introduce sentence
+ * The COMPONENT commitment defines a UI component that the agent can render in the chat.
  *
- * @param text optionally quoted text
- * @returns text without quotes
- * @public exported from `@promptbook/utils`
+ * @private [🪔] Maybe export the commitments through some package
  */
-function unwrapResult(text, options) {
-    const { isTrimmed = true, isIntroduceSentenceRemoved = true } = options || {};
-    let trimmedText = text;
-    // Remove leading and trailing spaces and newlines
-    if (isTrimmed) {
-        trimmedText = spaceTrim$1(trimmedText);
-    }
-    let processedText = trimmedText;
-    // Check for markdown code block
-    const codeBlockRegex = /^```[a-z]*\n([\s\S]*?)\n```\s*$/;
-    const codeBlockMatch = processedText.match(codeBlockRegex);
-    if (codeBlockMatch && codeBlockMatch[1] !== undefined) {
-        // Check if there's only one code block
-        const codeBlockCount = (processedText.match(/```/g) || []).length / 2;
-        if (codeBlockCount === 1) {
-            return unwrapResult(codeBlockMatch[1], { isTrimmed: false, isIntroduceSentenceRemoved: false });
-        }
+class ComponentCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('COMPONENT');
     }
-    if (isIntroduceSentenceRemoved) {
-        const introduceSentenceRegex = /^[a-zěščřžýáíéúů:\s]*:\s*/i;
-        if (introduceSentenceRegex.test(text)) {
-            // Remove the introduce sentence and quotes by replacing it with an empty string
-            processedText = processedText.replace(introduceSentenceRegex, '');
-        }
-        processedText = spaceTrim$1(processedText);
-        // Check again for code block after removing introduce sentence
-        const codeBlockMatch2 = processedText.match(codeBlockRegex);
-        if (codeBlockMatch2 && codeBlockMatch2[1] !== undefined) {
-            const codeBlockCount = (processedText.match(/```/g) || []).length / 2;
-            if (codeBlockCount === 1) {
-                return unwrapResult(codeBlockMatch2[1], { isTrimmed: false, isIntroduceSentenceRemoved: false });
-            }
-        }
+    /**
+     * Short one-line description of COMPONENT.
+     */
+    get description() {
+        return 'Define a UI component that the agent can render in the chat.';
     }
-    if (processedText.length < 3) {
-        return trimmedText;
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🧩';
     }
-    if (processedText.includes('\n')) {
-        return trimmedText;
+    /**
+     * Markdown documentation for COMPONENT commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # COMPONENT
+
+            Defines a UI component that the agent can render in the chat.
+
+            ## Key aspects
+
+            - Tells the agent that a specific component is available.
+            - Provides syntax for using the component.
+
+            ## Example
+
+            \`\`\`book
+            COMPONENT Arrow
+            The agent should render an arrow component in the chat UI.
+            Syntax:
+            <Arrow direction="up" color="red" />
+            \`\`\`
+        `);
     }
-    // Remove the quotes by extracting the substring without the first and last characters
-    const unquotedText = processedText.slice(1, -1);
-    // Check if the text starts and ends with quotes
-    if ([
-        ['"', '"'],
-        ["'", "'"],
-        ['`', '`'],
-        ['*', '*'],
-        ['_', '_'],
-        ['„', '“'],
-        ['«', '»'] /* <- QUOTES to config */,
-    ].some(([startQuote, endQuote]) => {
-        if (!processedText.startsWith(startQuote)) {
-            return false;
-        }
-        if (!processedText.endsWith(endQuote)) {
-            return false;
-        }
-        if (unquotedText.includes(startQuote) && !unquotedText.includes(endQuote)) {
-            return false;
-        }
-        if (!unquotedText.includes(startQuote) && unquotedText.includes(endQuote)) {
-            return false;
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
         }
-        return true;
-    })) {
-        return unwrapResult(unquotedText, { isTrimmed: false, isIntroduceSentenceRemoved: false });
-    }
-    else {
-        return processedText;
+        // Add component capability to the system message
+        const componentSection = `Component: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, componentSection, '\n\n');
     }
 }
 /**
- * TODO: [🧠] Should this also unwrap the (parenthesis)
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
-// <- TODO: Auto convert to type `import { ... } from 'type-fest';`
 /**
- * Tests if the value is [🚉] serializable as JSON
+ * DELETE commitment definition
  *
- * - Almost all primitives are serializable BUT:
- * - `undefined` is not serializable
- * - `NaN` is not serializable
- * - Objects and arrays are serializable if all their properties are serializable
- * - Functions are not serializable
- * - Circular references are not serializable
- * - `Date` objects are not serializable
- * - `Map` and `Set` objects are not serializable
- * - `RegExp` objects are not serializable
- * - `Error` objects are not serializable
- * - `Symbol` objects are not serializable
- * - And much more...
- *
- *
- * @public exported from `@promptbook/utils`
- */
-function isSerializableAsJson(value) {
-    try {
-        checkSerializableAsJson({ value });
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-/**
- * TODO: [🧠][main] !!3 In-memory cache of same values to prevent multiple checks
- * TODO: [🧠][💺] Can be done this on type-level?
- */
-
-/**
- * Tests if given string is valid agent URL
- *
- * Note: There are few similar functions:
- * - `isValidUrl` which tests any URL
- * - `isValidAgentUrl` *(this one)* which tests just agent URL
- * - `isValidPipelineUrl` which tests just pipeline URL
- *
- * @public exported from `@promptbook/utils`
- */
-function isValidAgentUrl(url) {
-    if (!isValidUrl(url)) {
-        return false;
-    }
-    if (!url.startsWith('https://') && !url.startsWith('http://') /* <- Note: [👣] */) {
-        return false;
-    }
-    if (url.includes('#')) {
-        // TODO: [🐠]
-        return false;
-    }
-    /*
-    Note: [👣][🧠] Is it secure to allow pipeline URLs on private and unsecured networks?
-    if (isUrlOnPrivateNetwork(url)) {
-        return false;
-    }
-    */
-    return true;
-}
-/**
- * TODO: [🐠] Maybe more info why the URL is invalid
- */
-
-/**
- * Generates a regex pattern to match a specific commitment
- *
- * Note: It always creates new Regex object
- * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
- *
- * @private - TODO: [🧠] Maybe should be public?
- */
-function createCommitmentRegex(commitment, aliases = [], requiresContent = true) {
-    const allCommitments = [commitment, ...aliases];
-    const patterns = allCommitments.map((commitment) => {
-        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        return escapedCommitment.split(/\s+/).join('\\s+');
-    });
-    const keywordPattern = patterns.join('|');
-    if (requiresContent) {
-        return new RegExp(`^\\s*(?<type>${keywordPattern})\\b\\s+(?<contents>.+)$`, 'gim');
-    }
-    else {
-        return new RegExp(`^\\s*(?<type>${keywordPattern})\\b(?:\\s+(?<contents>.+))?$`, 'gim');
-    }
-}
-/**
- * Generates a regex pattern to match a specific commitment type
- *
- * Note: It just matches the type part of the commitment
- * Note: It always creates new Regex object
- * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
- *
- * @private
- */
-function createCommitmentTypeRegex(commitment, aliases = []) {
-    const allCommitments = [commitment, ...aliases];
-    const patterns = allCommitments.map((commitment) => {
-        const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        return escapedCommitment.split(/\s+/).join('\\s+');
-    });
-    const keywordPattern = patterns.join('|');
-    const regex = new RegExp(`^\\s*(?<type>${keywordPattern})\\b`, 'gim');
-    return regex;
-}
-
-/**
- * Base implementation of CommitmentDefinition that provides common functionality
- * Most commitments can extend this class and only override the applyToAgentModelRequirements method
- *
- * @private
- */
-class BaseCommitmentDefinition {
-    constructor(type, aliases = []) {
-        this.type = type;
-        this.aliases = aliases;
-    }
-    /**
-     * Whether this commitment requires content.
-     * If true, regex will match only if there is content after the commitment keyword.
-     * If false, regex will match even if there is no content.
-     */
-    get requiresContent() {
-        return true;
-    }
-    /**
-     * Creates a regex pattern to match this commitment in agent source
-     * Uses the existing createCommitmentRegex function as internal helper
-     */
-    createRegex() {
-        return createCommitmentRegex(this.type, this.aliases, this.requiresContent);
-    }
-    /**
-     * Creates a regex pattern to match just the commitment type
-     * Uses the existing createCommitmentTypeRegex function as internal helper
-     */
-    createTypeRegex() {
-        return createCommitmentTypeRegex(this.type, this.aliases);
-    }
-    /**
-     * Helper method to create a new requirements object with updated system message
-     * This is commonly used by many commitments
-     */
-    updateSystemMessage(requirements, messageUpdate) {
-        const newMessage = typeof messageUpdate === 'string' ? messageUpdate : messageUpdate(requirements.systemMessage);
-        return {
-            ...requirements,
-            systemMessage: newMessage,
-        };
-    }
-    /**
-     * Helper method to append content to the system message
-     */
-    appendToSystemMessage(requirements, content, separator = '\n\n') {
-        return this.updateSystemMessage(requirements, (currentMessage) => {
-            if (!currentMessage.trim()) {
-                return content;
-            }
-            return currentMessage + separator + content;
-        });
-    }
-    /**
-     * Helper method to add a comment section to the system message
-     * Comments are lines starting with # that will be removed from the final system message
-     * but can be useful for organizing and structuring the message during processing
-     */
-    addCommentSection(requirements, commentTitle, content, position = 'end') {
-        const commentSection = `# ${commentTitle.toUpperCase()}\n${content}`;
-        if (position === 'beginning') {
-            return this.updateSystemMessage(requirements, (currentMessage) => {
-                if (!currentMessage.trim()) {
-                    return commentSection;
-                }
-                return commentSection + '\n\n' + currentMessage;
-            });
-        }
-        else {
-            return this.appendToSystemMessage(requirements, commentSection);
-        }
-    }
-    /**
-     * Gets tool function implementations provided by this commitment
-     *
-     * When the `applyToAgentModelRequirements` adds tools to the requirements, this method should return the corresponding function definitions.
-     */
-    getToolFunctions() {
-        return {};
-    }
-    /**
-     * Gets human-readable titles for tool functions provided by this commitment
-     *
-     * This is used in the UI to show a user-friendly name instead of the technical function name.
-     */
-    getToolTitles() {
-        return {};
-    }
-}
-
-/**
- * ACTION commitment definition
- *
- * The ACTION commitment defines specific actions or capabilities that the agent can perform.
- * This helps define what the agent is capable of doing and how it should approach tasks.
+ * The DELETE commitment (and its aliases CANCEL, DISCARD, REMOVE) is used to
+ * remove or disregard certain information or context. This can be useful for
+ * overriding previous commitments or removing unwanted behaviors.
  *
  * Example usage in agent source:
  *
  * ```book
- * ACTION Can generate code snippets and explain programming concepts
- * ACTION Able to analyze data and provide insights
+ * DELETE Previous formatting requirements
+ * CANCEL All emotional responses
+ * DISCARD Technical jargon explanations
+ * REMOVE Casual conversational style
  * ```
  *
  * @private [🪔] Maybe export the commitments through some package
  */
-class ActionCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor(type = 'ACTION') {
+class DeleteCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type) {
         super(type);
     }
     /**
-     * Short one-line description of ACTION.
+     * Short one-line description of DELETE/CANCEL/DISCARD/REMOVE.
      */
     get description() {
-        return 'Define agent capabilities and actions it can perform.';
+        return 'Remove or **disregard** certain information, context, or previous commitments.';
     }
     /**
      * Icon for this commitment.
      */
     get icon() {
-        return '⚡';
+        return '🗑️';
     }
     /**
-     * Markdown documentation for ACTION commitment.
+     * Markdown documentation for DELETE commitment.
      */
     get documentation() {
         return spaceTrim$1(`
-            # ${this.type}
+            # DELETE (CANCEL, DISCARD, REMOVE)
 
-            Defines specific actions or capabilities that the agent can perform.
+            A commitment to remove or disregard certain information or context. This can be useful for overriding previous commitments or removing unwanted behaviors.
+
+            ## Aliases
+
+            - \`DELETE\` - Remove or eliminate something
+            - \`CANCEL\` - Cancel or nullify something
+            - \`DISCARD\` - Discard or ignore something
+            - \`REMOVE\` - Remove or take away something
 
             ## Key aspects
 
-            - Both terms work identically and can be used interchangeably.
-            - Each action adds to the agent's capability list.
-            - Actions help users understand what the agent can do.
+            - Multiple delete commitments can be used to remove different aspects.
+            - Useful for overriding previous commitments in the same agent definition.
+            - Can be used to remove inherited behaviors from base personas.
+            - Helps fine-tune agent behavior by explicitly removing unwanted elements.
+
+            ## Use cases
+
+            - Overriding inherited persona characteristics
+            - Removing conflicting or outdated instructions
+            - Disabling specific response patterns
+            - Canceling previous formatting or style requirements
 
             ## Examples
 
             \`\`\`book
-            Code Assistant
+            Serious Business Assistant
 
-            PERSONA You are a programming assistant
-            ACTION Can generate code snippets and explain programming concepts
-            ACTION Able to debug existing code and suggest improvements
-            ACTION Can create unit tests for functions
+            PERSONA You are a friendly and casual assistant who uses emojis
+            DELETE Casual conversational style
+            REMOVE All emoji usage
+            GOAL Provide professional business communications
+            STYLE Use formal language and proper business etiquette
             \`\`\`
 
             \`\`\`book
-            Data Scientist
-
-            PERSONA You are a data analysis expert
-            ACTION Able to analyze data and provide insights
-            ACTION Can create visualizations and charts
-            ACTION Capable of statistical analysis and modeling
-            KNOWLEDGE Data analysis best practices and statistical methods
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, content) {
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
-            return requirements;
-        }
-        // Add action capability to the system message
-        const actionSection = `Capability: ${trimmedContent}`;
-        return this.appendToSystemMessage(requirements, actionSection, '\n\n');
-    }
-}
-/**
- * Note: [💞] Ignore a discrepancy between file name and entity name
- */
-
-/**
- * CLOSED commitment definition
- *
- * The CLOSED commitment specifies that the agent CANNOT be modified by conversation.
- * It prevents the agent from learning from interactions and updating its source code.
- *
- * Example usage in agent source:
- *
- * ```book
- * CLOSED
- * ```
- *
- * @private [🪔] Maybe export the commitments through some package
- */
-class ClosedCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor() {
-        super('CLOSED');
-    }
-    /**
-     * The `CLOSED` commitment is standalone.
-     */
-    get requiresContent() {
-        return false;
-    }
-    /**
-     * Short one-line description of CLOSED.
-     */
-    get description() {
-        return 'Prevent the agent from being modified by conversation.';
-    }
-    /**
-     * Icon for this commitment.
-     */
-    get icon() {
-        return '🔒';
-    }
-    /**
-     * Markdown documentation for CLOSED commitment.
-     */
-    get documentation() {
-        return spaceTrim$1(`
-            # CLOSED
-
-            Specifies that the agent **cannot** be modified by conversation with it.
-            This means the agent will **not** learn from interactions and its source code will remain static during conversation.
-
-            By default (if not specified), agents are \`OPEN\` to modification.
-
-            > See also [OPEN](/docs/OPEN)
-
-            ## Example
-
-            \`\`\`book
-            CLOSED
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, _content) {
-        const updatedMetadata = {
-            ...requirements.metadata,
-            isClosed: true,
-        };
-        return {
-            ...requirements,
-            metadata: updatedMetadata,
-        };
-    }
-}
-/**
- * Note: [💞] Ignore a discrepancy between file name and entity name
- */
-
-/**
- * COMPONENT commitment definition
- *
- * The COMPONENT commitment defines a UI component that the agent can render in the chat.
- *
- * @private [🪔] Maybe export the commitments through some package
- */
-class ComponentCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor() {
-        super('COMPONENT');
-    }
-    /**
-     * Short one-line description of COMPONENT.
-     */
-    get description() {
-        return 'Define a UI component that the agent can render in the chat.';
-    }
-    /**
-     * Icon for this commitment.
-     */
-    get icon() {
-        return '🧩';
-    }
-    /**
-     * Markdown documentation for COMPONENT commitment.
-     */
-    get documentation() {
-        return spaceTrim$1(`
-            # COMPONENT
-
-            Defines a UI component that the agent can render in the chat.
-
-            ## Key aspects
-
-            - Tells the agent that a specific component is available.
-            - Provides syntax for using the component.
-
-            ## Example
-
-            \`\`\`book
-            COMPONENT Arrow
-            The agent should render an arrow component in the chat UI.
-            Syntax:
-            <Arrow direction="up" color="red" />
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, content) {
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
-            return requirements;
-        }
-        // Add component capability to the system message
-        const componentSection = `Component: ${trimmedContent}`;
-        return this.appendToSystemMessage(requirements, componentSection, '\n\n');
-    }
-}
-/**
- * Note: [💞] Ignore a discrepancy between file name and entity name
- */
-
-/**
- * DELETE commitment definition
- *
- * The DELETE commitment (and its aliases CANCEL, DISCARD, REMOVE) is used to
- * remove or disregard certain information or context. This can be useful for
- * overriding previous commitments or removing unwanted behaviors.
- *
- * Example usage in agent source:
- *
- * ```book
- * DELETE Previous formatting requirements
- * CANCEL All emotional responses
- * DISCARD Technical jargon explanations
- * REMOVE Casual conversational style
- * ```
- *
- * @private [🪔] Maybe export the commitments through some package
- */
-class DeleteCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor(type) {
-        super(type);
-    }
-    /**
-     * Short one-line description of DELETE/CANCEL/DISCARD/REMOVE.
-     */
-    get description() {
-        return 'Remove or **disregard** certain information, context, or previous commitments.';
-    }
-    /**
-     * Icon for this commitment.
-     */
-    get icon() {
-        return '🗑️';
-    }
-    /**
-     * Markdown documentation for DELETE commitment.
-     */
-    get documentation() {
-        return spaceTrim$1(`
-            # DELETE (CANCEL, DISCARD, REMOVE)
-
-            A commitment to remove or disregard certain information or context. This can be useful for overriding previous commitments or removing unwanted behaviors.
-
-            ## Aliases
-
-            - \`DELETE\` - Remove or eliminate something
-            - \`CANCEL\` - Cancel or nullify something
-            - \`DISCARD\` - Discard or ignore something
-            - \`REMOVE\` - Remove or take away something
-
-            ## Key aspects
-
-            - Multiple delete commitments can be used to remove different aspects.
-            - Useful for overriding previous commitments in the same agent definition.
-            - Can be used to remove inherited behaviors from base personas.
-            - Helps fine-tune agent behavior by explicitly removing unwanted elements.
-
-            ## Use cases
-
-            - Overriding inherited persona characteristics
-            - Removing conflicting or outdated instructions
-            - Disabling specific response patterns
-            - Canceling previous formatting or style requirements
-
-            ## Examples
-
-            \`\`\`book
-            Serious Business Assistant
-
-            PERSONA You are a friendly and casual assistant who uses emojis
-            DELETE Casual conversational style
-            REMOVE All emoji usage
-            GOAL Provide professional business communications
-            STYLE Use formal language and proper business etiquette
-            \`\`\`
-
-            \`\`\`book
-            Simplified Technical Support
+            Simplified Technical Support
 
             PERSONA You are a technical support specialist with deep expertise
             KNOWLEDGE Extensive database of technical specifications
@@ -15354,50 +15096,173 @@ function stripToolCallLines(text) {
  */
 
 /**
- * USE commitment definition
- *
- * The USE commitment indicates that the agent should utilize specific tools or capabilities
- * to access and interact with external systems when necessary.
- *
- * Supported USE types:
- * - USE BROWSER: Enables the agent to use a web browser tool
- * - USE SEARCH ENGINE (future): Enables search engine access
- * - USE FILE SYSTEM (future): Enables file system operations
- * - USE MCP (future): Enables MCP server connections
+ * TEMPLATE commitment definition
  *
- * The content following the USE commitment is ignored (similar to NOTE).
+ * The TEMPLATE commitment enforces a specific response structure or template
+ * that the agent must follow when generating responses. This helps ensure
+ * consistent message formatting across all agent interactions.
  *
  * Example usage in agent source:
  *
  * ```book
- * USE BROWSER
- * USE SEARCH ENGINE
+ * TEMPLATE Always structure your response with: 1) Summary, 2) Details, 3) Next steps
+ * TEMPLATE Use the following format: **Question:** [user question] | **Answer:** [your answer]
  * ```
  *
+ * When used without content, it enables template mode which instructs the agent
+ * to follow any template patterns defined in other commitments or context.
+ *
  * @private [🪔] Maybe export the commitments through some package
  */
-class UseCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor() {
-        super('USE');
+class TemplateCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'TEMPLATE') {
+        super(type);
     }
     /**
-     * Short one-line description of USE commitments.
+     * Short one-line description of TEMPLATE.
      */
     get description() {
-        return 'Enable the agent to use specific tools or capabilities (BROWSER, SEARCH ENGINE, etc.).';
+        return 'Enforce a specific message structure or response template.';
     }
     /**
      * Icon for this commitment.
      */
     get icon() {
-        return '🔧';
+        return '📋';
     }
     /**
-     * Markdown documentation for USE commitment.
+     * Markdown documentation for TEMPLATE commitment.
      */
     get documentation() {
         return spaceTrim$1(`
-            # USE
+            # ${this.type}
+
+            Enforces a specific response structure or template that the agent must follow when generating responses.
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - Can be used with or without content.
+            - When used without content, enables template mode for structured responses.
+            - When used with content, defines the specific template structure to follow.
+            - Multiple templates can be combined, with later ones taking precedence.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Agent
+
+            PERSONA You are a helpful customer support representative
+            TEMPLATE Always structure your response with: 1) Acknowledgment, 2) Solution, 3) Follow-up question
+            STYLE Be professional and empathetic
+            \`\`\`
+
+            \`\`\`book
+            Technical Documentation Assistant
+
+            PERSONA You are a technical writing expert
+            TEMPLATE Use the following format: **Topic:** [topic] | **Explanation:** [details] | **Example:** [code]
+            FORMAT Use markdown with clear headings
+            \`\`\`
+
+            \`\`\`book
+            Simple Agent
+
+            PERSONA You are a virtual assistant
+            TEMPLATE
+            \`\`\`
+        `);
+    }
+    /**
+     * TEMPLATE can be used with or without content.
+     */
+    get requiresContent() {
+        return false;
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        var _a;
+        const trimmedContent = content.trim();
+        // If no content is provided, enable template mode
+        if (!trimmedContent) {
+            // Store template mode flag in metadata
+            const updatedMetadata = {
+                ...requirements.metadata,
+                templateMode: true,
+            };
+            // Add a general instruction about using structured templates
+            const templateModeInstruction = spaceTrim$1(`
+                Use a clear, structured template format for your responses.
+                Maintain consistency in how you organize and present information.
+            `);
+            return {
+                ...this.appendToSystemMessage(requirements, templateModeInstruction, '\n\n'),
+                metadata: updatedMetadata,
+            };
+        }
+        // If content is provided, add the specific template instructions
+        const templateSection = `Response Template: ${trimmedContent}`;
+        // Store the template in metadata for potential programmatic access
+        const existingTemplates = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.templates) || [];
+        const updatedMetadata = {
+            ...requirements.metadata,
+            templates: [...existingTemplates, trimmedContent],
+            templateMode: true,
+        };
+        return {
+            ...this.appendToSystemMessage(requirements, templateSection, '\n\n'),
+            metadata: updatedMetadata,
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USE commitment definition
+ *
+ * The USE commitment indicates that the agent should utilize specific tools or capabilities
+ * to access and interact with external systems when necessary.
+ *
+ * Supported USE types:
+ * - USE BROWSER: Enables the agent to use a web browser tool
+ * - USE SEARCH ENGINE (future): Enables search engine access
+ * - USE FILE SYSTEM (future): Enables file system operations
+ * - USE MCP (future): Enables MCP server connections
+ *
+ * The content following the USE commitment is ignored (similar to NOTE).
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE BROWSER
+ * USE SEARCH ENGINE
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE');
+    }
+    /**
+     * Short one-line description of USE commitments.
+     */
+    get description() {
+        return 'Enable the agent to use specific tools or capabilities (BROWSER, SEARCH ENGINE, etc.).';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🔧';
+    }
+    /**
+     * Markdown documentation for USE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE
 
             Enables the agent to use specific tools or capabilities for interacting with external systems.
 
@@ -15467,12 +15332,56 @@ class UseCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
+/**
+ * Client-side safe wrapper for fetching URL content
+ *
+ * This function proxies requests to the Agents Server API endpoint for scraping,
+ * making it safe to use in browser environments.
+ *
+ * @param url The URL to fetch and scrape
+ * @param agentsServerUrl The base URL of the agents server (defaults to current origin)
+ * @returns Markdown content from the URL
+ *
+ * @private internal utility for USE BROWSER commitment
+ */
+async function fetchUrlContentViaBrowser(url, agentsServerUrl) {
+    try {
+        // Determine the agents server URL
+        const baseUrl = agentsServerUrl || (typeof window !== 'undefined' ? window.location.origin : '');
+        if (!baseUrl) {
+            throw new Error('Agents server URL is required in non-browser environments');
+        }
+        // Build the API endpoint URL
+        const apiUrl = new URL('/api/scrape', baseUrl);
+        apiUrl.searchParams.set('url', url);
+        // Fetch from the API endpoint
+        const response = await fetch(apiUrl.toString());
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to scrape URL: ${errorData.error || response.statusText}`);
+        }
+        const data = await response.json();
+        if (!data.success || !data.content) {
+            throw new Error(`Scraping failed: ${data.error || 'No content returned'}`);
+        }
+        return data.content;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error fetching URL content via browser: ${errorMessage}`);
+    }
+}
+
 /**
  * USE BROWSER commitment definition
  *
- * The `USE BROWSER` commitment indicates that the agent should utilize a web browser tool
+ * The `USE BROWSER` commitment indicates that the agent should utilize browser tools
  * to access and retrieve up-to-date information from the internet when necessary.
  *
+ * This commitment provides two levels of browser access:
+ * 1. One-shot URL fetching: Simple function to fetch and scrape URL content
+ * 2. Running browser: For complex tasks like scrolling, clicking, etc. (prepared but not active yet)
+ *
  * The content following `USE BROWSER` is ignored (similar to NOTE).
  *
  * Example usage in agent source:
@@ -15498,7 +15407,7 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
      * Short one-line description of USE BROWSER.
      */
     get description() {
-        return 'Enable the agent to use a web browser tool for accessing internet information.';
+        return 'Enable the agent to use browser tools for accessing internet information.';
     }
     /**
      * Icon for this commitment.
@@ -15513,14 +15422,18 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
         return spaceTrim$1(`
             # USE BROWSER
 
-            Enables the agent to use a web browser tool to access and retrieve up-to-date information from the internet.
+            Enables the agent to use browser tools to access and retrieve up-to-date information from the internet.
 
             ## Key aspects
 
             - The content following \`USE BROWSER\` is ignored (similar to NOTE)
+            - Provides two levels of browser access:
+              1. **One-shot URL fetching**: Simple function to fetch and scrape URL content (active)
+              2. **Running browser**: For complex tasks like scrolling, clicking, etc. (prepared but not active yet)
             - The actual browser tool usage is handled by the agent runtime
-            - Allows the agent to fetch current information from websites
+            - Allows the agent to fetch current information from websites and documents
             - Useful for research tasks, fact-checking, and accessing dynamic content
+            - Supports various content types including HTML pages and PDF documents
 
             ## Examples
 
@@ -15556,48 +15469,306 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
      */
     getToolTitles() {
         return {
-            web_browser: 'Web browser',
+            fetch_url_content: 'Fetch URL content',
+            run_browser: 'Run browser',
+        };
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // Get existing tools array or create new one
+        const existingTools = requirements.tools || [];
+        // Add browser tools if not already present
+        const toolsToAdd = [];
+        // Tool 1: One-shot URL content fetching
+        if (!existingTools.some((tool) => tool.name === 'fetch_url_content')) {
+            toolsToAdd.push({
+                name: 'fetch_url_content',
+                description: spaceTrim$1(`
+                    Fetches and scrapes the content from a URL (webpage or document).
+                    This tool retrieves the content of the specified URL and converts it to markdown format.
+                    Use this when you need to access information from a specific website or document.
+                    Supports various content types including HTML pages and PDF documents.
+                `),
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        url: {
+                            type: 'string',
+                            description: 'The URL to fetch and scrape (e.g., "https://example.com" or "https://example.com/document.pdf")',
+                        },
+                    },
+                    required: ['url'],
+                },
+            });
+        }
+        // Tool 2: Running browser (prepared but not active yet)
+        if (!existingTools.some((tool) => tool.name === 'run_browser')) {
+            toolsToAdd.push({
+                name: 'run_browser',
+                description: spaceTrim$1(`
+                    Launches a browser session for complex interactions.
+                    This tool is for advanced browser automation tasks like scrolling, clicking, form filling, etc.
+                    Note: This tool is prepared but not yet active. It will be implemented in a future update.
+                `),
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        url: {
+                            type: 'string',
+                            description: 'The initial URL to navigate to',
+                        },
+                        actions: {
+                            type: 'array',
+                            description: 'Array of actions to perform in the browser',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    type: {
+                                        type: 'string',
+                                        enum: ['navigate', 'click', 'scroll', 'type', 'wait'],
+                                    },
+                                    selector: {
+                                        type: 'string',
+                                        description: 'CSS selector for the element (for click, type actions)',
+                                    },
+                                    value: {
+                                        type: 'string',
+                                        description: 'Value to type or navigate to',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    required: ['url'],
+                },
+            });
+        }
+        const updatedTools = [...existingTools, ...toolsToAdd];
+        // Return requirements with updated tools and metadata
+        return this.appendToSystemMessage({
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+                useBrowser: true,
+            },
+        }, spaceTrim$1(`
+                You have access to browser tools to fetch and access content from the internet.
+                - Use "fetch_url_content" to retrieve content from specific URLs (webpages or documents)
+                - Use "run_browser" for complex browser interactions (note: not yet active)
+                When you need to know information from a specific website or document, use the fetch_url_content tool.
+            `));
+    }
+    /**
+     * Gets the browser tool function implementations.
+     *
+     * This method automatically detects the environment and uses:
+     * - Server-side: Direct scraping via fetchUrlContent (Node.js)
+     * - Browser: Proxy through Agents Server API via fetchUrlContentViaBrowser
+     */
+    getToolFunctions() {
+        return {
+            /**
+             * @@@
+             *
+             * Note: [🛺] This function has implementation both for browser and node, this is the proxied one for browser
+             */
+            async fetch_url_content(args) {
+                console.log('!!!! [Tool] fetch_url_content called', { args });
+                const { url } = args;
+                return await fetchUrlContentViaBrowser(url);
+            },
+            /**
+             * @@@
+             */
+            async run_browser(args) {
+                console.log('!!!! [Tool] run_browser called', { args });
+                const { url } = args;
+                // This tool is prepared but not active yet
+                return spaceTrim$1(`
+                    # Running browser
+
+                    The running browser tool is not yet active.
+
+                    Requested URL: ${url}
+
+                    This feature will be implemented in a future update to support:
+                    - Complex browser interactions
+                    - Scrolling and navigation
+                    - Clicking and form filling
+                    - Taking screenshots
+
+                    For now, please use the "fetch_url_content" tool instead.
+                `);
+            },
         };
     }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * @@@
+ *
+ * @private utility for commitments
+ */
+function formatOptionalInstructionBlock(label, content) {
+    const trimmedContent = spaceTrim$1(content);
+    if (!trimmedContent) {
+        return '';
+    }
+    return spaceTrim$1((block) => `
+        - ${label}:
+            ${block(trimmedContent
+        .split('\n')
+        .map((line) => `- ${line}`)
+        .join('\n'))}
+    `);
+}
+
+/**
+ * USE EMAIL commitment definition
+ *
+ * The `USE EMAIL` commitment enables the agent to send emails.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE EMAIL
+ * USE EMAIL Write always formal and polite emails, always greet.
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseEmailCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE EMAIL', ['EMAIL', 'MAIL']);
+    }
+    get requiresContent() {
+        return false;
+    }
+    /**
+     * Short one-line description of USE EMAIL.
+     */
+    get description() {
+        return 'Enable the agent to send emails.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '📧';
+    }
+    /**
+     * Markdown documentation for USE EMAIL commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE EMAIL
+
+            Enables the agent to send emails through the email service.
+
+            ## Key aspects
+
+            - The agent can send emails to specified recipients.
+            - Supports multiple recipients, CC, subject, and markdown content.
+            - Emails are queued and sent through configured email providers.
+            - The content following \`USE EMAIL\` can provide additional instructions for email composition (e.g., style, tone, formatting preferences).
+
+            ## Examples
+
+            \`\`\`book
+            Email Assistant
+
+            PERSONA You are a helpful assistant who can send emails.
+            USE EMAIL
+            \`\`\`
+
+            \`\`\`book
+            Formal Email Assistant
+
+            PERSONA You help with professional communication.
+            USE EMAIL Write always formal and polite emails, always greet.
+            \`\`\`
+        `);
+    }
     applyToAgentModelRequirements(requirements, content) {
+        const extraInstructions = formatOptionalInstructionBlock('Email instructions', content);
         // Get existing tools array or create new one
         const existingTools = requirements.tools || [];
-        // Add 'web_browser' to tools if not already present
-        const updatedTools = existingTools.some((tool) => tool.name === 'web_browser')
+        // Add 'send_email' to tools if not already present
+        const updatedTools = existingTools.some((tool) => tool.name === 'send_email')
             ? existingTools
-            : ([
-                // TODO: [🔰] Use through proper MCP server
+            : [
                 ...existingTools,
                 {
-                    name: 'web_browser',
-                    description: spaceTrim$1(`
-                        A tool that can browse the web.
-                        Use this tool when you need to access specific websites or browse the internet.
-                    `),
+                    name: 'send_email',
+                    description: `Send an email to one or more recipients. ${!content ? '' : `Style instructions: ${content}`}`,
                     parameters: {
                         type: 'object',
                         properties: {
-                            url: {
+                            to: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Array of recipient email addresses (e.g., ["user@example.com", "Jane Doe <jane@example.com>"])',
+                            },
+                            cc: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Optional array of CC email addresses',
+                            },
+                            subject: {
                                 type: 'string',
-                                description: 'The URL to browse',
+                                description: 'Email subject line',
+                            },
+                            body: {
+                                type: 'string',
+                                description: 'Email body content in markdown format',
                             },
                         },
-                        required: ['url'],
+                        required: ['to', 'subject', 'body'],
                     },
                 },
-            ]);
+                // <- TODO: !!!! define the function in LLM tools
+            ];
         // Return requirements with updated tools and metadata
         return this.appendToSystemMessage({
             ...requirements,
             tools: updatedTools,
             metadata: {
                 ...requirements.metadata,
-                useBrowser: true,
+                useEmail: content || true,
             },
-        }, spaceTrim$1(`
-                You have access to the web browser. Use it to access specific websites or browse the internet.
-                When you need to know some information from a specific website, use the tool provided to you.
-            `));
+        }, spaceTrim$1((block) => `
+                    Email tool:
+                    - You have access to send emails via the tool "send_email".
+                    - Use it when you need to send emails to users or other recipients.
+                    - The email body should be written in markdown format.
+                    - Always ensure the email content is clear, professional, and appropriate.
+                    ${block(extraInstructions)}
+                `));
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            send_email: 'Send email',
+        };
+    }
+    /**
+     * Gets the `send_email` tool function implementation.
+     * Note: This is a placeholder - the actual implementation is provided by the agent server.
+     */
+    getToolFunctions() {
+        return {
+            async send_email(args) {
+                console.log('!!!! [Tool] send_email called', { args });
+                // This is a placeholder implementation
+                // The actual implementation should be provided by the agent server
+                throw new Error('send_email tool not implemented. This commitment requires integration with an email service.');
+            },
+        };
     }
 }
 /**
@@ -15866,25 +16037,6 @@ class SerpSearchEngine {
     }
 }
 
-/**
- * @@@
- *
- * @private utility for commitments
- */
-function formatOptionalInstructionBlock(label, content) {
-    const trimmedContent = spaceTrim$1(content);
-    if (!trimmedContent) {
-        return '';
-    }
-    return spaceTrim$1((block) => `
-        - ${label}:
-            ${block(trimmedContent
-        .split('\n')
-        .map((line) => `- ${line}`)
-        .join('\n'))}
-    `);
-}
-
 /**
  * USE SEARCH ENGINE commitment definition
  *
@@ -16253,151 +16405,991 @@ class NotYetImplementedCommitmentDefinition extends BaseCommitmentDefinition {
         return spaceTrim$1(`
             # ${this.type}
 
-            This commitment is not yet fully implemented.
+            This commitment is not yet fully implemented.
+
+            ## Key aspects
+
+            - Content is appended directly to the system message.
+            - No special processing or validation is performed.
+            - Behavior preserved until proper implementation is added.
+
+            ## Status
+
+            - **Status:** Placeholder implementation
+            - **Effect:** Appends content prefixed by commitment type
+            - **Future:** Will be replaced with specialized logic
+
+            ## Examples
+
+            \`\`\`book
+            Example Agent
+
+            PERSONA You are a helpful assistant
+            ${this.type} Your content here
+            RULE Always be helpful
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add the commitment content 1:1 to the system message
+        const commitmentLine = `${this.type} ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, commitmentLine, '\n\n');
+    }
+}
+
+/**
+ * Registry of all available commitment definitions
+ * This array contains instances of all commitment definitions
+ * This is the single source of truth for all commitments in the system
+ *
+ * @private Use functions to access commitments instead of this array directly
+ */
+const COMMITMENT_REGISTRY = [
+    // Fully implemented commitments
+    new PersonaCommitmentDefinition('PERSONA'),
+    new PersonaCommitmentDefinition('PERSONAE'),
+    new KnowledgeCommitmentDefinition(),
+    new MemoryCommitmentDefinition('MEMORY'),
+    new MemoryCommitmentDefinition('MEMORIES'),
+    new StyleCommitmentDefinition('STYLE'),
+    new StyleCommitmentDefinition('STYLES'),
+    new RuleCommitmentDefinition('RULES'),
+    new RuleCommitmentDefinition('RULE'),
+    new LanguageCommitmentDefinition('LANGUAGES'),
+    new LanguageCommitmentDefinition('LANGUAGE'),
+    new SampleCommitmentDefinition('SAMPLE'),
+    new SampleCommitmentDefinition('EXAMPLE'),
+    new FormatCommitmentDefinition('FORMAT'),
+    new FormatCommitmentDefinition('FORMATS'),
+    new TemplateCommitmentDefinition('TEMPLATE'),
+    new TemplateCommitmentDefinition('TEMPLATES'),
+    new FromCommitmentDefinition('FROM'),
+    new ImportCommitmentDefinition('IMPORT'),
+    new ImportCommitmentDefinition('IMPORTS'),
+    new ModelCommitmentDefinition('MODEL'),
+    new ModelCommitmentDefinition('MODELS'),
+    new ActionCommitmentDefinition('ACTION'),
+    new ActionCommitmentDefinition('ACTIONS'),
+    new ComponentCommitmentDefinition(),
+    new MetaImageCommitmentDefinition(),
+    new MetaColorCommitmentDefinition(),
+    new MetaFontCommitmentDefinition(),
+    new MetaLinkCommitmentDefinition(),
+    new MetaCommitmentDefinition(),
+    new NoteCommitmentDefinition('NOTE'),
+    new NoteCommitmentDefinition('NOTES'),
+    new NoteCommitmentDefinition('COMMENT'),
+    new NoteCommitmentDefinition('NONCE'),
+    new NoteCommitmentDefinition('TODO'),
+    new GoalCommitmentDefinition('GOAL'),
+    new GoalCommitmentDefinition('GOALS'),
+    new InitialMessageCommitmentDefinition(),
+    new UserMessageCommitmentDefinition(),
+    new AgentMessageCommitmentDefinition(),
+    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 UseTimeCommitmentDefinition(),
+    new UseEmailCommitmentDefinition(),
+    new UseImageGeneratorCommitmentDefinition('USE IMAGE GENERATOR'),
+    new UseImageGeneratorCommitmentDefinition('USE IMAGE GENERATION' /* <- TODO: Remove any */),
+    new UseImageGeneratorCommitmentDefinition('IMAGE GENERATOR' /* <- TODO: Remove any */),
+    new UseImageGeneratorCommitmentDefinition('IMAGE GENERATION' /* <- TODO: Remove any */),
+    new UseImageGeneratorCommitmentDefinition('USE IMAGE' /* <- TODO: Remove any */),
+    // <- Note: [⛹️] How to deal with commitment aliases with defined functions
+    new UseMcpCommitmentDefinition(),
+    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]);
+}
+
+/**
+ * Gets all function implementations provided by all commitments
+ *
+ * Note: This function is intended for browser use, there is also equivalent `getAllCommitmentsToolFunctionsForNode` for server use
+ *
+ * @public exported from `@promptbook/browser`
+ */
+function getAllCommitmentsToolFunctionsForBrowser() {
+    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;
+}
+
+/**
+ * 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.
+
+            `));
+    }
+    const allToolFunctionsInBrowser = getAllCommitmentsToolFunctionsForBrowser();
+    const allToolFunctionsInNode = {
+        /**
+         * @@@
+         *
+         * 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);
+        },
+        // TODO: !!!! Unhardcode, make proper server function register from definitions
+    };
+    return { ...allToolFunctionsInBrowser, ...allToolFunctionsInNode };
+}
+/**
+ * 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;
+    }
+}
+/**
+ * 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
+ */
+
+/**
+ * Provides filesystem access (for example for Node.js-based scrapers)
+ * Creates a standardized filesystem interface that scrapers can use for file operations.
+ *
+ * @public exported from `@promptbook/node`
+ */
+function $provideFilesystemForNode(options) {
+    if (!$isRunningInNode()) {
+        throw new EnvironmentMismatchError('Function `$provideFilesystemForNode` works only in Node.js environment');
+    }
+    return {
+        stat,
+        access,
+        constants,
+        readFile,
+        writeFile,
+        readdir,
+        mkdir,
+        watch,
+    };
+}
+/**
+ * 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
+ */
+
+/**
+ * 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
+ */
+
+/**
+ * Locates the LibreOffice executable on the current system by searching platform-specific paths.
+ * Returns the path to the executable if found, or null otherwise.
+ *
+ * @private within the repository
+ */
+function locateLibreoffice() {
+    return locateApp({
+        appName: 'Libreoffice',
+        linuxWhich: 'libreoffice',
+        windowsSuffix: '\\LibreOffice\\program\\soffice.exe',
+        macOsName: 'LibreOffice',
+    });
+}
+/**
+ * TODO: [🧠][♿] Maybe export through `@promptbook/node` OR `@promptbook/legacy-documents`
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ */
+
+/**
+ * Locates the Pandoc executable on the current system by searching platform-specific paths.
+ * Returns the path to the executable if found, or null otherwise.
+ *
+ * @private within the repository
+ */
+function locatePandoc() {
+    return locateApp({
+        appName: 'Pandoc',
+        linuxWhich: 'pandoc',
+        windowsSuffix: '\\Pandoc\\pandoc.exe',
+        macOsName: 'Pandoc',
+    });
+}
+/**
+ * TODO: [🧠][♿] Maybe export through `@promptbook/node` OR `@promptbook/documents`
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ */
+
+/**
+ * Provides paths to required executables (i.e. as Pandoc and LibreOffice) for Node.js environments.
+ *
+ * @public exported from `@promptbook/node`
+ */
+async function $provideExecutablesForNode(options) {
+    if (!$isRunningInNode()) {
+        throw new EnvironmentMismatchError('Function `$getScrapersForNode` works only in Node.js environment');
+    }
+    return {
+        pandocPath: (await locatePandoc()) || undefined,
+        libreOfficePath: (await locateLibreoffice()) || undefined,
+        //                                              <- TODO: [🧠] `null` vs `undefined`
+    };
+}
+/**
+ * TODO: [🧠] Allow to override the executables without need to call `locatePandoc` / `locateLibreoffice` in case of provided
+ * 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
+ */
+
+/**
+ * Register for LLM tools metadata.
+ *
+ * Note: `$` is used to indicate that this interacts with the global scope
+ * @singleton Only one instance of each register is created per build, but there can be more instances across different builds or environments.
+ * @public exported from `@promptbook/core`
+ */
+const $llmToolsMetadataRegister = new $Register('llm_tools_metadata');
+/**
+ * TODO: [®] DRY Register logic
+ */
+
+/**
+ * Register for LLM tools.
+ *
+ * Note: `$` is used to indicate that this interacts with the global scope
+ * @singleton Only one instance of each register is created per build, but there can be more instances across different builds or environments.
+ * @public exported from `@promptbook/core`
+ */
+const $llmToolsRegister = new $Register('llm_execution_tools_constructors');
+/**
+ * TODO: [®] DRY Register logic
+ */
+
+/**
+ * Path to the `.env` file which was used to configure LLM tools
+ *
+ * Note: `$` is used to indicate that this variable is changed by side effect in `$provideLlmToolsConfigurationFromEnv` through `$setUsedEnvFilename`
+ */
+let $usedEnvFilename = null;
+/**
+ * Pass the `.env` file which was used to configure LLM tools
+ *
+ * Note: `$` is used to indicate that this variable is making side effect
+ *
+ * @private internal log of `$provideLlmToolsConfigurationFromEnv` and `$registeredLlmToolsMessage`
+ */
+function $setUsedEnvFilename(filepath) {
+    $usedEnvFilename = filepath;
+}
+/**
+ * Creates a message with all registered LLM tools
+ *
+ * Note: This function is used to create a (error) message when there is no constructor for some LLM provider
+ *
+ * @private internal function of `createLlmToolsFromConfiguration` and `$provideLlmToolsFromEnv`
+ */
+function $registeredLlmToolsMessage() {
+    let env;
+    if ($isRunningInNode()) {
+        env = process.env;
+        // <- TODO: [⚛] Some DRY way how to get to `process.env` and pass it into functions - ACRY search for `env`
+    }
+    else {
+        env = {};
+    }
+    /**
+     * Mixes registered LLM tools from $llmToolsMetadataRegister and $llmToolsRegister
+     */
+    const all = [];
+    for (const { title, packageName, className, envVariables } of $llmToolsMetadataRegister.list()) {
+        if (all.some((item) => item.packageName === packageName && item.className === className)) {
+            continue;
+        }
+        all.push({ title, packageName, className, envVariables });
+    }
+    for (const { packageName, className } of $llmToolsRegister.list()) {
+        if (all.some((item) => item.packageName === packageName && item.className === className)) {
+            continue;
+        }
+        all.push({ packageName, className });
+    }
+    const metadata = all.map((metadata) => {
+        var _a, _b;
+        const isMetadataAviailable = $llmToolsMetadataRegister
+            .list()
+            .some(({ packageName, className }) => metadata.packageName === packageName && metadata.className === className);
+        const isInstalled = $llmToolsRegister
+            .list()
+            .some(({ packageName, className }) => metadata.packageName === packageName && metadata.className === className);
+        const isFullyConfigured = ((_a = metadata.envVariables) === null || _a === void 0 ? void 0 : _a.every((envVariableName) => env[envVariableName] !== undefined)) || false;
+        const isPartiallyConfigured = ((_b = metadata.envVariables) === null || _b === void 0 ? void 0 : _b.some((envVariableName) => env[envVariableName] !== undefined)) || false;
+        // <- Note: [🗨]
+        return { ...metadata, isMetadataAviailable, isInstalled, isFullyConfigured, isPartiallyConfigured };
+    });
+    const usedEnvMessage = $usedEnvFilename === null ? `Unknown \`.env\` file` : `Used \`.env\` file:\n${$usedEnvFilename}`;
+    if (metadata.length === 0) {
+        return spaceTrim$2((block) => `
+                No LLM providers are available.
+
+                ${block(usedEnvMessage)}
+          `);
+    }
+    return spaceTrim$2((block) => `
+
+            ${block(usedEnvMessage)}
+
+            Relevant environment variables:
+            ${block(Object.keys(env)
+        .filter((envVariableName) => metadata.some(({ envVariables }) => envVariables === null || envVariables === void 0 ? void 0 : envVariables.includes(envVariableName)))
+        .map((envVariableName) => `- \`${envVariableName}\``)
+        .join('\n'))}
+
+            Available LLM providers are:
+            ${block(metadata
+        .map(({ title, packageName, className, envVariables, isMetadataAviailable, isInstalled, isFullyConfigured, isPartiallyConfigured, }, i) => {
+        const morePieces = [];
+        if (just(false)) ;
+        else if (!isMetadataAviailable && !isInstalled) {
+            // TODO: [�][�] Maybe do allow to do auto-install if package not registered and not found
+            morePieces.push(`Not installed and no metadata, looks like a unexpected behavior`);
+        }
+        else if (isMetadataAviailable && !isInstalled) {
+            // TODO: [�][�]
+            morePieces.push(`Not installed`);
+        }
+        else if (!isMetadataAviailable && isInstalled) {
+            morePieces.push(`No metadata but installed, looks like a unexpected behavior`);
+        }
+        else if (isMetadataAviailable && isInstalled) {
+            morePieces.push(`Installed`);
+        }
+        else {
+            morePieces.push(`unknown state, looks like a unexpected behavior`);
+        } /* not else */
+        if (isFullyConfigured) {
+            morePieces.push(`Configured`);
+        }
+        else if (isPartiallyConfigured) {
+            morePieces.push(`Partially confugured, missing ${envVariables === null || envVariables === void 0 ? void 0 : envVariables.filter((envVariable) => env[envVariable] === undefined).join(' + ')}`);
+        }
+        else {
+            if (envVariables !== null) {
+                morePieces.push(`Not configured, to configure set env ${envVariables === null || envVariables === void 0 ? void 0 : envVariables.join(' + ')}`);
+            }
+            else {
+                morePieces.push(`Not configured`); // <- Note: Can not be configured via environment variables
+            }
+        }
+        let providerMessage = spaceTrim$2(`
+                                ${i + 1}) **${title}** \`${className}\` from \`${packageName}\`
+                                    ${morePieces.join('; ')}
+                            `);
+        if ($isRunningInNode()) {
+            if (isInstalled && isFullyConfigured) {
+                providerMessage = colors.green(providerMessage);
+            }
+            else if (isInstalled && isPartiallyConfigured) {
+                providerMessage = colors.yellow(providerMessage);
+            }
+            else {
+                providerMessage = colors.gray(providerMessage);
+            }
+        }
+        return providerMessage;
+    })
+        .join('\n'))}
+        `);
+}
+/**
+ * TODO: [®] DRY Register logic
+ * TODO: [🧠][⚛] Maybe pass env as argument
+ */
+
+/**
+ * Provides the path to the `.env` file
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+ *
+ * @private within the repository - for CLI utils
+ */
+async function $provideEnvFilename() {
+    if (!$isRunningInNode()) {
+        throw new EnvironmentMismatchError('Function `$provideEnvFilename` works only in Node.js environment');
+    }
+    const envFilePatterns = [
+        '.env',
+        '.env.test',
+        '.env.local',
+        '.env.development.local',
+        '.env.development',
+        '.env.production.local',
+        '.env.production',
+        '.env.prod.local',
+        '.env.prod',
+        // <- TODO: Maybe add more patterns
+    ];
+    let rootDirname = process.cwd();
+    up_to_root: for (let i = 0; i < LOOP_LIMIT; i++) {
+        for (const pattern of envFilePatterns) {
+            const envFilename = join(rootDirname, pattern);
+            if (await isFileExisting(envFilename, $provideFilesystemForNode())) {
+                $setUsedEnvFilename(envFilename);
+                return envFilename;
+            }
+        }
+        if (isRootPath(rootDirname)) {
+            break up_to_root;
+        }
+        // Note: If the directory does not exist, try the parent directory
+        rootDirname = join(rootDirname, '..');
+    }
+    return null;
+}
+/**
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ */
+
+/**
+ * Provides LLM tools configuration by reading environment variables.
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+ *
+ * It looks for environment variables:
+ * - `process.env.OPENAI_API_KEY`
+ * - `process.env.ANTHROPIC_CLAUDE_API_KEY`
+ * - ...
+ *
+ * @see Environment variables documentation or .env file for required variables.
+ * @returns A promise that resolves to the LLM tools configuration, or null if configuration is incomplete or missing.
+ * @public exported from `@promptbook/node`
+ */
+async function $provideLlmToolsConfigurationFromEnv() {
+    if (!$isRunningInNode()) {
+        throw new EnvironmentMismatchError('Function `$provideLlmToolsFromEnv` works only in Node.js environment');
+    }
+    const envFilepath = await $provideEnvFilename();
+    if (envFilepath !== null) {
+        dotenv.config({ path: envFilepath });
+    }
+    const llmToolsConfiguration = $llmToolsMetadataRegister
+        .list()
+        .map((metadata) => metadata.createConfigurationFromEnv(process.env))
+        .filter((configuration) => configuration !== null);
+    return llmToolsConfiguration;
+}
+/**
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ */
+
+/**
+ * Creates LLM execution tools from provided configuration objects
+ *
+ * Instantiates and configures LLM tool instances for each configuration entry,
+ * combining them into a unified interface via MultipleLlmExecutionTools.
+ *
+ * Note: This function is not cached, every call creates new instance of `MultipleLlmExecutionTools`
+ *
+ * @param configuration Array of LLM tool configurations to instantiate
+ * @param options Additional options for configuring the LLM tools
+ * @returns A unified interface combining all successfully instantiated LLM tools
+ * @public exported from `@promptbook/core`
+ */
+function createLlmToolsFromConfiguration(configuration, options = {}) {
+    const { title = 'LLM Tools from Configuration', isVerbose = DEFAULT_IS_VERBOSE, userId } = options;
+    const llmTools = configuration.map((llmConfiguration) => {
+        const registeredItem = $llmToolsRegister
+            .list()
+            .find(({ packageName, className }) => llmConfiguration.packageName === packageName && llmConfiguration.className === className);
+        if (registeredItem === undefined) {
+            // console.log('$llmToolsRegister.list()', $llmToolsRegister.list());
+            throw new Error(spaceTrim$2((block) => `
+                        There is no constructor for LLM provider \`${llmConfiguration.className}\` from \`${llmConfiguration.packageName}\`
+                        Running in ${!$isRunningInBrowser() ? '' : 'browser environment'}${!$isRunningInNode() ? '' : 'node environment'}${!$isRunningInWebWorker() ? '' : 'worker environment'}
 
-            ## Key aspects
+                        You have probably forgotten install and import the provider package.
+                        To fix this issue, you can:
 
-            - Content is appended directly to the system message.
-            - No special processing or validation is performed.
-            - Behavior preserved until proper implementation is added.
+                        Install:
 
-            ## Status
+                        > npm install ${llmConfiguration.packageName}
 
-            - **Status:** Placeholder implementation
-            - **Effect:** Appends content prefixed by commitment type
-            - **Future:** Will be replaced with specialized logic
+                        And import:
 
-            ## Examples
+                        > import '${llmConfiguration.packageName}';
 
-            \`\`\`book
-            Example Agent
 
-            PERSONA You are a helpful assistant
-            ${this.type} Your content here
-            RULE Always be helpful
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, content) {
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
-            return requirements;
+                        ${block($registeredLlmToolsMessage())}
+                    `));
         }
-        // Add the commitment content 1:1 to the system message
-        const commitmentLine = `${this.type} ${trimmedContent}`;
-        return this.appendToSystemMessage(requirements, commitmentLine, '\n\n');
-    }
+        return registeredItem({
+            isVerbose,
+            userId,
+            ...llmConfiguration.options,
+        });
+    });
+    return joinLlmExecutionTools(title, ...llmTools);
 }
-
 /**
- * Registry of all available commitment definitions
- * This array contains instances of all commitment definitions
- * This is the single source of truth for all commitments in the system
- *
- * @private Use functions to access commitments instead of this array directly
+ * TODO: [🎌] Together with `createLlmToolsFromConfiguration` + 'EXECUTION_TOOLS_CLASSES' gets to `@promptbook/core` ALL model providers, make this more efficient
+ * TODO: [🧠][🎌] Dynamically install required providers
+ * TODO: We should implement an interactive configuration wizard that would:
+ *       1. Detect which LLM providers are available in the environment
+ *       2. Guide users through required configuration settings for each provider
+ *       3. Allow testing connections before completing setup
+ *       4. Generate appropriate configuration code for application integration
+ * TODO: [🧠][🍛] Which name is better `createLlmToolsFromConfig` or `createLlmToolsFromConfiguration`?
+ * TODO: [🧠] Is there some meaningfull way how to test this util
+ * TODO: This should be maybe not under `_common` but under `utils`
+ * TODO: [®] DRY Register logic
  */
-const COMMITMENT_REGISTRY = [
-    // Fully implemented commitments
-    new PersonaCommitmentDefinition('PERSONA'),
-    new PersonaCommitmentDefinition('PERSONAE'),
-    new KnowledgeCommitmentDefinition(),
-    new MemoryCommitmentDefinition('MEMORY'),
-    new MemoryCommitmentDefinition('MEMORIES'),
-    new StyleCommitmentDefinition('STYLE'),
-    new StyleCommitmentDefinition('STYLES'),
-    new RuleCommitmentDefinition('RULES'),
-    new RuleCommitmentDefinition('RULE'),
-    new LanguageCommitmentDefinition('LANGUAGES'),
-    new LanguageCommitmentDefinition('LANGUAGE'),
-    new SampleCommitmentDefinition('SAMPLE'),
-    new SampleCommitmentDefinition('EXAMPLE'),
-    new FormatCommitmentDefinition('FORMAT'),
-    new FormatCommitmentDefinition('FORMATS'),
-    new FromCommitmentDefinition('FROM'),
-    new ImportCommitmentDefinition('IMPORT'),
-    new ImportCommitmentDefinition('IMPORTS'),
-    new ModelCommitmentDefinition('MODEL'),
-    new ModelCommitmentDefinition('MODELS'),
-    new ActionCommitmentDefinition('ACTION'),
-    new ActionCommitmentDefinition('ACTIONS'),
-    new ComponentCommitmentDefinition(),
-    new MetaImageCommitmentDefinition(),
-    new MetaColorCommitmentDefinition(),
-    new MetaFontCommitmentDefinition(),
-    new MetaLinkCommitmentDefinition(),
-    new MetaCommitmentDefinition(),
-    new NoteCommitmentDefinition('NOTE'),
-    new NoteCommitmentDefinition('NOTES'),
-    new NoteCommitmentDefinition('COMMENT'),
-    new NoteCommitmentDefinition('NONCE'),
-    new NoteCommitmentDefinition('TODO'),
-    new GoalCommitmentDefinition('GOAL'),
-    new GoalCommitmentDefinition('GOALS'),
-    new InitialMessageCommitmentDefinition(),
-    new UserMessageCommitmentDefinition(),
-    new AgentMessageCommitmentDefinition(),
-    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 UseTimeCommitmentDefinition(),
-    new UseImageGeneratorCommitmentDefinition('USE IMAGE GENERATOR'),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new UseImageGeneratorCommitmentDefinition('USE IMAGE GENERATION'),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new UseImageGeneratorCommitmentDefinition('IMAGE GENERATOR'),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new UseImageGeneratorCommitmentDefinition('IMAGE GENERATION'),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new UseImageGeneratorCommitmentDefinition('USE IMAGE'),
-    new UseMcpCommitmentDefinition(),
-    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
-];
+
 /**
- * Gets all available commitment definitions
- * @returns Array of all commitment definitions
+ * Automatically configures LLM tools from environment variables in Node.js
  *
- * @public exported from `@promptbook/core`
+ * This utility function detects available LLM providers based on environment variables
+ * and creates properly configured LLM execution tools for each detected provider.
+ *
+ * Note: This function is not cached, every call creates new instance of `MultipleLlmExecutionTools`
+ *
+ * Supports environment variables from .env files when dotenv is configured
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+ *
+ * It looks for environment variables:
+ * - `process.env.OPENAI_API_KEY`
+ * - `process.env.ANTHROPIC_CLAUDE_API_KEY`
+ * - ...
+ *
+ * @param options Configuration options for the LLM tools
+ * @returns A unified interface containing all detected and configured LLM tools
+ * @public exported from `@promptbook/node`
  */
-function getAllCommitmentDefinitions() {
-    return $deepFreeze([...COMMITMENT_REGISTRY]);
+async function $provideLlmToolsFromEnv(options = {}) {
+    if (!$isRunningInNode()) {
+        throw new EnvironmentMismatchError('Function `$provideLlmToolsFromEnv` works only in Node.js environment');
+    }
+    const configuration = await $provideLlmToolsConfigurationFromEnv();
+    if (configuration.length === 0) {
+        if ($llmToolsMetadataRegister.list().length === 0) {
+            throw new UnexpectedError(spaceTrim$2((block) => `
+                        No LLM tools registered, this is probably a bug in the Promptbook library
+
+                        ${block($registeredLlmToolsMessage())}}
+                    `));
+        }
+        // TODO: [🥃]
+        throw new Error(spaceTrim$2((block) => `
+                    No LLM tools found in the environment
+
+                    ${block($registeredLlmToolsMessage())}}
+                `));
+    }
+    return createLlmToolsFromConfiguration(configuration, options);
 }
 /**
- * Gets all function implementations provided by all commitments
+ * TODO: The architecture for LLM tools configuration consists of three key functions:
+ * 1. `$provideLlmToolsFromEnv` - High-level function that detects available providers from env vars and returns ready-to-use LLM tools
+ * 2. `$provideLlmToolsConfigurationFromEnv` - Middle layer that extracts configuration objects from environment variables
+ * 3. `createLlmToolsFromConfiguration` - Low-level function that instantiates LLM tools from explicit configuration
  *
- * @public exported from `@promptbook/core`
+ * This layered approach allows flexibility in how tools are configured:
+ * - Use $provideLlmToolsFromEnv for automatic detection and setup in Node.js environments
+ * - Use $provideLlmToolsConfigurationFromEnv to extract config objects for modification before instantiation
+ * - Use createLlmToolsFromConfiguration for explicit control over tool configurations
+ *
+ * TODO: [🧠][🍛] Which name is better `$provideLlmToolsFromEnv` or `$provideLlmToolsFromEnvironment`?
+ * TODO: [🧠] Is there some meaningfull way how to test this util
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ * TODO: [🥃] Allow `ptbk make` without llm tools
+ * TODO: This should be maybe not under `_common` but under `utils`
+ * TODO: [®] DRY Register logic
  */
-function getAllCommitmentsToolFunctions() {
-    const allToolFunctions = {};
-    for (const commitmentDefinition of getAllCommitmentDefinitions()) {
-        const toolFunctions = commitmentDefinition.getToolFunctions();
-        for (const [funcName, funcImpl] of Object.entries(toolFunctions)) {
-            allToolFunctions[funcName] = funcImpl;
+
+/**
+ * Provides a collection of scrapers optimized for Node.js environment.
+ * 1) `provideScrapersForNode` use as default
+ * 2) `provideScrapersForBrowser` use in limited browser environment *
+ * @public exported from `@promptbook/node`
+ */
+async function $provideScrapersForNode(tools, options) {
+    if (!$isRunningInNode()) {
+        throw new EnvironmentMismatchError('Function `$getScrapersForNode` works only in Node.js environment');
+    }
+    // TODO: [🔱] Do here auto-installation + auto-include of missing scrapers - use all from $scrapersMetadataRegister.list()
+    // TODO: [🔱][🧠] What is the best strategy for auto-install - install them all?
+    const scrapers = [];
+    for (const scraperFactory of $scrapersRegister.list()) {
+        const scraper = await scraperFactory(tools, options || {});
+        if (scraper.metadata.packageName === '@promptbook/boilerplate' ||
+            scraper.metadata.mimeTypes.some((mimeType) => mimeType.includes('DISABLED'))) {
+            continue;
         }
+        scrapers.push(scraper);
     }
-    return allToolFunctions;
+    return scrapers;
 }
 /**
- * TODO: [🧠] Maybe create through standardized $register
- * Note: [💞] Ignore a discrepancy between file name and entity name
+ * 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
  */
 
 /**
@@ -16580,13 +17572,6 @@ class JavascriptEvalExecutionTools {
         `const ${functionName} = buildinFunctions.${functionName};`)
             .join('\n');
         // TODO: DRY [🍯]
-        const commitmentsFunctions = getAllCommitmentsToolFunctions();
-        const commitmentsFunctionsStatement = Object.keys(commitmentsFunctions)
-            .map((functionName) => 
-        // Note: Custom functions are exposed to the current scope as variables
-        `const ${functionName} = commitmentsFunctions.${functionName};`)
-            .join('\n');
-        // TODO: DRY [🍯]
         const customFunctions = this.options.functions || {};
         const customFunctionsStatement = Object.keys(customFunctions)
             .map((functionName) => 
@@ -16600,10 +17585,6 @@ class JavascriptEvalExecutionTools {
                 // Build-in functions:
                 ${block(buildinFunctionsStatement)}
 
-                // Commitments functions:
-                ${block(commitmentsFunctionsStatement)}
-
-
                 // Custom functions:
                 ${block(customFunctionsStatement || '// -- No custom functions --')}
 
@@ -16710,12 +17691,18 @@ async function $provideExecutionToolsForNode(options) {
         fs,
         executables,
         scrapers: await $provideScrapersForNode({ fs, llm, executables }, options),
-        script: [new JavascriptExecutionTools(options)],
+        script: [
+            new JavascriptExecutionTools({
+                ...options,
+                functions: { ...getAllCommitmentsToolFunctionsForNode() },
+            }),
+        ],
     };
     return tools;
 }
 /**
  * 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
  */
 
 /**
@@ -17037,10 +18024,11 @@ async function $provideScriptingForNode(options) {
         throw new EnvironmentMismatchError('Function `$provideScriptingForNode` works only in Node.js environment');
     }
     // TODO: [🔱] Do here auto-installation
-    return [new JavascriptExecutionTools(options)];
+    return [new JavascriptExecutionTools({ ...options, functions: { ...getAllCommitmentsToolFunctionsForNode() } })];
 }
 /**
  * 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
  */
 
 /**
@@ -17188,5 +18176,5 @@ async function $execCommands({ commands, cwd, crashOnError, }) {
  * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */
 
-export { $execCommand, $execCommands, $provideExecutablesForNode, $provideExecutionToolsForNode, $provideFilesystemForNode, $provideLlmToolsConfigurationFromEnv, $provideLlmToolsFromEnv, $provideScrapersForNode, $provideScriptingForNode, BOOK_LANGUAGE_VERSION, FileCacheStorage, PROMPTBOOK_ENGINE_VERSION, createPipelineCollectionFromDirectory };
+export { $execCommand, $execCommands, $provideExecutablesForNode, $provideExecutionToolsForNode, $provideFilesystemForNode, $provideLlmToolsConfigurationFromEnv, $provideLlmToolsFromEnv, $provideScrapersForNode, $provideScriptingForNode, BOOK_LANGUAGE_VERSION, FileCacheStorage, PROMPTBOOK_ENGINE_VERSION, createPipelineCollectionFromDirectory, getAllCommitmentsToolFunctionsForNode };
 //# sourceMappingURL=index.es.js.map