@promptbook/core 0.105.0-1 → 0.105.0-4

package/esm/index.es.js

@@ -27,7 +27,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-1';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.0-4';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -992,6 +992,7 @@ const PROMPTBOOK_SYNTAX_COLORS = {
     SEPARATOR: Color.fromHex('#cccccc'),
     COMMITMENT: Color.fromHex('#DA0F78'),
     PARAMETER: Color.fromHex('#8e44ad'),
+    CODE_BLOCK: Color.fromHex('#7700ffff'),
 };
 // <- TODO: [🧠][🈵] Using `Color` here increases the package size approx 3kb, maybe remove it
 /**
@@ -3649,74 +3650,90 @@ function addUsage(...usageItems) {
  * in real-time through an observable.
  *
  * @param llmTools - The LLM tools to be intercepted and tracked
- * @returns An augmented version of the tools that includes usage tracking capabilities
+ * @returns Full proxy of the tools with added usage tracking capabilities
  * @public exported from `@promptbook/core`
  */
 function countUsage(llmTools) {
     let totalUsage = ZERO_USAGE;
     const spending = new Subject();
-    const proxyTools = {
-        get title() {
-            return `${llmTools.title} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        get description() {
-            return `${llmTools.description} (+usage)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
-        },
-        checkConfiguration() {
-            return /* not await */ llmTools.checkConfiguration();
-        },
-        listModels() {
-            return /* not await */ llmTools.listModels();
-        },
-        spending() {
-            return spending.asObservable();
-        },
-        getTotalUsage() {
-            // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
-            return totalUsage;
+    // Create a Proxy to intercept all property access and ensure full proxying of all properties
+    const proxyTools = new Proxy(llmTools, {
+        get(target, prop, receiver) {
+            // Handle title property
+            if (prop === 'title') {
+                return `${target.title} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle description property
+            if (prop === 'description') {
+                return `${target.description} (+usage)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(+usage)"?
+            }
+            // Handle spending method (new method added by this wrapper)
+            if (prop === 'spending') {
+                return () => {
+                    return spending.asObservable();
+                };
+            }
+            // Handle getTotalUsage method (new method added by this wrapper)
+            if (prop === 'getTotalUsage') {
+                // <- Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
+                return () => {
+                    return totalUsage;
+                };
+            }
+            // Handle callChatModel method with usage counting
+            if (prop === 'callChatModel' && target.callChatModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callChatModel through countTotalUsage');
+                    const promptResult = await target.callChatModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callCompletionModel method with usage counting
+            if (prop === 'callCompletionModel' && target.callCompletionModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callCompletionModel through countTotalUsage');
+                    const promptResult = await target.callCompletionModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callEmbeddingModel method with usage counting
+            if (prop === 'callEmbeddingModel' && target.callEmbeddingModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callEmbeddingModel through countTotalUsage');
+                    const promptResult = await target.callEmbeddingModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // Handle callImageGenerationModel method with usage counting
+            if (prop === 'callImageGenerationModel' && target.callImageGenerationModel !== undefined) {
+                return async (prompt) => {
+                    // console.info('[🚕] callImageGenerationModel through countTotalUsage');
+                    const promptResult = await target.callImageGenerationModel(prompt);
+                    totalUsage = addUsage(totalUsage, promptResult.usage);
+                    spending.next(promptResult.usage);
+                    return promptResult;
+                };
+            }
+            // <- Note: [🤖]
+            // For all other properties and methods, delegate to the original target
+            const value = Reflect.get(target, prop, receiver);
+            // If it's a function, bind it to the target to preserve context
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
         },
-    };
-    if (llmTools.callChatModel !== undefined) {
-        proxyTools.callChatModel = async (prompt) => {
-            // console.info('[🚕] callChatModel through countTotalUsage');
-            const promptResult = await llmTools.callChatModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callCompletionModel !== undefined) {
-        proxyTools.callCompletionModel = async (prompt) => {
-            // console.info('[🚕] callCompletionModel through countTotalUsage');
-            const promptResult = await llmTools.callCompletionModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callEmbeddingModel !== undefined) {
-        proxyTools.callEmbeddingModel = async (prompt) => {
-            // console.info('[🚕] callEmbeddingModel through countTotalUsage');
-            const promptResult = await llmTools.callEmbeddingModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    if (llmTools.callImageGenerationModel !== undefined) {
-        proxyTools.callImageGenerationModel = async (prompt) => {
-            // console.info('[🚕] callImageGenerationModel through countTotalUsage');
-            const promptResult = await llmTools.callImageGenerationModel(prompt);
-            totalUsage = addUsage(totalUsage, promptResult.usage);
-            spending.next(promptResult.usage);
-            return promptResult;
-        };
-    }
-    // <- Note: [🤖]
+    });
     return proxyTools;
 }
 /**
@@ -7494,6 +7511,40 @@ async function preparePersona(personaDescription, tools, options) {
  * TODO: [🏢] Check validity of `temperature` in pipeline
  */
 
+/**
+ * Creates an empty/basic agent model requirements object
+ * This serves as the starting point for the reduce-like pattern
+ * where each commitment applies its changes to build the final requirements
+ *
+ * @public exported from `@promptbook/core`
+ */
+function createEmptyAgentModelRequirements() {
+    return {
+        systemMessage: '',
+        // modelName: 'gpt-5',
+        modelName: 'gemini-2.5-flash-lite',
+        temperature: 0.7,
+        topP: 0.9,
+        topK: 50,
+    };
+}
+/**
+ * Creates a basic agent model requirements with just the agent name
+ * This is used when we have an agent name but no commitments
+ *
+ * @public exported from `@promptbook/core`
+ */
+function createBasicAgentModelRequirements(agentName) {
+    const empty = createEmptyAgentModelRequirements();
+    return {
+        ...empty,
+        systemMessage: `You are ${agentName || 'AI Agent'}`,
+    };
+}
+/**
+ * TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
+ */
+
 /**
  * Generates a regex pattern to match a specific commitment
  *
@@ -7610,6 +7661,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 {};
+    }
 }
 
 /**
@@ -8708,79 +8767,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
  *
@@ -8881,6 +8867,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
  *
@@ -9300,7 +9367,13 @@ class InitialMessageCommitmentDefinition extends BaseCommitmentDefinition {
         `);
     }
     applyToAgentModelRequirements(requirements, content) {
-        return requirements;
+        // INITIAL MESSAGE is for UI display purposes and for conversation history construction.
+        const newSample = { question: null, answer: content };
+        const newSamples = [...(requirements.samples || []), newSample];
+        return {
+            ...requirements,
+            samples: newSamples,
+        };
     }
 }
 
@@ -10332,27 +10405,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],
         };
     }
 }
@@ -11371,6 +11433,136 @@ 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: {
+                            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 {
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+            },
+        };
+    }
+    /**
+     * 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();
+                }
+            },
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
 /**
  * Placeholder commitment definition for commitments that are not yet implemented
  *
@@ -11438,7 +11630,6 @@ class NotYetImplementedCommitmentDefinition extends BaseCommitmentDefinition {
     }
 }
 
-// Import all commitment definition classes
 /**
  * Registry of all available commitment definitions
  * This array contains instances of all commitment definitions
@@ -11455,10 +11646,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'),
@@ -11498,6 +11689,7 @@ const COMMITMENT_REGISTRY = [
     new ClosedCommitmentDefinition(),
     new UseBrowserCommitmentDefinition(),
     new UseSearchEngineCommitmentDefinition(),
+    new UseTimeCommitmentDefinition(),
     new UseMcpCommitmentDefinition(),
     new UseCommitmentDefinition(),
     // Not yet implemented commitments (using placeholder)
@@ -11577,51 +11769,32 @@ function getGroupedCommitmentDefinitions() {
             lastGroup.aliases.push(commitment.type);
         }
         else {
-            groupedCommitments.push({
-                primary: commitment,
-                aliases: [],
-            });
-        }
-    }
-    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
- *
- * @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,
-    };
+            groupedCommitments.push({
+                primary: commitment,
+                aliases: [],
+            });
+        }
+    }
+    return $deepFreeze(groupedCommitments);
 }
 /**
- * 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 function implementations provided by all commitments
  *
  * @public exported from `@promptbook/core`
  */
-function createBasicAgentModelRequirements(agentName) {
-    const empty = createEmptyAgentModelRequirements();
-    return {
-        ...empty,
-        systemMessage: `You are ${agentName || 'AI Agent'}`,
-    };
+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;
 }
 /**
- * TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
+ * TODO: [🧠] Maybe create through standardized $register
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
 /**
@@ -11702,11 +11875,37 @@ function parseAgentSourceWithCommitments(agentSource) {
     let currentCommitment = null;
     // Process lines starting from after the agent name line
     const startIndex = agentNameLineIndex >= 0 ? agentNameLineIndex + 1 : 0;
+    let isInsideCodeBlock = false;
     for (let i = startIndex; i < lines.length; i++) {
         const line = lines[i];
         if (line === undefined) {
             continue;
         }
+        const trimmedLine = line.trim();
+        // Check if this line starts or ends a code block
+        if (trimmedLine.startsWith('```')) {
+            isInsideCodeBlock = !isInsideCodeBlock;
+            if (currentCommitment) {
+                // If we are inside a commitment, the code block is part of it
+                currentCommitment.contentLines.push(line);
+            }
+            else {
+                // If we are not inside a commitment, the code block is non-commitment
+                nonCommitmentLines.push(line);
+            }
+            continue;
+        }
+        if (isInsideCodeBlock) {
+            if (currentCommitment) {
+                // If we are inside a commitment and a code block, the line is part of the commitment
+                currentCommitment.contentLines.push(line);
+            }
+            else {
+                // If we are inside a code block but not a commitment, the line is non-commitment
+                nonCommitmentLines.push(line);
+            }
+            continue;
+        }
         // Check if this line starts a new commitment
         let foundNewCommitment = false;
         for (const definition of COMMITMENT_REGISTRY) {
@@ -11784,6 +11983,97 @@ function parseAgentSourceWithCommitments(agentSource) {
     };
 }
 
+/**
+ * Plugin for importing agent books *(`.book` files)*
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const AgentFileImportPlugin = {
+    name: 'agent-file-import-plugin',
+    canImport(mimeType) {
+        // [🧠] Should we have a specific MIME type for agent books?
+        // For now, let's assume it's identified by .book extension or certain MIME types if provided
+        return mimeType === 'text/x-promptbook' || mimeType === 'application/x-promptbook';
+    },
+    import(content) {
+        const parseResult = parseAgentSourceWithCommitments(content);
+        // Bring only the agent corpus (non-commitment lines and relevant commitments)
+        // Stripping the agent name (which is usually the first line)
+        const corpus = parseResult.nonCommitmentLines
+            .filter((line, index) => index > 0 || !parseResult.agentName)
+            .join('\n')
+            .trim();
+        // Also include relevant commitments that make up the "corpus" of the agent
+        // For example PERSONA, RULE, KNOWLEDGE
+        const relevantCommitments = parseResult.commitments
+            .filter((c) => ['PERSONA', 'RULE', 'KNOWLEDGE'].includes(c.type))
+            .map((c) => `${c.type} ${c.content}`)
+            .join('\n\n');
+        return spaceTrim$1((block) => `
+                ${block(relevantCommitments)}
+
+                ${block(corpus)}
+            `).trim();
+    },
+};
+
+/**
+ * Plugin for importing JSON files
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const JsonFileImportPlugin = {
+    name: 'json-file-import-plugin',
+    canImport(mimeType) {
+        return mimeType === 'application/json' || mimeType.endsWith('+json');
+    },
+    import(content) {
+        try {
+            const json = JSON.parse(content);
+            const formattedJson = JSON.stringify(json, null, 4);
+            return `\`\`\`json\n${formattedJson}\n\`\`\``;
+        }
+        catch (error) {
+            // If JSON is invalid, still import it but maybe not as pretty JSON
+            return `\`\`\`json\n${content}\n\`\`\``;
+        }
+    },
+};
+
+/**
+ * Plugin for importing generic text files
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const TextFileImportPlugin = {
+    name: 'text-file-import-plugin',
+    canImport(mimeType) {
+        return (mimeType === 'text/plain' ||
+            mimeType === 'text/markdown' ||
+            mimeType === 'text/x-typescript' ||
+            mimeType === 'text/javascript' ||
+            mimeType === 'text/css' ||
+            mimeType === 'text/html' ||
+            mimeType.startsWith('text/'));
+    },
+    import(content, mimeType) {
+        const extension = mimeTypeToExtension(mimeType);
+        const codeBlockType = extension || 'txt';
+        return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+    },
+};
+
+/**
+ * All available file import plugins
+ *
+ * @private [🥝] Maybe export the import plugins through some package
+ */
+const $fileImportPlugins = [
+    AgentFileImportPlugin,
+    JsonFileImportPlugin,
+    TextFileImportPlugin,
+];
+
 /**
  * Parses parameters from text using both supported notations:
  * 1. @Parameter - single word parameter starting with @
@@ -11873,6 +12163,7 @@ function removeCommentsFromSystemMessage(systemMessage) {
  * @public exported from `@promptbook/core`
  */
 async function createAgentModelRequirementsWithCommitments(agentSource, modelName) {
+    var _a;
     // Parse the agent source to extract commitments
     const parseResult = parseAgentSourceWithCommitments(agentSource);
     // Apply DELETE filtering: remove prior commitments tagged by parameters targeted by DELETE/CANCEL/DISCARD/REMOVE
@@ -11939,6 +12230,64 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
             }
         }
     }
+    // Handle IMPORT commitments for generic files
+    // Note: This logic could be moved to ImportCommitmentDefinition, but it needs to be asynchronous
+    if (requirements.importedFileUrls && requirements.importedFileUrls.length > 0) {
+        for (const fileUrl of requirements.importedFileUrls) {
+            try {
+                // 1. Mocked security check
+                await mockedSecurityCheck(fileUrl);
+                // 2. Fetch file content
+                let content;
+                let mimeType = null;
+                if (isValidUrl(fileUrl)) {
+                    const response = await promptbookFetch(fileUrl);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch ${fileUrl}: ${response.statusText}`);
+                    }
+                    content = await response.text();
+                    mimeType = response.headers.get('Content-Type');
+                    /*
+                TODO: !!!! Commented out this case because we need to work in Browser-compatible mode in many packages, use passed `fs` instead
+                } else if (isValidFilePath(fileUrl)) {
+                    // [x🟢x] This code is expected to run in Node environment if local files are used
+                    const fs = await import('fs/promises');
+                    content = await fs.readFile(fileUrl, 'utf-8');
+                    const extension = getFileExtension(fileUrl);
+                    mimeType = extensionToMimeType(extension as string);
+                */
+                }
+                else {
+                    throw new Error(`Invalid file URL or path: ${fileUrl}`);
+                }
+                if (!mimeType) {
+                    mimeType = 'text/plain';
+                }
+                // Remove charset from mime type
+                mimeType = mimeType.split(';')[0].trim();
+                // 3. Prevent importing binary files (mocked check)
+                if (isBinaryMimeType(mimeType)) {
+                    throw new Error(`Importing binary files is not allowed: ${mimeType}`);
+                }
+                // 4. Find appropriate plugin
+                const plugin = $fileImportPlugins.find((p) => p.canImport(mimeType));
+                if (!plugin) {
+                    throw new Error(`No import plugin found for MIME type: ${mimeType}`);
+                }
+                // 5. Process content
+                const importedContent = await plugin.import(content, mimeType);
+                // 6. Append to system message
+                requirements = {
+                    ...requirements,
+                    systemMessage: requirements.systemMessage + '\n\n' + importedContent,
+                };
+            }
+            catch (error) {
+                console.warn(`Failed to import file ${fileUrl}:`, error);
+                // Continue with other imports even if one fails
+            }
+        }
+    }
     // Handle MCP servers (extract from original agent source)
     const mcpServers = extractMcpServers(agentSource);
     if (mcpServers.length > 0) {
@@ -11948,9 +12297,11 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
         };
     }
     // Add non-commitment lines to system message if they exist
+    // Note: Filtering out horizontal lines (---) as requested
     const nonCommitmentContent = parseResult.nonCommitmentLines
         .filter((line, index) => index > 0 || !parseResult.agentName) // Skip first line if it's the agent name
         .filter((line) => line.trim()) // Remove empty lines
+        .filter((line) => !/^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/.test(line)) // Remove horizontal lines
         .join('\n')
         .trim();
     if (nonCommitmentContent) {
@@ -11959,6 +12310,26 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
             systemMessage: requirements.systemMessage + '\n\n' + nonCommitmentContent,
         };
     }
+    // Add example interactions to the system message
+    const examples = [];
+    // 1. Initial message as an example agent response
+    const initialMessage = (_a = parseResult.commitments.find((c) => c.type === 'INITIAL MESSAGE')) === null || _a === void 0 ? void 0 : _a.content;
+    if (initialMessage) {
+        examples.push(`Agent: ${initialMessage}`);
+    }
+    // 2. User and Agent message pairs
+    if (requirements.samples && requirements.samples.length > 0) {
+        for (const sample of requirements.samples) {
+            examples.push(`User: ${sample.question}\nAgent: ${sample.answer}`);
+        }
+    }
+    if (examples.length > 0) {
+        const exampleInteractionsContent = `Example interaction:\n\n${examples.join('\n\n')}`;
+        requirements = {
+            ...requirements,
+            systemMessage: requirements.systemMessage + '\n\n' + exampleInteractionsContent,
+        };
+    }
     // Remove comment lines (lines starting with #) from the final system message
     // while preserving the original content with comments in metadata
     const cleanedSystemMessage = removeCommentsFromSystemMessage(requirements.systemMessage);
@@ -11967,6 +12338,36 @@ async function createAgentModelRequirementsWithCommitments(agentSource, modelNam
         systemMessage: cleanedSystemMessage,
     };
 }
+/**
+ * Mocked security check for imported files
+ *
+ * @param urlOrPath - The URL or local path of the file to check
+ * @returns A promise that resolves if the file is safe
+ */
+async function mockedSecurityCheck(urlOrPath) {
+    // TODO: Implement proper security checks
+    await new Promise((resolve) => setTimeout(resolve, 10)); // Mock async delay
+    if (urlOrPath.includes('malicious')) {
+        throw new Error(`Security check failed for: ${urlOrPath}`);
+    }
+}
+/**
+ * Checks if the given MIME type belongs to a binary file
+ *
+ * @param mimeType - The MIME type to check
+ * @returns True if it's a binary MIME type
+ */
+function isBinaryMimeType(mimeType) {
+    const binaryPrefixes = [
+        'image/',
+        'video/',
+        'audio/',
+        'application/octet-stream',
+        'application/pdf',
+        'application/zip',
+    ];
+    return binaryPrefixes.some((prefix) => mimeType.startsWith(prefix));
+}
 
 /**
  * Normalizes agent name from arbitrary string to valid agent name
@@ -12027,7 +12428,24 @@ function parseAgentSource(agentSource) {
     const meta = {};
     const links = [];
     const capabilities = [];
+    const samples = [];
+    let pendingUserMessage = null;
     for (const commitment of parseResult.commitments) {
+        if (commitment.type === 'INITIAL MESSAGE') {
+            samples.push({ question: null, answer: commitment.content });
+            continue;
+        }
+        if (commitment.type === 'USER MESSAGE') {
+            pendingUserMessage = commitment.content;
+            continue;
+        }
+        if (commitment.type === 'AGENT MESSAGE') {
+            if (pendingUserMessage !== null) {
+                samples.push({ question: pendingUserMessage, answer: commitment.content });
+                pendingUserMessage = null;
+            }
+            continue;
+        }
         if (commitment.type === 'USE BROWSER') {
             capabilities.push({
                 type: 'browser',
@@ -12044,6 +12462,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;
@@ -12128,6 +12577,7 @@ function parseAgentSource(agentSource) {
         links,
         parameters,
         capabilities,
+        samples,
     };
 }
 /**
@@ -16758,6 +17208,9 @@ function filterModels(llmTools, predicate) {
                 return originalModels.filter(predicate);
             }
         },
+        checkConfiguration() {
+            return /* not await */ llmTools.checkConfiguration();
+        },
     };
     // Helper function to validate if a model is allowed
     async function isModelAllowed(modelName) {
@@ -17064,31 +17517,14 @@ class MemoryStorage {
  * Intercepts LLM tools and counts total usage of the tools
  *
  * Note: It can take extended `LlmExecutionTools` and cache the
+ * Note: Returns full proxy of all LLM tool properties and methods
  *
  * @param llmTools LLM tools to be intercepted with usage counting, it can contain extra methods like `totalUsage`
- * @returns LLM tools with same functionality with added total cost counting
+ * @returns Full proxy of LLM tools with same functionality with added caching
  * @public exported from `@promptbook/core`
  */
 function cacheLlmTools(llmTools, options = {}) {
     const { storage = new MemoryStorage(), isCacheReloaded = false, isVerbose = DEFAULT_IS_VERBOSE } = options;
-    const proxyTools = {
-        ...llmTools,
-        // <- Note: [🥫]
-        get title() {
-            return `${llmTools.title} (cached)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
-        },
-        get description() {
-            return `${llmTools.description} (cached)`;
-            // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
-            // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
-        },
-        listModels() {
-            // TODO: [🧠] Should be model listing also cached?
-            return /* not await */ llmTools.listModels();
-        },
-    };
     const callCommonModel = async (prompt) => {
         var _a;
         const { parameters, content, modelRequirements } = prompt;
@@ -17211,27 +17647,55 @@ function cacheLlmTools(llmTools, options = {}) {
         }
         return promptResult;
     };
-    if (llmTools.callChatModel !== undefined) {
-        proxyTools.callChatModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    if (llmTools.callCompletionModel !== undefined) {
-        proxyTools.callCompletionModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    if (llmTools.callEmbeddingModel !== undefined) {
-        proxyTools.callEmbeddingModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    if (llmTools.callImageGenerationModel !== undefined) {
-        proxyTools.callImageGenerationModel = async (prompt) => {
-            return /* not await */ callCommonModel(prompt);
-        };
-    }
-    // <- Note: [🤖]
+    // Create a Proxy to intercept all property access and ensure full proxying of all properties
+    const proxyTools = new Proxy(llmTools, {
+        get(target, prop, receiver) {
+            // Handle title property
+            if (prop === 'title') {
+                return `${target.title} (cached)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
+            }
+            // Handle description property
+            if (prop === 'description') {
+                return `${target.description} (cached)`;
+                // <- TODO: [🧈] Maybe standartize the suffix when wrapping `LlmExecutionTools` up
+                // <- TODO: [🧈][🧠] Does it make sense to suffix "(cached)"?
+            }
+            // Handle callChatModel method
+            if (prop === 'callChatModel' && target.callChatModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // Handle callCompletionModel method
+            if (prop === 'callCompletionModel' && target.callCompletionModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // Handle callEmbeddingModel method
+            if (prop === 'callEmbeddingModel' && target.callEmbeddingModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // Handle callImageGenerationModel method
+            if (prop === 'callImageGenerationModel' && target.callImageGenerationModel !== undefined) {
+                return async (prompt) => {
+                    return /* not await */ callCommonModel(prompt);
+                };
+            }
+            // <- Note: [🤖]
+            // For all other properties and methods, delegate to the original target
+            const value = Reflect.get(target, prop, receiver);
+            // If it's a function, bind it to the target to preserve context
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
     return proxyTools;
 }
 /**
@@ -18478,7 +18942,7 @@ class OpenAiCompatibleExecutionTools {
                                     const args = ${functionArgs};
                                     return await ${functionName}(args);
                                 `,
-                                parameters: {}, // <- TODO: [🧠] What parameters to pass?
+                                parameters: prompt.parameters,
                             });
                         }
                         catch (error) {
@@ -19217,7 +19681,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
      * Calls OpenAI API to use a chat model with streaming.
      */
     async callChatModelStream(prompt, onProgress) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         if (this.options.isVerbose) {
             console.info('💬 OpenAI callChatModel call', { prompt });
         }
@@ -19272,6 +19736,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: prompt.parameters,
+                                });
+                                if (this.options.isVerbose) {
+                                    console.info(`✅ Tool ${functionName} executed:`, functionResponse);
+                                }
+                            }
+                            catch (error) {
+                                assertsError(error);
+                                functionResponse = spaceTrim$2((block) => `
+                                    
+                                        The invoked tool \`${functionName}\` failed with error:
+                                        
+                                        \`\`\`json
+                                        ${block(JSON.stringify(serializeError(error), null, 4))}
+                                        \`\`\`
+
+                                    `);
+                                console.error(colors.bgRed(`❌ Error executing tool ${functionName}:`));
+                                console.error(error);
+                            }
+                            toolOutputs.push({
+                                tool_call_id: toolCall.id,
+                                output: functionResponse,
+                            });
+                        }
+                    }
+                    // Submit tool outputs
+                    run = await client.beta.threads.runs.submitToolOutputs(run.thread_id, run.id, {
+                        tool_outputs: toolOutputs,
+                    });
+                }
+                else {
+                    // Wait a bit before polling again
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                    run = await client.beta.threads.runs.retrieve(run.thread_id, run.id);
+                }
+            }
+            if (run.status !== 'completed') {
+                throw new PipelineExecutionError(`Assistant run failed with status: ${run.status}`);
+            }
+            // Get messages from the thread
+            const messages = await client.beta.threads.messages.list(run.thread_id);
+            const assistantMessages = messages.data.filter((msg) => msg.role === 'assistant');
+            if (assistantMessages.length === 0) {
+                throw new PipelineExecutionError('No assistant messages found after run completion');
+            }
+            const lastMessage = assistantMessages[0];
+            const textContent = lastMessage.content.find((c) => c.type === 'text');
+            if (!textContent || textContent.type !== 'text') {
+                throw new PipelineExecutionError('No text content in assistant response');
+            }
+            complete = $getCurrentDate();
+            const resultContent = textContent.text.value;
+            const usage = UNCERTAIN_USAGE;
+            // Progress callback with final result
+            const finalChunk = {
+                content: resultContent,
+                modelName: 'assistant',
+                timing: { start, complete },
+                usage,
+                rawPromptContent,
+                rawRequest,
+                rawResponse: { run, messages: messages.data },
+            };
+            onProgress(finalChunk);
+            return exportJson({
+                name: 'promptResult',
+                message: `Result of \`OpenAiAssistantExecutionTools.callChatModelStream\` (with tools)`,
+                order: [],
+                value: finalChunk,
+            });
+        }
+        // Streaming mode (without tools)
         const rawRequest = {
             // TODO: [👨‍👨‍👧‍👧] ...modelSettings,
             // TODO: [👨‍👨‍👧‍👧][🧠] What about system message for assistants, does it make sense - combination of OpenAI assistants with Promptbook Personas
@@ -19282,10 +19871,8 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             tools: modelRequirements.tools === undefined ? undefined : mapToolsToOpenAi(modelRequirements.tools),
             // <- TODO: Add user identification here> user: this.options.user,
         };
-        const start = $getCurrentDate();
-        let complete;
         if (this.options.isVerbose) {
-            console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
+            console.info(colors.bgWhite('rawRequest (streaming)'), JSON.stringify(rawRequest, null, 4));
         }
         const stream = await client.beta.threads.createAndRunStream(rawRequest);
         stream.on('connect', () => {
@@ -19321,6 +19908,15 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                 console.info('messageDone', message);
             }
         });
+        // TODO: [🐱‍🚀] Handle tool calls in assistants
+        // Note: OpenAI Assistant streaming with tool calls requires special handling.
+        // The stream will pause when a tool call is needed, and we need to:
+        // 1. Wait for the run to reach 'requires_action' status
+        // 2. Execute the tool calls
+        // 3. Submit tool outputs via a separate API call (not on the stream)
+        // 4. Continue the run
+        // This requires switching to non-streaming mode or using the Runs API directly.
+        // For now, tools with assistants should use the non-streaming chat completions API instead.
         const rawResponse = await stream.finalMessages();
         if (this.options.isVerbose) {
             console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
@@ -19331,10 +19927,10 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         if (rawResponse[0].content.length !== 1) {
             throw new PipelineExecutionError(`There is NOT 1 BUT ${rawResponse[0].content.length} finalMessages content from OpenAI`);
         }
-        if (((_a = rawResponse[0].content[0]) === null || _a === void 0 ? void 0 : _a.type) !== 'text') {
-            throw new PipelineExecutionError(`There is NOT 'text' BUT ${(_b = rawResponse[0].content[0]) === null || _b === void 0 ? void 0 : _b.type} finalMessages content type from OpenAI`);
+        if (((_b = rawResponse[0].content[0]) === null || _b === void 0 ? void 0 : _b.type) !== 'text') {
+            throw new PipelineExecutionError(`There is NOT 'text' BUT ${(_c = rawResponse[0].content[0]) === null || _c === void 0 ? void 0 : _c.type} finalMessages content type from OpenAI`);
         }
-        const resultContent = (_c = rawResponse[0].content[0]) === null || _c === void 0 ? void 0 : _c.text.value;
+        const resultContent = (_d = rawResponse[0].content[0]) === null || _d === void 0 ? void 0 : _d.text.value;
         //                                                     <- TODO: [🧠] There are also annotations, maybe use them
         // eslint-disable-next-line prefer-const
         complete = $getCurrentDate();
@@ -19402,7 +19998,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             throw new NotAllowed(`Creating new assistants is not allowed. Set \`isCreatingNewAssistantsAllowed: true\` in options to enable this feature.`);
         }
         // await this.playground();
-        const { name, instructions, knowledgeSources } = options;
+        const { name, instructions, knowledgeSources, tools } = options;
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
@@ -19473,7 +20069,11 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             description: 'Assistant created via Promptbook',
             model: 'gpt-4o',
             instructions,
-            tools: [/* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */ { type: 'file_search' }],
+            tools: [
+                /* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */
+                { type: 'file_search' },
+                ...(tools === undefined ? [] : mapToolsToOpenAi(tools)),
+            ],
         };
         // Attach vector store if created
         if (vectorStoreId) {
@@ -19498,7 +20098,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         if (!this.isCreatingNewAssistantsAllowed) {
             throw new NotAllowed(`Updating assistants is not allowed. Set \`isCreatingNewAssistantsAllowed: true\` in options to enable this feature.`);
         }
-        const { assistantId, name, instructions, knowledgeSources } = options;
+        const { assistantId, name, instructions, knowledgeSources, tools } = options;
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
@@ -19567,7 +20167,11 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         const assistantUpdate = {
             name,
             instructions,
-            tools: [/* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */ { type: 'file_search' }],
+            tools: [
+                /* TODO: [🧠] Maybe add { type: 'code_interpreter' }, */
+                { type: 'file_search' },
+                ...(tools === undefined ? [] : mapToolsToOpenAi(tools)),
+            ],
         };
         if (vectorStoreId) {
             assistantUpdate.tool_resources = {
@@ -19608,6 +20212,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
  */
 const DISCRIMINANT = 'OPEN_AI_ASSISTANT_V1';
 /**
+ * TODO: [🙎] In `OpenAiAssistantExecutionTools` Allow to create abstract assistants with `isCreatingNewAssistantsAllowed`
  * TODO: [🧠][🧙‍♂️] Maybe there can be some wizard for those who want to use just OpenAI
  * TODO: Maybe make custom OpenAiError
  * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
@@ -19666,8 +20271,10 @@ class AgentLlmExecutionTools {
     }
     /**
      * Get cached or create agent model requirements
+     *
+     * Note: [🐤] This is names `getModelRequirements` *(not `getAgentModelRequirements`)* because in future these two will be united
      */
-    async getAgentModelRequirements() {
+    async getModelRequirements() {
         if (this._cachedModelRequirements === null) {
             // Get available models from underlying LLM tools for best model selection
             const availableModels = await this.options.llmTools.listModels();
@@ -19737,9 +20344,25 @@ class AgentLlmExecutionTools {
         if (prompt.modelRequirements.modelVariant !== 'CHAT') {
             throw new Error('AgentLlmExecutionTools only supports chat prompts');
         }
-        const modelRequirements = await this.getAgentModelRequirements();
+        const modelRequirements = await this.getModelRequirements();
         const chatPrompt = prompt;
         let underlyingLlmResult;
+        // Create modified chat prompt with agent system message
+        const promptWithAgentModelRequirements = {
+            ...chatPrompt,
+            modelRequirements: {
+                ...chatPrompt.modelRequirements,
+                ...modelRequirements,
+                // Spread tools to convert readonly array to mutable
+                tools: modelRequirements.tools ? [...modelRequirements.tools] : chatPrompt.modelRequirements.tools,
+                // Prepend agent system message to existing system message
+                systemMessage: modelRequirements.systemMessage +
+                    (chatPrompt.modelRequirements.systemMessage
+                        ? `\n\n${chatPrompt.modelRequirements.systemMessage}`
+                        : ''),
+            },
+        };
+        console.log('!!!! promptWithAgentModelRequirements:', promptWithAgentModelRequirements);
         if (OpenAiAssistantExecutionTools.isOpenAiAssistantExecutionTools(this.options.llmTools)) {
             const requirementsHash = SHA256(JSON.stringify(modelRequirements)).toString();
             const cached = AgentLlmExecutionTools.assistantCache.get(this.title);
@@ -19760,6 +20383,7 @@ class AgentLlmExecutionTools {
                         name: this.title,
                         instructions: modelRequirements.systemMessage,
                         knowledgeSources: modelRequirements.knowledgeSources,
+                        tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                     });
                     AgentLlmExecutionTools.assistantCache.set(this.title, {
                         assistantId: assistant.assistantId,
@@ -19776,6 +20400,7 @@ class AgentLlmExecutionTools {
                     name: this.title,
                     instructions: modelRequirements.systemMessage,
                     knowledgeSources: modelRequirements.knowledgeSources,
+                    tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                     /*
                     !!!
                     metadata: {
@@ -19788,32 +20413,28 @@ class AgentLlmExecutionTools {
                     requirementsHash,
                 });
             }
-            underlyingLlmResult = await assistant.callChatModelStream(chatPrompt, onProgress);
+            // Create modified chat prompt with agent system message specific to OpenAI Assistant
+            const promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools = {
+                ...promptWithAgentModelRequirements,
+                modelRequirements: {
+                    ...promptWithAgentModelRequirements.modelRequirements,
+                    modelName: undefined,
+                    systemMessage: undefined,
+                    temperature: undefined, // <- Note: Let the Assistant use its default temperature
+                },
+            };
+            console.log('!!!! promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools:', promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools);
+            underlyingLlmResult = await assistant.callChatModelStream(promptWithAgentModelRequirementsForOpenAiAssistantExecutionTools, onProgress);
         }
         else {
             if (this.options.isVerbose) {
                 console.log(`2️⃣ Creating Assistant ${this.title} on generic LLM execution tools...`);
             }
-            // Create modified chat prompt with agent system message
-            const modifiedChatPrompt = {
-                ...chatPrompt,
-                modelRequirements: {
-                    ...chatPrompt.modelRequirements,
-                    ...modelRequirements,
-                    // Spread tools to convert readonly array to mutable
-                    tools: modelRequirements.tools ? [...modelRequirements.tools] : chatPrompt.modelRequirements.tools,
-                    // Prepend agent system message to existing system message
-                    systemMessage: modelRequirements.systemMessage +
-                        (chatPrompt.modelRequirements.systemMessage
-                            ? `\n\n${chatPrompt.modelRequirements.systemMessage}`
-                            : ''),
-                },
-            };
             if (this.options.llmTools.callChatModelStream) {
-                underlyingLlmResult = await this.options.llmTools.callChatModelStream(modifiedChatPrompt, onProgress);
+                underlyingLlmResult = await this.options.llmTools.callChatModelStream(promptWithAgentModelRequirements, onProgress);
             }
             else if (this.options.llmTools.callChatModel) {
-                underlyingLlmResult = await this.options.llmTools.callChatModel(modifiedChatPrompt);
+                underlyingLlmResult = await this.options.llmTools.callChatModel(promptWithAgentModelRequirements);
                 onProgress(underlyingLlmResult);
             }
             else {
@@ -19842,7 +20463,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
  *
@@ -19902,6 +20524,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
          */
@@ -19911,12 +20537,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 };
         });
     }
@@ -19928,10 +20555,10 @@ class Agent extends AgentLlmExecutionTools {
     async callChatModelStream(prompt, onProgress) {
         var _a;
         // [1] Check if the user is asking the same thing as in the samples
-        const modelRequirements = await this.getAgentModelRequirements();
+        const modelRequirements = await this.getModelRequirements();
         if (modelRequirements.samples) {
             const normalizedPrompt = normalizeMessageText(prompt.content);
-            const sample = modelRequirements.samples.find((sample) => normalizeMessageText(sample.question) === normalizedPrompt);
+            const sample = modelRequirements.samples.find((sample) => sample.question !== null && normalizeMessageText(sample.question) === normalizedPrompt);
             if (sample) {
                 const now = new Date().toISOString();
                 const result = {
@@ -19977,17 +20604,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) => `
 
                 ---
@@ -19999,52 +20631,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);
 };
@@ -21286,7 +21875,7 @@ const OpenAiSdkTranspiler = {
                         {
                             role: 'system',
                             content: spaceTrim(\`
-                                ${block(modelRequirements.systemMessage)}
+                                ${block(modelRequirements.systemMessage.split('`').join('\\`'))}
                             \`),
                         },
                     ];
@@ -21372,7 +21961,7 @@ const OpenAiSdkTranspiler = {
                     {
                         role: 'system',
                         content: spaceTrim(\`
-                            ${block(modelRequirements.systemMessage)}
+                            ${block(modelRequirements.systemMessage.split('`').join('\\`'))}
                         \`),
                     },
                 ];
@@ -21433,7 +22022,16 @@ const CORE_AGENTS_SERVER = {
  *
  * @public exported from `@promptbook/core`
  */
-const CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES = { ADAM: 'adam', TEACHER: 'teacher' };
+const CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES = {
+    /**
+     * The default ancestor agent for new agents
+     */
+    ADAM: 'adam',
+    /**
+     * Agent that knows book syntax and can help with self-learning
+     */
+    TEACHER: 'teacher',
+};
 // <- TODO: [🆎] Allow to override (set) well-known agent names via Metadata
 /**
  * Available agents servers for the Promptbook
@@ -21933,5 +22531,5 @@ function $generateBookBoilerplate(options) {
  * TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
  */
 
-export { $bookTranspilersRegister, $generateBookBoilerplate, $llmToolsMetadataRegister, $llmToolsRegister, $scrapersMetadataRegister, $scrapersRegister, ADMIN_EMAIL, ADMIN_GITHUB_NAME, API_REQUEST_TIMEOUT, AbstractFormatError, Agent, AgentCollectionInSupabase, AgentLlmExecutionTools, AuthenticationError, BIG_DATASET_TRESHOLD, BOOK_LANGUAGE_VERSION, BlackholeStorage, BoilerplateError, BoilerplateFormfactorDefinition, CLAIM, CLI_APP_ID, CORE_AGENTS_SERVER, CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES, CallbackInterfaceTools, ChatbotFormfactorDefinition, CollectionError, CompletionFormfactorDefinition, CsvFormatError, CsvFormatParser, DEFAULT_AGENTS_DIRNAME, DEFAULT_BOOK, DEFAULT_BOOKS_DIRNAME, DEFAULT_BOOK_OUTPUT_PARAMETER_NAME, DEFAULT_BOOK_TITLE, DEFAULT_CSV_SETTINGS, DEFAULT_DOWNLOAD_CACHE_DIRNAME, DEFAULT_EXECUTION_CACHE_DIRNAME, DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME, DEFAULT_INTERMEDIATE_FILES_STRATEGY, DEFAULT_IS_AUTO_INSTALLED, DEFAULT_IS_VERBOSE, DEFAULT_MAX_EXECUTION_ATTEMPTS, DEFAULT_MAX_FILE_SIZE, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_DEPTH, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_TOTAL, DEFAULT_MAX_PARALLEL_COUNT, DEFAULT_MAX_RECURSION, DEFAULT_MAX_REQUESTS_PER_MINUTE, DEFAULT_PIPELINE_COLLECTION_BASE_FILENAME, DEFAULT_PROMPT_TASK_TITLE, DEFAULT_REMOTE_SERVER_URL, DEFAULT_SCRAPE_CACHE_DIRNAME, DEFAULT_TASK_SIMULATED_DURATION_MS, DEFAULT_TASK_TITLE, DatabaseError, EXPECTATION_UNITS, EnvironmentMismatchError, ExecutionReportStringOptionsDefaults, ExpectError, FAILED_VALUE_PLACEHOLDER, FORMFACTOR_DEFINITIONS, FormattedBookInMarkdownTranspiler, GENERIC_PIPELINE_INTERFACE, GeneratorFormfactorDefinition, GenericFormfactorDefinition, ImageGeneratorFormfactorDefinition, KnowledgeScrapeError, LimitReachedError, MANDATORY_CSV_SETTINGS, MAX_FILENAME_LENGTH, MODEL_ORDERS, MODEL_TRUST_LEVELS, MODEL_VARIANTS, MatcherFormfactorDefinition, MemoryStorage, MissingToolsError, MultipleLlmExecutionTools, NAME, NonTaskSectionTypes, NotAllowed, NotFoundError, NotYetImplementedCommitmentDefinition, NotYetImplementedError, ORDER_OF_PIPELINE_JSON, OpenAiSdkTranspiler, PADDING_LINES, PENDING_VALUE_PLACEHOLDER, PLAYGROUND_APP_ID, PROMPTBOOK_CHAT_COLOR, PROMPTBOOK_COLOR, PROMPTBOOK_ENGINE_VERSION, PROMPTBOOK_ERRORS, PROMPTBOOK_LEGAL_ENTITY, PROMPTBOOK_LOGO_URL, PROMPTBOOK_SYNTAX_COLORS, PUBLIC_AGENTS_SERVERS, ParseError, PipelineExecutionError, PipelineLogicError, PipelineUrlError, PrefixStorage, PromptbookFetchError, RESERVED_PARAMETER_NAMES, RemoteAgent, SET_IS_VERBOSE, SectionTypes, SheetsFormfactorDefinition, TaskTypes, TextFormatParser, TranslatorFormfactorDefinition, UNCERTAIN_USAGE, UNCERTAIN_ZERO_VALUE, USER_CHAT_COLOR, UnexpectedError, WrappedError, ZERO_USAGE, ZERO_VALUE, _AgentMetadata, _AgentRegistration, _AnthropicClaudeMetadataRegistration, _AzureOpenAiMetadataRegistration, _BoilerplateScraperMetadataRegistration, _DeepseekMetadataRegistration, _DocumentScraperMetadataRegistration, _GoogleMetadataRegistration, _LegacyDocumentScraperMetadataRegistration, _MarkdownScraperMetadataRegistration, _MarkitdownScraperMetadataRegistration, _OllamaMetadataRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiCompatibleMetadataRegistration, _OpenAiMetadataRegistration, _PdfScraperMetadataRegistration, _WebsiteScraperMetadataRegistration, aboutPromptbookInformation, addUsage, book, cacheLlmTools, compilePipeline, computeAgentHash, computeCosineSimilarity, countUsage, createAgentLlmExecutionTools, createAgentModelRequirements, createAgentModelRequirementsWithCommitments, createBasicAgentModelRequirements, createDefaultAgentName, createEmptyAgentModelRequirements, createLlmToolsFromConfiguration, createPipelineCollectionFromJson, createPipelineCollectionFromPromise, createPipelineCollectionFromUrl, createPipelineExecutor, createPipelineSubcollection, embeddingVectorToString, executionReportJsonToString, extractParameterNamesFromTask, filterModels, generatePlaceholderAgentProfileImageUrl, getAllCommitmentDefinitions, getAllCommitmentTypes, getCommitmentDefinition, getGroupedCommitmentDefinitions, getPipelineInterface, getSingleLlmExecutionTools, identificationToPromptbookToken, isCommitmentSupported, isPassingExpectations, isPipelineImplementingInterface, isPipelineInterfacesEqual, isPipelinePrepared, isValidBook, isValidPipelineString, joinLlmExecutionTools, limitTotalUsage, makeKnowledgeSourceHandler, migratePipeline, normalizeAgentName, padBook, parseAgentSource, parseParameters, parsePipeline, pipelineCollectionToJson, pipelineJsonToString, prepareKnowledgePieces, preparePersona, preparePipeline, prettifyPipelineString, promptbookFetch, promptbookTokenToIdentification, unpreparePipeline, usageToHuman, usageToWorktime, validateBook, validatePipeline, validatePipelineString };
+export { $bookTranspilersRegister, $generateBookBoilerplate, $llmToolsMetadataRegister, $llmToolsRegister, $scrapersMetadataRegister, $scrapersRegister, ADMIN_EMAIL, ADMIN_GITHUB_NAME, API_REQUEST_TIMEOUT, AbstractFormatError, Agent, AgentCollectionInSupabase, AgentLlmExecutionTools, AuthenticationError, BIG_DATASET_TRESHOLD, BOOK_LANGUAGE_VERSION, BlackholeStorage, BoilerplateError, BoilerplateFormfactorDefinition, CLAIM, CLI_APP_ID, CORE_AGENTS_SERVER, CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES, CallbackInterfaceTools, ChatbotFormfactorDefinition, CollectionError, CompletionFormfactorDefinition, CsvFormatError, CsvFormatParser, DEFAULT_AGENTS_DIRNAME, DEFAULT_BOOK, DEFAULT_BOOKS_DIRNAME, DEFAULT_BOOK_OUTPUT_PARAMETER_NAME, DEFAULT_BOOK_TITLE, DEFAULT_CSV_SETTINGS, DEFAULT_DOWNLOAD_CACHE_DIRNAME, DEFAULT_EXECUTION_CACHE_DIRNAME, DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME, DEFAULT_INTERMEDIATE_FILES_STRATEGY, DEFAULT_IS_AUTO_INSTALLED, DEFAULT_IS_VERBOSE, DEFAULT_MAX_EXECUTION_ATTEMPTS, DEFAULT_MAX_FILE_SIZE, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_DEPTH, DEFAULT_MAX_KNOWLEDGE_SOURCES_SCRAPING_TOTAL, DEFAULT_MAX_PARALLEL_COUNT, DEFAULT_MAX_RECURSION, DEFAULT_MAX_REQUESTS_PER_MINUTE, DEFAULT_PIPELINE_COLLECTION_BASE_FILENAME, DEFAULT_PROMPT_TASK_TITLE, DEFAULT_REMOTE_SERVER_URL, DEFAULT_SCRAPE_CACHE_DIRNAME, DEFAULT_TASK_SIMULATED_DURATION_MS, DEFAULT_TASK_TITLE, DatabaseError, EXPECTATION_UNITS, EnvironmentMismatchError, ExecutionReportStringOptionsDefaults, ExpectError, FAILED_VALUE_PLACEHOLDER, FORMFACTOR_DEFINITIONS, FormattedBookInMarkdownTranspiler, GENERIC_PIPELINE_INTERFACE, GeneratorFormfactorDefinition, GenericFormfactorDefinition, ImageGeneratorFormfactorDefinition, KnowledgeScrapeError, LimitReachedError, MANDATORY_CSV_SETTINGS, MAX_FILENAME_LENGTH, MODEL_ORDERS, MODEL_TRUST_LEVELS, MODEL_VARIANTS, MatcherFormfactorDefinition, MemoryStorage, MissingToolsError, MultipleLlmExecutionTools, NAME, NonTaskSectionTypes, NotAllowed, NotFoundError, NotYetImplementedCommitmentDefinition, NotYetImplementedError, ORDER_OF_PIPELINE_JSON, OpenAiSdkTranspiler, PADDING_LINES, PENDING_VALUE_PLACEHOLDER, PLAYGROUND_APP_ID, PROMPTBOOK_CHAT_COLOR, PROMPTBOOK_COLOR, PROMPTBOOK_ENGINE_VERSION, PROMPTBOOK_ERRORS, PROMPTBOOK_LEGAL_ENTITY, PROMPTBOOK_LOGO_URL, PROMPTBOOK_SYNTAX_COLORS, PUBLIC_AGENTS_SERVERS, ParseError, PipelineExecutionError, PipelineLogicError, PipelineUrlError, PrefixStorage, PromptbookFetchError, RESERVED_PARAMETER_NAMES, RemoteAgent, SET_IS_VERBOSE, SectionTypes, SheetsFormfactorDefinition, TaskTypes, TextFormatParser, TranslatorFormfactorDefinition, UNCERTAIN_USAGE, UNCERTAIN_ZERO_VALUE, USER_CHAT_COLOR, UnexpectedError, WrappedError, ZERO_USAGE, ZERO_VALUE, _AgentMetadata, _AgentRegistration, _AnthropicClaudeMetadataRegistration, _AzureOpenAiMetadataRegistration, _BoilerplateScraperMetadataRegistration, _DeepseekMetadataRegistration, _DocumentScraperMetadataRegistration, _GoogleMetadataRegistration, _LegacyDocumentScraperMetadataRegistration, _MarkdownScraperMetadataRegistration, _MarkitdownScraperMetadataRegistration, _OllamaMetadataRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiCompatibleMetadataRegistration, _OpenAiMetadataRegistration, _PdfScraperMetadataRegistration, _WebsiteScraperMetadataRegistration, aboutPromptbookInformation, addUsage, book, cacheLlmTools, compilePipeline, computeAgentHash, computeCosineSimilarity, countUsage, createAgentLlmExecutionTools, createAgentModelRequirements, createAgentModelRequirementsWithCommitments, createBasicAgentModelRequirements, createDefaultAgentName, createEmptyAgentModelRequirements, createLlmToolsFromConfiguration, createPipelineCollectionFromJson, createPipelineCollectionFromPromise, createPipelineCollectionFromUrl, createPipelineExecutor, createPipelineSubcollection, embeddingVectorToString, executionReportJsonToString, extractParameterNamesFromTask, filterModels, generatePlaceholderAgentProfileImageUrl, getAllCommitmentDefinitions, getAllCommitmentTypes, getAllCommitmentsToolFunctions, getCommitmentDefinition, getGroupedCommitmentDefinitions, getPipelineInterface, getSingleLlmExecutionTools, identificationToPromptbookToken, isCommitmentSupported, isPassingExpectations, isPipelineImplementingInterface, isPipelineInterfacesEqual, isPipelinePrepared, isValidBook, isValidPipelineString, joinLlmExecutionTools, limitTotalUsage, makeKnowledgeSourceHandler, migratePipeline, normalizeAgentName, padBook, parseAgentSource, parseParameters, parsePipeline, pipelineCollectionToJson, pipelineJsonToString, prepareKnowledgePieces, preparePersona, preparePipeline, prettifyPipelineString, promptbookFetch, promptbookTokenToIdentification, unpreparePipeline, usageToHuman, usageToWorktime, validateBook, validatePipeline, validatePipelineString };
 //# sourceMappingURL=index.es.js.map