@promptbook/core 0.105.0-0 → 0.105.0-10

package/esm/index.es.js

@@ -27,7 +27,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-0';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.0-10';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -992,6 +992,7 @@ const PROMPTBOOK_SYNTAX_COLORS = {
     SEPARATOR: Color.fromHex('#cccccc'),
     COMMITMENT: Color.fromHex('#DA0F78'),
     PARAMETER: Color.fromHex('#8e44ad'),
+    CODE_BLOCK: Color.fromHex('#7700ffff'),
 };
 // <- TODO: [🧠][🈵] Using `Color` here increases the package size approx 3kb, maybe remove it
 /**
@@ -3649,74 +3650,90 @@ function addUsage(...usageItems) {
  * in real-time through an observable.
  *
  * @param llmTools - The LLM tools to be intercepted and tracked
- * @returns An augmented version of the tools that includes usage tracking capabilities
+ * @returns Full proxy of the tools with added usage tracking capabilities
  * @public exported from `@promptbook/core`
  */
 function countUsage(llmTools) {
     let totalUsage = ZERO_USAGE;
     const spending = new Subject();
-    const proxyTools = {
-        get title() {
-            return `${llmTools.title} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        get description() {
-            return `${llmTools.description} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        checkConfiguration() {
-            return /* not await */ llmTools.checkConfiguration();
-        },
-        listModels() {
-            return /* not await */ llmTools.listModels();
-        },
-        spending() {
-            return spending.asObservable();
-        },
-        getTotalUsage() {
-            // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
-            return totalUsage;
+    // Create a Proxy to intercept all property access and ensure full proxying of all properties
+    const proxyTools = new Proxy(llmTools, {
+        get(target, prop, receiver) {
+            // Handle title property
+            if (prop === 'title') {
+                return `${target.title} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle description property
+            if (prop === 'description') {
+                return `${target.description} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle spending method (new method added by this wrapper)
+            if (prop === 'spending') {
+                return () => {
+                    return spending.asObservable();
+                };
+            }
+            // Handle getTotalUsage method (new method added by this wrapper)
+            if (prop === 'getTotalUsage') {
+                // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
+                return () => {
+                    return totalUsage;
+                };
+            }
+            // Handle callChatModel method with usage counting
+            if (prop === 'callChatModel' && target.callChatModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callChatModel through countTotalUsage');
+                    const promptResult = await target.callChatModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callCompletionModel method with usage counting
+            if (prop === 'callCompletionModel' && target.callCompletionModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callCompletionModel through countTotalUsage');
+                    const promptResult = await target.callCompletionModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callEmbeddingModel method with usage counting
+            if (prop === 'callEmbeddingModel' && target.callEmbeddingModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callEmbeddingModel through countTotalUsage');
+                    const promptResult = await target.callEmbeddingModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callImageGenerationModel method with usage counting
+            if (prop === 'callImageGenerationModel' && target.callImageGenerationModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callImageGenerationModel through countTotalUsage');
+                    const promptResult = await target.callImageGenerationModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // <- Note: [🤖]
+            // For all other properties and methods, delegate to the original target
+            const value = Reflect.get(target, prop, receiver);
+            // If it's a function, bind it to the target to preserve context
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
         },
-    };
-    if (llmTools.callChatModel !== undefined) {
-        proxyTools.callChatModel = async (prompt) => {
-            // console.info('[🚕] callChatModel through countTotalUsage');
-            const promptResult = await llmTools.callChatModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callCompletionModel !== undefined) {
-        proxyTools.callCompletionModel = async (prompt) => {
-            // console.info('[🚕] callCompletionModel through countTotalUsage');
-            const promptResult = await llmTools.callCompletionModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callEmbeddingModel !== undefined) {
-        proxyTools.callEmbeddingModel = async (prompt) => {
-            // console.info('[🚕] callEmbeddingModel through countTotalUsage');
-            const promptResult = await llmTools.callEmbeddingModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callImageGenerationModel !== undefined) {
-        proxyTools.callImageGenerationModel = async (prompt) => {
-            // console.info('[🚕] callImageGenerationModel through countTotalUsage');
-            const promptResult = await llmTools.callImageGenerationModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    // <- Note: [🤖]
+    });
     return proxyTools;
 }
 /**
@@ -7494,6 +7511,40 @@ async function preparePersona(personaDescription, tools, options) {
  * TODO: [🏢] Check validity of `temperature` in pipeline
  */
 
+/**
+ * Creates an empty/basic agent model requirements object
+ * This serves as the starting point for the reduce-like pattern
+ * where each commitment applies its changes to build the final requirements
+ *
+ * @public exported from `@promptbook/core`
+ */
+function createEmptyAgentModelRequirements() {
+    return {
+        systemMessage: '',
+        // modelName: 'gpt-5',
+        modelName: 'gemini-2.5-flash-lite',
+        temperature: 0.7,
+        topP: 0.9,
+        topK: 50,
+    };
+}
+/**
+ * Creates a basic agent model requirements with just the agent name
+ * This is used when we have an agent name but no commitments
+ *
+ * @public exported from `@promptbook/core`
+ */
+function createBasicAgentModelRequirements(agentName) {
+    const empty = createEmptyAgentModelRequirements();
+    return {
+        ...empty,
+        systemMessage: `You are ${agentName || 'AI Agent'}`,
+    };
+}
+/**
+ * TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
+ */
+
 /**
  * Generates a regex pattern to match a specific commitment
  *
@@ -7610,6 +7661,22 @@ class BaseCommitmentDefinition {
             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 {};
+    }
 }
 
 /**
@@ -8466,6 +8533,698 @@ function $getCurrentDate() {
     return new Date().toISOString();
 }
 
+/**
+ * Creates human-readable hash
+ *
+ * @public exported from `@promptbook/utils`
+ */
+async function linguisticHash(input) {
+    const hash = computeHash(input);
+    // Use parts of the hash to select words
+    // SHA256 is 64 hex characters
+    // We use different slices of the hash to ensure variety even with small changes in input
+    const part1 = parseInt(hash.substring(0, 10), 16);
+    const part2 = parseInt(hash.substring(10, 20), 16);
+    const part3 = parseInt(hash.substring(20, 30), 16);
+    const adjective = ADJECTIVES[part1 % ADJECTIVES.length];
+    const noun = NOUNS[part2 % NOUNS.length];
+    const verb = VERBS[part3 % VERBS.length];
+    return `${capitalize(adjective)} ${noun.toLowerCase()} ${verb.toLowerCase()}`;
+}
+const ADJECTIVES = [
+    'red',
+    'blue',
+    'green',
+    'yellow',
+    'quick',
+    'slow',
+    'bright',
+    'dark',
+    'happy',
+    'sad',
+    'brave',
+    'calm',
+    'clever',
+    'eager',
+    'fancy',
+    'grand',
+    'jolly',
+    'kind',
+    'lucky',
+    'nice',
+    'proud',
+    'silly',
+    'wise',
+    'young',
+    'old',
+    'big',
+    'small',
+    'fast',
+    'shiny',
+    'wild',
+    'silent',
+    'loud',
+    'soft',
+    'hard',
+    'warm',
+    'cold',
+    'sweet',
+    'sour',
+    'bitter',
+    'salty',
+    'rich',
+    'poor',
+    'heavy',
+    'light',
+    'strong',
+    'weak',
+    'smooth',
+    'rough',
+    'clean',
+    'dirty',
+    'fresh',
+    'stale',
+    'sharp',
+    'blunt',
+    'thick',
+    'thin',
+    'wide',
+    'narrow',
+    'deep',
+    'shallow',
+    'mighty',
+    'gentle',
+    'fierce',
+    'vibrant',
+    'dusty',
+    'golden',
+    'silver',
+    'frozen',
+    'burning',
+    'ancient',
+    'modern',
+    'hidden',
+    'lost',
+    'found',
+    'magic',
+    'mystic',
+    'cosmic',
+    'stellar',
+    'lunar',
+    'solar',
+    'misty',
+    'foggy',
+    'stormy',
+    'sunny',
+    'windy',
+    'quiet',
+    'noisy',
+    'peaceful',
+    'busy',
+    'empty',
+    'full',
+    'round',
+    'square',
+    'flat',
+    'curved',
+    'tiny',
+    'huge',
+    'giant',
+    'little',
+    'short',
+    'long',
+    'near',
+    'distant',
+    'inner',
+    'outer',
+    'patient',
+    'steady',
+    'noble',
+    'pure',
+    'graceful',
+    'honest',
+    'simple',
+    'complex',
+    'active',
+    'passive',
+    'vivid',
+    'pale',
+    'loyal',
+    'true',
+    'false',
+    'fair',
+    'clear',
+    'murky',
+    'vast',
+    'slick',
+    'slippery',
+    'sticky',
+    'dull',
+    'keen',
+    'broad',
+    'slim',
+    'slender',
+    'fat',
+    'lean',
+    'stiff',
+    'flexible',
+    'rigid',
+    'elastic',
+    'tough',
+    'brittle',
+    'fragile',
+    'solid',
+    'liquid',
+    'gaseous',
+    'airy',
+    'weighty',
+    'buoyant',
+    'dense',
+    'sparse',
+    'hollow',
+    'stuffed',
+    'crowded',
+    'lonely',
+    'social',
+    'private',
+    'public',
+    'secret',
+    'famous',
+    'certain',
+    'vague',
+    'plain',
+    'easy',
+    'tame',
+    'mild',
+    'hot',
+    'cool',
+    'dry',
+    'wet',
+    'damp',
+    'moist',
+    'soaked',
+    'parched',
+    'hungry',
+    'thirsty',
+    'sleepy',
+    'awake',
+    'tired',
+    'lazy',
+    'idle',
+    'swift',
+    'rapid',
+    'unstable',
+    'shaky',
+    'firm',
+    'bold',
+    'timid',
+    'brave',
+    'cowardly',
+    'smart',
+    'dumb',
+    'foolish',
+    'mean',
+    'rude',
+    'tasty',
+    'bland',
+    'arctic',
+    'tropical',
+    'deserted',
+    'urban',
+    'rural',
+    'local',
+    'global',
+    'digital',
+    'analog',
+    'virtual',
+    'real',
+    'fake',
+    'natural',
+    'artificial',
+    'living',
+    'dead',
+    'broken',
+    'fixed',
+    'new',
+    'worn',
+    'neat',
+    'messy',
+    'brave',
+    'fearful',
+    'proud',
+    'humble',
+    'greedy',
+    'generous',
+    'calm',
+    'angry',
+    'happy',
+    'sad',
+    'excited',
+    'bored',
+    'strange',
+    'normal',
+    'odd',
+    'even',
+    'rare',
+    'common',
+    'unique',
+    'plain',
+    'fancy',
+    'basic',
+    'prime',
+    'super',
+    'mega',
+    'ultra',
+    'micro',
+    'nano',
+    'macro',
+    'mini',
+];
+const NOUNS = [
+    'apple',
+    'sky',
+    'tree',
+    'fox',
+    'cat',
+    'bird',
+    'dog',
+    'river',
+    'mountain',
+    'forest',
+    'ocean',
+    'star',
+    'moon',
+    'sun',
+    'cloud',
+    'flower',
+    'leaf',
+    'stone',
+    'wind',
+    'rain',
+    'fire',
+    'ice',
+    'book',
+    'dream',
+    'song',
+    'road',
+    'gate',
+    'key',
+    'lamp',
+    'map',
+    'house',
+    'city',
+    'bridge',
+    'field',
+    'garden',
+    'lake',
+    'beach',
+    'island',
+    'valley',
+    'desert',
+    'world',
+    'spirit',
+    'heart',
+    'mind',
+    'soul',
+    'life',
+    'time',
+    'space',
+    'light',
+    'shadow',
+    'sound',
+    'music',
+    'voice',
+    'word',
+    'page',
+    'story',
+    'pearl',
+    'gold',
+    'silver',
+    'crystal',
+    'diamond',
+    'emerald',
+    'ruby',
+    'path',
+    'trail',
+    'peak',
+    'shore',
+    'wave',
+    'tide',
+    'flame',
+    'spark',
+    'beam',
+    'ray',
+    'seed',
+    'root',
+    'branch',
+    'bloom',
+    'thorn',
+    'bark',
+    'shell',
+    'feather',
+    'wing',
+    'claw',
+    'paw',
+    'nest',
+    'cave',
+    'grove',
+    'tower',
+    'castle',
+    'crown',
+    'sword',
+    'shield',
+    'coin',
+    'gem',
+    'ring',
+    'bell',
+    'clock',
+    'compass',
+    'anchor',
+    'torch',
+    'flute',
+    'harp',
+    'drum',
+    'lens',
+    'glass',
+    'sand',
+    'dust',
+    'mist',
+    'dew',
+    'dawn',
+    'dusk',
+    'night',
+    'day',
+    'year',
+    'age',
+    'bolt',
+    'drop',
+    'storm',
+    'snow',
+    'hail',
+    'fog',
+    'smoke',
+    'vapor',
+    'gas',
+    'fluid',
+    'liquid',
+    'solid',
+    'metal',
+    'rock',
+    'dirt',
+    'clay',
+    'sand',
+    'salt',
+    'sugar',
+    'wood',
+    'bone',
+    'skin',
+    'flesh',
+    'blood',
+    'cell',
+    'atom',
+    'pulse',
+    'beat',
+    'breath',
+    'sigh',
+    'name',
+    'echo',
+    'image',
+    'vision',
+    'thought',
+    'idea',
+    'plan',
+    'goal',
+    'wish',
+    'hope',
+    'fear',
+    'joy',
+    'love',
+    'hate',
+    'will',
+    'power',
+    'force',
+    'energy',
+    'motion',
+    'speed',
+    'place',
+    'point',
+    'line',
+    'shape',
+    'form',
+    'size',
+    'mass',
+    'weight',
+    'heat',
+    'cold',
+    'color',
+    'tone',
+    'pitch',
+    'rhythm',
+    'vibe',
+    'mood',
+    'state',
+    'way',
+    'step',
+    'move',
+    'turn',
+    'fall',
+    'rise',
+    'jump',
+    'leap',
+    'run',
+    'walk',
+    'rest',
+    'stay',
+    'trip',
+    'quest',
+    'task',
+    'work',
+    'job',
+    'play',
+    'game',
+    'sport',
+    'art',
+    'craft',
+    'tool',
+    'ship',
+    'boat',
+    'car',
+    'bike',
+    'train',
+    'plane',
+    'hub',
+    'base',
+    'core',
+    'node',
+    'link',
+    'net',
+    'web',
+    'box',
+    'bag',
+    'jar',
+    'cup',
+    'bowl',
+    'plate',
+    'dish',
+    'spoon',
+    'fork',
+    'knife',
+    'pan',
+    'pot',
+    'bed',
+    'desk',
+    'chair',
+    'door',
+    'wall',
+    'roof',
+    'floor',
+];
+const VERBS = [
+    'jumping',
+    'dancing',
+    'flying',
+    'running',
+    'singing',
+    'shining',
+    'growing',
+    'flowing',
+    'falling',
+    'rising',
+    'sleeping',
+    'walking',
+    'talking',
+    'thinking',
+    'dreaming',
+    'looking',
+    'feeling',
+    'smiling',
+    'laughing',
+    'playing',
+    'working',
+    'resting',
+    'moving',
+    'staying',
+    'beaming',
+    'glowing',
+    'sparkling',
+    'waiting',
+    'waking',
+    'drifting',
+    'spinning',
+    'gliding',
+    'soaring',
+    'floating',
+    'whispering',
+    'calling',
+    'seeking',
+    'finding',
+    'giving',
+    'taking',
+    'weaving',
+    'building',
+    'creating',
+    'burning',
+    'freezing',
+    'melting',
+    'breathing',
+    'pulsing',
+    'beating',
+    'living',
+    'learning',
+    'knowing',
+    'hidden',
+    'shown',
+    'broken',
+    'mended',
+    'lost',
+    'found',
+    'starting',
+    'ending',
+    'climbing',
+    'diving',
+    'swimming',
+    'sailing',
+    'rolling',
+    'shaking',
+    'turning',
+    'shifting',
+    'changing',
+    'fading',
+    'dying',
+    'born',
+    'humming',
+    'crying',
+    'racing',
+    'creeping',
+    'hiding',
+    'watching',
+    'hearing',
+    'sensing',
+    'longing',
+    'hoping',
+    'loving',
+    'fearing',
+    'wondering',
+    'wandering',
+    'traveling',
+    'crossing',
+    'meeting',
+    'parting',
+    'keeping',
+    'sharing',
+    'sparking',
+    'flaming',
+    'healing',
+    'solving',
+    'opening',
+    'closing',
+    'lifting',
+    'pulling',
+    'pushing',
+    'holding',
+    'tossing',
+    'throwing',
+    'catching',
+    'fixing',
+    'making',
+    'doing',
+    'seeing',
+    'tasting',
+    'smelling',
+    'touching',
+    'pacing',
+    'hurrying',
+    'pausing',
+    'going',
+    'coming',
+    'leaving',
+    'acting',
+    'being',
+    'seeming',
+    'shrinking',
+    'widening',
+    'narrowing',
+    'heating',
+    'cooling',
+    'drying',
+    'wetting',
+    'filling',
+    'filling',
+    'emptying',
+    'letting',
+    'gaining',
+    'winning',
+    'failing',
+    'trying',
+    'using',
+    'getting',
+    'showing',
+    'hiding',
+    'breaking',
+    'fixing',
+    'saving',
+    'spending',
+    'buying',
+    'selling',
+    'paying',
+    'costing',
+    'reaching',
+    'missing',
+    'hitting',
+    'striking',
+    'leading',
+    'following',
+    'helping',
+    'serving',
+    'teaching',
+    'training',
+    'coding',
+    'writing',
+    'reading',
+    'drawing',
+    'painting',
+    'crafting',
+    'shaping',
+    'forming',
+    'joining',
+    'splitting',
+    'sharing',
+    'bonding',
+    'healing',
+    'harming',
+    'protecting',
+    'fighting',
+    'defending',
+    'attacking',
+    'escaping',
+    'catching',
+    'trapping',
+    'freeing',
+    'binding',
+    'weaving',
+    'spinning',
+];
+
 /**
  * Function parseNumber will parse number from string
  *
@@ -8574,6 +9333,95 @@ function removeQuotes(text) {
     return text;
 }
 
+/**
+ * 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);
+    }
+    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 });
+        }
+    }
+    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 });
+            }
+        }
+    }
+    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;
+        }
+        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: [🧠] Should this also unwrap the (parenthesis)
+ */
+
 /**
  * Checks if the given value is a valid JavaScript identifier name.
  *
@@ -8708,79 +9556,6 @@ class FromCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
-/**
- * IMPORT commitment definition
- *
- * The IMPORT commitment tells the agent to import content from another agent at the current location.
- *
- * Example usage in agent source:
- *
- * ```book
- * IMPORT https://s6.ptbk.io/benjamin-white
- * ```
- *
- * @private [🪔] Maybe export the commitments through some package
- */
-class ImportCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor(type = 'IMPORT') {
-        super(type);
-    }
-    /**
-     * Short one-line description of IMPORT.
-     */
-    get description() {
-        return 'Import content from another agent.';
-    }
-    /**
-     * Icon for this commitment.
-     */
-    get icon() {
-        return '📥';
-    }
-    /**
-     * Markdown documentation for IMPORT commitment.
-     */
-    get documentation() {
-        return spaceTrim$1(`
-            # ${this.type}
-
-            Imports content from another agent at the location of the commitment.
-
-            ## Examples
-
-            \`\`\`book
-            My AI Agent
-
-            IMPORT https://s6.ptbk.io/benjamin-white
-            RULE Speak only in English.
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, content) {
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
-            return requirements;
-        }
-        if (!isValidAgentUrl(trimmedContent)) {
-            throw new Error(spaceTrim$1((block) => `
-                        Invalid agent URL in IMPORT commitment: "${trimmedContent}"
-
-                        \`\`\`book
-                        ${block(content)}
-                        \`\`\`
-                `));
-        }
-        const importedAgentUrl = trimmedContent;
-        return {
-            ...requirements,
-            importedAgentUrls: [...(requirements.importedAgentUrls || []), importedAgentUrl],
-        };
-    }
-}
-/**
- * Note: [💞] Ignore a discrepancy between file name and entity name
- */
-
 /**
  * GOAL commitment definition
  *
@@ -8882,80 +9657,52 @@ class GoalCommitmentDefinition extends BaseCommitmentDefinition {
  */
 
 /**
- * KNOWLEDGE commitment definition
- *
- * The KNOWLEDGE commitment adds specific knowledge, facts, or context to the agent
- * using RAG (Retrieval-Augmented Generation) approach for external sources.
+ * IMPORT commitment definition
  *
- * Supports both direct text knowledge and external sources like PDFs.
+ * The IMPORT commitment tells the agent to import content from another agent at the current location.
  *
  * Example usage in agent source:
  *
  * ```book
- * KNOWLEDGE The company was founded in 2020 and specializes in AI-powered solutions
- * KNOWLEDGE https://example.com/company-handbook.pdf
- * KNOWLEDGE https://example.com/product-documentation.pdf
+ * IMPORT https://s6.ptbk.io/benjamin-white
  * ```
  *
  * @private [🪔] Maybe export the commitments through some package
  */
-class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor() {
-        super('KNOWLEDGE');
+class ImportCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'IMPORT') {
+        super(type);
     }
     /**
-     * Short one-line description of KNOWLEDGE.
+     * Short one-line description of IMPORT.
      */
     get description() {
-        return 'Add domain **knowledge** via direct text or external sources (RAG).';
+        return 'Import content from another agent or a generic text file.';
     }
     /**
      * Icon for this commitment.
      */
     get icon() {
-        return '🧠';
+        return '📥';
     }
     /**
-     * Markdown documentation for KNOWLEDGE commitment.
+     * Markdown documentation for IMPORT commitment.
      */
     get documentation() {
         return spaceTrim$1(`
             # ${this.type}
 
-            Adds specific knowledge, facts, or context to the agent using a RAG (Retrieval-Augmented Generation) approach for external sources.
-
-            ## Key aspects
-
-            - Both terms work identically and can be used interchangeably.
-            - Supports both direct text knowledge and external URLs.
-            - External sources (PDFs, websites) are processed via RAG for context retrieval.
-
-            ## Supported formats
-
-            - Direct text: Immediate knowledge incorporated into agent
-            - URLs: External documents processed for contextual retrieval
-            - Supported file types: PDF, text, markdown, HTML
+            Imports content from another agent or a generic text file at the location of the commitment.
 
             ## Examples
 
             \`\`\`book
-            Customer Support Bot
-
-            PERSONA You are a helpful customer support agent for TechCorp
-            KNOWLEDGE TechCorp was founded in 2020 and specializes in AI-powered solutions
-            KNOWLEDGE https://example.com/company-handbook.pdf
-            KNOWLEDGE https://example.com/product-documentation.pdf
-            RULE Always be polite and professional
-            \`\`\`
-
-            \`\`\`book
-            Research Assistant
+            My AI Agent
 
-            PERSONA You are a knowledgeable research assistant
-            KNOWLEDGE Academic research requires careful citation and verification
-            KNOWLEDGE https://example.com/research-guidelines.pdf
-            ACTION Can help with literature reviews and data analysis
-            STYLE Present information in clear, academic format
+            IMPORT https://s6.ptbk.io/benjamin-white
+            IMPORT https://example.com/some-text-file.txt
+            IMPORT ./path/to/local-file.json
+            RULE Speak only in English.
             \`\`\`
         `);
     }
@@ -8964,13 +9711,122 @@ class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition {
         if (!trimmedContent) {
             return requirements;
         }
-        // Check if content is a URL (external knowledge source)
-        if (isValidUrl(trimmedContent)) {
-            // Store the URL for later async processing
-            const updatedRequirements = {
+        if (isValidAgentUrl(trimmedContent)) {
+            const importedAgentUrl = trimmedContent;
+            return {
                 ...requirements,
-                knowledgeSources: [
-                    ...(requirements.knowledgeSources || []),
+                importedAgentUrls: [...(requirements.importedAgentUrls || []), importedAgentUrl],
+            };
+        }
+        if (isValidUrl(trimmedContent) || isValidFilePath(trimmedContent)) {
+            return {
+                ...requirements,
+                importedFileUrls: [...(requirements.importedFileUrls || []), trimmedContent],
+            };
+        }
+        throw new Error(spaceTrim$1((block) => `
+                    Invalid agent URL or file path in IMPORT commitment: "${trimmedContent}"
+
+                    \`\`\`book
+                    ${block(content)}
+                    \`\`\`
+            `));
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * KNOWLEDGE commitment definition
+ *
+ * The KNOWLEDGE commitment adds specific knowledge, facts, or context to the agent
+ * using RAG (Retrieval-Augmented Generation) approach for external sources.
+ *
+ * Supports both direct text knowledge and external sources like PDFs.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * KNOWLEDGE The company was founded in 2020 and specializes in AI-powered solutions
+ * KNOWLEDGE https://example.com/company-handbook.pdf
+ * KNOWLEDGE https://example.com/product-documentation.pdf
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('KNOWLEDGE');
+    }
+    /**
+     * Short one-line description of KNOWLEDGE.
+     */
+    get description() {
+        return 'Add domain **knowledge** via direct text or external sources (RAG).';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🧠';
+    }
+    /**
+     * Markdown documentation for KNOWLEDGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Adds specific knowledge, facts, or context to the agent using a RAG (Retrieval-Augmented Generation) approach for external sources.
+
+            ## Key aspects
+
+            - Both terms work identically and can be used interchangeably.
+            - Supports both direct text knowledge and external URLs.
+            - External sources (PDFs, websites) are processed via RAG for context retrieval.
+
+            ## Supported formats
+
+            - Direct text: Immediate knowledge incorporated into agent
+            - URLs: External documents processed for contextual retrieval
+            - Supported file types: PDF, text, markdown, HTML
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Bot
+
+            PERSONA You are a helpful customer support agent for TechCorp
+            KNOWLEDGE TechCorp was founded in 2020 and specializes in AI-powered solutions
+            KNOWLEDGE https://example.com/company-handbook.pdf
+            KNOWLEDGE https://example.com/product-documentation.pdf
+            RULE Always be polite and professional
+            \`\`\`
+
+            \`\`\`book
+            Research Assistant
+
+            PERSONA You are a knowledgeable research assistant
+            KNOWLEDGE Academic research requires careful citation and verification
+            KNOWLEDGE https://example.com/research-guidelines.pdf
+            ACTION Can help with literature reviews and data analysis
+            STYLE Present information in clear, academic format
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Check if content is a URL (external knowledge source)
+        if (isValidUrl(trimmedContent)) {
+            // Store the URL for later async processing
+            const updatedRequirements = {
+                ...requirements,
+                knowledgeSources: [
+                    ...(requirements.knowledgeSources || []),
                     trimmedContent,
                 ],
             };
@@ -9300,7 +10156,13 @@ class InitialMessageCommitmentDefinition extends BaseCommitmentDefinition {
         `);
     }
     applyToAgentModelRequirements(requirements, content) {
-        return requirements;
+        // INITIAL MESSAGE is for UI display purposes and for conversation history construction.
+        const newSample = { question: null, answer: content };
+        const newSamples = [...(requirements.samples || []), newSample];
+        return {
+            ...requirements,
+            samples: newSamples,
+        };
     }
 }
 
@@ -10332,27 +11194,16 @@ class NoteCommitmentDefinition extends BaseCommitmentDefinition {
         `);
     }
     applyToAgentModelRequirements(requirements, content) {
-        var _a;
         // The NOTE commitment makes no changes to the system message or model requirements
         // It only stores the note content in metadata for documentation purposes
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
+        const trimmedContent = spaceTrim$1(content);
+        if (trimmedContent === '') {
             return requirements;
         }
-        // Get existing note content from metadata
-        const existingNoteContent = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.NOTE) || '';
-        // Merge the new content with existing note content
-        // When multiple NOTE commitments exist, they are aggregated together
-        const mergedNoteContent = existingNoteContent ? `${existingNoteContent}\n${trimmedContent}` : trimmedContent;
-        // Store the merged note content in metadata for debugging and inspection
-        const updatedMetadata = {
-            ...requirements.metadata,
-            NOTE: mergedNoteContent,
-        };
-        // Return requirements with updated metadata but no changes to system message
+        // Return requirements with updated notes but no changes to system message
         return {
             ...requirements,
-            metadata: updatedMetadata,
+            notes: [...(requirements.notes || []), trimmedContent],
         };
     }
 }
@@ -11136,6 +11987,14 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
             \`\`\`
         `);
     }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            web_browser: 'Web browser',
+        };
+    }
     applyToAgentModelRequirements(requirements, content) {
         // Get existing tools array or create new one
         const existingTools = requirements.tools || [];
@@ -11164,14 +12023,17 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
                 },
             ]);
         // Return requirements with updated tools and metadata
-        return {
+        return this.appendToSystemMessage({
             ...requirements,
             tools: updatedTools,
             metadata: {
                 ...requirements.metadata,
                 useBrowser: 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.
+            `));
     }
 }
 /**
@@ -11255,6 +12117,49 @@ class UseMcpCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
+/**
+ * A search engine implementation that uses the SerpApi to fetch Google search results.
+ *
+ * @private <- TODO: !!!! Export via some package
+ */
+class SerpSearchEngine {
+    get title() {
+        return 'SerpApi Search Engine';
+    }
+    get description() {
+        return 'Search engine that uses SerpApi to fetch Google search results';
+    }
+    checkConfiguration() {
+        if (!process.env.SERP_API_KEY) {
+            throw new Error('SERP_API_KEY is not configured');
+        }
+    }
+    async search(query, options = {}) {
+        const apiKey = process.env.SERP_API_KEY;
+        if (!apiKey) {
+            throw new Error('SERP_API_KEY is not configured');
+        }
+        const url = new URL('https://serpapi.com/search');
+        url.searchParams.set('api_key', apiKey);
+        url.searchParams.set('engine', 'google');
+        url.searchParams.set('q', query);
+        for (const [key, value] of Object.entries(options)) {
+            url.searchParams.set(key, String(value));
+        }
+        const response = await fetch(url.toString());
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`SerpApi failed with status ${response.status}: ${response.statusText}\n${body}`);
+        }
+        const data = (await response.json());
+        return (data.organic_results || []).map((item) => ({
+            title: item.title,
+            url: item.link,
+            snippet: item.snippet || '',
+        }));
+    }
+}
+
 /**
  * USE SEARCH ENGINE commitment definition
  *
@@ -11274,7 +12179,7 @@ class UseMcpCommitmentDefinition extends BaseCommitmentDefinition {
  */
 class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
     constructor() {
-        super('USE SEARCH ENGINE', ['SEARCH ENGINE', 'SEARCH']);
+        super('USE SEARCH ENGINE', ['USE SEARCH']);
     }
     /**
      * Short one-line description of USE SEARCH ENGINE.
@@ -11331,18 +12236,13 @@ class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
             ? existingTools
             : [
                 ...existingTools,
-                { type: 'web_search' },
-                // <- Note: [🔰] This is just using simple native search tool by OpenAI @see https://platform.openai.com/docs/guides/tools-web-search
-                //          In future we will use proper MCP search tool:
-                /*
- 
                 {
                     name: 'web_search',
-                    description: spaceTrim(`
-                      Search the internet for information.
-                      Use this tool when you need to find up-to-date information or facts that you don't know.
-                      ${!content ? '' : `Search scope / instructions: ${content}`}
-                  `),
+                    description: spaceTrim$1(`
+                        Search the internet for information.
+                        Use this tool when you need to find up-to-date information or facts that you don't know.
+                        ${!content ? '' : `Search scope / instructions: ${content}`}
+                    `),
                     parameters: {
                         type: 'object',
                         properties: {
@@ -11350,20 +12250,224 @@ class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
                                 type: 'string',
                                 description: 'The search query',
                             },
+                            location: {
+                                type: 'string',
+                                description: 'The location for the search (e.g., "Austin, Texas, United States" or "Prague, Czechia")',
+                            },
+                            gl: {
+                                type: 'string',
+                                description: 'The country code (e.g., "us" for United States, "cz" for Czechia)',
+                            },
+                            hl: {
+                                type: 'string',
+                                description: 'The language code (e.g., "en" for English, "cs" for Czech)',
+                            },
+                            num: {
+                                type: 'integer',
+                                description: 'Number of results to return',
+                            },
+                            engine: {
+                                type: 'string',
+                                description: 'The search engine to use (e.g., "google", "bing", "yahoo", "baidu")',
+                            },
+                            google_domain: {
+                                type: 'string',
+                                description: 'The Google domain to use (e.g., "google.com", "google.cz")',
+                            },
                         },
                         required: ['query'],
                     },
                 },
-                */
             ];
         // Return requirements with updated tools and metadata
-        return {
+        return this.appendToSystemMessage({
             ...requirements,
             tools: updatedTools,
             metadata: {
                 ...requirements.metadata,
                 useSearchEngine: content || true,
             },
+        }, spaceTrim$1(`
+                You have access to the web search engine. Use it to find up-to-date information or facts that you don't know.
+                When you need to know some information from the internet, use the tool provided to you.
+            `));
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            web_search: 'Web search',
+        };
+    }
+    /**
+     * Gets the `web_search` tool function implementation.
+     */
+    getToolFunctions() {
+        return {
+            async web_search(args) {
+                console.log('!!!! [Tool] web_search called', { args });
+                const { query, ...options } = args;
+                if (!query) {
+                    throw new Error('Search query is required');
+                }
+                const searchEngine = new SerpSearchEngine();
+                const results = await searchEngine.search(query, options);
+                return spaceTrim$1((block) => `
+                        Search results for "${query}"${Object.keys(options).length === 0
+                    ? ''
+                    : ` with options ${JSON.stringify(options)}`}:
+
+                        ${block(results
+                    .map((result) => spaceTrim$1(`
+                                            - **${result.title}**
+                                              ${result.url}
+                                              ${result.snippet}
+                                        `))
+                    .join('\n\n'))}
+                    `);
+            },
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USE TIME commitment definition
+ *
+ * The `USE TIME` commitment indicates that the agent should be able to determine the current date and time.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE TIME
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseTimeCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE TIME', ['CURRENT TIME', 'TIME', 'DATE']);
+    }
+    /**
+     * Short one-line description of USE TIME.
+     */
+    get description() {
+        return 'Enable the agent to determine the current date and time.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🕒';
+    }
+    /**
+     * Markdown documentation for USE TIME commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE TIME
+
+            Enables the agent to determine the current date and time.
+
+            ## Key aspects
+
+            - This tool won't receive any input.
+            - It outputs the current date and time as an ISO 8601 string.
+            - Allows the agent to answer questions about the current time or date.
+
+            ## Examples
+
+            \`\`\`book
+            Time-aware Assistant
+
+            PERSONA You are a helpful assistant who knows the current time.
+            USE TIME
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // Get existing tools array or create new one
+        const existingTools = requirements.tools || [];
+        // Add 'get_current_time' to tools if not already present
+        const updatedTools = existingTools.some((tool) => tool.name === 'get_current_time')
+            ? existingTools
+            : [
+                ...existingTools,
+                {
+                    name: 'get_current_time',
+                    description: 'Get the current date and time in ISO 8601 format.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            timezone: {
+                                type: 'string',
+                                description: 'Optional timezone name (e.g. "Europe/Prague", "UTC", "America/New_York").',
+                            },
+                        },
+                        required: [],
+                    },
+                },
+                // <- TODO: !!!! define the function in LLM tools
+            ];
+        // Return requirements with updated tools and metadata
+        return this.appendToSystemMessage({
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+            },
+        }, spaceTrim$1(`
+                You have access to the current date and time. Use it to answer questions about the current date and time.
+                When you need to know the current date or time, use the tool provided to you.
+            `));
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            get_current_time: 'Get current time',
+        };
+    }
+    /**
+     * Gets the `get_current_time` tool function implementation.
+     */
+    getToolFunctions() {
+        return {
+            async get_current_time(args) {
+                var _a;
+                console.log('!!!! [Tool] get_current_time called', { args });
+                const { timezone } = args;
+                if (!timezone) {
+                    return new Date().toISOString();
+                }
+                try {
+                    // Note: Returning ISO 8601 string but in the requested timezone
+                    const formatter = new Intl.DateTimeFormat('en-CA', {
+                        timeZone: timezone,
+                        year: 'numeric',
+                        month: '2-digit',
+                        day: '2-digit',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        hour12: false,
+                        timeZoneName: 'shortOffset',
+                    });
+                    const parts = formatter.formatToParts(new Date());
+                    const part = (type) => { var _a; return (_a = parts.find((p) => p.type === type)) === null || _a === void 0 ? void 0 : _a.value; };
+                    // en-CA format is YYYY-MM-DD
+                    const isoString = `${part('year')}-${part('month')}-${part('day')}T${part('hour')}:${part('minute')}:${part('second')}${(_a = part('timeZoneName')) === null || _a === void 0 ? void 0 : _a.replace('GMT', '')}`;
+                    return isoString;
+                }
+                catch (error) {
+                    // Fallback to UTC if timezone is invalid
+                    return new Date().toISOString();
+                }
+            },
         };
     }
 }
@@ -11438,7 +12542,6 @@ class NotYetImplementedCommitmentDefinition extends BaseCommitmentDefinition {
     }
 }
 
-// Import all commitment definition classes
 /**
  * Registry of all available commitment definitions
  * This array contains instances of all commitment definitions
@@ -11455,10 +12558,10 @@ const COMMITMENT_REGISTRY = [
     new MemoryCommitmentDefinition('MEMORIES'),
     new StyleCommitmentDefinition('STYLE'),
     new StyleCommitmentDefinition('STYLES'),
-    new RuleCommitmentDefinition('RULE'),
     new RuleCommitmentDefinition('RULES'),
-    new LanguageCommitmentDefinition('LANGUAGE'),
+    new RuleCommitmentDefinition('RULE'),
     new LanguageCommitmentDefinition('LANGUAGES'),
+    new LanguageCommitmentDefinition('LANGUAGE'),
     new SampleCommitmentDefinition('SAMPLE'),
     new SampleCommitmentDefinition('EXAMPLE'),
     new FormatCommitmentDefinition('FORMAT'),
@@ -11480,6 +12583,7 @@ const COMMITMENT_REGISTRY = [
     new NoteCommitmentDefinition('NOTES'),
     new NoteCommitmentDefinition('COMMENT'),
     new NoteCommitmentDefinition('NONCE'),
+    new NoteCommitmentDefinition('TODO'),
     new GoalCommitmentDefinition('GOAL'),
     new GoalCommitmentDefinition('GOALS'),
     new InitialMessageCommitmentDefinition(),
@@ -11498,6 +12602,7 @@ const COMMITMENT_REGISTRY = [
     new ClosedCommitmentDefinition(),
     new UseBrowserCommitmentDefinition(),
     new UseSearchEngineCommitmentDefinition(),
+    new UseTimeCommitmentDefinition(),
     new UseMcpCommitmentDefinition(),
     new UseCommitmentDefinition(),
     // Not yet implemented commitments (using placeholder)
@@ -11507,6 +12612,7 @@ const COMMITMENT_REGISTRY = [
     new NotYetImplementedCommitmentDefinition('AVOID'),
     new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
     new NotYetImplementedCommitmentDefinition('CONTEXT'),
+    // <- TODO: Prompt: Leverage aliases instead of duplicating commitment definitions
 ];
 /**
  * Gets a commitment definition by its type
@@ -11586,42 +12692,38 @@ function getGroupedCommitmentDefinitions() {
     return $deepFreeze(groupedCommitments);
 }
 /**
- * TODO: [🧠] Maybe create through standardized $register
- * Note: [💞] Ignore a discrepancy between file name and entity name
- */
-
-/**
- * Creates an empty/basic agent model requirements object
- * This serves as the starting point for the reduce-like pattern
- * where each commitment applies its changes to build the final requirements
+ * Gets all function implementations provided by all commitments
  *
  * @public exported from `@promptbook/core`
  */
-function createEmptyAgentModelRequirements() {
-    return {
-        systemMessage: '',
-        // modelName: 'gpt-5',
-        modelName: 'gemini-2.5-flash-lite',
-        temperature: 0.7,
-        topP: 0.9,
-        topK: 50,
-    };
+function getAllCommitmentsToolFunctions() {
+    const allToolFunctions = {};
+    for (const commitmentDefinition of getAllCommitmentDefinitions()) {
+        const toolFunctions = commitmentDefinition.getToolFunctions();
+        for (const [funcName, funcImpl] of Object.entries(toolFunctions)) {
+            allToolFunctions[funcName] = funcImpl;
+        }
+    }
+    return allToolFunctions;
 }
 /**
- * Creates a basic agent model requirements with just the agent name
- * This is used when we have an agent name but no commitments
+ * Gets all tool titles provided by all commitments
  *
  * @public exported from `@promptbook/core`
  */
-function createBasicAgentModelRequirements(agentName) {
-    const empty = createEmptyAgentModelRequirements();
-    return {
-        ...empty,
-        systemMessage: `You are ${agentName || 'AI Agent'}`,
-    };
+function getAllCommitmentsToolTitles() {
+    const allToolTitles = {};
+    for (const commitmentDefinition of getAllCommitmentDefinitions()) {
+        const toolTitles = commitmentDefinition.getToolTitles();
+        for (const [funcName, title] of Object.entries(toolTitles)) {
+            allToolTitles[funcName] = title;
+        }
+    }
+    return allToolTitles;
 }
 /**
- * TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
+ * TODO: [🧠] Maybe create through standardized $register
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
 /**
@@ -11702,11 +12804,37 @@ function parseAgentSourceWithCommitments(agentSource) {
     let currentCommitment = null;
     // Process lines starting from after the agent name line
     const startIndex = agentNameLineIndex >= 0 ? agentNameLineIndex + 1 : 0;
+    let isInsideCodeBlock = false;
     for (let i = startIndex; i < lines.length; i++) {
         const line = lines[i];
         if (line === undefined) {
             continue;
         }
+        const trimmedLine = line.trim();
+        // Check if this line starts or ends a code block
+        if (trimmedLine.startsWith('```')) {
+            isInsideCodeBlock = !isInsideCodeBlock;
+            if (currentCommitment) {
+                // If we are inside a commitment, the code block is part of it
+                currentCommitment.contentLines.push(line);
+            }
+            else {
+                // If we are not inside a commitment, the code block is non-commitment
+                nonCommitmentLines.push(line);
+            }
+            continue;
+        }
+        if (isInsideCodeBlock) {
+            if (currentCommitment) {
+                // If we are inside a commitment and a code block, the line is part of the commitment
+                currentCommitment.contentLines.push(line);
+            }
+            else {
+                // If we are inside a code block but not a commitment, the line is non-commitment
+                nonCommitmentLines.push(line);
+            }
+            continue;
+        }
         // Check if this line starts a new commitment
         let foundNewCommitment = false;
         for (const definition of COMMITMENT_REGISTRY) {
@@ -11784,6 +12912,97 @@ function parseAgentSourceWithCommitments(agentSource) {
     };
 }
 
+/**
+ * Plugin for importing agent books *(`.book` files)*
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const AgentFileImportPlugin = {
+    name: 'agent-file-import-plugin',
+    canImport(mimeType) {
+        // [🧠] Should we have a specific MIME type for agent books?
+        // For now, let's assume it's identified by .book extension or certain MIME types if provided
+        return mimeType === 'text/x-promptbook' || mimeType === 'application/x-promptbook';
+    },
+    import(content) {
+        const parseResult = parseAgentSourceWithCommitments(content);
+        // Bring only the agent corpus (non-commitment lines and relevant commitments)
+        // Stripping the agent name (which is usually the first line)
+        const corpus = parseResult.nonCommitmentLines
+            .filter((line, index) => index > 0 || !parseResult.agentName)
+            .join('\n')
+            .trim();
+        // Also include relevant commitments that make up the "corpus" of the agent
+        // For example PERSONA, RULE, KNOWLEDGE
+        const relevantCommitments = parseResult.commitments
+            .filter((c) => ['PERSONA', 'RULE', 'KNOWLEDGE'].includes(c.type))
+            .map((c) => `${c.type} ${c.content}`)
+            .join('\n\n');
+        return spaceTrim$1((block) => `
+                ${block(relevantCommitments)}
+
+                ${block(corpus)}
+            `).trim();
+    },
+};
+
+/**
+ * Plugin for importing JSON files
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const JsonFileImportPlugin = {
+    name: 'json-file-import-plugin',
+    canImport(mimeType) {
+        return mimeType === 'application/json' || mimeType.endsWith('+json');
+    },
+    import(content) {
+        try {
+            const json = JSON.parse(content);
+            const formattedJson = JSON.stringify(json, null, 4);
+            return `\`\`\`json\n${formattedJson}\n\`\`\``;
+        }
+        catch (error) {
+            // If JSON is invalid, still import it but maybe not as pretty JSON
+            return `\`\`\`json\n${content}\n\`\`\``;
+        }
+    },
+};
+
+/**
+ * Plugin for importing generic text files
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const TextFileImportPlugin = {
+    name: 'text-file-import-plugin',
+    canImport(mimeType) {
+        return (mimeType === 'text/plain' ||
+            mimeType === 'text/markdown' ||
+            mimeType === 'text/x-typescript' ||
+            mimeType === 'text/javascript' ||
+            mimeType === 'text/css' ||
+            mimeType === 'text/html' ||
+            mimeType.startsWith('text/'));
+    },
+    import(content, mimeType) {
+        const extension = mimeTypeToExtension(mimeType);
+        const codeBlockType = extension || 'txt';
+        return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+    },
+};
+
+/**
+ * All available file import plugins
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const $fileImportPlugins = [
+    AgentFileImportPlugin,
+    JsonFileImportPlugin,
+    TextFileImportPlugin,
+];
+
 /**
  * Parses parameters from text using both supported notations:
  * 1. @Parameter - single word parameter starting with @
@@ -11873,6 +13092,7 @@ function removeCommentsFromSystemMessage(systemMessage) {
  * @public exported from `@promptbook/core`
  */
 async function createAgentModelRequirementsWithCommitments(agentSource, modelName) {
+    var _a;
     // Parse the agent source to extract commitments
     const parseResult = parseAgentSourceWithCommitments(agentSource);
     // Apply DELETE filtering: remove prior commitments tagged by parameters targeted by DELETE/CANCEL/DISCARD/REMOVE
@@ -11939,6 +13159,64 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
             }
         }
     }
+    // Handle IMPORT commitments for generic files
+    // Note: This logic could be moved to ImportCommitmentDefinition, but it needs to be asynchronous
+    if (requirements.importedFileUrls && requirements.importedFileUrls.length > 0) {
+        for (const fileUrl of requirements.importedFileUrls) {
+            try {
+                // 1. Mocked security check
+                await mockedSecurityCheck(fileUrl);
+                // 2. Fetch file content
+                let content;
+                let mimeType = null;
+                if (isValidUrl(fileUrl)) {
+                    const response = await promptbookFetch(fileUrl);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch ${fileUrl}: ${response.statusText}`);
+                    }
+                    content = await response.text();
+                    mimeType = response.headers.get('Content-Type');
+                    /*
+                TODO: !!!! Commented out this case because we need to work in Browser-compatible mode in many packages, use passed `fs` instead
+                } else if (isValidFilePath(fileUrl)) {
+                    // [x🟢x] This code is expected to run in Node environment if local files are used
+                    const fs = await import('fs/promises');
+                    content = await fs.readFile(fileUrl, 'utf-8');
+                    const extension = getFileExtension(fileUrl);
+                    mimeType = extensionToMimeType(extension as string);
+                */
+                }
+                else {
+                    throw new Error(`Invalid file URL or path: ${fileUrl}`);
+                }
+                if (!mimeType) {
+                    mimeType = 'text/plain';
+                }
+                // Remove charset from mime type
+                mimeType = mimeType.split(';')[0].trim();
+                // 3. Prevent importing binary files (mocked check)
+                if (isBinaryMimeType(mimeType)) {
+                    throw new Error(`Importing binary files is not allowed: ${mimeType}`);
+                }
+                // 4. Find appropriate plugin
+                const plugin = $fileImportPlugins.find((p) => p.canImport(mimeType));
+                if (!plugin) {
+                    throw new Error(`No import plugin found for MIME type: ${mimeType}`);
+                }
+                // 5. Process content
+                const importedContent = await plugin.import(content, mimeType);
+                // 6. Append to system message
+                requirements = {
+                    ...requirements,
+                    systemMessage: requirements.systemMessage + '\n\n' + importedContent,
+                };
+            }
+            catch (error) {
+                console.warn(`Failed to import file ${fileUrl}:`, error);
+                // Continue with other imports even if one fails
+            }
+        }
+    }
     // Handle MCP servers (extract from original agent source)
     const mcpServers = extractMcpServers(agentSource);
     if (mcpServers.length > 0) {
@@ -11948,9 +13226,11 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
         };
     }
     // Add non-commitment lines to system message if they exist
+    // Note: Filtering out horizontal lines (---) as requested
     const nonCommitmentContent = parseResult.nonCommitmentLines
         .filter((line, index) => index > 0 || !parseResult.agentName) // Skip first line if it's the agent name
         .filter((line) => line.trim()) // Remove empty lines
+        .filter((line) => !/^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/.test(line)) // Remove horizontal lines
         .join('\n')
         .trim();
     if (nonCommitmentContent) {
@@ -11959,6 +13239,26 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
             systemMessage: requirements.systemMessage + '\n\n' + nonCommitmentContent,
         };
     }
+    // Add example interactions to the system message
+    const examples = [];
+    // 1. Initial message as an example agent response
+    const initialMessage = (_a = parseResult.commitments.find((c) => c.type === 'INITIAL MESSAGE')) === null || _a === void 0 ? void 0 : _a.content;
+    if (initialMessage) {
+        examples.push(`Agent: ${initialMessage}`);
+    }
+    // 2. User and Agent message pairs
+    if (requirements.samples && requirements.samples.length > 0) {
+        for (const sample of requirements.samples) {
+            examples.push(`User: ${sample.question}\nAgent: ${sample.answer}`);
+        }
+    }
+    if (examples.length > 0) {
+        const exampleInteractionsContent = `Example interaction:\n\n${examples.join('\n\n')}`;
+        requirements = {
+            ...requirements,
+            systemMessage: requirements.systemMessage + '\n\n' + exampleInteractionsContent,
+        };
+    }
     // Remove comment lines (lines starting with #) from the final system message
     // while preserving the original content with comments in metadata
     const cleanedSystemMessage = removeCommentsFromSystemMessage(requirements.systemMessage);
@@ -11967,6 +13267,36 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
         systemMessage: cleanedSystemMessage,
     };
 }
+/**
+ * Mocked security check for imported files
+ *
+ * @param urlOrPath - The URL or local path of the file to check
+ * @returns A promise that resolves if the file is safe
+ */
+async function mockedSecurityCheck(urlOrPath) {
+    // TODO: Implement proper security checks
+    await new Promise((resolve) => setTimeout(resolve, 10)); // Mock async delay
+    if (urlOrPath.includes('malicious')) {
+        throw new Error(`Security check failed for: ${urlOrPath}`);
+    }
+}
+/**
+ * Checks if the given MIME type belongs to a binary file
+ *
+ * @param mimeType - The MIME type to check
+ * @returns True if it's a binary MIME type
+ */
+function isBinaryMimeType(mimeType) {
+    const binaryPrefixes = [
+        'image/',
+        'video/',
+        'audio/',
+        'application/octet-stream',
+        'application/pdf',
+        'application/zip',
+    ];
+    return binaryPrefixes.some((prefix) => mimeType.startsWith(prefix));
+}
 
 /**
  * Normalizes agent name from arbitrary string to valid agent name
@@ -12027,7 +13357,24 @@ function parseAgentSource(agentSource) {
     const meta = {};
     const links = [];
     const capabilities = [];
+    const samples = [];
+    let pendingUserMessage = null;
     for (const commitment of parseResult.commitments) {
+        if (commitment.type === 'INITIAL MESSAGE') {
+            samples.push({ question: null, answer: commitment.content });
+            continue;
+        }
+        if (commitment.type === 'USER MESSAGE') {
+            pendingUserMessage = commitment.content;
+            continue;
+        }
+        if (commitment.type === 'AGENT MESSAGE') {
+            if (pendingUserMessage !== null) {
+                samples.push({ question: pendingUserMessage, answer: commitment.content });
+                pendingUserMessage = null;
+            }
+            continue;
+        }
         if (commitment.type === 'USE BROWSER') {
             capabilities.push({
                 type: 'browser',
@@ -12044,6 +13391,71 @@ function parseAgentSource(agentSource) {
             });
             continue;
         }
+        if (commitment.type === 'USE SEARCH') {
+            capabilities.push({
+                type: 'search-engine',
+                label: 'Search Internet',
+                iconName: 'Search',
+            });
+            continue;
+        }
+        if (commitment.type === 'USE TIME') {
+            capabilities.push({
+                type: 'time',
+                label: 'Time',
+                iconName: 'Clock',
+            });
+            continue;
+        }
+        if (commitment.type === 'FROM') {
+            const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
+            if (content === 'Adam' || content === '' /* <- Note: Adam is implicit */) {
+                continue;
+            }
+            let label = content;
+            let iconName = 'SquareArrowOutUpRight'; // Inheritance remote
+            if (content.startsWith('./') || content.startsWith('../') || content.startsWith('/')) {
+                label = content.split('/').pop() || content;
+                iconName = 'SquareArrowUpRight'; // Inheritance local
+            }
+            if (content === 'VOID') {
+                label = 'VOID';
+                iconName = 'ShieldAlert'; // [🧠] Or some other icon for VOID
+            }
+            capabilities.push({
+                type: 'inheritance',
+                label,
+                iconName,
+                agentUrl: content,
+            });
+            continue;
+        }
+        if (commitment.type === 'IMPORT') {
+            const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
+            let label = content;
+            let iconName = 'ExternalLink'; // Import remote
+            try {
+                if (content.startsWith('http://') || content.startsWith('https://')) {
+                    const url = new URL(content);
+                    label = url.hostname.replace(/^www\./, '') + '.../' + url.pathname.split('/').pop();
+                    iconName = 'ExternalLink';
+                }
+                else if (content.startsWith('./') || content.startsWith('../') || content.startsWith('/')) {
+                    label = content.split('/').pop() || content;
+                    iconName = 'Link'; // Import local
+                }
+            }
+            catch (e) {
+                // Invalid URL or path, keep default label
+            }
+            capabilities.push({
+                type: 'import',
+                label,
+                iconName,
+                agentUrl: content,
+            });
+            continue;
+        }
         if (commitment.type === 'KNOWLEDGE') {
             const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
             let label = content;
@@ -12128,6 +13540,7 @@ function parseAgentSource(agentSource) {
         links,
         parameters,
         capabilities,
+        samples,
     };
 }
 /**
@@ -16758,6 +18171,9 @@ function filterModels(llmTools, predicate) {
                 return originalModels.filter(predicate);
             }
         },
+        checkConfiguration() {
+            return /* not await */ llmTools.checkConfiguration();
+        },
     };
     // Helper function to validate if a model is allowed
     async function isModelAllowed(modelName) {
@@ -17064,31 +18480,14 @@ class MemoryStorage {
  * Intercepts LLM tools and counts total usage of the tools
  *
  * Note: It can take extended `LlmExecutionTools` and cache the
+ * Note: Returns full proxy of all LLM tool properties and methods
  *
  * @param llmTools LLM tools to be intercepted with usage counting, it can contain extra methods like `totalUsage`
- * @returns LLM tools with same functionality with added total cost counting
+ * @returns Full proxy of LLM tools with same functionality with added caching
  * @public exported from `@promptbook/core`
  */
 function cacheLlmTools(llmTools, options = {}) {
     const { storage = new MemoryStorage(), isCacheReloaded = false, isVerbose = DEFAULT_IS_VERBOSE } = options;
-    const proxyTools = {
-        ...llmTools,
-        // <- Note: [🥫]
-        get title() {
-            return `${llmTools.title} (cached)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
-        },
-        get description() {
-            return `${llmTools.description} (cached)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
-        },
-        listModels() {
-            // TODO: [🧠] Should be model listing also cached?
-            return /* not await */ llmTools.listModels();
-        },
-    };
     const callCommonModel = async (prompt) => {
         var _a;
         const { parameters, content, modelRequirements } = prompt;
@@ -17185,6 +18584,16 @@ function cacheLlmTools(llmTools, options = {}) {
                 }
             }
         }
+        if (shouldCache && promptResult.toolCalls !== undefined) {
+            // Note: Do not cache results that contain tool calls because they are dynamic and should be always fresh
+            //       For example, it doesn't make sense to cache the message 'What time is it? 3:30 pm' because when the question is asked another time, it can be a different time.
+            shouldCache = false;
+            if (isVerbose) {
+                console.info('Not caching result that contains tool calls for key:', key, {
+                    toolCalls: promptResult.toolCalls,
+                });
+            }
+        }
         if (shouldCache) {
             await storage.setItem(key, {
                 date: $getCurrentDate(),
@@ -17211,27 +18620,55 @@ function cacheLlmTools(llmTools, options = {}) {
         }
         return promptResult;
     };
-    if (llmTools.callChatModel !== undefined) {
-        proxyTools.callChatModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    if (llmTools.callCompletionModel !== undefined) {
-        proxyTools.callCompletionModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    if (llmTools.callEmbeddingModel !== undefined) {
-        proxyTools.callEmbeddingModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    if (llmTools.callImageGenerationModel !== undefined) {
-        proxyTools.callImageGenerationModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    // <- Note: [🤖]
+    // Create a Proxy to intercept all property access and ensure full proxying of all properties
+    const proxyTools = new Proxy(llmTools, {
+        get(target, prop, receiver) {
+            // Handle title property
+            if (prop === 'title') {
+                return `${target.title} (cached)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
+            }
+            // Handle description property
+            if (prop === 'description') {
+                return `${target.description} (cached)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
+            }
+            // Handle callChatModel method
+            if (prop === 'callChatModel' && target.callChatModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // Handle callCompletionModel method
+            if (prop === 'callCompletionModel' && target.callCompletionModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // Handle callEmbeddingModel method
+            if (prop === 'callEmbeddingModel' && target.callEmbeddingModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // Handle callImageGenerationModel method
+            if (prop === 'callImageGenerationModel' && target.callImageGenerationModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // <- Note: [🤖]
+            // For all other properties and methods, delegate to the original target
+            const value = Reflect.get(target, prop, receiver);
+            // If it's a function, bind it to the target to preserve context
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
     return proxyTools;
 }
 /**
@@ -18338,20 +19775,29 @@ class OpenAiCompatibleExecutionTools {
         });
         return availableModels;
     }
+    /**
+     * Calls OpenAI compatible API to use a chat model.
+     */
     /**
      * Calls OpenAI compatible API to use a chat model.
      */
     async callChatModel(prompt) {
+        return this.callChatModelStream(prompt, () => { });
+    }
+    /**
+     * Calls OpenAI compatible API to use a chat model with streaming.
+     */
+    async callChatModelStream(prompt, onProgress) {
         // Deep clone prompt and modelRequirements to avoid mutation across calls
         const clonedPrompt = JSON.parse(JSON.stringify(prompt));
         // Use local Set for retried parameters to ensure independence and thread safety
         const retriedUnsupportedParameters = new Set();
-        return this.callChatModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters);
+        return this.callChatModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters, onProgress);
     }
     /**
      * Internal method that handles parameter retry for chat model calls
      */
-    async callChatModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set()) {
+    async callChatModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set(), onProgress) {
         var _a;
         if (this.options.isVerbose) {
             console.info(`💬 ${this.title} callChatModel call`, { prompt, currentModelRequirements });
@@ -18457,6 +19903,23 @@ class OpenAiCompatibleExecutionTools {
                 const usage = this.computeUsage(content || '', responseMessage.content || '', rawResponse);
                 totalUsage = addUsage(totalUsage, usage);
                 if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
+                    if (onProgress) {
+                        onProgress({
+                            content: responseMessage.content || '',
+                            modelName: rawResponse.model || modelName,
+                            timing: { start, complete: $getCurrentDate() },
+                            usage: totalUsage,
+                            toolCalls: responseMessage.tool_calls.map((toolCall) => ({
+                                name: toolCall.function.name,
+                                arguments: toolCall.function.arguments,
+                                result: '',
+                                rawToolCall: toolCall,
+                            })),
+                            rawPromptContent,
+                            rawRequest,
+                            rawResponse,
+                        });
+                    }
                     await forEachAsync(responseMessage.tool_calls, {}, async (toolCall) => {
                         const functionName = toolCall.function.name;
                         const functionArgs = toolCall.function.arguments;
@@ -18478,7 +19941,7 @@ class OpenAiCompatibleExecutionTools {
                                     const args = ${functionArgs};
                                     return await ${functionName}(args);
                                 `,
-                                parameters: {}, // <- TODO: [🧠] What parameters to pass?
+                                parameters: prompt.parameters,
                             });
                         }
                         catch (error) {
@@ -18584,7 +20047,7 @@ class OpenAiCompatibleExecutionTools {
                 });
                 // Remove the unsupported parameter and retry
                 const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
-                return this.callChatModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
+                return this.callChatModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters, onProgress);
             }
         }
         throw new PipelineExecutionError(`Tool calling loop did not return a result from ${this.title}`);
@@ -19217,7 +20680,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
      * Calls OpenAI API to use a chat model with streaming.
      */
     async callChatModelStream(prompt, onProgress) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         if (this.options.isVerbose) {
             console.info('💬 OpenAI callChatModel call', { prompt });
         }
@@ -19272,6 +20735,157 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         }
         // Always add the current user message
         threadMessages.push({ role: 'user', content: rawPromptContent });
+        // Check if tools are being used - if so, use non-streaming mode
+        const hasTools = modelRequirements.tools !== undefined && modelRequirements.tools.length > 0;
+        const start = $getCurrentDate();
+        let complete;
+        // [🐱‍🚀] When tools are present, we need to use the non-streaming Runs API
+        // because streaming doesn't support tool execution flow properly
+        if (hasTools) {
+            onProgress({
+                content: '',
+                modelName: 'assistant',
+                timing: { start, complete: $getCurrentDate() },
+                usage: UNCERTAIN_USAGE,
+                rawPromptContent,
+                rawRequest: null,
+                rawResponse: null,
+            });
+            const rawRequest = {
+                assistant_id: this.assistantId,
+                thread: {
+                    messages: threadMessages,
+                },
+                tools: mapToolsToOpenAi(modelRequirements.tools),
+            };
+            if (this.options.isVerbose) {
+                console.info(colors.bgWhite('rawRequest (non-streaming with tools)'), JSON.stringify(rawRequest, null, 4));
+            }
+            // Create thread and run
+            const threadAndRun = await client.beta.threads.createAndRun(rawRequest);
+            let run = threadAndRun;
+            // Poll until run completes or requires action
+            while (run.status === 'queued' || run.status === 'in_progress' || run.status === 'requires_action') {
+                if (run.status === 'requires_action' && ((_a = run.required_action) === null || _a === void 0 ? void 0 : _a.type) === 'submit_tool_outputs') {
+                    // Execute tools
+                    const toolCalls = run.required_action.submit_tool_outputs.tool_calls;
+                    const toolOutputs = [];
+                    for (const toolCall of toolCalls) {
+                        if (toolCall.type === 'function') {
+                            const functionName = toolCall.function.name;
+                            const functionArgs = JSON.parse(toolCall.function.arguments);
+                            onProgress({
+                                content: '',
+                                modelName: 'assistant',
+                                timing: { start, complete: $getCurrentDate() },
+                                usage: UNCERTAIN_USAGE,
+                                rawPromptContent,
+                                rawRequest: null,
+                                rawResponse: null,
+                                toolCalls: [
+                                    {
+                                        name: functionName,
+                                        arguments: toolCall.function.arguments,
+                                        result: '',
+                                        rawToolCall: toolCall,
+                                    },
+                                ],
+                            });
+                            if (this.options.isVerbose) {
+                                console.info(`🔧 Executing tool: ${functionName}`, functionArgs);
+                            }
+                            // Get execution tools for script execution
+                            const executionTools = this.options
+                                .executionTools;
+                            if (!executionTools || !executionTools.script) {
+                                throw new PipelineExecutionError(`Model requested tool '${functionName}' but no executionTools.script were provided in OpenAiAssistantExecutionTools options`);
+                            }
+                            // TODO: [DRY] Use some common tool caller (similar to OpenAiCompatibleExecutionTools)
+                            const scriptTools = Array.isArray(executionTools.script)
+                                ? executionTools.script
+                                : [executionTools.script];
+                            let functionResponse;
+                            try {
+                                const scriptTool = scriptTools[0]; // <- TODO: [🧠] Which script tool to use?
+                                functionResponse = await scriptTool.execute({
+                                    scriptLanguage: 'javascript',
+                                    script: `
+                                        const args = ${JSON.stringify(functionArgs)};
+                                        return await ${functionName}(args);
+                                    `,
+                                    parameters: prompt.parameters,
+                                });
+                                if (this.options.isVerbose) {
+                                    console.info(`✅ Tool ${functionName} executed:`, functionResponse);
+                                }
+                            }
+                            catch (error) {
+                                assertsError(error);
+                                functionResponse = spaceTrim$2((block) => `
+                                    
+                                        The invoked tool \`${functionName}\` failed with error:
+                                        
+                                        \`\`\`json
+                                        ${block(JSON.stringify(serializeError(error), null, 4))}
+                                        \`\`\`
+
+                                    `);
+                                console.error(colors.bgRed(`❌ Error executing tool ${functionName}:`));
+                                console.error(error);
+                            }
+                            toolOutputs.push({
+                                tool_call_id: toolCall.id,
+                                output: functionResponse,
+                            });
+                        }
+                    }
+                    // Submit tool outputs
+                    run = await client.beta.threads.runs.submitToolOutputs(run.thread_id, run.id, {
+                        tool_outputs: toolOutputs,
+                    });
+                }
+                else {
+                    // Wait a bit before polling again
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                    run = await client.beta.threads.runs.retrieve(run.thread_id, run.id);
+                }
+            }
+            if (run.status !== 'completed') {
+                throw new PipelineExecutionError(`Assistant run failed with status: ${run.status}`);
+            }
+            // Get messages from the thread
+            const messages = await client.beta.threads.messages.list(run.thread_id);
+            const assistantMessages = messages.data.filter((msg) => msg.role === 'assistant');
+            if (assistantMessages.length === 0) {
+                throw new PipelineExecutionError('No assistant messages found after run completion');
+            }
+            const lastMessage = assistantMessages[0];
+            const textContent = lastMessage.content.find((c) => c.type === 'text');
+            if (!textContent || textContent.type !== 'text') {
+                throw new PipelineExecutionError('No text content in assistant response');
+            }
+            complete = $getCurrentDate();
+            const resultContent = textContent.text.value;
+            const usage = UNCERTAIN_USAGE;
+            // Progress callback with final result
+            const finalChunk = {
+                content: resultContent,
+                modelName: 'assistant',
+                timing: { start, complete },
+                usage,
+                rawPromptContent,
+                rawRequest,
+                rawResponse: { run, messages: messages.data },
+            };
+            onProgress(finalChunk);
+            return exportJson({
+                name: 'promptResult',
+                message: `Result of \`OpenAiAssistantExecutionTools.callChatModelStream\` (with tools)`,
+                order: [],
+                value: finalChunk,
+            });
+        }
+        // Streaming mode (without tools)
         const rawRequest = {
             // TODO: [👨‍👨‍👧‍👧] ...modelSettings,
             // TODO: [👨‍👨‍👧‍👧][🧠] What about system message for assistants, does it make sense - combination of OpenAI assistants with Promptbook Personas
@@ -19282,10 +20896,8 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             tools: modelRequirements.tools === undefined ? undefined : mapToolsToOpenAi(modelRequirements.tools),
             // <- TODO: Add user identification here> user: this.options.user,
         };
-        const start = $getCurrentDate();
-        let complete;
         if (this.options.isVerbose) {
-            console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
+            console.info(colors.bgWhite('rawRequest (streaming)'), JSON.stringify(rawRequest, null, 4));
         }
         const stream = await client.beta.threads.createAndRunStream(rawRequest);
         stream.on('connect', () => {
@@ -19321,6 +20933,15 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                 console.info('messageDone', message);
             }
         });
+        // TODO: [🐱‍🚀] Handle tool calls in assistants
+        // Note: OpenAI Assistant streaming with tool calls requires special handling.
+        // The stream will pause when a tool call is needed, and we need to:
+        // 1. Wait for the run to reach 'requires_action' status
+        // 2. Execute the tool calls
+        // 3. Submit tool outputs via a separate API call (not on the stream)
+        // 4. Continue the run
+        // This requires switching to non-streaming mode or using the Runs API directly.
+        // For now, tools with assistants should use the non-streaming chat completions API instead.
         const rawResponse = await stream.finalMessages();
         if (this.options.isVerbose) {
             console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
@@ -19331,10 +20952,10 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         if (rawResponse[0].content.length !== 1) {
             throw new PipelineExecutionError(`There is NOT 1 BUT ${rawResponse[0].content.length} finalMessages content from OpenAI`);
         }
-        if (((_a = rawResponse[0].content[0]) === null || _a === void 0 ? void 0 : _a.type) !== 'text') {
-            throw new PipelineExecutionError(`There is NOT 'text' BUT ${(_b = rawResponse[0].content[0]) === null || _b === void 0 ? void 0 : _b.type} finalMessages content type from OpenAI`);
+        if (((_b = rawResponse[0].content[0]) === null || _b === void 0 ? void 0 : _b.type) !== 'text') {
+            throw new PipelineExecutionError(`There is NOT 'text' BUT ${(_c = rawResponse[0].content[0]) === null || _c === void 0 ? void 0 : _c.type} finalMessages content type from OpenAI`);
         }
-        const resultContent = (_c = rawResponse[0].content[0]) === null || _c === void 0 ? void 0 : _c.text.value;
+        const resultContent = (_d = rawResponse[0].content[0]) === null || _d === void 0 ? void 0 : _d.text.value;
         //                                                     <- TODO: [🧠] There are also annotations, maybe use them
         // eslint-disable-next-line prefer-const
         complete = $getCurrentDate();
@@ -19402,7 +21023,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             throw new NotAllowed(`Creating new assistants is not allowed. Set \`isCreatingNewAssistantsAllowed: true\` in options to enable this feature.`);
         }
         // await this.playground();
-        const { name, instructions, knowledgeSources } = options;
+        const { name, instructions, knowledgeSources, tools } = options;
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
@@ -19473,7 +21094,11 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             description: 'Assistant created via Promptbook',
             model: 'gpt-4o',
             instructions,
-            tools: [/* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */ { type: 'file_search' }],
+            tools: [
+                /* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */
+                { type: 'file_search' },
+                ...(tools === undefined ? [] : mapToolsToOpenAi(tools)),
+            ],
         };
         // Attach vector store if created
         if (vectorStoreId) {
@@ -19498,7 +21123,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         if (!this.isCreatingNewAssistantsAllowed) {
             throw new NotAllowed(`Updating assistants is not allowed. Set \`isCreatingNewAssistantsAllowed: true\` in options to enable this feature.`);
         }
-        const { assistantId, name, instructions, knowledgeSources } = options;
+        const { assistantId, name, instructions, knowledgeSources, tools } = options;
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
@@ -19567,7 +21192,11 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         const assistantUpdate = {
             name,
             instructions,
-            tools: [/* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */ { type: 'file_search' }],
+            tools: [
+                /* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */
+                { type: 'file_search' },
+                ...(tools === undefined ? [] : mapToolsToOpenAi(tools)),
+            ],
         };
         if (vectorStoreId) {
             assistantUpdate.tool_resources = {
@@ -19608,6 +21237,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
  */
 const DISCRIMINANT = 'OPEN_AI_ASSISTANT_V1';
 /**
+ * TODO: [🙎] In `OpenAiAssistantExecutionTools` Allow to create abstract assistants with `isCreatingNewAssistantsAllowed`
  * TODO: [🧠][🧙‍♂️] Maybe there can be some wizard for those who want to use just OpenAI
  * TODO: Maybe make custom OpenAiError
  * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
@@ -19666,8 +21296,10 @@ class AgentLlmExecutionTools {
     }
     /**
      * Get cached or create agent model requirements
+     *
+     * Note: [🐤] This is names `getModelRequirements` *(not `getAgentModelRequirements`)* because in future these two will be united
      */
-    async getAgentModelRequirements() {
+    async getModelRequirements() {
         if (this._cachedModelRequirements === null) {
             // Get available models from underlying LLM tools for best model selection
             const availableModels = await this.options.llmTools.listModels();
@@ -19737,9 +21369,25 @@ class AgentLlmExecutionTools {
         if (prompt.modelRequirements.modelVariant !== 'CHAT') {
             throw new Error('AgentLlmExecutionTools only supports chat prompts');
         }
-        const modelRequirements = await this.getAgentModelRequirements();
+        const modelRequirements = await this.getModelRequirements();
         const chatPrompt = prompt;
         let underlyingLlmResult;
+        // Create modified chat prompt with agent system message
+        const promptWithAgentModelRequirements = {
+            ...chatPrompt,
+            modelRequirements: {
+                ...chatPrompt.modelRequirements,
+                ...modelRequirements,
+                // Spread tools to convert readonly array to mutable
+                tools: modelRequirements.tools ? [...modelRequirements.tools] : chatPrompt.modelRequirements.tools,
+                // Prepend agent system message to existing system message
+                systemMessage: modelRequirements.systemMessage +
+                    (chatPrompt.modelRequirements.systemMessage
+                        ? `\n\n${chatPrompt.modelRequirements.systemMessage}`
+                        : ''),
+            },
+        };
+        console.log('!!!! promptWithAgentModelRequirements:', promptWithAgentModelRequirements);
         if (OpenAiAssistantExecutionTools.isOpenAiAssistantExecutionTools(this.options.llmTools)) {
             const requirementsHash = SHA256(JSON.stringify(modelRequirements)).toString();
             const cached = AgentLlmExecutionTools.assistantCache.get(this.title);
@@ -19760,6 +21408,7 @@ class AgentLlmExecutionTools {
                         name: this.title,
                         instructions: modelRequirements.systemMessage,
                         knowledgeSources: modelRequirements.knowledgeSources,
+                        tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                     });
                     AgentLlmExecutionTools.assistantCache.set(this.title, {
                         assistantId: assistant.assistantId,
@@ -19776,6 +21425,7 @@ class AgentLlmExecutionTools {
                     name: this.title,
                     instructions: modelRequirements.systemMessage,
                     knowledgeSources: modelRequirements.knowledgeSources,
+                    tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                     /*
                     !!!
                     metadata: {
@@ -19788,32 +21438,28 @@ class AgentLlmExecutionTools {
                     requirementsHash,
                 });
             }
-            underlyingLlmResult = await assistant.callChatModelStream(chatPrompt, onProgress);
+            // Create modified chat prompt with agent system message specific to OpenAI Assistant
+            const promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools = {
+                ...promptWithAgentModelRequirements,
+                modelRequirements: {
+                    ...promptWithAgentModelRequirements.modelRequirements,
+                    modelName: undefined,
+                    systemMessage: undefined,
+                    temperature: undefined, // <- Note: Let the Assistant use its default temperature
+                },
+            };
+            console.log('!!!! promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools:', promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools);
+            underlyingLlmResult = await assistant.callChatModelStream(promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools, onProgress);
         }
         else {
             if (this.options.isVerbose) {
                 console.log(`2️⃣ Creating Assistant ${this.title} on generic LLM execution tools...`);
             }
-            // Create modified chat prompt with agent system message
-            const modifiedChatPrompt = {
-                ...chatPrompt,
-                modelRequirements: {
-                    ...chatPrompt.modelRequirements,
-                    ...modelRequirements,
-                    // Spread tools to convert readonly array to mutable
-                    tools: modelRequirements.tools ? [...modelRequirements.tools] : chatPrompt.modelRequirements.tools,
-                    // Prepend agent system message to existing system message
-                    systemMessage: modelRequirements.systemMessage +
-                        (chatPrompt.modelRequirements.systemMessage
-                            ? `\n\n${chatPrompt.modelRequirements.systemMessage}`
-                            : ''),
-                },
-            };
             if (this.options.llmTools.callChatModelStream) {
-                underlyingLlmResult = await this.options.llmTools.callChatModelStream(modifiedChatPrompt, onProgress);
+                underlyingLlmResult = await this.options.llmTools.callChatModelStream(promptWithAgentModelRequirements, onProgress);
             }
             else if (this.options.llmTools.callChatModel) {
-                underlyingLlmResult = await this.options.llmTools.callChatModel(modifiedChatPrompt);
+                underlyingLlmResult = await this.options.llmTools.callChatModel(promptWithAgentModelRequirements);
                 onProgress(underlyingLlmResult);
             }
             else {
@@ -19842,7 +21488,7 @@ AgentLlmExecutionTools.assistantCache = new Map();
  * TODO: [🧠] Adding parameter substitution support (here or should be responsibility of the underlying LLM Tools)
  */
 
-var _Agent_instances, _Agent_selfLearn;
+var _Agent_instances, _Agent_selfLearnNonce, _Agent_selfLearnSamples, _Agent_selfLearnTeacher;
 /**
  * Represents one AI Agent
  *
@@ -19902,22 +21548,33 @@ class Agent extends AgentLlmExecutionTools {
          * This is parsed from commitments like USE BROWSER, USE SEARCH ENGINE, KNOWLEDGE, etc.
          */
         this.capabilities = [];
+        /**
+         * List of sample conversations (question/answer pairs)
+         */
+        this.samples = [];
         /**
          * Metadata like image or color
          */
         this.meta = {};
+        /**
+         * Human-readable titles for tool functions
+         */
+        this.toolTitles = {};
         // TODO: [🐱‍🚀] Add `Agent` simple "mocked" learning by appending to agent source
         // TODO: [🐱‍🚀] Add `Agent` learning by promptbookAgent
+        this.teacherAgent = options.teacherAgent;
         this.agentSource = agentSource;
         this.agentSource.subscribe((source) => {
             this.updateAgentSource(source);
-            const { agentName, personaDescription, initialMessage, links, meta, capabilities } = parseAgentSource(source);
+            const { agentName, personaDescription, initialMessage, links, meta, capabilities, samples } = parseAgentSource(source);
             this._agentName = agentName;
             this.personaDescription = personaDescription;
             this.initialMessage = initialMessage;
             this.links = links;
             this.capabilities = capabilities;
+            this.samples = samples;
             this.meta = { ...this.meta, ...meta };
+            this.toolTitles = getAllCommitmentsToolTitles();
         });
     }
     /**
@@ -19928,10 +21585,10 @@ class Agent extends AgentLlmExecutionTools {
     async callChatModelStream(prompt, onProgress) {
         var _a;
         // [1] Check if the user is asking the same thing as in the samples
-        const modelRequirements = await this.getAgentModelRequirements();
+        const modelRequirements = await this.getModelRequirements();
         if (modelRequirements.samples) {
             const normalizedPrompt = normalizeMessageText(prompt.content);
-            const sample = modelRequirements.samples.find((sample) => normalizeMessageText(sample.question) === normalizedPrompt);
+            const sample = modelRequirements.samples.find((sample) => sample.question !== null && normalizeMessageText(sample.question) === normalizedPrompt);
             if (sample) {
                 const now = new Date().toISOString();
                 const result = {
@@ -19977,21 +21634,42 @@ class Agent extends AgentLlmExecutionTools {
         if ((_a = modelRequirements.metadata) === null || _a === void 0 ? void 0 : _a.isClosed) {
             return result;
         }
-        await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearn).call(this, prompt, result);
-        // <- TODO: !!!! Do not await self-learn, run in background with error handling
+        // TODO: !!!!! Return the answer and do the learning asynchronously
+        // Note: [0] Asynchronously add nonce
+        if (just(false)) {
+            await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearnNonce).call(this);
+        }
+        // Note: [1] Do the append of the samples
+        await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearnSamples).call(this, prompt, result);
+        // Note: [2] Asynchronously call the teacher agent and invoke the silver link. When the teacher fails, keep just the samples
+        await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearnTeacher).call(this, prompt, result).catch((error) => {
+            // !!!!! if (this.options.isVerbose) {
+            console.error(colors.bgCyan('[Self-learning]') + colors.red(' Failed to learn from teacher agent'));
+            console.error(error);
+            // }
+        });
         return result;
     }
 }
-_Agent_instances = new WeakSet(), _Agent_selfLearn = 
+_Agent_instances = new WeakSet(), _Agent_selfLearnNonce = 
 /**
- * Self-learning: Appends the conversation and extracted knowledge to the agent source
+ * Self-learning Step 0: Asynchronously with random timing add nonce to the agent source
  */
-async function _Agent_selfLearn(prompt, result) {
-    // Learning: Append the conversation sample to the agent source
+async function _Agent_selfLearnNonce() {
+    await forTime(Math.random() * 5000);
+    // <- TODO: [🕓] `await forRandom(...)`
+    console.info(colors.bgCyan('[Self-learning]') + colors.cyan(' Nonce'));
+    const nonce = `NONCE ${await linguisticHash(Math.random().toString())}`;
+    // Append to the current source
+    const currentSource = this.agentSource.value;
+    const newSource = padBook(validateBook(spaceTrim$2(currentSource) + '\n\n---\n\n' + nonce));
+    // <- TODO: [🈲] Use some object-based way how to append on book (with sections `---`)
+    // Update the source (which will trigger the subscription and update the underlying tools)
+    this.agentSource.next(newSource);
+}, _Agent_selfLearnSamples = function _Agent_selfLearnSamples(prompt, result) {
+    console.info(colors.bgCyan('[Self-learning]') + colors.cyan(' Sampling'));
     const learningExample = spaceTrim$2((block) => `
 
-                ---
-
                 USER MESSAGE
                 ${block(prompt.content)}
 
@@ -19999,53 +21677,81 @@ async function _Agent_selfLearn(prompt, result) {
                 ${block(result.content)}
 
             `);
-    // Extract knowledge
-    let knowledgeBlock = '';
-    try {
-        const extractionPrompt = {
-            title: 'Knowledge Extraction',
-            modelRequirements: {
-                modelVariant: 'CHAT',
-            },
-            content: spaceTrim$2((block) => `
-                        You are an AI agent that is learning from a conversation.
+    // Append to the current source
+    const currentSource = this.agentSource.value;
+    const newSource = padBook(validateBook(spaceTrim$2(currentSource) + '\n\n---\n\n' + learningExample));
+    // <- TODO: [🈲] Use some object-based way how to append on book (with sections `---`)
+    // Update the source (which will trigger the subscription and update the underlying tools)
+    this.agentSource.next(newSource);
+}, _Agent_selfLearnTeacher = 
+/**
+ * Self-learning Step 2: Asynchronously call the teacher agent and invoke the silver link
+ */
+async function _Agent_selfLearnTeacher(prompt, result) {
+    // [1] Call the teacher agent // <- !!!!! Emojis
+    if (this.teacherAgent === null) {
+        return;
+    }
+    console.info(colors.bgCyan('[Self-learning]') + colors.cyan(' Teacher'));
+    const teacherResult = await this.teacherAgent.callChatModel({
+        title: 'Self-learning',
+        modelRequirements: {
+            modelVariant: 'CHAT',
+        },
+        // TODO: !!!! Use prompt notation
+        content: spaceTrim$2((block) => `
 
-                        Here is the conversation so far:
+                    You are a teacher agent helping another agent to learn from its interactions.
 
-                        User: ${block(prompt.content)}
-                        Agent: ${block(result.content)}
+                    Here is your current client which you are teaching:
 
-                        Extract any new knowledge, facts, or important information that should be remembered for future interactions.
-                        Format the output as a list of KNOWLEDGE blocks.
-                        If there is no new knowledge, return nothing.
+                    \`\`\`book
+                    ${block(this.agentSource.value)}
+                    \`\`\`
 
-                        Example output:
-                        KNOWLEDGE The user's name is Alice.
-                        KNOWLEDGE The project deadline is next Friday.
-                    `),
-            pipelineUrl: 'https://github.com/webgptorg/promptbook/blob/main/prompts/knowledge-extraction.ptbk.md',
-            parameters: {},
-        };
-        if (this.options.llmTools.callChatModel) {
-            const extractionResult = await this.options.llmTools.callChatModel(extractionPrompt);
-            const extractedContent = extractionResult.content;
-            if (extractedContent.includes('KNOWLEDGE')) {
-                knowledgeBlock = '\n\n' + spaceTrim$2(extractedContent);
-            }
-        }
-        else {
-            // TODO: [🧠] Fallback to callChatModelStream if callChatModel is not available
-        }
-    }
-    catch (error) {
-        if (this.options.isVerbose) {
-            console.warn('Failed to extract knowledge', error);
-        }
+                    **And here is the latest interaction:**
+
+                    **User:**
+                    ${block(prompt.content)}
+
+                    **Agent:**
+                    ${block(result.content)}
+
+
+                    **Rules:**
+
+                    - Decide what the agent should learn from this interaction.
+                    - Append new commitments at the end of the agent source.
+                    - Do not modify the current agent source, just return new commitments (KNOWLEDGE, RULE, etc.).
+                    - If there is nothing new to learn, return empty book code block
+                    - Wrap the commitments in a book code block.
+                    - Do not explain anything, just return the commitments wrapped in a book code block.
+                    - Write the learned commitments in the same style and language as in the original agent source.
+
+
+                    This is how book code block looks like:
+
+                    \`\`\`book
+                    KNOWLEDGE The sky is blue.
+                    RULE Always be polite.
+                    \`\`\`
+                `),
+        // pipelineUrl: 'https://github.com/webgptorg/promptbook/blob/main/prompts/self-learning.ptbk.md',
+        // <- TODO: !!!! Remove and `pipelineUrl` for agent purposes
+        parameters: {},
+    });
+    console.log('!!!! teacherResult', teacherResult);
+    const teacherCommitments = unwrapResult(teacherResult.content);
+    if (teacherCommitments === '') {
+        console.info(colors.bgCyan('[Self-learning]') +
+            colors.cyan(' Teacher agent did not provide new commitments to learn'));
+        return;
     }
-    // Append to the current source
+    // [2] Append to the current source
     const currentSource = this.agentSource.value;
-    const newSource = padBook(validateBook(spaceTrim$2(currentSource) + '\n\n' + learningExample + knowledgeBlock));
-    // Update the source (which will trigger the subscription and update the underlying tools)
+    const newSource = padBook(validateBook(spaceTrim$2(currentSource) + '\n\n' + teacherCommitments));
+    // <- TODO: [🈲] Use some object-based way how to append on book (with sections `---`)
+    // [3] Update the source
     this.agentSource.next(newSource);
 };
 /**
@@ -20190,10 +21896,25 @@ function book(strings, ...values) {
  */
 class RemoteAgent extends Agent {
     static async connect(options) {
-        console.log('[🐱‍🚀]', `${options.agentUrl}/api/profile`);
-        const profileResponse = await fetch(`${options.agentUrl}/api/profile`);
+        const agentProfileUrl = `${options.agentUrl}/api/profile`;
+        const profileResponse = await fetch(agentProfileUrl);
         // <- TODO: [🐱‍🚀] What about closed-source agents?
         // <- TODO: [🐱‍🚀] Maybe use promptbookFetch
+        if (!profileResponse.ok) {
+            throw new Error(spaceTrim$2((block) => `
+                        Failed to fetch remote agent profile:
+
+                        Agent URL:
+                        ${options.agentUrl}
+
+                        Agent Profile URL:
+                        ${agentProfileUrl}
+                        
+                        Http Error:
+                        ${block(profileResponse.statusText)}
+                
+                `));
+        }
         const profile = await profileResponse.json();
         // Note: We are creating dummy agent source because we don't have the source from the remote agent
         //       But we populate the metadata from the profile
@@ -20220,6 +21941,7 @@ class RemoteAgent extends Agent {
             */
             },
             agentSource,
+            teacherAgent: null, // <- Note:
         });
         remoteAgent._remoteAgentName = profile.agentName;
         remoteAgent._remoteAgentHash = profile.agentHash;
@@ -20227,11 +21949,13 @@ class RemoteAgent extends Agent {
         remoteAgent.initialMessage = profile.initialMessage;
         remoteAgent.links = profile.links;
         remoteAgent.meta = profile.meta;
+        remoteAgent.toolTitles = profile.toolTitles || {};
         remoteAgent._isVoiceCallingEnabled = profile.isVoiceCallingEnabled === true; // [✨✷] Store voice calling status
         return remoteAgent;
     }
     constructor(options) {
         super(options);
+        this.toolTitles = {};
         this._isVoiceCallingEnabled = false; // [✨✷] Track voice calling status
         this.agentUrl = options.agentUrl;
     }
@@ -20311,6 +22035,7 @@ class RemoteAgent extends Agent {
         // <- TODO: [🐱‍🚀] What about closed-source agents?
         // <- TODO: [🐱‍🚀] Maybe use promptbookFetch
         let content = '';
+        const toolCalls = [];
         if (!bookResponse.body) {
             content = await bookResponse.text();
         }
@@ -20326,6 +22051,36 @@ class RemoteAgent extends Agent {
                     doneReading = !!done;
                     if (value) {
                         const textChunk = decoder.decode(value, { stream: true });
+                        let isHandled = false;
+                        try {
+                            const lines = textChunk.split('\n');
+                            for (const line of lines) {
+                                const trimmedLine = line.trim();
+                                if (trimmedLine.startsWith('{') && trimmedLine.endsWith('}')) {
+                                    const chunk = JSON.parse(trimmedLine);
+                                    if (chunk.toolCalls) {
+                                        toolCalls.push(...chunk.toolCalls);
+                                        onProgress({
+                                            content,
+                                            modelName: this.modelName,
+                                            timing: {},
+                                            usage: {},
+                                            rawPromptContent: {},
+                                            rawRequest: {},
+                                            rawResponse: {},
+                                            toolCalls: chunk.toolCalls,
+                                        });
+                                        isHandled = true;
+                                    }
+                                }
+                            }
+                        }
+                        catch (error) {
+                            // Ignore non-json chunks
+                        }
+                        if (isHandled) {
+                            continue;
+                        }
                         // console.debug('RemoteAgent chunk:', textChunk);
                         content += textChunk;
                         onProgress({
@@ -20336,6 +22091,7 @@ class RemoteAgent extends Agent {
                             rawPromptContent: {},
                             rawRequest: {},
                             rawResponse: {},
+                            toolCalls,
                         });
                     }
                 }
@@ -20351,6 +22107,7 @@ class RemoteAgent extends Agent {
                         rawPromptContent: {},
                         rawRequest: {},
                         rawResponse: {},
+                        toolCalls,
                     });
                 }
             }
@@ -20367,6 +22124,7 @@ class RemoteAgent extends Agent {
             rawPromptContent: {},
             rawRequest: {},
             rawResponse: {},
+            toolCalls,
             // <- TODO: [🐱‍🚀] Transfer and proxy the metadata
         };
         return agentResult;
@@ -21286,7 +23044,7 @@ const OpenAiSdkTranspiler = {
                         {
                             role: 'system',
                             content: spaceTrim(\`
-                                ${block(modelRequirements.systemMessage)}
+                                ${block(modelRequirements.systemMessage.split('`').join('\\`'))}
                             \`),
                         },
                     ];
@@ -21372,7 +23130,7 @@ const OpenAiSdkTranspiler = {
                     {
                         role: 'system',
                         content: spaceTrim(\`
-                            ${block(modelRequirements.systemMessage)}
+                            ${block(modelRequirements.systemMessage.split('`').join('\\`'))}
                         \`),
                     },
                 ];
@@ -21433,7 +23191,16 @@ const CORE_AGENTS_SERVER = {
  *
  * @public exported from `@promptbook/core`
  */
-const CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES = { ADAM: 'adam', TEACHER: 'teacher' };
+const CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES = {
+    /**
+     * The default ancestor agent for new agents
+     */
+    ADAM: 'adam',
+    /**
+     * Agent that knows book syntax and can help with self-learning
+     */
+    TEACHER: 'teacher',
+};
 // <- TODO: [🆎] Allow to override (set) well-known agent names via Metadata
 /**
  * Available agents servers for the Promptbook
@@ -21542,29 +23309,82 @@ function $randomItem(...items) {
  * TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
  */
 
-const PERSONALITIES = [
-    'Friendly and helpful AI agent.',
-    'Professional and efficient virtual assistant.',
-    'Creative and imaginative digital companion.',
-    'Knowledgeable and informative AI guide.',
-    'Empathetic and understanding support bot.',
-    'Energetic and enthusiastic conversational partner.',
-    'Calm and patient virtual helper.',
-    'Curious and inquisitive AI explorer.',
-    'Witty and humorous digital friend.',
-    'Serious and focused AI consultant.',
-];
+const PERSONALITIES = {
+    ENGLISH: [
+        'Friendly and helpful AI agent.',
+        'Professional and efficient virtual assistant.',
+        'Creative and imaginative digital companion.',
+        'Knowledgeable and informative AI guide.',
+        'Empathetic and understanding support bot.',
+        'Energetic and enthusiastic conversational partner.',
+        'Calm and patient virtual helper.',
+        'Curious and inquisitive AI explorer.',
+        'Witty and humorous digital friend.',
+        'Serious and focused AI consultant.',
+    ],
+    CZECH: [
+        // spell-checker:disable
+        'Přátelský a nápomocný AI agent.',
+        'Profesionální a efektivní virtuální asistent.',
+        'Kreativní a nápaditý digitální společník.',
+        'Zkušený a informativní AI průvodce.',
+        'Empatický a chápavý robot podpory.',
+        'Energický a nadšený partner pro konverzaci.',
+        'Klidný a trpělivý virtuální pomocník.',
+        'Zvědavý a hloubavý AI průzkumník.',
+        'Vtipný a humorný digitální přítel.',
+        'Vážný a soustředěný AI konzultant.',
+        // spell-checker:enable
+    ],
+};
 /**
  * Generates a random agent persona description.
  *
  * This function selects a random personality profile from a predefined pool
  * of common AI agent characteristics (e.g., friendly, professional, creative).
  *
+ * @param language - The language code (e.g. 'ENGLISH', 'CZECH')
  * @returns A string describing the agent's persona
  * @private internal helper function
  */
-function $randomAgentPersona() {
-    return $randomItem(...PERSONALITIES);
+function $randomAgentPersona(language = 'ENGLISH') {
+    const normalizedLanguage = language.toUpperCase().trim();
+    const personalities = PERSONALITIES[normalizedLanguage] || PERSONALITIES['ENGLISH'];
+    return $randomItem(...personalities);
+}
+/**
+ * TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
+ */
+
+const RULES = {
+    ENGLISH: [
+        'Always prioritize user privacy and data security.',
+        'Respond in a friendly and approachable manner.',
+        'Avoid using technical jargon unless necessary.',
+        'Maintain a neutral and unbiased tone in all responses.',
+    ],
+    CZECH: [
+        // spell-checker:disable
+        'Vždy upřednostňujte soukromí uživatelů a bezpečnost dat.',
+        'Odpovídejte přátelským a přístupným způsobem.',
+        'Vyhněte se používání technického žargonu, pokud to není nutné.',
+        'Udržujte ve všech odpovědích neutrální a nezaujatý tón.',
+        // spell-checker:enable
+    ],
+};
+/**
+ * Generates a random agent rule description.
+ *
+ * This function selects a random rule
+ *
+ * @param language - The language code (e.g. 'ENGLISH', 'CZECH')
+ * @returns A string describing the agent's rule
+ * @private internal helper function
+ */
+function $randomAgentRule(language = 'ENGLISH') {
+    const normalizedLanguage = language.toUpperCase().trim();
+    const rules = RULES[normalizedLanguage] || RULES['ENGLISH'];
+    return $randomItem(...rules);
 }
 /**
  * TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
@@ -21850,10 +23670,9 @@ function getNamePool(language) {
  * @public exported from `@promptbook/core`
  */
 function $generateBookBoilerplate(options) {
-    // eslint-disable-next-line prefer-const
-    let { agentName, parentAgentName = 'Adam', personaDescription, meta, namePool = 'ENGLISH' } = options || {};
-    // eslint-disable-next-line prefer-const
-    let { image, color, ...restMeta } = meta || {};
+    const { parentAgentName = 'Adam', initialRules = [], meta, namePool = 'ENGLISH' } = options || {};
+    let { agentName, personaDescription } = options || {};
+    let { color } = meta || {};
     if (!agentName) {
         const namePoolInstance = getNamePool(namePool);
         const randomFullnameWithColor = namePoolInstance.generateName();
@@ -21861,20 +23680,26 @@ function $generateBookBoilerplate(options) {
         color = color || randomFullnameWithColor.color;
     }
     if (!personaDescription) {
-        personaDescription = $randomAgentPersona();
+        personaDescription = $randomAgentPersona(namePool);
+    }
+    if (initialRules.length === 0) {
+        initialRules.push($randomAgentRule(namePool));
     }
     const agentSource = validateBook(spaceTrim$2((block) => `
                 ${agentName}
     
-                META COLOR ${color || PROMPTBOOK_COLOR.toHex()}
-                META FONT Playfair Display, sans-serif
+                
                 PERSONA ${block(personaDescription)}
+                ${block(initialRules.map((rule) => `RULE ${rule}`).join('\n'))}
             `));
+    // Note: `META COLOR ${color || PROMPTBOOK_COLOR.toHex()}` was removed for now
+    // Note: `META FONT Playfair Display, sans-serif` was removed for now
+    // <- TODO: [🈲] Simple and object-constructive way how to create new books
     return agentSource;
 }
 /**
  * TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
  */
 
-export { $bookTranspilersRegister, $generateBookBoilerplate, $llmToolsMetadataRegister, $llmToolsRegister, $scrapersMetadataRegister, $scrapersRegister, ADMIN_EMAIL, ADMIN_GITHUB_NAME, API_REQUEST_TIMEOUT, AbstractFormatError, Agent, AgentCollectionInSupabase, AgentLlmExecutionTools, AuthenticationError, BIG_DATASET_TRESHOLD, BOOK_LANGUAGE_VERSION, BlackholeStorage, BoilerplateError, BoilerplateFormfactorDefinition, CLAIM, CLI_APP_ID, CORE_AGENTS_SERVER, CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES, CallbackInterfaceTools, ChatbotFormfactorDefinition, CollectionError, CompletionFormfactorDefinition, CsvFormatError, CsvFormatParser, DEFAULT_AGENTS_DIRNAME, DEFAULT_BOOK, DEFAULT_BOOKS_DIRNAME, DEFAULT_BOOK_OUTPUT_PARAMETER_NAME, DEFAULT_BOOK_TITLE, DEFAULT_CSV_SETTINGS, DEFAULT_DOWNLOAD_CACHE_DIRNAME, DEFAULT_EXECUTION_CACHE_DIRNAME, DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME, DEFAULT_INTERMEDIATE_FILES_STRATEGY, DEFAULT_IS_AUTO_INSTALLED, DEFAULT_IS_VERBOSE, DEFAULT_MAX_EXECUTION_ATTEMPTS, DEFAULT_MAX_FILE_SIZE, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_DEPTH, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_TOTAL, DEFAULT_MAX_PARALLEL_COUNT, DEFAULT_MAX_RECURSION, DEFAULT_MAX_REQUESTS_PER_MINUTE, DEFAULT_PIPELINE_COLLECTION_BASE_FILENAME, DEFAULT_PROMPT_TASK_TITLE, DEFAULT_REMOTE_SERVER_URL, DEFAULT_SCRAPE_CACHE_DIRNAME, DEFAULT_TASK_SIMULATED_DURATION_MS, DEFAULT_TASK_TITLE, DatabaseError, EXPECTATION_UNITS, EnvironmentMismatchError, ExecutionReportStringOptionsDefaults, ExpectError, FAILED_VALUE_PLACEHOLDER, FORMFACTOR_DEFINITIONS, FormattedBookInMarkdownTranspiler, GENERIC_PIPELINE_INTERFACE, GeneratorFormfactorDefinition, GenericFormfactorDefinition, ImageGeneratorFormfactorDefinition, KnowledgeScrapeError, LimitReachedError, MANDATORY_CSV_SETTINGS, MAX_FILENAME_LENGTH, MODEL_ORDERS, MODEL_TRUST_LEVELS, MODEL_VARIANTS, MatcherFormfactorDefinition, MemoryStorage, MissingToolsError, MultipleLlmExecutionTools, NAME, NonTaskSectionTypes, NotAllowed, NotFoundError, NotYetImplementedCommitmentDefinition, NotYetImplementedError, ORDER_OF_PIPELINE_JSON, OpenAiSdkTranspiler, PADDING_LINES, PENDING_VALUE_PLACEHOLDER, PLAYGROUND_APP_ID, PROMPTBOOK_CHAT_COLOR, PROMPTBOOK_COLOR, PROMPTBOOK_ENGINE_VERSION, PROMPTBOOK_ERRORS, PROMPTBOOK_LEGAL_ENTITY, PROMPTBOOK_LOGO_URL, PROMPTBOOK_SYNTAX_COLORS, PUBLIC_AGENTS_SERVERS, ParseError, PipelineExecutionError, PipelineLogicError, PipelineUrlError, PrefixStorage, PromptbookFetchError, RESERVED_PARAMETER_NAMES, RemoteAgent, SET_IS_VERBOSE, SectionTypes, SheetsFormfactorDefinition, TaskTypes, TextFormatParser, TranslatorFormfactorDefinition, UNCERTAIN_USAGE, UNCERTAIN_ZERO_VALUE, USER_CHAT_COLOR, UnexpectedError, WrappedError, ZERO_USAGE, ZERO_VALUE, _AgentMetadata, _AgentRegistration, _AnthropicClaudeMetadataRegistration, _AzureOpenAiMetadataRegistration, _BoilerplateScraperMetadataRegistration, _DeepseekMetadataRegistration, _DocumentScraperMetadataRegistration, _GoogleMetadataRegistration, _LegacyDocumentScraperMetadataRegistration, _MarkdownScraperMetadataRegistration, _MarkitdownScraperMetadataRegistration, _OllamaMetadataRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiCompatibleMetadataRegistration, _OpenAiMetadataRegistration, _PdfScraperMetadataRegistration, _WebsiteScraperMetadataRegistration, aboutPromptbookInformation, addUsage, book, cacheLlmTools, compilePipeline, computeAgentHash, computeCosineSimilarity, countUsage, createAgentLlmExecutionTools, createAgentModelRequirements, createAgentModelRequirementsWithCommitments, createBasicAgentModelRequirements, createDefaultAgentName, createEmptyAgentModelRequirements, createLlmToolsFromConfiguration, createPipelineCollectionFromJson, createPipelineCollectionFromPromise, createPipelineCollectionFromUrl, createPipelineExecutor, createPipelineSubcollection, embeddingVectorToString, executionReportJsonToString, extractParameterNamesFromTask, filterModels, generatePlaceholderAgentProfileImageUrl, getAllCommitmentDefinitions, getAllCommitmentTypes, getCommitmentDefinition, getGroupedCommitmentDefinitions, getPipelineInterface, getSingleLlmExecutionTools, identificationToPromptbookToken, isCommitmentSupported, isPassingExpectations, isPipelineImplementingInterface, isPipelineInterfacesEqual, isPipelinePrepared, isValidBook, isValidPipelineString, joinLlmExecutionTools, limitTotalUsage, makeKnowledgeSourceHandler, migratePipeline, normalizeAgentName, padBook, parseAgentSource, parseParameters, parsePipeline, pipelineCollectionToJson, pipelineJsonToString, prepareKnowledgePieces, preparePersona, preparePipeline, prettifyPipelineString, promptbookFetch, promptbookTokenToIdentification, unpreparePipeline, usageToHuman, usageToWorktime, validateBook, validatePipeline, validatePipelineString };
+export { $bookTranspilersRegister, $generateBookBoilerplate, $llmToolsMetadataRegister, $llmToolsRegister, $scrapersMetadataRegister, $scrapersRegister, ADMIN_EMAIL, ADMIN_GITHUB_NAME, API_REQUEST_TIMEOUT, AbstractFormatError, Agent, AgentCollectionInSupabase, AgentLlmExecutionTools, AuthenticationError, BIG_DATASET_TRESHOLD, BOOK_LANGUAGE_VERSION, BlackholeStorage, BoilerplateError, BoilerplateFormfactorDefinition, CLAIM, CLI_APP_ID, CORE_AGENTS_SERVER, CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES, CallbackInterfaceTools, ChatbotFormfactorDefinition, CollectionError, CompletionFormfactorDefinition, CsvFormatError, CsvFormatParser, DEFAULT_AGENTS_DIRNAME, DEFAULT_BOOK, DEFAULT_BOOKS_DIRNAME, DEFAULT_BOOK_OUTPUT_PARAMETER_NAME, DEFAULT_BOOK_TITLE, DEFAULT_CSV_SETTINGS, DEFAULT_DOWNLOAD_CACHE_DIRNAME, DEFAULT_EXECUTION_CACHE_DIRNAME, DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME, DEFAULT_INTERMEDIATE_FILES_STRATEGY, DEFAULT_IS_AUTO_INSTALLED, DEFAULT_IS_VERBOSE, DEFAULT_MAX_EXECUTION_ATTEMPTS, DEFAULT_MAX_FILE_SIZE, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_DEPTH, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_TOTAL, DEFAULT_MAX_PARALLEL_COUNT, DEFAULT_MAX_RECURSION, DEFAULT_MAX_REQUESTS_PER_MINUTE, DEFAULT_PIPELINE_COLLECTION_BASE_FILENAME, DEFAULT_PROMPT_TASK_TITLE, DEFAULT_REMOTE_SERVER_URL, DEFAULT_SCRAPE_CACHE_DIRNAME, DEFAULT_TASK_SIMULATED_DURATION_MS, DEFAULT_TASK_TITLE, DatabaseError, EXPECTATION_UNITS, EnvironmentMismatchError, ExecutionReportStringOptionsDefaults, ExpectError, FAILED_VALUE_PLACEHOLDER, FORMFACTOR_DEFINITIONS, FormattedBookInMarkdownTranspiler, GENERIC_PIPELINE_INTERFACE, GeneratorFormfactorDefinition, GenericFormfactorDefinition, ImageGeneratorFormfactorDefinition, KnowledgeScrapeError, LimitReachedError, MANDATORY_CSV_SETTINGS, MAX_FILENAME_LENGTH, MODEL_ORDERS, MODEL_TRUST_LEVELS, MODEL_VARIANTS, MatcherFormfactorDefinition, MemoryStorage, MissingToolsError, MultipleLlmExecutionTools, NAME, NonTaskSectionTypes, NotAllowed, NotFoundError, NotYetImplementedCommitmentDefinition, NotYetImplementedError, ORDER_OF_PIPELINE_JSON, OpenAiSdkTranspiler, PADDING_LINES, PENDING_VALUE_PLACEHOLDER, PLAYGROUND_APP_ID, PROMPTBOOK_CHAT_COLOR, PROMPTBOOK_COLOR, PROMPTBOOK_ENGINE_VERSION, PROMPTBOOK_ERRORS, PROMPTBOOK_LEGAL_ENTITY, PROMPTBOOK_LOGO_URL, PROMPTBOOK_SYNTAX_COLORS, PUBLIC_AGENTS_SERVERS, ParseError, PipelineExecutionError, PipelineLogicError, PipelineUrlError, PrefixStorage, PromptbookFetchError, RESERVED_PARAMETER_NAMES, RemoteAgent, SET_IS_VERBOSE, SectionTypes, SheetsFormfactorDefinition, TaskTypes, TextFormatParser, TranslatorFormfactorDefinition, UNCERTAIN_USAGE, UNCERTAIN_ZERO_VALUE, USER_CHAT_COLOR, UnexpectedError, WrappedError, ZERO_USAGE, ZERO_VALUE, _AgentMetadata, _AgentRegistration, _AnthropicClaudeMetadataRegistration, _AzureOpenAiMetadataRegistration, _BoilerplateScraperMetadataRegistration, _DeepseekMetadataRegistration, _DocumentScraperMetadataRegistration, _GoogleMetadataRegistration, _LegacyDocumentScraperMetadataRegistration, _MarkdownScraperMetadataRegistration, _MarkitdownScraperMetadataRegistration, _OllamaMetadataRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiCompatibleMetadataRegistration, _OpenAiMetadataRegistration, _PdfScraperMetadataRegistration, _WebsiteScraperMetadataRegistration, aboutPromptbookInformation, addUsage, book, cacheLlmTools, compilePipeline, computeAgentHash, computeCosineSimilarity, countUsage, createAgentLlmExecutionTools, createAgentModelRequirements, createAgentModelRequirementsWithCommitments, createBasicAgentModelRequirements, createDefaultAgentName, createEmptyAgentModelRequirements, createLlmToolsFromConfiguration, createPipelineCollectionFromJson, createPipelineCollectionFromPromise, createPipelineCollectionFromUrl, createPipelineExecutor, createPipelineSubcollection, embeddingVectorToString, executionReportJsonToString, extractParameterNamesFromTask, filterModels, generatePlaceholderAgentProfileImageUrl, getAllCommitmentDefinitions, getAllCommitmentTypes, getAllCommitmentsToolFunctions, getAllCommitmentsToolTitles, getCommitmentDefinition, getGroupedCommitmentDefinitions, getPipelineInterface, getSingleLlmExecutionTools, identificationToPromptbookToken, isCommitmentSupported, isPassingExpectations, isPipelineImplementingInterface, isPipelineInterfacesEqual, isPipelinePrepared, isValidBook, isValidPipelineString, joinLlmExecutionTools, limitTotalUsage, makeKnowledgeSourceHandler, migratePipeline, normalizeAgentName, padBook, parseAgentSource, parseParameters, parsePipeline, pipelineCollectionToJson, pipelineJsonToString, prepareKnowledgePieces, preparePersona, preparePipeline, prettifyPipelineString, promptbookFetch, promptbookTokenToIdentification, unpreparePipeline, usageToHuman, usageToWorktime, validateBook, validatePipeline, validatePipelineString };
 //# sourceMappingURL=index.es.js.map