@promptbook/browser 0.107.0-0 → 0.110.0-0

package/esm/index.es.js

@@ -28,7 +28,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.107.0-0';
+const PROMPTBOOK_ENGINE_VERSION = '0.110.0-0';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3587,13 +3587,125 @@ function escapePromptParameterValue(value, options) {
     return value.replace(pattern, '\\$&');
 }
 /**
- * Builds the parameter name used in prompt placeholders.
+ * Builds numeric parameter name used in prompt placeholders.
  *
  * @param index Zero-based parameter index.
  */
-function buildParameterName(index) {
+function buildNumericParameterName(index) {
     return `${index + 1}`;
 }
+/**
+ * Builds alphabetic parameter name used in prompt placeholders.
+ *
+ * @param index Zero-based parameter index.
+ */
+function buildAlphabeticParameterName(index) {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+    let result = '';
+    let remaining = index;
+    while (remaining >= 0) {
+        result = alphabet[remaining % alphabet.length] + result;
+        remaining = Math.floor(remaining / alphabet.length) - 1;
+    }
+    return result;
+}
+/**
+ * Converts a positive integer into a Roman numeral string.
+ *
+ * @param value Positive integer value.
+ */
+function toRomanNumeral(value) {
+    const romanTable = [
+        { symbol: 'M', value: 1000 },
+        { symbol: 'CM', value: 900 },
+        { symbol: 'D', value: 500 },
+        { symbol: 'CD', value: 400 },
+        { symbol: 'C', value: 100 },
+        { symbol: 'XC', value: 90 },
+        { symbol: 'L', value: 50 },
+        { symbol: 'XL', value: 40 },
+        { symbol: 'X', value: 10 },
+        { symbol: 'IX', value: 9 },
+        { symbol: 'V', value: 5 },
+        { symbol: 'IV', value: 4 },
+        { symbol: 'I', value: 1 },
+    ];
+    let remaining = Math.max(1, Math.floor(value));
+    let result = '';
+    for (const entry of romanTable) {
+        while (remaining >= entry.value) {
+            result += entry.symbol;
+            remaining -= entry.value;
+        }
+    }
+    return result;
+}
+/**
+ * Builds Roman numeral parameter name used in prompt placeholders.
+ *
+ * @param index Zero-based parameter index.
+ */
+function buildRomanParameterName(index) {
+    return toRomanNumeral(index + 1);
+}
+/**
+ * Creates a parameter name builder that prefixes another builder.
+ *
+ * @param prefix Prefix to add.
+ * @param builder Base builder to wrap.
+ */
+function buildPrefixedParameterName(prefix, builder) {
+    return (index) => `${prefix}${builder(index)}`;
+}
+/**
+ * Ordered list of strategies for parameter naming.
+ */
+const PARAMETER_NAME_STRATEGIES = [
+    { buildName: buildNumericParameterName },
+    { buildName: buildAlphabeticParameterName },
+    { buildName: buildRomanParameterName },
+    { buildName: buildPrefixedParameterName('p', buildNumericParameterName) },
+    { buildName: buildPrefixedParameterName('p', buildAlphabeticParameterName) },
+];
+/**
+ * Collects bracketed tokens from parameter values to avoid placeholder collisions.
+ *
+ * @param values Parameter values to scan.
+ */
+function collectBracketedParameterTokens(values) {
+    const tokens = new Set();
+    for (const value of values) {
+        const pattern = /{(\w+)}/g;
+        let match;
+        while ((match = pattern.exec(value)) !== null) {
+            const token = match[1];
+            if (token) {
+                tokens.add(token);
+            }
+        }
+    }
+    return tokens;
+}
+/**
+ * Builds parameter names used in prompt placeholders while avoiding collisions.
+ *
+ * @param values Parameter values to scan for conflicting tokens.
+ */
+function buildParameterNames(values) {
+    const count = values.length;
+    if (count === 0) {
+        return [];
+    }
+    const conflicts = collectBracketedParameterTokens(values);
+    for (const strategy of PARAMETER_NAME_STRATEGIES) {
+        const names = Array.from({ length: count }, (_, index) => strategy.buildName(index));
+        const hasConflict = names.some((name) => conflicts.has(name));
+        if (!hasConflict) {
+            return names;
+        }
+    }
+    return Array.from({ length: count }, (_, index) => `${REPLACING_NONCE}${index + 1}`);
+}
 /**
  * Formats the placeholder used in the prompt body for a parameter.
  *
@@ -3648,26 +3760,40 @@ function prompt(strings, ...values) {
         return new PromptString(spaceTrim$2(strings.join('')));
     }
     const stringsWithHiddenParameters = strings.map((stringsItem) => hideBrackets(stringsItem));
-    const parameterEntries = values.map((value, index) => {
-        const name = buildParameterName(index);
+    const parameterMetadata = values.map((value) => {
         const isPrompt = isPromptString(value);
         const stringValue = isPrompt ? value.toString() : valueToString(value);
         const isInline = isPrompt ? true : shouldInlineParameterValue(stringValue);
         const jsonValue = !isPrompt && !isInline ? normalizeJsonString(stringValue) : null;
+        return { isPrompt, stringValue, isInline, jsonValue };
+    });
+    const parameterNames = buildParameterNames(parameterMetadata.map((entry) => entry.stringValue));
+    const parameterEntries = parameterMetadata.map((entry, index) => {
+        var _a;
+        const name = (_a = parameterNames[index]) !== null && _a !== void 0 ? _a : buildNumericParameterName(index);
         const promptMarker = `${REPLACING_NONCE}prompt-${index}`;
         const parameterMarker = `${REPLACING_NONCE}parameter-${index}`;
-        const templateValue = isPrompt
+        const templateValue = entry.isPrompt
             ? promptMarker
-            : isInline
-                ? escapePromptParameterValue(stringValue, { includeBraces: false })
+            : entry.isInline
+                ? escapePromptParameterValue(entry.stringValue, { includeBraces: false })
                 : parameterMarker;
-        return { name, stringValue, jsonValue, isPrompt, isInline, promptMarker, parameterMarker, templateValue };
+        return {
+            name,
+            stringValue: entry.stringValue,
+            jsonValue: entry.jsonValue,
+            isPrompt: entry.isPrompt,
+            isInline: entry.isInline,
+            promptMarker,
+            parameterMarker,
+            templateValue,
+        };
     });
     const parameters = Object.fromEntries(parameterEntries.map((entry) => [entry.name, entry.templateValue]));
-    const parameterNames = parameterEntries.map((entry) => entry.name);
+    const parameterNamesOrdered = parameterEntries.map((entry) => entry.name);
     // Combine strings and values
     let pipelineString = stringsWithHiddenParameters.reduce((result, stringsItem, i) => {
-        const parameterName = parameterNames[i];
+        const parameterName = parameterNamesOrdered[i];
         return parameterName === undefined
             ? `${result}${stringsItem}`
             : `${result}${stringsItem}${formatParameterPlaceholder(parameterName)}`;
@@ -3680,7 +3806,7 @@ function prompt(strings, ...values) {
         if (!(error instanceof PipelineExecutionError)) {
             throw error;
         }
-        console.error({ pipelineString, parameters, parameterNames, error });
+        console.error({ pipelineString, parameters, parameterNames: parameterNamesOrdered, error });
         throw new UnexpectedError(spaceTrim$2((block) => `
                     Internal error in prompt template literal
                   
@@ -3695,9 +3821,7 @@ function prompt(strings, ...values) {
             continue;
         }
         if (!entry.isInline) {
-            pipelineString = pipelineString
-                .split(entry.parameterMarker)
-                .join(formatParameterPlaceholder(entry.name));
+            pipelineString = pipelineString.split(entry.parameterMarker).join(formatParameterPlaceholder(entry.name));
         }
     }
     const structuredParameters = parameterEntries.filter((entry) => !entry.isPrompt && !entry.isInline);
@@ -5219,60 +5343,12 @@ function getLinguisticHashLanguageConfig(language) {
     return LANGUAGE_CONFIGS[normalized];
 }
 
-// <- TODO: !!!! Remove re-exports
-/**
- * Creates a human-readable hash as a short, story-like phrase.
- *
- * @param wordCount how many words to include (defaults to {@link DEFAULT_LINGUISTIC_HASH_WORD_COUNT}, clamped to
- * {@link MIN_LINGUISTIC_HASH_WORD_COUNT}..{@link MAX_LINGUISTIC_HASH_WORD_COUNT})
- * @param language optional language code (defaults to {@link DEFAULT_LINGUISTIC_HASH_LANGUAGE})
- *
- * @public exported from `@promptbook/utils`
- */
-async function linguisticHash(input, wordCount, language) {
-    const hash = computeHash(input);
-    const normalizedWordCount = normalizeLinguisticHashWordCount(wordCount);
-    const languageConfig = getLinguisticHashLanguageConfig(language);
-    const words = createLinguisticHashWords(hash, normalizedWordCount, languageConfig.wordLists);
-    return capitalize(words.join(' '));
-}
 /**
  * @@@
  *
  * @private utility of `linguisticHash`
  */
 const HASH_SEGMENT_LENGTH = 8;
-/**
- * The minimum number of words for a linguistic hash.
- *
- * @private utility of `linguisticHash`
- */
-const MIN_LINGUISTIC_HASH_WORD_COUNT = 1;
-/**
- * The default number of words for a linguistic hash.
- *
- * @private utility of `linguisticHash`
- */
-const DEFAULT_LINGUISTIC_HASH_WORD_COUNT = 7;
-/**
- * Extracts a deterministic numeric seed from a SHA-256 hash.
- *
- * @private utility of `linguisticHash`
- */
-function getHashSeed(hash, segmentIndex) {
-    const expandedHash = `${hash}${hash}`;
-    const start = (segmentIndex * HASH_SEGMENT_LENGTH + segmentIndex) % hash.length;
-    return parseInt(expandedHash.substring(start, start + HASH_SEGMENT_LENGTH), 16);
-}
-/**
- * Picks a deterministic item from a list based on the hash seed.
- *
- * @private utility of `linguisticHash`
- */
-function pickFromHash(hash, segmentIndex, list) {
-    const seed = getHashSeed(hash, segmentIndex);
-    return list[seed % list.length];
-}
 /**
  * Ordered word kinds used to build the linguistic hash output.
  *
@@ -5313,16 +5389,23 @@ const MAX_LINGUISTIC_HASH_WORD_COUNT = WORD_SEQUENCE.length;
  */
 const SINGLE_WORD_INDEX = 1;
 /**
- * Normalizes the word count to a supported integer range.
+ * Extracts a deterministic numeric seed from a SHA-256 hash.
  *
  * @private utility of `linguisticHash`
  */
-function normalizeLinguisticHashWordCount(wordCount) {
-    if (typeof wordCount !== 'number' || !Number.isFinite(wordCount)) {
-        return DEFAULT_LINGUISTIC_HASH_WORD_COUNT;
-    }
-    const rounded = Math.round(wordCount);
-    return Math.min(MAX_LINGUISTIC_HASH_WORD_COUNT, Math.max(MIN_LINGUISTIC_HASH_WORD_COUNT, rounded));
+function getHashSeed(hash, segmentIndex) {
+    const expandedHash = `${hash}${hash}`;
+    const start = (segmentIndex * HASH_SEGMENT_LENGTH + segmentIndex) % hash.length;
+    return parseInt(expandedHash.substring(start, start + HASH_SEGMENT_LENGTH), 16);
+}
+/**
+ * Picks a deterministic item from a list based on the hash seed.
+ *
+ * @private utility of `linguisticHash`
+ */
+function pickFromHash(hash, segmentIndex, list) {
+    const seed = getHashSeed(hash, segmentIndex);
+    return list[seed % list.length];
 }
 /**
  * Picks a deterministic word from the hash by kind.
@@ -5353,6 +5436,49 @@ function createLinguisticHashWords(hash, wordCount, wordLists) {
     return words.slice(0, wordCount);
 }
 
+/**
+ * The minimum number of words for a linguistic hash.
+ *
+ * @private utility of `linguisticHash`
+ */
+const MIN_LINGUISTIC_HASH_WORD_COUNT = 1;
+/**
+ * The default number of words for a linguistic hash.
+ *
+ * @private utility of `linguisticHash`
+ */
+const DEFAULT_LINGUISTIC_HASH_WORD_COUNT = 7;
+/**
+ * Normalizes the word count to a supported integer range.
+ *
+ * @private utility of `linguisticHash`
+ */
+function normalizeLinguisticHashWordCount(wordCount) {
+    if (typeof wordCount !== 'number' || !Number.isFinite(wordCount)) {
+        return DEFAULT_LINGUISTIC_HASH_WORD_COUNT;
+    }
+    const rounded = Math.round(wordCount);
+    return Math.min(MAX_LINGUISTIC_HASH_WORD_COUNT, Math.max(MIN_LINGUISTIC_HASH_WORD_COUNT, rounded));
+}
+
+// <- TODO: !!!! Remove re-exports
+/**
+ * Creates a human-readable hash as a short, story-like phrase.
+ *
+ * @param wordCount how many words to include (defaults to {@link DEFAULT_LINGUISTIC_HASH_WORD_COUNT}, clamped to
+ * {@link MIN_LINGUISTIC_HASH_WORD_COUNT}..{@link MAX_LINGUISTIC_HASH_WORD_COUNT})
+ * @param language optional language code (defaults to {@link DEFAULT_LINGUISTIC_HASH_LANGUAGE})
+ *
+ * @public exported from `@promptbook/utils`
+ */
+async function linguisticHash(input, wordCount, language) {
+    const hash = computeHash(input);
+    const normalizedWordCount = normalizeLinguisticHashWordCount(wordCount);
+    const languageConfig = getLinguisticHashLanguageConfig(language);
+    const words = createLinguisticHashWords(hash, normalizedWordCount, languageConfig.wordLists);
+    return capitalize(words.join(' '));
+}
+
 /**
  * Simple wrapper `new Date().toISOString()`
  *
@@ -15968,14 +16094,27 @@ function humanizeAiTextEmdashed(aiText) {
  * @public exported from `@promptbook/markdown-utils`
  */
 function humanizeAiTextQuotes(aiText) {
-    return aiText
-        .replace(/[“”„‟«»❝❞〝〞〟＂]/g, '"')
-        .replace(/[‚‘’‛‹›❛❜＇ʼ]/g, "'");
+    return aiText.replace(/[“”„‟«»❝❞〝〞〟＂]/g, '"').replace(/[‚‘’‛‹›❛❜＇ʼ]/g, "'");
 }
 /**
  * Note: [🏂] This function is not tested by itself but together with other cleanup functions with `humanizeAiText`
  */
 
+/**
+ * Remove bracketed source citation artifacts like `\u30105:1\u2020source\u3011`.
+ *
+ * Note: [??] This function is idempotent.
+ * Tip: If you want to do the full cleanup, look for `humanizeAiText` exported `@promptbook/markdown-utils`
+ *
+ * @public exported from `@promptbook/markdown-utils`
+ */
+function humanizeAiTextSources(aiText) {
+    return aiText.replace(/[ \t]*\u3010\s*\d+(?:\s*:\s*\d+)?\s*\u2020source\s*\u3011/g, '');
+}
+/**
+ * Note: [??] This function is not tested by itself but together with other cleanup functions with `humanizeAiText`
+ */
+
 /**
  * Change unprintable hard spaces to regular spaces and drop zero-width spaces
  *
@@ -15985,9 +16124,7 @@ function humanizeAiTextQuotes(aiText) {
  * @public exported from `@promptbook/markdown-utils`
  */
 function humanizeAiTextWhitespace(aiText) {
-    return aiText
-        .replace(/[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g, ' ')
-        .replace(/[\u200B\uFEFF\u2060]/g, '');
+    return aiText.replace(/[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g, ' ').replace(/[\u200B\uFEFF\u2060]/g, '');
 }
 /**
  * Note: [🏂] This function is not tested by itself but together with other cleanup functions with `humanizeAiText`
@@ -16006,6 +16143,7 @@ function humanizeAiText(aiText) {
     cleanedText = humanizeAiTextEllipsis(cleanedText);
     cleanedText = humanizeAiTextEmdashed(cleanedText);
     cleanedText = humanizeAiTextQuotes(cleanedText);
+    cleanedText = humanizeAiTextSources(cleanedText);
     cleanedText = humanizeAiTextWhitespace(cleanedText);
     return cleanedText;
 }
@@ -18496,17 +18634,32 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         });
     }
     async createNewAssistant(options) {
+        var _a, _b, _c;
         if (!this.isCreatingNewAssistantsAllowed) {
             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, tools } = options;
+        const preparationStartedAtMs = Date.now();
+        const knowledgeSourcesCount = (_a = knowledgeSources === null || knowledgeSources === void 0 ? void 0 : knowledgeSources.length) !== null && _a !== void 0 ? _a : 0;
+        const toolsCount = (_b = tools === null || tools === void 0 ? void 0 : tools.length) !== null && _b !== void 0 ? _b : 0;
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Starting OpenAI assistant creation', {
+                name,
+                knowledgeSourcesCount,
+                toolsCount,
+                instructionsLength: instructions.length,
+            });
+        }
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
         if (knowledgeSources && knowledgeSources.length > 0) {
             if (this.options.isVerbose) {
-                console.info(`📚 Creating vector store with ${knowledgeSources.length} knowledge sources...`);
+                console.info('[🤰]', 'Creating vector store with knowledge sources', {
+                    name,
+                    knowledgeSourcesCount,
+                });
             }
             // Create a vector store
             const vectorStore = await client.beta.vectorStores.create({
@@ -18514,12 +18667,22 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             });
             vectorStoreId = vectorStore.id;
             if (this.options.isVerbose) {
-                console.info(`✅ Vector store created: ${vectorStoreId}`);
+                console.info('[🤰]', 'Vector store created', {
+                    vectorStoreId,
+                });
             }
             // Upload files from knowledge sources to the vector store
             const fileStreams = [];
-            for (const source of knowledgeSources) {
+            for (const [index, source] of knowledgeSources.entries()) {
                 try {
+                    if (this.options.isVerbose) {
+                        console.info('[🤰]', 'Processing knowledge source', {
+                            index: index + 1,
+                            total: knowledgeSources.length,
+                            source,
+                            sourceType: source.startsWith('http') || source.startsWith('https') ? 'url' : 'file',
+                        });
+                    }
                     // Check if it's a URL
                     if (source.startsWith('http://') || source.startsWith('https://')) {
                         // Download the file
@@ -18564,7 +18727,10 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                         files: fileStreams,
                     });
                     if (this.options.isVerbose) {
-                        console.info(`✅ Uploaded ${fileStreams.length} files to vector store`);
+                        console.info('[🤰]', 'Uploaded files to vector store', {
+                            vectorStoreId,
+                            fileCount: fileStreams.length,
+                        });
                     }
                 }
                 catch (error) {
@@ -18592,8 +18758,21 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                 },
             };
         }
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Creating OpenAI assistant', {
+                name,
+                model: assistantConfig.model,
+                toolCount: (_c = assistantConfig === null || assistantConfig === void 0 ? void 0 : assistantConfig.tools) === null || _c === void 0 ? void 0 : _c.length,
+                hasVectorStore: Boolean(vectorStoreId),
+            });
+        }
         const assistant = await client.beta.assistants.create(assistantConfig);
-        console.log(`✅ Assistant created: ${assistant.id}`);
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'OpenAI assistant created', {
+                assistantId: assistant.id,
+                elapsedMs: Date.now() - preparationStartedAtMs,
+            });
+        }
         // TODO: [🐱‍🚀] Try listing existing assistants
         // TODO: [🐱‍🚀] Try marking existing assistants by DISCRIMINANT
         // TODO: [🐱‍🚀] Allow to update and reconnect to existing assistants
@@ -18604,17 +18783,34 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         });
     }
     async updateAssistant(options) {
+        var _a, _b, _c, _d;
         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, tools } = options;
+        const preparationStartedAtMs = Date.now();
+        const knowledgeSourcesCount = (_a = knowledgeSources === null || knowledgeSources === void 0 ? void 0 : knowledgeSources.length) !== null && _a !== void 0 ? _a : 0;
+        const toolsCount = (_b = tools === null || tools === void 0 ? void 0 : tools.length) !== null && _b !== void 0 ? _b : 0;
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Starting OpenAI assistant update', {
+                assistantId,
+                name,
+                knowledgeSourcesCount,
+                toolsCount,
+                instructionsLength: (_c = instructions === null || instructions === void 0 ? void 0 : instructions.length) !== null && _c !== void 0 ? _c : 0,
+            });
+        }
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
         // TODO: [🧠] Reuse vector store creation logic from createNewAssistant
         if (knowledgeSources && knowledgeSources.length > 0) {
             if (this.options.isVerbose) {
-                console.info(`📚 Creating vector store for update with ${knowledgeSources.length} knowledge sources...`);
+                console.info('[🤰]', 'Creating vector store for assistant update', {
+                    assistantId,
+                    name,
+                    knowledgeSourcesCount,
+                });
             }
             // Create a vector store
             const vectorStore = await client.beta.vectorStores.create({
@@ -18622,12 +18818,22 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
             });
             vectorStoreId = vectorStore.id;
             if (this.options.isVerbose) {
-                console.info(`✅ Vector store created: ${vectorStoreId}`);
+                console.info('[🤰]', 'Vector store created for assistant update', {
+                    vectorStoreId,
+                });
             }
             // Upload files from knowledge sources to the vector store
             const fileStreams = [];
-            for (const source of knowledgeSources) {
+            for (const [index, source] of knowledgeSources.entries()) {
                 try {
+                    if (this.options.isVerbose) {
+                        console.info('[🤰]', 'Processing knowledge source for update', {
+                            index: index + 1,
+                            total: knowledgeSources.length,
+                            source,
+                            sourceType: source.startsWith('http') || source.startsWith('https') ? 'url' : 'file',
+                        });
+                    }
                     // Check if it's a URL
                     if (source.startsWith('http://') || source.startsWith('https://')) {
                         // Download the file
@@ -18672,7 +18878,10 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                         files: fileStreams,
                     });
                     if (this.options.isVerbose) {
-                        console.info(`✅ Uploaded ${fileStreams.length} files to vector store`);
+                        console.info('[🤰]', 'Uploaded files to vector store for update', {
+                            vectorStoreId,
+                            fileCount: fileStreams.length,
+                        });
                     }
                 }
                 catch (error) {
@@ -18696,9 +18905,20 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                 },
             };
         }
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Updating OpenAI assistant', {
+                assistantId,
+                name,
+                toolCount: (_d = assistantUpdate === null || assistantUpdate === void 0 ? void 0 : assistantUpdate.tools) === null || _d === void 0 ? void 0 : _d.length,
+                hasVectorStore: Boolean(vectorStoreId),
+            });
+        }
         const assistant = await client.beta.assistants.update(assistantId, assistantUpdate);
         if (this.options.isVerbose) {
-            console.log(`✅ Assistant updated: ${assistant.id}`);
+            console.info('[🤰]', 'OpenAI assistant updated', {
+                assistantId: assistant.id,
+                elapsedMs: Date.now() - preparationStartedAtMs,
+            });
         }
         return new OpenAiAssistantExecutionTools({
             ...this.options,
@@ -18757,7 +18977,7 @@ function emitAssistantPreparationProgress(options) {
         toolCalls: [
             {
                 name: ASSISTANT_PREPARATION_TOOL_CALL_NAME,
-                arguments: {},
+                arguments: options.phase ? { phase: options.phase } : {},
                 createdAt: startedAt,
             },
         ],
@@ -18821,10 +19041,32 @@ class AgentLlmExecutionTools {
      */
     async getModelRequirements() {
         if (this._cachedModelRequirements === null) {
+            const preparationStartedAtMs = Date.now();
+            if (this.options.isVerbose) {
+                console.info('[🤰]', 'Preparing agent model requirements', {
+                    agent: this.title,
+                });
+            }
             // Get available models from underlying LLM tools for best model selection
+            const availableModelsStartedAtMs = Date.now();
             const availableModels = await this.options.llmTools.listModels();
+            if (this.options.isVerbose) {
+                console.info('[🤰]', 'Available models resolved for agent', {
+                    agent: this.title,
+                    modelCount: availableModels.length,
+                    elapsedMs: Date.now() - availableModelsStartedAtMs,
+                });
+            }
+            const requirementsStartedAtMs = Date.now();
             this._cachedModelRequirements = await createAgentModelRequirements(this.options.agentSource, undefined, // Let the function pick the best model
             availableModels);
+            if (this.options.isVerbose) {
+                console.info('[🤰]', 'Agent model requirements ready', {
+                    agent: this.title,
+                    elapsedMs: Date.now() - requirementsStartedAtMs,
+                    totalElapsedMs: Date.now() - preparationStartedAtMs,
+                });
+            }
         }
         return this._cachedModelRequirements;
     }
@@ -18978,18 +19220,25 @@ class AgentLlmExecutionTools {
             if (cached) {
                 if (cached.requirementsHash === requirementsHash) {
                     if (this.options.isVerbose) {
-                        console.log(`1️⃣ Using cached OpenAI Assistant for agent ${this.title}...`);
+                        console.info('[🤰]', 'Using cached OpenAI Assistant', {
+                            agent: this.title,
+                            assistantId: cached.assistantId,
+                        });
                     }
                     assistant = this.options.llmTools.getAssistant(cached.assistantId);
                 }
                 else {
                     if (this.options.isVerbose) {
-                        console.log(`1️⃣ Updating OpenAI Assistant for agent ${this.title}...`);
+                        console.info('[🤰]', 'Updating OpenAI Assistant', {
+                            agent: this.title,
+                            assistantId: cached.assistantId,
+                        });
                     }
                     emitAssistantPreparationProgress({
                         onProgress,
                         prompt,
                         modelName: this.modelName,
+                        phase: 'Updating assistant',
                     });
                     assistant = await this.options.llmTools.updateAssistant({
                         assistantId: cached.assistantId,
@@ -19006,13 +19255,16 @@ class AgentLlmExecutionTools {
             }
             else {
                 if (this.options.isVerbose) {
-                    console.log(`1️⃣ Creating new OpenAI Assistant for agent ${this.title}...`);
+                    console.info('[🤰]', 'Creating new OpenAI Assistant', {
+                        agent: this.title,
+                    });
                 }
                 // <- TODO: [🐱‍🚀] Check also `isCreatingNewAssistantsAllowed` and warn about it
                 emitAssistantPreparationProgress({
                     onProgress,
                     prompt,
                     modelName: this.modelName,
+                    phase: 'Creating assistant',
                 });
                 assistant = await this.options.llmTools.createNewAssistant({
                     name: this.title,
@@ -19086,6 +19338,65 @@ AgentLlmExecutionTools.vectorStoreCache = new Map();
  */
 
 var _Agent_instances, _Agent_selfLearnNonce, _Agent_selfLearnSamples, _Agent_selfLearnTeacher;
+/**
+ * Creates an empty commitment breakdown for self-learning summaries.
+ */
+function createEmptySelfLearningCommitmentCounts() {
+    return {
+        total: 0,
+        knowledge: 0,
+        rule: 0,
+        persona: 0,
+        other: 0,
+    };
+}
+/**
+ * Normalizes teacher commitments into trimmed, display-ready lines.
+ */
+function getTeacherCommitmentLines(commitments) {
+    return commitments
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && line !== '---' && !line.startsWith('```'));
+}
+/**
+ * Summarizes teacher commitment lines into user-friendly counts for self-learning.
+ */
+function summarizeTeacherCommitmentLines(lines) {
+    var _a, _b;
+    const counts = createEmptySelfLearningCommitmentCounts();
+    for (const line of lines) {
+        const keyword = (_b = (_a = line.split(/\s+/)[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase()) !== null && _b !== void 0 ? _b : '';
+        if (!/^[A-Z][A-Z_-]*$/.test(keyword)) {
+            continue;
+        }
+        counts.total += 1;
+        if (keyword === 'KNOWLEDGE') {
+            counts.knowledge += 1;
+        }
+        else if (keyword === 'RULE') {
+            counts.rule += 1;
+        }
+        else if (keyword === 'PERSONA') {
+            counts.persona += 1;
+        }
+        else {
+            counts.other += 1;
+        }
+    }
+    return counts;
+}
+/**
+ * Builds the teacher summary payload for the self-learning tool call.
+ */
+function buildTeacherSummary(commitments, used) {
+    const commitmentLines = getTeacherCommitmentLines(commitments);
+    return {
+        used,
+        commitmentTypes: summarizeTeacherCommitmentLines(commitmentLines),
+        commitments: commitmentLines.length > 0 ? commitmentLines : undefined,
+    };
+}
 /**
  * Represents one AI Agent
  *
@@ -19260,16 +19571,29 @@ class Agent extends AgentLlmExecutionTools {
         // Note: [2] Do the append of the samples
         await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearnSamples).call(this, prompt, result);
         // Note: [3] Asynchronously call the teacher agent and invoke the silver link. When the teacher fails, keep just the samples
-        await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearnTeacher).call(this, prompt, result).catch((error) => {
+        let teacherSummary = null;
+        try {
+            teacherSummary = await __classPrivateFieldGet(this, _Agent_instances, "m", _Agent_selfLearnTeacher).call(this, prompt, result);
+        }
+        catch (error) {
             // !!!!! if (this.options.isVerbose) {
             console.error(colors.bgCyan('[Self-learning]') + colors.red(' Failed to learn from teacher agent'));
             console.error(error);
             // }
-        });
+            teacherSummary = this.teacherAgent ? buildTeacherSummary('', true) : null;
+        }
         // Note: [4] Notify end of self-learning
+        const completedAt = new Date().toISOString();
+        const selfLearningResult = {
+            success: true,
+            startedAt: selfLearningToolCall.createdAt,
+            completedAt,
+            samplesAdded: 1,
+            teacher: teacherSummary || undefined,
+        };
         const completedSelfLearningToolCall = {
             ...selfLearningToolCall,
-            result: { success: true },
+            result: selfLearningResult,
         };
         const finalResult = {
             ...result,
@@ -19318,7 +19642,7 @@ async function _Agent_selfLearnNonce() {
 async function _Agent_selfLearnTeacher(prompt, result) {
     // [1] Call the teacher agent // <- !!!!! Emojis
     if (this.teacherAgent === null) {
-        return;
+        return null;
     }
     console.info(colors.bgCyan('[Self-learning]') + colors.cyan(' Teacher'));
     const teacherResult = await this.teacherAgent.callChatModel({
@@ -19373,7 +19697,7 @@ async function _Agent_selfLearnTeacher(prompt, result) {
     if (teacherCommitments === '') {
         console.info(colors.bgCyan('[Self-learning]') +
             colors.cyan(' Teacher agent did not provide new commitments to learn'));
-        return;
+        return buildTeacherSummary('', true);
     }
     // [2] Append to the current source
     const currentSource = this.agentSource.value;
@@ -19381,6 +19705,7 @@ async function _Agent_selfLearnTeacher(prompt, result) {
     // <- TODO: [🈲] Use some object-based way how to append on book (with sections `---`)
     // [3] Update the source
     this.agentSource.next(newSource);
+    return buildTeacherSummary(teacherCommitments, true);
 };
 /**
  * TODO: [🧠][😰]Agent is not working with the parameters, should it be?