@promptbook/core 0.105.0-1 → 0.105.0-10

package/umd/index.umd.js

@@ -28,7 +28,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.105.0-1';
+    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
@@ -993,6 +993,7 @@
         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
     /**
@@ -3650,74 +3651,90 @@
      * 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 rxjs.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;
     }
     /**
@@ -7495,6 +7512,40 @@
      * 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
      *
@@ -7611,6 +7662,22 @@
                 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 {};
+        }
     }
 
     /**
@@ -8467,6 +8534,698 @@
         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
      *
@@ -8575,6 +9334,95 @@
         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.spaceTrim(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.spaceTrim(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.
      *
@@ -8709,79 +9557,6 @@
      * 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.spaceTrim(`
-            # ${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.spaceTrim((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,6 +9657,87 @@
      * 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 or a generic text file.';
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '📥';
+        }
+        /**
+         * Markdown documentation for IMPORT commitment.
+         */
+        get documentation() {
+            return spaceTrim$1.spaceTrim(`
+            # ${this.type}
+
+            Imports content from another agent or a generic text file at the location of the commitment.
+
+            ## Examples
+
+            \`\`\`book
+            My AI Agent
+
+            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.
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            if (isValidAgentUrl(trimmedContent)) {
+                const importedAgentUrl = trimmedContent;
+                return {
+                    ...requirements,
+                    importedAgentUrls: [...(requirements.importedAgentUrls || []), importedAgentUrl],
+                };
+            }
+            if (isValidUrl(trimmedContent) || isValidFilePath(trimmedContent)) {
+                return {
+                    ...requirements,
+                    importedFileUrls: [...(requirements.importedFileUrls || []), trimmedContent],
+                };
+            }
+            throw new Error(spaceTrim$1.spaceTrim((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
      *
@@ -9301,7 +10157,13 @@
         `);
         }
         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,
+            };
         }
     }
 
@@ -10333,27 +11195,16 @@
         `);
         }
         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.spaceTrim(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],
             };
         }
     }
@@ -11137,6 +11988,14 @@
             \`\`\`
         `);
         }
+        /**
+         * 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 || [];
@@ -11165,14 +12024,17 @@
                     },
                 ]);
             // Return requirements with updated tools and metadata
-            return {
+            return this.appendToSystemMessage({
                 ...requirements,
                 tools: updatedTools,
                 metadata: {
                     ...requirements.metadata,
                     useBrowser: true,
                 },
-            };
+            }, spaceTrim$1.spaceTrim(`
+                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.
+            `));
         }
     }
     /**
@@ -11256,6 +12118,49 @@
      * 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
      *
@@ -11275,7 +12180,7 @@
      */
     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.
@@ -11332,18 +12237,13 @@
                 ? 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.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}`}
+                    `),
                         parameters: {
                             type: 'object',
                             properties: {
@@ -11351,20 +12251,224 @@
                                     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.spaceTrim(`
+                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.spaceTrim((block) => `
+                        Search results for "${query}"${Object.keys(options).length === 0
+                    ? ''
+                    : ` with options ${JSON.stringify(options)}`}:
+
+                        ${block(results
+                    .map((result) => spaceTrim$1.spaceTrim(`
+                                            - **${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.spaceTrim(`
+            # 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.spaceTrim(`
+                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();
+                    }
+                },
             };
         }
     }
@@ -11439,7 +12543,6 @@
         }
     }
 
-    // Import all commitment definition classes
     /**
      * Registry of all available commitment definitions
      * This array contains instances of all commitment definitions
@@ -11456,10 +12559,10 @@
         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'),
@@ -11481,6 +12584,7 @@
         new NoteCommitmentDefinition('NOTES'),
         new NoteCommitmentDefinition('COMMENT'),
         new NoteCommitmentDefinition('NONCE'),
+        new NoteCommitmentDefinition('TODO'),
         new GoalCommitmentDefinition('GOAL'),
         new GoalCommitmentDefinition('GOALS'),
         new InitialMessageCommitmentDefinition(),
@@ -11499,6 +12603,7 @@
         new ClosedCommitmentDefinition(),
         new UseBrowserCommitmentDefinition(),
         new UseSearchEngineCommitmentDefinition(),
+        new UseTimeCommitmentDefinition(),
         new UseMcpCommitmentDefinition(),
         new UseCommitmentDefinition(),
         // Not yet implemented commitments (using placeholder)
@@ -11508,6 +12613,7 @@
         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
@@ -11587,42 +12693,38 @@
         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
      */
 
     /**
@@ -11703,11 +12805,37 @@
         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) {
@@ -11785,6 +12913,97 @@
         };
     }
 
+    /**
+     * 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.spaceTrim((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 @
@@ -11874,6 +13093,7 @@
      * @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
@@ -11935,8 +13155,66 @@
                     requirements = definition.applyToAgentModelRequirements(requirements, commitment.content);
                 }
                 catch (error) {
-                    console.warn(`Failed to apply commitment ${commitment.type}:`, error);
-                    // Continue with other commitments even if one fails
+                    console.warn(`Failed to apply commitment ${commitment.type}:`, error);
+                    // Continue with other commitments even if one fails
+                }
+            }
+        }
+        // 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
                 }
             }
         }
@@ -11949,9 +13227,11 @@
             };
         }
         // 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) {
@@ -11960,6 +13240,26 @@
                 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);
@@ -11968,6 +13268,36 @@
             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
@@ -12028,7 +13358,24 @@
         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',
@@ -12045,6 +13392,71 @@
                 });
                 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__default["default"](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__default["default"](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__default["default"](commitment.content).split('\n')[0] || '';
                 let label = content;
@@ -12129,6 +13541,7 @@
             links,
             parameters,
             capabilities,
+            samples,
         };
     }
     /**
@@ -16759,6 +18172,9 @@
                     return originalModels.filter(predicate);
                 }
             },
+            checkConfiguration() {
+                return /* not await */ llmTools.checkConfiguration();
+            },
         };
         // Helper function to validate if a model is allowed
         async function isModelAllowed(modelName) {
@@ -17065,31 +18481,14 @@
      * 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 = exports.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;
@@ -17186,6 +18585,16 @@
                     }
                 }
             }
+            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(),
@@ -17212,27 +18621,55 @@
             }
             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;
     }
     /**
@@ -18339,20 +19776,29 @@
             });
             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 });
@@ -18458,6 +19904,23 @@
                     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;
@@ -18479,7 +19942,7 @@
                                     const args = ${functionArgs};
                                     return await ${functionName}(args);
                                 `,
-                                    parameters: {}, // <- TODO: [🧠] What parameters to pass?
+                                    parameters: prompt.parameters,
                                 });
                             }
                             catch (error) {
@@ -18585,7 +20048,7 @@
                     });
                     // 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}`);
@@ -19218,7 +20681,7 @@
          * 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 });
             }
@@ -19273,6 +20736,157 @@
             }
             // 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__default["default"].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__default["default"]((block) => `
+                                    
+                                        The invoked tool \`${functionName}\` failed with error:
+                                        
+                                        \`\`\`json
+                                        ${block(JSON.stringify(serializeError(error), null, 4))}
+                                        \`\`\`
+
+                                    `);
+                                    console.error(colors__default["default"].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
@@ -19283,10 +20897,8 @@
                 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__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
+                console.info(colors__default["default"].bgWhite('rawRequest (streaming)'), JSON.stringify(rawRequest, null, 4));
             }
             const stream = await client.beta.threads.createAndRunStream(rawRequest);
             stream.on('connect', () => {
@@ -19322,6 +20934,15 @@
                     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__default["default"].bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
@@ -19332,10 +20953,10 @@
             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();
@@ -19403,7 +21024,7 @@
                 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
@@ -19474,7 +21095,11 @@
                 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) {
@@ -19499,7 +21124,7 @@
             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
@@ -19568,7 +21193,11 @@
             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 = {
@@ -19609,6 +21238,7 @@
      */
     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
@@ -19667,8 +21297,10 @@
         }
         /**
          * 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();
@@ -19738,9 +21370,25 @@
             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 = cryptoJs.SHA256(JSON.stringify(modelRequirements)).toString();
                 const cached = AgentLlmExecutionTools.assistantCache.get(this.title);
@@ -19761,6 +21409,7 @@
                             name: this.title,
                             instructions: modelRequirements.systemMessage,
                             knowledgeSources: modelRequirements.knowledgeSources,
+                            tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                         });
                         AgentLlmExecutionTools.assistantCache.set(this.title, {
                             assistantId: assistant.assistantId,
@@ -19777,6 +21426,7 @@
                         name: this.title,
                         instructions: modelRequirements.systemMessage,
                         knowledgeSources: modelRequirements.knowledgeSources,
+                        tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                         /*
                         !!!
                         metadata: {
@@ -19789,32 +21439,28 @@
                         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 {
@@ -19843,7 +21489,7 @@
      * 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
      *
@@ -19903,22 +21549,33 @@
              * 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();
             });
         }
         /**
@@ -19929,10 +21586,10 @@
         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 = {
@@ -19978,21 +21635,42 @@
             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__default["default"].bgCyan('[Self-learning]') + colors__default["default"].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 waitasecond.forTime(Math.random() * 5000);
+        // <- TODO: [🕓] `await forRandom(...)`
+        console.info(colors__default["default"].bgCyan('[Self-learning]') + colors__default["default"].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__default["default"](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__default["default"].bgCyan('[Self-learning]') + colors__default["default"].cyan(' Sampling'));
         const learningExample = spaceTrim__default["default"]((block) => `
 
-                ---
-
                 USER MESSAGE
                 ${block(prompt.content)}
 
@@ -20000,53 +21678,81 @@
                 ${block(result.content)}
 
             `);
-        // Extract knowledge
-        let knowledgeBlock = '';
-        try {
-            const extractionPrompt = {
-                title: 'Knowledge Extraction',
-                modelRequirements: {
-                    modelVariant: 'CHAT',
-                },
-                content: spaceTrim__default["default"]((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__default["default"](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__default["default"].bgCyan('[Self-learning]') + colors__default["default"].cyan(' Teacher'));
+        const teacherResult = await this.teacherAgent.callChatModel({
+            title: 'Self-learning',
+            modelRequirements: {
+                modelVariant: 'CHAT',
+            },
+            // TODO: !!!! Use prompt notation
+            content: spaceTrim__default["default"]((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__default["default"](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__default["default"].bgCyan('[Self-learning]') +
+                colors__default["default"].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__default["default"](currentSource) + '\n\n' + learningExample + knowledgeBlock));
-        // Update the source (which will trigger the subscription and update the underlying tools)
+        const newSource = padBook(validateBook(spaceTrim__default["default"](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);
     };
     /**
@@ -20191,10 +21897,25 @@
      */
     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__default["default"]((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
@@ -20221,6 +21942,7 @@
                 */
                 },
                 agentSource,
+                teacherAgent: null, // <- Note:
             });
             remoteAgent._remoteAgentName = profile.agentName;
             remoteAgent._remoteAgentHash = profile.agentHash;
@@ -20228,11 +21950,13 @@
             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;
         }
@@ -20312,6 +22036,7 @@
             // <- TODO: [🐱‍🚀] What about closed-source agents?
             // <- TODO: [🐱‍🚀] Maybe use promptbookFetch
             let content = '';
+            const toolCalls = [];
             if (!bookResponse.body) {
                 content = await bookResponse.text();
             }
@@ -20327,6 +22052,36 @@
                         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({
@@ -20337,6 +22092,7 @@
                                 rawPromptContent: {},
                                 rawRequest: {},
                                 rawResponse: {},
+                                toolCalls,
                             });
                         }
                     }
@@ -20352,6 +22108,7 @@
                             rawPromptContent: {},
                             rawRequest: {},
                             rawResponse: {},
+                            toolCalls,
                         });
                     }
                 }
@@ -20368,6 +22125,7 @@
                 rawPromptContent: {},
                 rawRequest: {},
                 rawResponse: {},
+                toolCalls,
                 // <- TODO: [🐱‍🚀] Transfer and proxy the metadata
             };
             return agentResult;
@@ -21287,7 +23045,7 @@
                         {
                             role: 'system',
                             content: spaceTrim(\`
-                                ${block(modelRequirements.systemMessage)}
+                                ${block(modelRequirements.systemMessage.split('`').join('\\`'))}
                             \`),
                         },
                     ];
@@ -21373,7 +23131,7 @@
                     {
                         role: 'system',
                         content: spaceTrim(\`
-                            ${block(modelRequirements.systemMessage)}
+                            ${block(modelRequirements.systemMessage.split('`').join('\\`'))}
                         \`),
                     },
                 ];
@@ -21434,7 +23192,16 @@
      *
      * @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
@@ -21922,10 +23689,11 @@
         const agentSource = validateBook(spaceTrim__default["default"]((block) => `
                 ${agentName}
     
-                META COLOR ${color || PROMPTBOOK_COLOR.toHex()}
+                
                 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;
@@ -22094,6 +23862,8 @@
     exports.generatePlaceholderAgentProfileImageUrl = generatePlaceholderAgentProfileImageUrl;
     exports.getAllCommitmentDefinitions = getAllCommitmentDefinitions;
     exports.getAllCommitmentTypes = getAllCommitmentTypes;
+    exports.getAllCommitmentsToolFunctions = getAllCommitmentsToolFunctions;
+    exports.getAllCommitmentsToolTitles = getAllCommitmentsToolTitles;
     exports.getCommitmentDefinition = getCommitmentDefinition;
     exports.getGroupedCommitmentDefinitions = getGroupedCommitmentDefinitions;
     exports.getPipelineInterface = getPipelineInterface;