@promptbook/browser 0.105.0-0 → 0.105.0-10

package/esm/index.es.js

@@ -19,7 +19,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-0';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.0-10';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1071,6 +1071,7 @@ const PROMPTBOOK_COLOR = Color.fromString('promptbook');
     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
 /**
@@ -1405,6 +1406,104 @@ async function $provideScrapersForBrowser(tools, options) {
     return scrapers;
 }
 
+/**
+ * Speech recognition using Web Speech API `SpeechRecognition` available in modern browsers
+ *
+ * @public exported from `@promptbook/browser`
+ */
+class BrowserSpeechRecognition {
+    get state() {
+        return this._state;
+    }
+    constructor() {
+        this.recognition = null;
+        this.callbacks = [];
+        this._state = 'IDLE';
+        if (typeof window !== 'undefined') {
+            const SpeechRecognitionValue = window.SpeechRecognition ||
+                window /* <- TODO: !!!! Make special windowAny */.webkitSpeechRecognition;
+            if (SpeechRecognitionValue) {
+                this.recognition = new SpeechRecognitionValue();
+                this.recognition.continuous = true;
+                this.recognition.interimResults = true;
+                this.recognition.onstart = () => {
+                    this._state = 'RECORDING';
+                    this.emit({ type: 'START' });
+                };
+                this.recognition.onresult = (event) => {
+                    let finalTranscript = '';
+                    let interimTranscript = '';
+                    for (let i = event.resultIndex; i < event.results.length; ++i) {
+                        if (event.results[i].isFinal) {
+                            finalTranscript += event.results[i][0].transcript;
+                        }
+                        else {
+                            interimTranscript += event.results[i][0].transcript;
+                        }
+                    }
+                    const text = (finalTranscript + interimTranscript).trim();
+                    if (text) {
+                        this.emit({
+                            type: 'RESULT',
+                            text,
+                            isFinal: interimTranscript === '',
+                        });
+                    }
+                };
+                this.recognition.onerror = (event) => {
+                    this._state = 'ERROR';
+                    this.emit({ type: 'ERROR', message: event.error || 'Unknown error' });
+                };
+                this.recognition.onend = () => {
+                    this._state = 'IDLE';
+                    this.emit({ type: 'STOP' });
+                };
+            }
+        }
+    }
+    $start(options = {}) {
+        var _a;
+        if (!this.recognition) {
+            this.emit({ type: 'ERROR', message: 'Speech recognition is not supported in this browser.' });
+            return;
+        }
+        if (this._state !== 'IDLE') {
+            return;
+        }
+        this._state = 'STARTING';
+        this.recognition.lang = options.language || 'en'; // Note: Web Speech API usually accepts ISO-639-1 or BCP-47
+        this.recognition.interimResults = (_a = options.interimResults) !== null && _a !== void 0 ? _a : true;
+        try {
+            this.recognition.start();
+        }
+        catch (error) {
+            this._state = 'ERROR';
+            this.emit({ type: 'ERROR', message: error.message });
+        }
+    }
+    $stop() {
+        if (!this.recognition || this._state === 'IDLE') {
+            return;
+        }
+        this.recognition.stop();
+    }
+    subscribe(callback) {
+        this.callbacks.push(callback);
+        return () => {
+            this.callbacks = this.callbacks.filter((cb) => cb !== callback);
+        };
+    }
+    emit(event) {
+        for (const callback of this.callbacks) {
+            callback(event);
+        }
+    }
+}
+/**
+ * TODO: !!!! Search ACRY for `window` and put -> [🔵]
+ * Note: [🔵] Code in this file should never be published outside of `@promptbook/browser`
+ */
+
 /**
  * Creates a PromptbookStorage backed by IndexedDB.
  * Uses a single object store named 'promptbook'.
@@ -2791,6 +2890,22 @@ class BaseCommitmentDefinition {
             return this.appendToSystemMessage(requirements, commentSection);
         }
     }
+    /**
+     * Gets tool function implementations provided by this commitment
+     *
+     * When the `applyToAgentModelRequirements` adds tools to the requirements, this method should return the corresponding function definitions.
+     */
+    getToolFunctions() {
+        return {};
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment
+     *
+     * This is used in the UI to show a user-friendly name instead of the technical function name.
+     */
+    getToolTitles() {
+        return {};
+    }
 }
 
 /**
@@ -3406,79 +3521,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
  *
@@ -3579,6 +3621,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
  *
@@ -3998,7 +4121,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,
+        };
     }
 }
 
@@ -5030,27 +5159,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],
         };
     }
 }
@@ -5834,6 +5952,14 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
             \`\`\`
         `);
     }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            web_browser: 'Web browser',
+        };
+    }
     applyToAgentModelRequirements(requirements, content) {
         // Get existing tools array or create new one
         const existingTools = requirements.tools || [];
@@ -5862,14 +5988,17 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
                 },
             ]);
         // Return requirements with updated tools and metadata
-        return {
+        return this.appendToSystemMessage({
             ...requirements,
             tools: updatedTools,
             metadata: {
                 ...requirements.metadata,
                 useBrowser: true,
             },
-        };
+        }, spaceTrim$1(`
+                You have access to the web browser. Use it to access specific websites or browse the internet.
+                When you need to know some information from a specific website, use the tool provided to you.
+            `));
     }
 }
 /**
@@ -5953,6 +6082,49 @@ class UseMcpCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
+/**
+ * A search engine implementation that uses the SerpApi to fetch Google search results.
+ *
+ * @private <- TODO: !!!! Export via some package
+ */
+class SerpSearchEngine {
+    get title() {
+        return 'SerpApi Search Engine';
+    }
+    get description() {
+        return 'Search engine that uses SerpApi to fetch Google search results';
+    }
+    checkConfiguration() {
+        if (!process.env.SERP_API_KEY) {
+            throw new Error('SERP_API_KEY is not configured');
+        }
+    }
+    async search(query, options = {}) {
+        const apiKey = process.env.SERP_API_KEY;
+        if (!apiKey) {
+            throw new Error('SERP_API_KEY is not configured');
+        }
+        const url = new URL('https://serpapi.com/search');
+        url.searchParams.set('api_key', apiKey);
+        url.searchParams.set('engine', 'google');
+        url.searchParams.set('q', query);
+        for (const [key, value] of Object.entries(options)) {
+            url.searchParams.set(key, String(value));
+        }
+        const response = await fetch(url.toString());
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`SerpApi failed with status ${response.status}: ${response.statusText}\n${body}`);
+        }
+        const data = (await response.json());
+        return (data.organic_results || []).map((item) => ({
+            title: item.title,
+            url: item.link,
+            snippet: item.snippet || '',
+        }));
+    }
+}
+
 /**
  * USE SEARCH ENGINE commitment definition
  *
@@ -5972,7 +6144,7 @@ class UseMcpCommitmentDefinition extends BaseCommitmentDefinition {
  */
 class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
     constructor() {
-        super('USE SEARCH ENGINE', ['SEARCH ENGINE', 'SEARCH']);
+        super('USE SEARCH ENGINE', ['USE SEARCH']);
     }
     /**
      * Short one-line description of USE SEARCH ENGINE.
@@ -6029,18 +6201,13 @@ class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
             ? existingTools
             : [
                 ...existingTools,
-                { type: 'web_search' },
-                // <- Note: [🔰] This is just using simple native search tool by OpenAI @see https://platform.openai.com/docs/guides/tools-web-search
-                //          In future we will use proper MCP search tool:
-                /*
- 
                 {
                     name: 'web_search',
-                    description: spaceTrim(`
-                      Search the internet for information.
-                      Use this tool when you need to find up-to-date information or facts that you don't know.
-                      ${!content ? '' : `Search scope / instructions: ${content}`}
-                  `),
+                    description: spaceTrim$1(`
+                        Search the internet for information.
+                        Use this tool when you need to find up-to-date information or facts that you don't know.
+                        ${!content ? '' : `Search scope / instructions: ${content}`}
+                    `),
                     parameters: {
                         type: 'object',
                         properties: {
@@ -6048,20 +6215,224 @@ class UseSearchEngineCommitmentDefinition extends BaseCommitmentDefinition {
                                 type: 'string',
                                 description: 'The search query',
                             },
+                            location: {
+                                type: 'string',
+                                description: 'The location for the search (e.g., "Austin, Texas, United States" or "Prague, Czechia")',
+                            },
+                            gl: {
+                                type: 'string',
+                                description: 'The country code (e.g., "us" for United States, "cz" for Czechia)',
+                            },
+                            hl: {
+                                type: 'string',
+                                description: 'The language code (e.g., "en" for English, "cs" for Czech)',
+                            },
+                            num: {
+                                type: 'integer',
+                                description: 'Number of results to return',
+                            },
+                            engine: {
+                                type: 'string',
+                                description: 'The search engine to use (e.g., "google", "bing", "yahoo", "baidu")',
+                            },
+                            google_domain: {
+                                type: 'string',
+                                description: 'The Google domain to use (e.g., "google.com", "google.cz")',
+                            },
                         },
                         required: ['query'],
                     },
                 },
-                */
             ];
         // Return requirements with updated tools and metadata
-        return {
+        return this.appendToSystemMessage({
             ...requirements,
             tools: updatedTools,
             metadata: {
                 ...requirements.metadata,
                 useSearchEngine: content || true,
             },
+        }, spaceTrim$1(`
+                You have access to the web search engine. Use it to find up-to-date information or facts that you don't know.
+                When you need to know some information from the internet, use the tool provided to you.
+            `));
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            web_search: 'Web search',
+        };
+    }
+    /**
+     * Gets the `web_search` tool function implementation.
+     */
+    getToolFunctions() {
+        return {
+            async web_search(args) {
+                console.log('!!!! [Tool] web_search called', { args });
+                const { query, ...options } = args;
+                if (!query) {
+                    throw new Error('Search query is required');
+                }
+                const searchEngine = new SerpSearchEngine();
+                const results = await searchEngine.search(query, options);
+                return spaceTrim$1((block) => `
+                        Search results for "${query}"${Object.keys(options).length === 0
+                    ? ''
+                    : ` with options ${JSON.stringify(options)}`}:
+
+                        ${block(results
+                    .map((result) => spaceTrim$1(`
+                                            - **${result.title}**
+                                              ${result.url}
+                                              ${result.snippet}
+                                        `))
+                    .join('\n\n'))}
+                    `);
+            },
+        };
+    }
+}
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * USE TIME commitment definition
+ *
+ * The `USE TIME` commitment indicates that the agent should be able to determine the current date and time.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * USE TIME
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class UseTimeCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('USE TIME', ['CURRENT TIME', 'TIME', 'DATE']);
+    }
+    /**
+     * Short one-line description of USE TIME.
+     */
+    get description() {
+        return 'Enable the agent to determine the current date and time.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '🕒';
+    }
+    /**
+     * Markdown documentation for USE TIME commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # USE TIME
+
+            Enables the agent to determine the current date and time.
+
+            ## Key aspects
+
+            - This tool won't receive any input.
+            - It outputs the current date and time as an ISO 8601 string.
+            - Allows the agent to answer questions about the current time or date.
+
+            ## Examples
+
+            \`\`\`book
+            Time-aware Assistant
+
+            PERSONA You are a helpful assistant who knows the current time.
+            USE TIME
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // Get existing tools array or create new one
+        const existingTools = requirements.tools || [];
+        // Add 'get_current_time' to tools if not already present
+        const updatedTools = existingTools.some((tool) => tool.name === 'get_current_time')
+            ? existingTools
+            : [
+                ...existingTools,
+                {
+                    name: 'get_current_time',
+                    description: 'Get the current date and time in ISO 8601 format.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            timezone: {
+                                type: 'string',
+                                description: 'Optional timezone name (e.g. "Europe/Prague", "UTC", "America/New_York").',
+                            },
+                        },
+                        required: [],
+                    },
+                },
+                // <- TODO: !!!! define the function in LLM tools
+            ];
+        // Return requirements with updated tools and metadata
+        return this.appendToSystemMessage({
+            ...requirements,
+            tools: updatedTools,
+            metadata: {
+                ...requirements.metadata,
+            },
+        }, spaceTrim$1(`
+                You have access to the current date and time. Use it to answer questions about the current date and time.
+                When you need to know the current date or time, use the tool provided to you.
+            `));
+    }
+    /**
+     * Gets human-readable titles for tool functions provided by this commitment.
+     */
+    getToolTitles() {
+        return {
+            get_current_time: 'Get current time',
+        };
+    }
+    /**
+     * Gets the `get_current_time` tool function implementation.
+     */
+    getToolFunctions() {
+        return {
+            async get_current_time(args) {
+                var _a;
+                console.log('!!!! [Tool] get_current_time called', { args });
+                const { timezone } = args;
+                if (!timezone) {
+                    return new Date().toISOString();
+                }
+                try {
+                    // Note: Returning ISO 8601 string but in the requested timezone
+                    const formatter = new Intl.DateTimeFormat('en-CA', {
+                        timeZone: timezone,
+                        year: 'numeric',
+                        month: '2-digit',
+                        day: '2-digit',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        hour12: false,
+                        timeZoneName: 'shortOffset',
+                    });
+                    const parts = formatter.formatToParts(new Date());
+                    const part = (type) => { var _a; return (_a = parts.find((p) => p.type === type)) === null || _a === void 0 ? void 0 : _a.value; };
+                    // en-CA format is YYYY-MM-DD
+                    const isoString = `${part('year')}-${part('month')}-${part('day')}T${part('hour')}:${part('minute')}:${part('second')}${(_a = part('timeZoneName')) === null || _a === void 0 ? void 0 : _a.replace('GMT', '')}`;
+                    return isoString;
+                }
+                catch (error) {
+                    // Fallback to UTC if timezone is invalid
+                    return new Date().toISOString();
+                }
+            },
         };
     }
 }
@@ -6136,7 +6507,6 @@ class NotYetImplementedCommitmentDefinition extends BaseCommitmentDefinition {
     }
 }
 
-// Import all commitment definition classes
 /**
  * Registry of all available commitment definitions
  * This array contains instances of all commitment definitions
@@ -6153,10 +6523,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'),
@@ -6178,6 +6548,7 @@ const COMMITMENT_REGISTRY = [
     new NoteCommitmentDefinition('NOTES'),
     new NoteCommitmentDefinition('COMMENT'),
     new NoteCommitmentDefinition('NONCE'),
+    new NoteCommitmentDefinition('TODO'),
     new GoalCommitmentDefinition('GOAL'),
     new GoalCommitmentDefinition('GOALS'),
     new InitialMessageCommitmentDefinition(),
@@ -6196,6 +6567,7 @@ const COMMITMENT_REGISTRY = [
     new ClosedCommitmentDefinition(),
     new UseBrowserCommitmentDefinition(),
     new UseSearchEngineCommitmentDefinition(),
+    new UseTimeCommitmentDefinition(),
     new UseMcpCommitmentDefinition(),
     new UseCommitmentDefinition(),
     // Not yet implemented commitments (using placeholder)
@@ -6205,6 +6577,7 @@ const COMMITMENT_REGISTRY = [
     new NotYetImplementedCommitmentDefinition('AVOID'),
     new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
     new NotYetImplementedCommitmentDefinition('CONTEXT'),
+    // <- TODO: Prompt: Leverage aliases instead of duplicating commitment definitions
 ];
 /**
  * TODO: [🧠] Maybe create through standardized $register
@@ -6289,11 +6662,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) {
@@ -6467,7 +6866,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',
@@ -6484,6 +6900,71 @@ function parseAgentSource(agentSource) {
             });
             continue;
         }
+        if (commitment.type === 'USE SEARCH') {
+            capabilities.push({
+                type: 'search-engine',
+                label: 'Search Internet',
+                iconName: 'Search',
+            });
+            continue;
+        }
+        if (commitment.type === 'USE TIME') {
+            capabilities.push({
+                type: 'time',
+                label: 'Time',
+                iconName: 'Clock',
+            });
+            continue;
+        }
+        if (commitment.type === 'FROM') {
+            const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
+            if (content === 'Adam' || content === '' /* <- Note: Adam is implicit */) {
+                continue;
+            }
+            let label = content;
+            let iconName = 'SquareArrowOutUpRight'; // Inheritance remote
+            if (content.startsWith('./') || content.startsWith('../') || content.startsWith('/')) {
+                label = content.split('/').pop() || content;
+                iconName = 'SquareArrowUpRight'; // Inheritance local
+            }
+            if (content === 'VOID') {
+                label = 'VOID';
+                iconName = 'ShieldAlert'; // [🧠] Or some other icon for VOID
+            }
+            capabilities.push({
+                type: 'inheritance',
+                label,
+                iconName,
+                agentUrl: content,
+            });
+            continue;
+        }
+        if (commitment.type === 'IMPORT') {
+            const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
+            let label = content;
+            let iconName = 'ExternalLink'; // Import remote
+            try {
+                if (content.startsWith('http://') || content.startsWith('https://')) {
+                    const url = new URL(content);
+                    label = url.hostname.replace(/^www\./, '') + '.../' + url.pathname.split('/').pop();
+                    iconName = 'ExternalLink';
+                }
+                else if (content.startsWith('./') || content.startsWith('../') || content.startsWith('/')) {
+                    label = content.split('/').pop() || content;
+                    iconName = 'Link'; // Import local
+                }
+            }
+            catch (e) {
+                // Invalid URL or path, keep default label
+            }
+            capabilities.push({
+                type: 'import',
+                label,
+                iconName,
+                agentUrl: content,
+            });
+            continue;
+        }
         if (commitment.type === 'KNOWLEDGE') {
             const content = spaceTrim$2(commitment.content).split('\n')[0] || '';
             let label = content;
@@ -6568,6 +7049,7 @@ function parseAgentSource(agentSource) {
         links,
         parameters,
         capabilities,
+        samples,
     };
 }
 /**
@@ -6705,5 +7187,5 @@ async function $induceBookDownload(book) {
  * Note: [🔵] Code in this file should never be published outside of `@promptbook/browser`
  */
 
-export { $induceBookDownload, $induceFileDownload, $provideScrapersForBrowser, BOOK_LANGUAGE_VERSION, ObjectUrl, PROMPTBOOK_ENGINE_VERSION, SimplePromptInterfaceTools, getIndexedDbStorage, getLocalStorage, getSessionStorage };
+export { $induceBookDownload, $induceFileDownload, $provideScrapersForBrowser, BOOK_LANGUAGE_VERSION, BrowserSpeechRecognition, ObjectUrl, PROMPTBOOK_ENGINE_VERSION, SimplePromptInterfaceTools, getIndexedDbStorage, getLocalStorage, getSessionStorage };
 //# sourceMappingURL=index.es.js.map