@promptbook/components 0.105.0-1 → 0.105.0-3

package/esm/index.es.js

@@ -35,7 +35,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-1';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.0-3';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1106,6 +1106,7 @@ const PROMPTBOOK_SYNTAX_COLORS = {
     SEPARATOR: Color.fromHex('#cccccc'),
     COMMITMENT: Color.fromHex('#DA0F78'),
     PARAMETER: Color.fromHex('#8e44ad'),
+    CODE_BLOCK: Color.fromHex('#7700ffff'),
 };
 // <- TODO: [🧠][🈵] Using `Color` here increases the package size approx 3kb, maybe remove it
 /**
@@ -3714,6 +3715,14 @@ class BaseCommitmentDefinition {
             return this.appendToSystemMessage(requirements, commentSection);
         }
     }
+    /**
+     * Gets tool function implementations provided by this commitment
+     *
+     * When the `applyToAgentModelRequirements` adds tools to the requirements, this method should return the corresponding function definitions.
+     */
+    getToolFunctions() {
+        return {};
+    }
 }
 
 /**
@@ -4346,79 +4355,6 @@ class FromCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
-/**
- * IMPORT commitment definition
- *
- * The IMPORT commitment tells the agent to import content from another agent at the current location.
- *
- * Example usage in agent source:
- *
- * ```book
- * IMPORT https://s6.ptbk.io/benjamin-white
- * ```
- *
- * @private [🪔] Maybe export the commitments through some package
- */
-class ImportCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor(type = 'IMPORT') {
-        super(type);
-    }
-    /**
-     * Short one-line description of IMPORT.
-     */
-    get description() {
-        return 'Import content from another agent.';
-    }
-    /**
-     * Icon for this commitment.
-     */
-    get icon() {
-        return '📥';
-    }
-    /**
-     * Markdown documentation for IMPORT commitment.
-     */
-    get documentation() {
-        return spaceTrim$1(`
-            # ${this.type}
-
-            Imports content from another agent at the location of the commitment.
-
-            ## Examples
-
-            \`\`\`book
-            My AI Agent
-
-            IMPORT https://s6.ptbk.io/benjamin-white
-            RULE Speak only in English.
-            \`\`\`
-        `);
-    }
-    applyToAgentModelRequirements(requirements, content) {
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
-            return requirements;
-        }
-        if (!isValidAgentUrl(trimmedContent)) {
-            throw new Error(spaceTrim$1((block) => `
-                        Invalid agent URL in IMPORT commitment: "${trimmedContent}"
-
-                        \`\`\`book
-                        ${block(content)}
-                        \`\`\`
-                `));
-        }
-        const importedAgentUrl = trimmedContent;
-        return {
-            ...requirements,
-            importedAgentUrls: [...(requirements.importedAgentUrls || []), importedAgentUrl],
-        };
-    }
-}
-/**
- * Note: [💞] Ignore a discrepancy between file name and entity name
- */
-
 /**
  * GOAL commitment definition
  *
@@ -4519,6 +4455,87 @@ class GoalCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
+/**
+ * IMPORT commitment definition
+ *
+ * The IMPORT commitment tells the agent to import content from another agent at the current location.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * IMPORT https://s6.ptbk.io/benjamin-white
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class ImportCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'IMPORT') {
+        super(type);
+    }
+    /**
+     * Short one-line description of IMPORT.
+     */
+    get description() {
+        return 'Import content from another agent or a generic text file.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '📥';
+    }
+    /**
+     * Markdown documentation for IMPORT commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${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((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
  *
@@ -4938,7 +4955,13 @@ class InitialMessageCommitmentDefinition extends BaseCommitmentDefinition {
         `);
     }
     applyToAgentModelRequirements(requirements, content) {
-        return requirements;
+        // INITIAL MESSAGE is for UI display purposes and for conversation history construction.
+        const newSample = { question: null, answer: content };
+        const newSamples = [...(requirements.samples || []), newSample];
+        return {
+            ...requirements,
+            samples: newSamples,
+        };
     }
 }
 
@@ -5970,27 +5993,16 @@ class NoteCommitmentDefinition extends BaseCommitmentDefinition {
         `);
     }
     applyToAgentModelRequirements(requirements, content) {
-        var _a;
         // The NOTE commitment makes no changes to the system message or model requirements
         // It only stores the note content in metadata for documentation purposes
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
+        const trimmedContent = spaceTrim$1(content);
+        if (trimmedContent === '') {
             return requirements;
         }
-        // Get existing note content from metadata
-        const existingNoteContent = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.NOTE) || '';
-        // Merge the new content with existing note content
-        // When multiple NOTE commitments exist, they are aggregated together
-        const mergedNoteContent = existingNoteContent ? `${existingNoteContent}\n${trimmedContent}` : trimmedContent;
-        // Store the merged note content in metadata for debugging and inspection
-        const updatedMetadata = {
-            ...requirements.metadata,
-            NOTE: mergedNoteContent,
-        };
-        // Return requirements with updated metadata but no changes to system message
+        // Return requirements with updated notes but no changes to system message
         return {
             ...requirements,
-            metadata: updatedMetadata,
+            notes: [...(requirements.notes || []), trimmedContent],
         };
     }
 }
@@ -7009,6 +7021,104 @@ class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
+/**
+ * USE TIME commitment definition
+ *
+ * The `USE TIME` commitment indicates that the agent should be able to determine the current date and time.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE TIME
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseTimeCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE TIME', ['CURRENT TIME', 'TIME', 'DATE']);
+    }
+    /**
+     * Short one-line description of USE TIME.
+     */
+    get description() {
+        return 'Enable the agent to determine the current date and time.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🕒';
+    }
+    /**
+     * Markdown documentation for USE TIME commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE TIME
+
+            Enables the agent to determine the current date and time.
+
+            ## Key aspects
+
+            - This tool won't receive any input.
+            - It outputs the current date and time as an ISO 8601 string.
+            - Allows the agent to answer questions about the current time or date.
+
+            ## Examples
+
+            \`\`\`book
+            Time-aware Assistant
+
+            PERSONA You are a helpful assistant who knows the current time.
+            USE TIME
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // Get existing tools array or create new one
+        const existingTools = requirements.tools || [];
+        // Add 'get_current_time' to tools if not already present
+        const updatedTools = existingTools.some((tool) => tool.name === 'get_current_time')
+            ? existingTools
+            : [
+                ...existingTools,
+                {
+                    name: 'get_current_time',
+                    description: 'Get the current date and time in ISO 8601 format.',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+                // <- TODO: !!!! define the function in LLM tools
+            ];
+        // Return requirements with updated tools and metadata
+        return {
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+            },
+        };
+    }
+    /**
+     * Gets the `get_current_time` tool function implementation.
+     */
+    getToolFunctions() {
+        return {
+            async get_current_time() {
+                console.log('!!!! [Tool] get_current_time called');
+                return new Date().toISOString();
+            },
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
 /**
  * Placeholder commitment definition for commitments that are not yet implemented
  *
@@ -7076,7 +7186,6 @@ class NotYetImplementedCommitmentDefinition extends BaseCommitmentDefinition {
     }
 }
 
-// Import all commitment definition classes
 /**
  * Registry of all available commitment definitions
  * This array contains instances of all commitment definitions
@@ -7093,10 +7202,10 @@ const COMMITMENT_REGISTRY = [
     new MemoryCommitmentDefinition('MEMORIES'),
     new StyleCommitmentDefinition('STYLE'),
     new StyleCommitmentDefinition('STYLES'),
-    new RuleCommitmentDefinition('RULE'),
     new RuleCommitmentDefinition('RULES'),
-    new LanguageCommitmentDefinition('LANGUAGE'),
+    new RuleCommitmentDefinition('RULE'),
     new LanguageCommitmentDefinition('LANGUAGES'),
+    new LanguageCommitmentDefinition('LANGUAGE'),
     new SampleCommitmentDefinition('SAMPLE'),
     new SampleCommitmentDefinition('EXAMPLE'),
     new FormatCommitmentDefinition('FORMAT'),
@@ -7136,6 +7245,7 @@ const COMMITMENT_REGISTRY = [
     new ClosedCommitmentDefinition(),
     new UseBrowserCommitmentDefinition(),
     new UseSearchEngineCommitmentDefinition(),
+    new UseTimeCommitmentDefinition(),
     new UseMcpCommitmentDefinition(),
     new UseCommitmentDefinition(),
     // Not yet implemented commitments (using placeholder)
@@ -7248,11 +7358,37 @@ function parseAgentSourceWithCommitments(agentSource) {
     let currentCommitment = null;
     // Process lines starting from after the agent name line
     const startIndex = agentNameLineIndex >= 0 ? agentNameLineIndex + 1 : 0;
+    let isInsideCodeBlock = false;
     for (let i = startIndex; i < lines.length; i++) {
         const line = lines[i];
         if (line === undefined) {
             continue;
         }
+        const trimmedLine = line.trim();
+        // Check if this line starts or ends a code block
+        if (trimmedLine.startsWith('```')) {
+            isInsideCodeBlock = !isInsideCodeBlock;
+            if (currentCommitment) {
+                // If we are inside a commitment, the code block is part of it
+                currentCommitment.contentLines.push(line);
+            }
+            else {
+                // If we are not inside a commitment, the code block is non-commitment
+                nonCommitmentLines.push(line);
+            }
+            continue;
+        }
+        if (isInsideCodeBlock) {
+            if (currentCommitment) {
+                // If we are inside a commitment and a code block, the line is part of the commitment
+                currentCommitment.contentLines.push(line);
+            }
+            else {
+                // If we are inside a code block but not a commitment, the line is non-commitment
+                nonCommitmentLines.push(line);
+            }
+            continue;
+        }
         // Check if this line starts a new commitment
         let foundNewCommitment = false;
         for (const definition of COMMITMENT_REGISTRY) {
@@ -7426,7 +7562,24 @@ function parseAgentSource(agentSource) {
     const meta = {};
     const links = [];
     const capabilities = [];
+    const samples = [];
+    let pendingUserMessage = null;
     for (const commitment of parseResult.commitments) {
+        if (commitment.type === 'INITIAL MESSAGE') {
+            samples.push({ question: null, answer: commitment.content });
+            continue;
+        }
+        if (commitment.type === 'USER MESSAGE') {
+            pendingUserMessage = commitment.content;
+            continue;
+        }
+        if (commitment.type === 'AGENT MESSAGE') {
+            if (pendingUserMessage !== null) {
+                samples.push({ question: pendingUserMessage, answer: commitment.content });
+                pendingUserMessage = null;
+            }
+            continue;
+        }
         if (commitment.type === 'USE BROWSER') {
             capabilities.push({
                 type: 'browser',
@@ -7443,6 +7596,37 @@ function parseAgentSource(agentSource) {
             });
             continue;
         }
+        if (commitment.type === 'USE TIME') {
+            capabilities.push({
+                type: 'time',
+                label: 'Time',
+                iconName: 'Clock',
+            });
+            continue;
+        }
+        if (commitment.type === 'IMPORT') {
+            const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
+            let label = content;
+            const iconName = 'Download';
+            try {
+                if (content.startsWith('http://') || content.startsWith('https://')) {
+                    const url = new URL(content);
+                    label = url.hostname.replace(/^www\./, '') + '.../' + url.pathname.split('/').pop();
+                }
+                else if (content.startsWith('./') || content.startsWith('../') || content.startsWith('/')) {
+                    label = content.split('/').pop() || content;
+                }
+            }
+            catch (e) {
+                // Invalid URL or path, keep default label
+            }
+            capabilities.push({
+                type: 'knowledge',
+                label,
+                iconName,
+            });
+            continue;
+        }
         if (commitment.type === 'KNOWLEDGE') {
             const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
             let label = content;
@@ -7527,6 +7711,7 @@ function parseAgentSource(agentSource) {
         links,
         parameters,
         capabilities,
+        samples,
     };
 }
 /**
@@ -8596,13 +8781,17 @@ function BookEditorMonaco(props) {
         // Register a new language
         monaco.languages.register({ id: BOOK_LANGUAGE_ID });
         const commitmentTypes = [...new Set(getAllCommitmentDefinitions().map(({ type }) => type))];
-        const commitmentRegex = new RegExp(`^(${commitmentTypes.map((type) => (type === 'META' ? 'META\\s+\\w+' : type)).join('|')})`);
+        const commitmentRegex = new RegExp(`^\\s*(${commitmentTypes
+            .sort((a, b) => b.length - a.length) // [1] Prefer longer commitments to avoid partial matching (e.g. LANGUAGES vs LANGUAGE)
+            .map((type) => (type === 'META' ? 'META\\s+\\w+' : type.replace(/\s+/, '\\s+')))
+            .join('|')})(?=\\s|$)`);
         // Note: Using a broad character set for Latin and Cyrillic to support international characters in parameters.
         //       Monarch tokenizer does not support Unicode property escapes like \p{L}.
         const parameterRegex = /@([a-zA-Z0-9_á-žÁ-Žč-řČ-Řš-žŠ-Žа-яА-ЯёЁ]+)/;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const bookRules = [
             [/^---[-]*$/, ''],
+            [/^```.*$/, 'code-block', '@codeblock'],
             [parameterRegex, 'parameter'],
             [/\{[^}]+\}/, 'parameter'],
             [commitmentRegex, 'commitment'],
@@ -8614,10 +8803,15 @@ function BookEditorMonaco(props) {
                 root: [
                     [/^\s*$/, 'empty'],
                     [/^-*$/, 'line'],
+                    [/^```.*$/, 'code-block', '@codeblock'],
                     [/^.*$/, 'title', '@body'],
                     [commitmentRegex, 'commitment'],
                 ],
                 body: bookRules,
+                codeblock: [
+                    [/^```.*$/, 'code-block', '@pop'],
+                    [/^.*$/, 'code-block'],
+                ],
             },
         });
         // Register a completion item provider for the language
@@ -8659,6 +8853,10 @@ function BookEditorMonaco(props) {
                     foreground: PROMPTBOOK_SYNTAX_COLORS.PARAMETER.toHex(),
                     fontStyle: `italic`,
                 },
+                {
+                    token: 'code-block',
+                    foreground: PROMPTBOOK_SYNTAX_COLORS.CODE_BLOCK.toHex(),
+                },
             ],
             colors: {
                 'editor.scrollbarSlider.background': '#E0E0E0',
@@ -8715,12 +8913,35 @@ function BookEditorMonaco(props) {
             .${instanceClass} .monaco-editor .transparent-text {
                 color: transparent !important;
             }
+            
+            .${instanceClass} .monaco-editor .code-block-box {
+                background-color: #f5f5f566;
+                border-left: 1px solid ${PROMPTBOOK_SYNTAX_COLORS.CODE_BLOCK.toHex()};
+                border-right: 1px solid ${PROMPTBOOK_SYNTAX_COLORS.CODE_BLOCK.toHex()};
+                padding-left: ${Math.round(8 * zoomLevel)}px;
+                padding-right: ${Math.round(8 * zoomLevel)}px;
+            }
+            
+            .${instanceClass} .monaco-editor .code-block-top {
+                border-top: 1px solid ${PROMPTBOOK_SYNTAX_COLORS.CODE_BLOCK.toHex()};
+                border-top-left-radius: ${Math.round(10 * zoomLevel)}px;
+                border-top-right-radius: ${Math.round(10 * zoomLevel)}px;
+                overflow: hidden;
+            }
+            
+            .${instanceClass} .monaco-editor .code-block-bottom {
+                border-bottom: 1px solid ${PROMPTBOOK_SYNTAX_COLORS.CODE_BLOCK.toHex()};
+                border-bottom-left-radius: ${Math.round(10 * zoomLevel)}px;
+                border-bottom-right-radius: ${Math.round(10 * zoomLevel)}px;
+                overflow: hidden;
+            }
         `;
         return () => {
             // Note: Style is not removed on purpose to avoid flickering during development with fast refresh
         };
     }, [scaledLineHeight, scaledContentPaddingLeft, scaledVerticalLineLeft]);
     const decorationIdsRef = useRef([]);
+    const codeBlockDecorationIdsRef = useRef([]);
     useEffect(() => {
         if (!editor || !monaco) {
             return;
@@ -8749,6 +8970,39 @@ function BookEditorMonaco(props) {
                 });
             }
             decorationIdsRef.current = editor.deltaDecorations(decorationIdsRef.current, newDecorations);
+            // Add decorations for code blocks
+            const lines = text.split('\n');
+            const codeBlockDecorations = [];
+            let inCodeBlock = false;
+            let codeBlockStartLine = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (line === null || line === void 0 ? void 0 : line.trim().startsWith('```')) {
+                    if (!inCodeBlock) {
+                        // Starting a code block
+                        inCodeBlock = true;
+                        codeBlockStartLine = i + 1; // 1-based line number
+                    }
+                    else {
+                        // Ending a code block
+                        inCodeBlock = false;
+                        const endLine = i + 1; // 1-based line number
+                        // Add decorations for each line in the code block
+                        for (let j = codeBlockStartLine; j <= endLine; j++) {
+                            const isFirst = j === codeBlockStartLine;
+                            const isLast = j === endLine;
+                            codeBlockDecorations.push({
+                                range: new monaco.Range(j, 1, j, 1),
+                                options: {
+                                    isWholeLine: true,
+                                    className: `code-block-box${isFirst ? ' code-block-top' : ''}${isLast ? ' code-block-bottom' : ''}`,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+            codeBlockDecorationIdsRef.current = editor.deltaDecorations(codeBlockDecorationIdsRef.current, codeBlockDecorations);
         };
         updateDecorations();
         const changeListener = editor.onDidChangeModelContent(() => {
@@ -12716,74 +12970,90 @@ function addUsage(...usageItems) {
  * in real-time through an observable.
  *
  * @param llmTools - The LLM tools to be intercepted and tracked
- * @returns An augmented version of the tools that includes usage tracking capabilities
+ * @returns Full proxy of the tools with added usage tracking capabilities
  * @public exported from `@promptbook/core`
  */
 function countUsage(llmTools) {
     let totalUsage = ZERO_USAGE;
     const spending = new Subject();
-    const proxyTools = {
-        get title() {
-            return `${llmTools.title} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        get description() {
-            return `${llmTools.description} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        checkConfiguration() {
-            return /* not await */ llmTools.checkConfiguration();
-        },
-        listModels() {
-            return /* not await */ llmTools.listModels();
-        },
-        spending() {
-            return spending.asObservable();
-        },
-        getTotalUsage() {
-            // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
-            return totalUsage;
+    // Create a Proxy to intercept all property access and ensure full proxying of all properties
+    const proxyTools = new Proxy(llmTools, {
+        get(target, prop, receiver) {
+            // Handle title property
+            if (prop === 'title') {
+                return `${target.title} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle description property
+            if (prop === 'description') {
+                return `${target.description} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle spending method (new method added by this wrapper)
+            if (prop === 'spending') {
+                return () => {
+                    return spending.asObservable();
+                };
+            }
+            // Handle getTotalUsage method (new method added by this wrapper)
+            if (prop === 'getTotalUsage') {
+                // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
+                return () => {
+                    return totalUsage;
+                };
+            }
+            // Handle callChatModel method with usage counting
+            if (prop === 'callChatModel' && target.callChatModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callChatModel through countTotalUsage');
+                    const promptResult = await target.callChatModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callCompletionModel method with usage counting
+            if (prop === 'callCompletionModel' && target.callCompletionModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callCompletionModel through countTotalUsage');
+                    const promptResult = await target.callCompletionModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callEmbeddingModel method with usage counting
+            if (prop === 'callEmbeddingModel' && target.callEmbeddingModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callEmbeddingModel through countTotalUsage');
+                    const promptResult = await target.callEmbeddingModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callImageGenerationModel method with usage counting
+            if (prop === 'callImageGenerationModel' && target.callImageGenerationModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callImageGenerationModel through countTotalUsage');
+                    const promptResult = await target.callImageGenerationModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // <- Note: [🤖]
+            // For all other properties and methods, delegate to the original target
+            const value = Reflect.get(target, prop, receiver);
+            // If it's a function, bind it to the target to preserve context
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
         },
-    };
-    if (llmTools.callChatModel !== undefined) {
-        proxyTools.callChatModel = async (prompt) => {
-            // console.info('[🚕] callChatModel through countTotalUsage');
-            const promptResult = await llmTools.callChatModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callCompletionModel !== undefined) {
-        proxyTools.callCompletionModel = async (prompt) => {
-            // console.info('[🚕] callCompletionModel through countTotalUsage');
-            const promptResult = await llmTools.callCompletionModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callEmbeddingModel !== undefined) {
-        proxyTools.callEmbeddingModel = async (prompt) => {
-            // console.info('[🚕] callEmbeddingModel through countTotalUsage');
-            const promptResult = await llmTools.callEmbeddingModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callImageGenerationModel !== undefined) {
-        proxyTools.callImageGenerationModel = async (prompt) => {
-            // console.info('[🚕] callImageGenerationModel through countTotalUsage');
-            const promptResult = await llmTools.callImageGenerationModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    // <- Note: [🤖]
+    });
     return proxyTools;
 }
 /**
@@ -15563,6 +15833,97 @@ function createBasicAgentModelRequirements(agentName) {
  * TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
  */
 
+/**
+ * Plugin for importing agent books *(`.book` files)*
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const AgentFileImportPlugin = {
+    name: 'agent-file-import-plugin',
+    canImport(mimeType) {
+        // [🧠] Should we have a specific MIME type for agent books?
+        // For now, let's assume it's identified by .book extension or certain MIME types if provided
+        return mimeType === 'text/x-promptbook' || mimeType === 'application/x-promptbook';
+    },
+    import(content) {
+        const parseResult = parseAgentSourceWithCommitments(content);
+        // Bring only the agent corpus (non-commitment lines and relevant commitments)
+        // Stripping the agent name (which is usually the first line)
+        const corpus = parseResult.nonCommitmentLines
+            .filter((line, index) => index > 0 || !parseResult.agentName)
+            .join('\n')
+            .trim();
+        // Also include relevant commitments that make up the "corpus" of the agent
+        // For example PERSONA, RULE, KNOWLEDGE
+        const relevantCommitments = parseResult.commitments
+            .filter((c) => ['PERSONA', 'RULE', 'KNOWLEDGE'].includes(c.type))
+            .map((c) => `${c.type} ${c.content}`)
+            .join('\n\n');
+        return spaceTrim$1((block) => `
+                ${block(relevantCommitments)}
+
+                ${block(corpus)}
+            `).trim();
+    },
+};
+
+/**
+ * Plugin for importing JSON files
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const JsonFileImportPlugin = {
+    name: 'json-file-import-plugin',
+    canImport(mimeType) {
+        return mimeType === 'application/json' || mimeType.endsWith('+json');
+    },
+    import(content) {
+        try {
+            const json = JSON.parse(content);
+            const formattedJson = JSON.stringify(json, null, 4);
+            return `\`\`\`json\n${formattedJson}\n\`\`\``;
+        }
+        catch (error) {
+            // If JSON is invalid, still import it but maybe not as pretty JSON
+            return `\`\`\`json\n${content}\n\`\`\``;
+        }
+    },
+};
+
+/**
+ * Plugin for importing generic text files
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const TextFileImportPlugin = {
+    name: 'text-file-import-plugin',
+    canImport(mimeType) {
+        return (mimeType === 'text/plain' ||
+            mimeType === 'text/markdown' ||
+            mimeType === 'text/x-typescript' ||
+            mimeType === 'text/javascript' ||
+            mimeType === 'text/css' ||
+            mimeType === 'text/html' ||
+            mimeType.startsWith('text/'));
+    },
+    import(content, mimeType) {
+        const extension = mimeTypeToExtension(mimeType);
+        const codeBlockType = extension || 'txt';
+        return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+    },
+};
+
+/**
+ * All available file import plugins
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const $fileImportPlugins = [
+    AgentFileImportPlugin,
+    JsonFileImportPlugin,
+    TextFileImportPlugin,
+];
+
 /**
  * Removes comment lines (lines starting with #) from a system message
  * This is used to clean up the final system message before sending it to the AI model
@@ -15594,6 +15955,7 @@ function removeCommentsFromSystemMessage(systemMessage) {
  * @public exported from `@promptbook/core`
  */
 async function createAgentModelRequirementsWithCommitments(agentSource, modelName) {
+    var _a;
     // Parse the agent source to extract commitments
     const parseResult = parseAgentSourceWithCommitments(agentSource);
     // Apply DELETE filtering: remove prior commitments tagged by parameters targeted by DELETE/CANCEL/DISCARD/REMOVE
@@ -15660,6 +16022,64 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
             }
         }
     }
+    // Handle IMPORT commitments for generic files
+    // Note: This logic could be moved to ImportCommitmentDefinition, but it needs to be asynchronous
+    if (requirements.importedFileUrls && requirements.importedFileUrls.length > 0) {
+        for (const fileUrl of requirements.importedFileUrls) {
+            try {
+                // 1. Mocked security check
+                await mockedSecurityCheck(fileUrl);
+                // 2. Fetch file content
+                let content;
+                let mimeType = null;
+                if (isValidUrl(fileUrl)) {
+                    const response = await promptbookFetch(fileUrl);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch ${fileUrl}: ${response.statusText}`);
+                    }
+                    content = await response.text();
+                    mimeType = response.headers.get('Content-Type');
+                    /*
+                TODO: !!!! Commented out this case because we need to work in Browser-compatible mode in many packages, use passed `fs` instead
+                } else if (isValidFilePath(fileUrl)) {
+                    // [x🟢x] This code is expected to run in Node environment if local files are used
+                    const fs = await import('fs/promises');
+                    content = await fs.readFile(fileUrl, 'utf-8');
+                    const extension = getFileExtension(fileUrl);
+                    mimeType = extensionToMimeType(extension as string);
+                */
+                }
+                else {
+                    throw new Error(`Invalid file URL or path: ${fileUrl}`);
+                }
+                if (!mimeType) {
+                    mimeType = 'text/plain';
+                }
+                // Remove charset from mime type
+                mimeType = mimeType.split(';')[0].trim();
+                // 3. Prevent importing binary files (mocked check)
+                if (isBinaryMimeType(mimeType)) {
+                    throw new Error(`Importing binary files is not allowed: ${mimeType}`);
+                }
+                // 4. Find appropriate plugin
+                const plugin = $fileImportPlugins.find((p) => p.canImport(mimeType));
+                if (!plugin) {
+                    throw new Error(`No import plugin found for MIME type: ${mimeType}`);
+                }
+                // 5. Process content
+                const importedContent = await plugin.import(content, mimeType);
+                // 6. Append to system message
+                requirements = {
+                    ...requirements,
+                    systemMessage: requirements.systemMessage + '\n\n' + importedContent,
+                };
+            }
+            catch (error) {
+                console.warn(`Failed to import file ${fileUrl}:`, error);
+                // Continue with other imports even if one fails
+            }
+        }
+    }
     // Handle MCP servers (extract from original agent source)
     const mcpServers = extractMcpServers(agentSource);
     if (mcpServers.length > 0) {
@@ -15669,9 +16089,11 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
         };
     }
     // Add non-commitment lines to system message if they exist
+    // Note: Filtering out horizontal lines (---) as requested
     const nonCommitmentContent = parseResult.nonCommitmentLines
         .filter((line, index) => index > 0 || !parseResult.agentName) // Skip first line if it's the agent name
         .filter((line) => line.trim()) // Remove empty lines
+        .filter((line) => !/^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/.test(line)) // Remove horizontal lines
         .join('\n')
         .trim();
     if (nonCommitmentContent) {
@@ -15680,6 +16102,26 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
             systemMessage: requirements.systemMessage + '\n\n' + nonCommitmentContent,
         };
     }
+    // Add example interactions to the system message
+    const examples = [];
+    // 1. Initial message as an example agent response
+    const initialMessage = (_a = parseResult.commitments.find((c) => c.type === 'INITIAL MESSAGE')) === null || _a === void 0 ? void 0 : _a.content;
+    if (initialMessage) {
+        examples.push(`Agent: ${initialMessage}`);
+    }
+    // 2. User and Agent message pairs
+    if (requirements.samples && requirements.samples.length > 0) {
+        for (const sample of requirements.samples) {
+            examples.push(`User: ${sample.question}\nAgent: ${sample.answer}`);
+        }
+    }
+    if (examples.length > 0) {
+        const exampleInteractionsContent = `Example interaction:\n\n${examples.join('\n\n')}`;
+        requirements = {
+            ...requirements,
+            systemMessage: requirements.systemMessage + '\n\n' + exampleInteractionsContent,
+        };
+    }
     // Remove comment lines (lines starting with #) from the final system message
     // while preserving the original content with comments in metadata
     const cleanedSystemMessage = removeCommentsFromSystemMessage(requirements.systemMessage);
@@ -15688,6 +16130,36 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
         systemMessage: cleanedSystemMessage,
     };
 }
+/**
+ * Mocked security check for imported files
+ *
+ * @param urlOrPath - The URL or local path of the file to check
+ * @returns A promise that resolves if the file is safe
+ */
+async function mockedSecurityCheck(urlOrPath) {
+    // TODO: Implement proper security checks
+    await new Promise((resolve) => setTimeout(resolve, 10)); // Mock async delay
+    if (urlOrPath.includes('malicious')) {
+        throw new Error(`Security check failed for: ${urlOrPath}`);
+    }
+}
+/**
+ * Checks if the given MIME type belongs to a binary file
+ *
+ * @param mimeType - The MIME type to check
+ * @returns True if it's a binary MIME type
+ */
+function isBinaryMimeType(mimeType) {
+    const binaryPrefixes = [
+        'image/',
+        'video/',
+        'audio/',
+        'application/octet-stream',
+        'application/pdf',
+        'application/zip',
+    ];
+    return binaryPrefixes.some((prefix) => mimeType.startsWith(prefix));
+}
 
 /**
  * Creates model requirements for an agent based on its source
@@ -17514,7 +17986,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
      * Calls OpenAI API to use a chat model with streaming.
      */
     async callChatModelStream(prompt, onProgress) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         if (this.options.isVerbose) {
             console.info('💬 OpenAI callChatModel call', { prompt });
         }
@@ -17569,6 +18041,131 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         }
         // Always add the current user message
         threadMessages.push({ role: 'user', content: rawPromptContent });
+        // Check if tools are being used - if so, use non-streaming mode
+        const hasTools = modelRequirements.tools !== undefined && modelRequirements.tools.length > 0;
+        const start = $getCurrentDate();
+        let complete;
+        // [🐱‍🚀] When tools are present, we need to use the non-streaming Runs API
+        // because streaming doesn't support tool execution flow properly
+        if (hasTools) {
+            const rawRequest = {
+                assistant_id: this.assistantId,
+                thread: {
+                    messages: threadMessages,
+                },
+                tools: mapToolsToOpenAi(modelRequirements.tools),
+            };
+            if (this.options.isVerbose) {
+                console.info(colors.bgWhite('rawRequest (non-streaming with tools)'), JSON.stringify(rawRequest, null, 4));
+            }
+            // Create thread and run
+            const threadAndRun = await client.beta.threads.createAndRun(rawRequest);
+            let run = threadAndRun;
+            // Poll until run completes or requires action
+            while (run.status === 'queued' || run.status === 'in_progress' || run.status === 'requires_action') {
+                if (run.status === 'requires_action' && ((_a = run.required_action) === null || _a === void 0 ? void 0 : _a.type) === 'submit_tool_outputs') {
+                    // Execute tools
+                    const toolCalls = run.required_action.submit_tool_outputs.tool_calls;
+                    const toolOutputs = [];
+                    for (const toolCall of toolCalls) {
+                        if (toolCall.type === 'function') {
+                            const functionName = toolCall.function.name;
+                            const functionArgs = JSON.parse(toolCall.function.arguments);
+                            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: {}, // <- TODO: [🧠] What parameters to pass?
+                                });
+                                if (this.options.isVerbose) {
+                                    console.info(`✅ Tool ${functionName} executed:`, functionResponse);
+                                }
+                            }
+                            catch (error) {
+                                assertsError(error);
+                                functionResponse = spaceTrim$2((block) => `
+                                    
+                                        The invoked tool \`${functionName}\` failed with error:
+                                        
+                                        \`\`\`json
+                                        ${block(JSON.stringify(serializeError(error), null, 4))}
+                                        \`\`\`
+
+                                    `);
+                                console.error(colors.bgRed(`❌ Error executing tool ${functionName}:`));
+                                console.error(error);
+                            }
+                            toolOutputs.push({
+                                tool_call_id: toolCall.id,
+                                output: functionResponse,
+                            });
+                        }
+                    }
+                    // Submit tool outputs
+                    run = await client.beta.threads.runs.submitToolOutputs(run.thread_id, run.id, {
+                        tool_outputs: toolOutputs,
+                    });
+                }
+                else {
+                    // Wait a bit before polling again
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                    run = await client.beta.threads.runs.retrieve(run.thread_id, run.id);
+                }
+            }
+            if (run.status !== 'completed') {
+                throw new PipelineExecutionError(`Assistant run failed with status: ${run.status}`);
+            }
+            // Get messages from the thread
+            const messages = await client.beta.threads.messages.list(run.thread_id);
+            const assistantMessages = messages.data.filter((msg) => msg.role === 'assistant');
+            if (assistantMessages.length === 0) {
+                throw new PipelineExecutionError('No assistant messages found after run completion');
+            }
+            const lastMessage = assistantMessages[0];
+            const textContent = lastMessage.content.find((c) => c.type === 'text');
+            if (!textContent || textContent.type !== 'text') {
+                throw new PipelineExecutionError('No text content in assistant response');
+            }
+            complete = $getCurrentDate();
+            const resultContent = textContent.text.value;
+            const usage = UNCERTAIN_USAGE;
+            // Progress callback with final result
+            const finalChunk = {
+                content: resultContent,
+                modelName: 'assistant',
+                timing: { start, complete },
+                usage,
+                rawPromptContent,
+                rawRequest,
+                rawResponse: { run, messages: messages.data },
+            };
+            onProgress(finalChunk);
+            return exportJson({
+                name: 'promptResult',
+                message: `Result of \`OpenAiAssistantExecutionTools.callChatModelStream\` (with tools)`,
+                order: [],
+                value: finalChunk,
+            });
+        }
+        // Streaming mode (without tools)
         const rawRequest = {
             // TODO: [👨‍👨‍👧‍👧] ...modelSettings,
             // TODO: [👨‍👨‍👧‍👧][🧠] What about system message for assistants, does it make sense - combination of OpenAI assistants with Promptbook Personas
@@ -17579,10 +18176,8 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             tools: modelRequirements.tools === undefined ? undefined : mapToolsToOpenAi(modelRequirements.tools),
             // <- TODO: Add user identification here> user: this.options.user,
         };
-        const start = $getCurrentDate();
-        let complete;
         if (this.options.isVerbose) {
-            console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
+            console.info(colors.bgWhite('rawRequest (streaming)'), JSON.stringify(rawRequest, null, 4));
         }
         const stream = await client.beta.threads.createAndRunStream(rawRequest);
         stream.on('connect', () => {
@@ -17618,6 +18213,15 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                 console.info('messageDone', message);
             }
         });
+        // TODO: [🐱‍🚀] Handle tool calls in assistants
+        // Note: OpenAI Assistant streaming with tool calls requires special handling.
+        // The stream will pause when a tool call is needed, and we need to:
+        // 1. Wait for the run to reach 'requires_action' status
+        // 2. Execute the tool calls
+        // 3. Submit tool outputs via a separate API call (not on the stream)
+        // 4. Continue the run
+        // This requires switching to non-streaming mode or using the Runs API directly.
+        // For now, tools with assistants should use the non-streaming chat completions API instead.
         const rawResponse = await stream.finalMessages();
         if (this.options.isVerbose) {
             console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
@@ -17628,10 +18232,10 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         if (rawResponse[0].content.length !== 1) {
             throw new PipelineExecutionError(`There is NOT 1 BUT ${rawResponse[0].content.length} finalMessages content from OpenAI`);
         }
-        if (((_a = rawResponse[0].content[0]) === null || _a === void 0 ? void 0 : _a.type) !== 'text') {
-            throw new PipelineExecutionError(`There is NOT 'text' BUT ${(_b = rawResponse[0].content[0]) === null || _b === void 0 ? void 0 : _b.type} finalMessages content type from OpenAI`);
+        if (((_b = rawResponse[0].content[0]) === null || _b === void 0 ? void 0 : _b.type) !== 'text') {
+            throw new PipelineExecutionError(`There is NOT 'text' BUT ${(_c = rawResponse[0].content[0]) === null || _c === void 0 ? void 0 : _c.type} finalMessages content type from OpenAI`);
         }
-        const resultContent = (_c = rawResponse[0].content[0]) === null || _c === void 0 ? void 0 : _c.text.value;
+        const resultContent = (_d = rawResponse[0].content[0]) === null || _d === void 0 ? void 0 : _d.text.value;
         //                                                     <- TODO: [🧠] There are also annotations, maybe use them
         // eslint-disable-next-line prefer-const
         complete = $getCurrentDate();
@@ -17699,7 +18303,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             throw new NotAllowed(`Creating new assistants is not allowed. Set \`isCreatingNewAssistantsAllowed: true\` in options to enable this feature.`);
         }
         // await this.playground();
-        const { name, instructions, knowledgeSources } = options;
+        const { name, instructions, knowledgeSources, tools } = options;
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
@@ -17770,7 +18374,11 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             description: 'Assistant created via Promptbook',
             model: 'gpt-4o',
             instructions,
-            tools: [/* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */ { type: 'file_search' }],
+            tools: [
+                /* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */
+                { type: 'file_search' },
+                ...(tools === undefined ? [] : mapToolsToOpenAi(tools)),
+            ],
         };
         // Attach vector store if created
         if (vectorStoreId) {
@@ -17795,7 +18403,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         if (!this.isCreatingNewAssistantsAllowed) {
             throw new NotAllowed(`Updating assistants is not allowed. Set \`isCreatingNewAssistantsAllowed: true\` in options to enable this feature.`);
         }
-        const { assistantId, name, instructions, knowledgeSources } = options;
+        const { assistantId, name, instructions, knowledgeSources, tools } = options;
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
@@ -17864,7 +18472,11 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         const assistantUpdate = {
             name,
             instructions,
-            tools: [/* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */ { type: 'file_search' }],
+            tools: [
+                /* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */
+                { type: 'file_search' },
+                ...(tools === undefined ? [] : mapToolsToOpenAi(tools)),
+            ],
         };
         if (vectorStoreId) {
             assistantUpdate.tool_resources = {
@@ -17905,6 +18517,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
  */
 const DISCRIMINANT = 'OPEN_AI_ASSISTANT_V1';
 /**
+ * TODO: [🙎] In `OpenAiAssistantExecutionTools` Allow to create abstract assistants with `isCreatingNewAssistantsAllowed`
  * TODO: [🧠][🧙‍♂️] Maybe there can be some wizard for those who want to use just OpenAI
  * TODO: Maybe make custom OpenAiError
  * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
@@ -17963,8 +18576,10 @@ class AgentLlmExecutionTools {
     }
     /**
      * Get cached or create agent model requirements
+     *
+     * Note: [🐤] This is names `getModelRequirements` *(not `getAgentModelRequirements`)* because in future these two will be united
      */
-    async getAgentModelRequirements() {
+    async getModelRequirements() {
         if (this._cachedModelRequirements === null) {
             // Get available models from underlying LLM tools for best model selection
             const availableModels = await this.options.llmTools.listModels();
@@ -18034,9 +18649,25 @@ class AgentLlmExecutionTools {
         if (prompt.modelRequirements.modelVariant !== 'CHAT') {
             throw new Error('AgentLlmExecutionTools only supports chat prompts');
         }
-        const modelRequirements = await this.getAgentModelRequirements();
+        const modelRequirements = await this.getModelRequirements();
         const chatPrompt = prompt;
         let underlyingLlmResult;
+        // Create modified chat prompt with agent system message
+        const promptWithAgentModelRequirements = {
+            ...chatPrompt,
+            modelRequirements: {
+                ...chatPrompt.modelRequirements,
+                ...modelRequirements,
+                // Spread tools to convert readonly array to mutable
+                tools: modelRequirements.tools ? [...modelRequirements.tools] : chatPrompt.modelRequirements.tools,
+                // Prepend agent system message to existing system message
+                systemMessage: modelRequirements.systemMessage +
+                    (chatPrompt.modelRequirements.systemMessage
+                        ? `\n\n${chatPrompt.modelRequirements.systemMessage}`
+                        : ''),
+            },
+        };
+        console.log('!!!! promptWithAgentModelRequirements:', promptWithAgentModelRequirements);
         if (OpenAiAssistantExecutionTools.isOpenAiAssistantExecutionTools(this.options.llmTools)) {
             const requirementsHash = SHA256(JSON.stringify(modelRequirements)).toString();
             const cached = AgentLlmExecutionTools.assistantCache.get(this.title);
@@ -18057,6 +18688,7 @@ class AgentLlmExecutionTools {
                         name: this.title,
                         instructions: modelRequirements.systemMessage,
                         knowledgeSources: modelRequirements.knowledgeSources,
+                        tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                     });
                     AgentLlmExecutionTools.assistantCache.set(this.title, {
                         assistantId: assistant.assistantId,
@@ -18073,6 +18705,7 @@ class AgentLlmExecutionTools {
                     name: this.title,
                     instructions: modelRequirements.systemMessage,
                     knowledgeSources: modelRequirements.knowledgeSources,
+                    tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                     /*
                     !!!
                     metadata: {
@@ -18085,32 +18718,28 @@ class AgentLlmExecutionTools {
                     requirementsHash,
                 });
             }
-            underlyingLlmResult = await assistant.callChatModelStream(chatPrompt, onProgress);
+            // Create modified chat prompt with agent system message specific to OpenAI Assistant
+            const promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools = {
+                ...promptWithAgentModelRequirements,
+                modelRequirements: {
+                    ...promptWithAgentModelRequirements.modelRequirements,
+                    modelName: undefined,
+                    systemMessage: undefined,
+                    temperature: undefined, // <- Note: Let the Assistant use its default temperature
+                },
+            };
+            console.log('!!!! promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools:', promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools);
+            underlyingLlmResult = await assistant.callChatModelStream(promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools, onProgress);
         }
         else {
             if (this.options.isVerbose) {
                 console.log(`2️⃣ Creating Assistant ${this.title} on generic LLM execution tools...`);
             }
-            // Create modified chat prompt with agent system message
-            const modifiedChatPrompt = {
-                ...chatPrompt,
-                modelRequirements: {
-                    ...chatPrompt.modelRequirements,
-                    ...modelRequirements,
-                    // Spread tools to convert readonly array to mutable
-                    tools: modelRequirements.tools ? [...modelRequirements.tools] : chatPrompt.modelRequirements.tools,
-                    // Prepend agent system message to existing system message
-                    systemMessage: modelRequirements.systemMessage +
-                        (chatPrompt.modelRequirements.systemMessage
-                            ? `\n\n${chatPrompt.modelRequirements.systemMessage}`
-                            : ''),
-                },
-            };
             if (this.options.llmTools.callChatModelStream) {
-                underlyingLlmResult = await this.options.llmTools.callChatModelStream(modifiedChatPrompt, onProgress);
+                underlyingLlmResult = await this.options.llmTools.callChatModelStream(promptWithAgentModelRequirements, onProgress);
             }
             else if (this.options.llmTools.callChatModel) {
-                underlyingLlmResult = await this.options.llmTools.callChatModel(modifiedChatPrompt);
+                underlyingLlmResult = await this.options.llmTools.callChatModel(promptWithAgentModelRequirements);
                 onProgress(underlyingLlmResult);
             }
             else {
@@ -18139,7 +18768,8 @@ AgentLlmExecutionTools.assistantCache = new Map();
  * TODO: [🧠] Adding parameter substitution support (here or should be responsibility of the underlying LLM Tools)
  */
 
-var _Agent_instances, _Agent_selfLearn;
+var _Agent_instances, _Agent_selfLearnSamples;
+// !!!!! import { RemoteAgent } from './RemoteAgent'; // <- [💞] <- !!!!!
 /**
  * Represents one AI Agent
  *
@@ -18199,6 +18829,10 @@ class Agent extends AgentLlmExecutionTools {
          * This is parsed from commitments like USE BROWSER, USE SEARCH ENGINE, KNOWLEDGE, etc.
          */
         this.capabilities = [];
+        /**
+         * List of sample conversations (question/answer pairs)
+         */
+        this.samples = [];
         /**
          * Metadata like image or color
          */
@@ -18208,12 +18842,13 @@ class Agent extends AgentLlmExecutionTools {
         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 };
         });
     }
@@ -18225,10 +18860,10 @@ class Agent extends AgentLlmExecutionTools {
     async callChatModelStream(prompt, onProgress) {
         var _a;
         // [1] Check if the user is asking the same thing as in the samples
-        const modelRequirements = await this.getAgentModelRequirements();
+        const modelRequirements = await this.getModelRequirements();
         if (modelRequirements.samples) {
             const normalizedPrompt = normalizeMessageText(prompt.content);
-            const sample = modelRequirements.samples.find((sample) => normalizeMessageText(sample.question) === normalizedPrompt);
+            const sample = modelRequirements.samples.find((sample) => sample.question !== null && normalizeMessageText(sample.question) === normalizedPrompt);
             if (sample) {
                 const now = new Date().toISOString();
                 const result = {
@@ -18274,17 +18909,22 @@ class Agent extends AgentLlmExecutionTools {
         if ((_a = modelRequirements.metadata) === null || _a === void 0 ? void 0 : _a.isClosed) {
             return result;
         }
-        await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearn).call(this, prompt, result);
-        // <- TODO: !!!! Do not await self-learn, run in background with error handling
+        // TODO: !!!!! Is this timed properly?
+        // Note: [1] Do the append of the samples
+        __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
+        this.#selfLearnTeacher(prompt, result).catch((error) => {
+            if (this.options.isVerbose) {
+                console.error('Failed to self-learn from teacher agent', error);
+            }
+        });
+        */
         return result;
     }
 }
-_Agent_instances = new WeakSet(), _Agent_selfLearn = 
-/**
- * Self-learning: Appends the conversation and extracted knowledge to the agent source
- */
-async function _Agent_selfLearn(prompt, result) {
-    // Learning: Append the conversation sample to the agent source
+_Agent_instances = new WeakSet(), _Agent_selfLearnSamples = function _Agent_selfLearnSamples(prompt, result) {
     const learningExample = spaceTrim$2((block) => `
 
                 ---
@@ -18296,52 +18936,9 @@ async function _Agent_selfLearn(prompt, result) {
                 ${block(result.content)}
 
             `);
-    // Extract knowledge
-    let knowledgeBlock = '';
-    try {
-        const extractionPrompt = {
-            title: 'Knowledge Extraction',
-            modelRequirements: {
-                modelVariant: 'CHAT',
-            },
-            content: spaceTrim$2((block) => `
-                        You are an AI agent that is learning from a conversation.
-
-                        Here is the conversation so far:
-
-                        User: ${block(prompt.content)}
-                        Agent: ${block(result.content)}
-
-                        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.
-
-                        Example output:
-                        KNOWLEDGE The user's name is Alice.
-                        KNOWLEDGE The project deadline is next Friday.
-                    `),
-            pipelineUrl: 'https://github.com/webgptorg/promptbook/blob/main/prompts/knowledge-extraction.ptbk.md',
-            parameters: {},
-        };
-        if (this.options.llmTools.callChatModel) {
-            const extractionResult = await this.options.llmTools.callChatModel(extractionPrompt);
-            const extractedContent = extractionResult.content;
-            if (extractedContent.includes('KNOWLEDGE')) {
-                knowledgeBlock = '\n\n' + spaceTrim$2(extractedContent);
-            }
-        }
-        else {
-            // TODO: [🧠] Fallback to callChatModelStream if callChatModel is not available
-        }
-    }
-    catch (error) {
-        if (this.options.isVerbose) {
-            console.warn('Failed to extract knowledge', error);
-        }
-    }
     // Append to the current source
     const currentSource = this.agentSource.value;
-    const newSource = padBook(validateBook(spaceTrim$2(currentSource) + '\n\n' + learningExample + knowledgeBlock));
+    const newSource = padBook(validateBook(spaceTrim$2(currentSource) + '\n\n' + learningExample));
     // Update the source (which will trigger the subscription and update the underlying tools)
     this.agentSource.next(newSource);
 };