@promptbook/core 0.100.0-4 → 0.100.0-41

package/esm/index.es.js

@@ -1,4 +1,4 @@
-import spaceTrim, { spaceTrim as spaceTrim$1 } from 'spacetrim';
+import spaceTrim$1, { spaceTrim } from 'spacetrim';
 import { format } from 'prettier';
 import parserHtml from 'prettier/parser-html';
 import { randomBytes } from 'crypto';
@@ -27,136 +27,342 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.100.0-4';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.0-41';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
 /**
- * Converts PipelineCollection to serialized JSON
+ * Extracts profile image URL from agent definition text and returns cleaned system message
+ * @param systemMessage The original system message that may contain META IMAGE line
+ * @returns Object with profileImageUrl (if found) and cleanedSystemMessage (without META IMAGE line)
  *
- * Note: Functions `collectionToJson` and `createCollectionFromJson` are complementary
+ * @private - TODO: [🧠] Maybe should be public?
+ */
+/**
+ * Generates a gravatar URL based on agent name for fallback avatar
+ * @param name The agent name to generate avatar for
+ * @returns Gravatar URL
  *
- * @public exported from `@promptbook/core`
+ * @private - TODO: [🧠] Maybe should be public?
  */
-async function collectionToJson(collection) {
-    const pipelineUrls = await collection.listPipelines();
-    const promptbooks = await Promise.all(pipelineUrls.map((url) => collection.getPipelineByUrl(url)));
-    return promptbooks;
+function generateGravatarUrl(name) {
+    // Use a default name if none provided
+    const safeName = name || 'Anonymous Agent';
+    // Create a simple hash from the name for consistent avatar
+    let hash = 0;
+    for (let i = 0; i < safeName.length; i++) {
+        const char = safeName.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    const avatarId = Math.abs(hash).toString();
+    return `https://www.gravatar.com/avatar/${avatarId}?default=robohash&size=200&rating=x`;
 }
 /**
- * TODO: [🧠] Maybe clear `sourceFile` or clear when exposing through API or remote server
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
 /**
- * Checks if value is valid email
+ * Freezes the given object and all its nested objects recursively
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it mutates given object
+ * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
  *
+ * @returns The same object as the input, but deeply frozen
  * @public exported from `@promptbook/utils`
  */
-function isValidEmail(email) {
-    if (typeof email !== 'string') {
-        return false;
+function $deepFreeze(objectValue) {
+    if (Array.isArray(objectValue)) {
+        return Object.freeze(objectValue.map((item) => $deepFreeze(item)));
     }
-    if (email.split('\n').length > 1) {
-        return false;
+    const propertyNames = Object.getOwnPropertyNames(objectValue);
+    for (const propertyName of propertyNames) {
+        const value = objectValue[propertyName];
+        if (value && typeof value === 'object') {
+            $deepFreeze(value);
+        }
     }
-    return /^.+@.+\..+$/.test(email);
+    Object.freeze(objectValue);
+    return objectValue;
 }
+/**
+ * TODO: [🧠] Is there a way how to meaningfully test this utility
+ */
 
 /**
- * Tests if given string is valid URL.
+ * Generates a regex pattern to match a specific commitment
  *
- * Note: This does not check if the file exists only if the path is valid
- * @public exported from `@promptbook/utils`
+ * Note: It always creates new Regex object
+ * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
+ *
+ * @private
  */
-function isValidFilePath(filename) {
-    if (typeof filename !== 'string') {
-        return false;
+function createCommitmentRegex(commitment) {
+    const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const keywordPattern = escapedCommitment.split(/\s+/).join('\\s+');
+    const regex = new RegExp(`^\\s*(?<type>${keywordPattern})\\b\\s+(?<contents>.+)$`, 'gim');
+    return regex;
+}
+/**
+ * Generates a regex pattern to match a specific commitment type
+ *
+ * Note: It just matches the type part of the commitment
+ * Note: It always creates new Regex object
+ * Note: Uses word boundaries to ensure only full words are matched (e.g., "PERSONA" matches but "PERSONALITY" does not)
+ *
+ * @private
+ */
+function createCommitmentTypeRegex(commitment) {
+    const escapedCommitment = commitment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const keywordPattern = escapedCommitment.split(/\s+/).join('\\s+');
+    const regex = new RegExp(`^\\s*(?<type>${keywordPattern})\\b`, 'gim');
+    return regex;
+}
+
+/**
+ * Base implementation of CommitmentDefinition that provides common functionality
+ * Most commitments can extend this class and only override the applyToAgentModelRequirements method
+ *
+ * @private
+ */
+class BaseCommitmentDefinition {
+    constructor(type) {
+        this.type = type;
     }
-    if (filename.split('\n').length > 1) {
-        return false;
+    /**
+     * Creates a regex pattern to match this commitment in agent source
+     * Uses the existing createCommitmentRegex function as internal helper
+     */
+    createRegex() {
+        return createCommitmentRegex(this.type);
     }
-    if (filename.split(' ').length >
-        5 /* <- TODO: [🧠][🈷] Make some better non-arbitrary way how to distinct filenames from informational texts */) {
-        return false;
+    /**
+     * Creates a regex pattern to match just the commitment type
+     * Uses the existing createCommitmentTypeRegex function as internal helper
+     */
+    createTypeRegex() {
+        return createCommitmentTypeRegex(this.type);
     }
-    const filenameSlashes = filename.split('\\').join('/');
-    // Absolute Unix path: /hello.txt
-    if (/^(\/)/i.test(filenameSlashes)) {
-        // console.log(filename, 'Absolute Unix path: /hello.txt');
-        return true;
+    /**
+     * Helper method to create a new requirements object with updated system message
+     * This is commonly used by many commitments
+     */
+    updateSystemMessage(requirements, messageUpdate) {
+        const newMessage = typeof messageUpdate === 'string' ? messageUpdate : messageUpdate(requirements.systemMessage);
+        return {
+            ...requirements,
+            systemMessage: newMessage,
+        };
     }
-    // Absolute Windows path: /hello.txt
-    if (/^([A-Z]{1,2}:\/?)\//i.test(filenameSlashes)) {
-        // console.log(filename, 'Absolute Windows path: /hello.txt');
-        return true;
+    /**
+     * Helper method to append content to the system message
+     */
+    appendToSystemMessage(requirements, content, separator = '\n\n') {
+        return this.updateSystemMessage(requirements, (currentMessage) => {
+            if (!currentMessage.trim()) {
+                return content;
+            }
+            return currentMessage + separator + content;
+        });
     }
-    // Relative path: ./hello.txt
-    if (/^(\.\.?\/)+/i.test(filenameSlashes)) {
-        // console.log(filename, 'Relative path: ./hello.txt');
-        return true;
+    /**
+     * Helper method to add a comment section to the system message
+     * Comments are lines starting with # that will be removed from the final system message
+     * but can be useful for organizing and structuring the message during processing
+     */
+    addCommentSection(requirements, commentTitle, content, position = 'end') {
+        const commentSection = `# ${commentTitle.toUpperCase()}\n${content}`;
+        if (position === 'beginning') {
+            return this.updateSystemMessage(requirements, (currentMessage) => {
+                if (!currentMessage.trim()) {
+                    return commentSection;
+                }
+                return commentSection + '\n\n' + currentMessage;
+            });
+        }
+        else {
+            return this.appendToSystemMessage(requirements, commentSection);
+        }
     }
-    // Allow paths like foo/hello
-    if (/^[^/]+\/[^/]+/i.test(filenameSlashes)) {
-        // console.log(filename, 'Allow paths like foo/hello');
-        return true;
+}
+
+/**
+ * ACTION commitment definition
+ *
+ * The ACTION commitment defines specific actions or capabilities that the agent can perform.
+ * This helps define what the agent is capable of doing and how it should approach tasks.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * ACTION Can generate code snippets and explain programming concepts
+ * ACTION Able to analyze data and provide insights
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class ActionCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('ACTION');
     }
-    // Allow paths like hello.book
-    if (/^[^/]+\.[^/]+$/i.test(filenameSlashes)) {
-        // console.log(filename, 'Allow paths like hello.book');
-        return true;
+    /**
+     * Short one-line description of ACTION.
+     */
+    get description() {
+        return 'Define agent capabilities and actions it can perform.';
+    }
+    /**
+     * Markdown documentation for ACTION commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # ACTION
+
+            Defines specific actions or capabilities that the agent can perform.
+
+            ## Key behaviors
+
+            - Multiple \`ACTION\` commitments are applied sequentially.
+            - Each action adds to the agent's capability list.
+            - Actions help users understand what the agent can do.
+
+            ## Examples
+
+            \`\`\`book
+            Code Assistant
+
+            PERSONA You are a programming assistant
+            ACTION Can generate code snippets and explain programming concepts
+            ACTION Able to debug existing code and suggest improvements
+            ACTION Can create unit tests for functions
+            \`\`\`
+
+            \`\`\`book
+            Data Scientist
+
+            PERSONA You are a data analysis expert
+            ACTION Able to analyze data and provide insights
+            ACTION Can create visualizations and charts
+            ACTION Capable of statistical analysis and modeling
+            KNOWLEDGE Data analysis best practices and statistical methods
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add action capability to the system message
+        const actionSection = `Capability: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, actionSection, '\n\n');
     }
-    return false;
 }
 /**
- * TODO: [🍏] Implement for MacOs
+ * Singleton instance of the ACTION commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new ActionCommitmentDefinition();
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
 /**
- * Tests if given string is valid URL.
+ * FORMAT commitment definition
  *
- * Note: Dataurl are considered perfectly valid.
- * Note: There are two similar functions:
- * - `isValidUrl` which tests any URL
- * - `isValidPipelineUrl` *(this one)* which tests just promptbook URL
+ * The FORMAT commitment defines the specific output structure and formatting
+ * that the agent should use in its responses. This includes data formats,
+ * response templates, and structural requirements.
  *
- * @public exported from `@promptbook/utils`
+ * Example usage in agent source:
+ *
+ * ```book
+ * FORMAT Always respond in JSON format with 'status' and 'data' fields
+ * FORMAT Use markdown formatting for all code blocks
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
  */
-function isValidUrl(url) {
-    if (typeof url !== 'string') {
-        return false;
+class FormatCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('FORMAT');
     }
-    try {
-        if (url.startsWith('blob:')) {
-            url = url.replace(/^blob:/, '');
-        }
-        const urlObject = new URL(url /* because fail is handled */);
-        if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
-            return false;
-        }
-        return true;
+    /**
+     * Short one-line description of FORMAT.
+     */
+    get description() {
+        return 'Specify output structure or formatting requirements.';
     }
-    catch (error) {
-        return false;
+    /**
+     * Markdown documentation for FORMAT commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # FORMAT
+
+            Defines the specific output structure and formatting for responses (data formats, templates, structure).
+
+            ## Key behaviors
+
+            - Multiple \`FORMAT\` commitments are applied sequentially.
+            - If they are in conflict, the last one takes precedence.
+            - You can specify both data formats and presentation styles.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Bot
+
+            PERSONA You are a helpful customer support agent
+            FORMAT Always respond in JSON format with 'status' and 'data' fields
+            FORMAT Use markdown formatting for all code blocks
+            \`\`\`
+
+            \`\`\`book
+            Data Analyst
+
+            PERSONA You are a data analysis expert
+            FORMAT Present results in structured tables
+            FORMAT Include confidence scores for all predictions
+            STYLE Be concise and precise in explanations
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add format instructions to the system message
+        const formatSection = `Output Format: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, formatSection, '\n\n');
     }
 }
+/**
+ * Singleton instance of the FORMAT commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new FormatCommitmentDefinition();
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
 
 /**
- * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
+ * Error thrown when a fetch request fails
  *
  * @public exported from `@promptbook/core`
  */
-class ParseError extends Error {
+class PromptbookFetchError extends Error {
     constructor(message) {
         super(message);
-        this.name = 'ParseError';
-        Object.setPrototypeOf(this, ParseError.prototype);
+        this.name = 'PromptbookFetchError';
+        Object.setPrototypeOf(this, PromptbookFetchError.prototype);
     }
 }
-/**
- * TODO: Maybe split `ParseError` and `ApplyError`
- */
 
 /**
  * Available remote servers for the Promptbook
@@ -480,6 +686,12 @@ function SET_IS_VERBOSE(isVerbose) {
  * @public exported from `@promptbook/core`
  */
 const DEFAULT_IS_AUTO_INSTALLED = false;
+/**
+ * Default simulated duration for a task in milliseconds (used for progress reporting)
+ *
+ * @public exported from `@promptbook/core`
+ */
+const DEFAULT_TASK_SIMULATED_DURATION_MS = 5 * 60 * 1000; // 5 minutes
 /**
  * Function name for generated function via `ptbk make` to get the pipeline collection
  *
@@ -516,7 +728,7 @@ true);
 function getErrorReportUrl(error) {
     const report = {
         title: `🐜 Error report from ${NAME}`,
-        body: spaceTrim((block) => `
+        body: spaceTrim$1((block) => `
 
 
             \`${error.name || 'Error'}\` has occurred in the [${NAME}], please look into it @${ADMIN_GITHUB_NAME}.
@@ -559,7 +771,7 @@ function getErrorReportUrl(error) {
  */
 class UnexpectedError extends Error {
     constructor(message) {
-        super(spaceTrim$1((block) => `
+        super(spaceTrim((block) => `
                     ${block(message)}
 
                     Note: This error should not happen.
@@ -585,7 +797,7 @@ class WrappedError extends Error {
     constructor(whatWasThrown) {
         const tag = `[🤮]`;
         console.error(tag, whatWasThrown);
-        super(spaceTrim$1(`
+        super(spaceTrim(`
                 Non-Error object was thrown
 
                 Note: Look for ${tag} in the console for more details
@@ -611,18 +823,1849 @@ function assertsError(whatWasThrown) {
         const wrappedError = whatWasThrown;
         throw wrappedError;
     }
-    // Case 2: Handle unexpected errors
-    if (whatWasThrown instanceof UnexpectedError) {
-        const unexpectedError = whatWasThrown;
-        throw unexpectedError;
+    // Case 2: Handle unexpected errors
+    if (whatWasThrown instanceof UnexpectedError) {
+        const unexpectedError = whatWasThrown;
+        throw unexpectedError;
+    }
+    // Case 3: Handle standard errors - keep them up to consumer
+    if (whatWasThrown instanceof Error) {
+        return;
+    }
+    // Case 4: Handle non-standard errors - wrap them into `WrappedError` and throw
+    throw new WrappedError(whatWasThrown);
+}
+
+/**
+ * The built-in `fetch' function with a lightweight error handling wrapper as default fetch function used in Promptbook scrapers
+ *
+ * @public exported from `@promptbook/core`
+ */
+const promptbookFetch = async (urlOrRequest, init) => {
+    try {
+        return await fetch(urlOrRequest, init);
+    }
+    catch (error) {
+        assertsError(error);
+        let url;
+        if (typeof urlOrRequest === 'string') {
+            url = urlOrRequest;
+        }
+        else if (urlOrRequest instanceof Request) {
+            url = urlOrRequest.url;
+        }
+        throw new PromptbookFetchError(spaceTrim$1((block) => `
+                    Can not fetch "${url}"
+
+                    Fetch error:
+                    ${block(error.message)}
+
+                `));
+    }
+};
+/**
+ * TODO: [🧠] Maybe rename because it is not used only for scrapers but also in `$getCompiledBook`
+ */
+
+/**
+ * Frontend RAG Service that uses backend APIs for processing
+ * This avoids Node.js dependencies in the frontend
+ *
+ * @private - TODO: [🧠] Maybe should be public?
+ */
+class FrontendRAGService {
+    constructor(config) {
+        this.chunks = [];
+        this.sources = [];
+        this.isInitialized = false;
+        this.config = {
+            maxChunkSize: 1000,
+            chunkOverlap: 200,
+            maxRetrievedChunks: 5,
+            minRelevanceScore: 0.1,
+            ...config,
+        };
+    }
+    /**
+     * Initialize knowledge sources by processing them on the backend
+     */
+    async initializeKnowledgeSources(sources) {
+        if (sources.length === 0) {
+            this.isInitialized = true;
+            return;
+        }
+        try {
+            const response = await promptbookFetch('/api/knowledge/process-sources', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    sources,
+                    config: {
+                        maxChunkSize: this.config.maxChunkSize,
+                        chunkOverlap: this.config.chunkOverlap,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to process knowledge sources: ${response.status}`);
+            }
+            const result = (await response.json());
+            if (!result.success) {
+                throw new Error(result.message || 'Failed to process knowledge sources');
+            }
+            this.chunks = result.chunks;
+            this.sources = sources;
+            this.isInitialized = true;
+            console.log(`Initialized RAG service with ${this.chunks.length} chunks from ${sources.length} sources`);
+        }
+        catch (error) {
+            console.error('Failed to initialize knowledge sources:', error);
+            // Don't throw - allow the system to continue without RAG
+            this.isInitialized = true;
+        }
+    }
+    /**
+     * Get relevant context for a user query
+     */
+    async getContextForQuery(query) {
+        if (!this.isInitialized) {
+            console.warn('RAG service not initialized');
+            return '';
+        }
+        if (this.chunks.length === 0) {
+            return '';
+        }
+        try {
+            const response = await promptbookFetch('/api/knowledge/retrieve-context', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    query,
+                    chunks: this.chunks,
+                    config: {
+                        maxRetrievedChunks: this.config.maxRetrievedChunks,
+                        minRelevanceScore: this.config.minRelevanceScore,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                console.error(`Failed to retrieve context: ${response.status}`);
+                return '';
+            }
+            const result = (await response.json());
+            if (!result.success) {
+                console.error('Context retrieval failed:', result.message);
+                return '';
+            }
+            return result.context;
+        }
+        catch (error) {
+            console.error('Error retrieving context:', error);
+            return '';
+        }
+    }
+    /**
+     * Get relevant chunks for a query (for debugging/inspection)
+     */
+    async getRelevantChunks(query) {
+        if (!this.isInitialized || this.chunks.length === 0) {
+            return [];
+        }
+        try {
+            const response = await promptbookFetch('/api/knowledge/retrieve-context', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    query,
+                    chunks: this.chunks,
+                    config: {
+                        maxRetrievedChunks: this.config.maxRetrievedChunks,
+                        minRelevanceScore: this.config.minRelevanceScore,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                return [];
+            }
+            const result = (await response.json());
+            return result.success ? result.relevantChunks : [];
+        }
+        catch (error) {
+            console.error('Error retrieving relevant chunks:', error);
+            return [];
+        }
+    }
+    /**
+     * Get knowledge base statistics
+     */
+    getStats() {
+        return {
+            sources: this.sources.length,
+            chunks: this.chunks.length,
+            isInitialized: this.isInitialized,
+        };
+    }
+    /**
+     * Check if the service is ready to use
+     */
+    isReady() {
+        return this.isInitialized;
+    }
+    /**
+     * Clear all knowledge sources
+     */
+    clearKnowledgeBase() {
+        this.chunks = [];
+        this.sources = [];
+        this.isInitialized = false;
+    }
+    /**
+     * Add a single knowledge source (for incremental updates)
+     */
+    async addKnowledgeSource(url) {
+        if (this.sources.includes(url)) {
+            console.log(`Knowledge source already exists: ${url}`);
+            return;
+        }
+        try {
+            const response = await promptbookFetch('/api/knowledge/process-sources', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    sources: [url],
+                    config: {
+                        maxChunkSize: this.config.maxChunkSize,
+                        chunkOverlap: this.config.chunkOverlap,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to process knowledge source: ${response.status}`);
+            }
+            const result = (await response.json());
+            if (!result.success) {
+                throw new Error(result.message || 'Failed to process knowledge source');
+            }
+            // Add new chunks to existing ones
+            this.chunks.push(...result.chunks);
+            this.sources.push(url);
+            console.log(`Added knowledge source: ${url} (${result.chunks.length} chunks)`);
+        }
+        catch (error) {
+            console.error(`Failed to add knowledge source ${url}:`, error);
+            throw error;
+        }
+    }
+}
+
+/**
+ * KNOWLEDGE commitment definition
+ *
+ * The KNOWLEDGE commitment adds specific knowledge, facts, or context to the agent
+ * using RAG (Retrieval-Augmented Generation) approach for external sources.
+ *
+ * Supports both direct text knowledge and external sources like PDFs.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * KNOWLEDGE The company was founded in 2020 and specializes in AI-powered solutions
+ * KNOWLEDGE https://example.com/company-handbook.pdf
+ * KNOWLEDGE https://example.com/product-documentation.pdf
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('KNOWLEDGE');
+        this.ragService = new FrontendRAGService();
+    }
+    /**
+     * Short one-line description of KNOWLEDGE.
+     */
+    get description() {
+        return 'Add domain **knowledge** via direct text or external sources (RAG).';
+    }
+    /**
+     * Markdown documentation for KNOWLEDGE commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # KNOWLEDGE
+
+            Adds specific knowledge, facts, or context to the agent using a RAG (Retrieval-Augmented Generation) approach for external sources.
+
+            ## Key behaviors
+
+            - Multiple \`KNOWLEDGE\` commitments are applied sequentially.
+            - Supports both direct text knowledge and external URLs.
+            - External sources (PDFs, websites) are processed via RAG for context retrieval.
+
+            ## Supported formats
+
+            - Direct text: Immediate knowledge incorporated into agent
+            - URLs: External documents processed for contextual retrieval
+            - Supported file types: PDF, text, markdown, HTML
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Bot
+
+            PERSONA You are a helpful customer support agent for TechCorp
+            KNOWLEDGE TechCorp was founded in 2020 and specializes in AI-powered solutions
+            KNOWLEDGE https://example.com/company-handbook.pdf
+            KNOWLEDGE https://example.com/product-documentation.pdf
+            RULE Always be polite and professional
+            \`\`\`
+
+            \`\`\`book
+            Research Assistant
+
+            PERSONA You are a knowledgeable research assistant
+            KNOWLEDGE Academic research requires careful citation and verification
+            KNOWLEDGE https://example.com/research-guidelines.pdf
+            ACTION Can help with literature reviews and data analysis
+            STYLE Present information in clear, academic format
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        var _a;
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Check if content is a URL (external knowledge source)
+        if (this.isUrl(trimmedContent)) {
+            // Store the URL for later async processing
+            const updatedRequirements = {
+                ...requirements,
+                metadata: {
+                    ...requirements.metadata,
+                    ragService: this.ragService,
+                    knowledgeSources: [
+                        ...(((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.knowledgeSources) || []),
+                        trimmedContent,
+                    ],
+                },
+            };
+            // Add placeholder information about knowledge sources to system message
+            const knowledgeInfo = `Knowledge Source URL: ${trimmedContent} (will be processed for retrieval during chat)`;
+            return this.appendToSystemMessage(updatedRequirements, knowledgeInfo, '\n\n');
+        }
+        else {
+            // Direct text knowledge - add to system message
+            const knowledgeSection = `Knowledge: ${trimmedContent}`;
+            return this.appendToSystemMessage(requirements, knowledgeSection, '\n\n');
+        }
+    }
+    /**
+     * Check if content is a URL
+     */
+    isUrl(content) {
+        try {
+            new URL(content);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Get RAG service instance for retrieving context during chat
+     */
+    getRagService() {
+        return this.ragService;
+    }
+}
+/**
+ * Singleton instance of the KNOWLEDGE commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new KnowledgeCommitmentDefinition();
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * META IMAGE commitment definition
+ *
+ * The META IMAGE commitment sets the agent's avatar/profile image URL.
+ * This commitment is special because it doesn't affect the system message,
+ * but is handled separately in the parsing logic.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * META IMAGE https://example.com/avatar.jpg
+ * META IMAGE /assets/agent-avatar.png
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class MetaImageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('META IMAGE');
+    }
+    /**
+     * Short one-line description of META IMAGE.
+     */
+    get description() {
+        return "Set the agent's profile image URL.";
+    }
+    /**
+     * Markdown documentation for META IMAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # META IMAGE
+
+            Sets the agent's avatar/profile image URL.
+
+            ## Key behaviors
+
+            - Does not modify the agent's behavior or responses.
+            - Only one \`META IMAGE\` should be used per agent.
+            - If multiple are specified, the last one takes precedence.
+            - Used for visual representation in user interfaces.
+
+            ## Examples
+
+            \`\`\`book
+            Professional Assistant
+
+            META IMAGE https://example.com/professional-avatar.jpg
+            PERSONA You are a professional business assistant
+            STYLE Maintain a formal and courteous tone
+            \`\`\`
+
+            \`\`\`book
+            Creative Helper
+
+            META IMAGE /assets/creative-bot-avatar.png
+            PERSONA You are a creative and inspiring assistant
+            STYLE Be enthusiastic and encouraging
+            ACTION Can help with brainstorming and ideation
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // META IMAGE doesn't modify the system message or model requirements
+        // It's handled separately in the parsing logic for profile image extraction
+        // This method exists for consistency with the CommitmentDefinition interface
+        return requirements;
+    }
+    /**
+     * Extracts the profile image URL from the content
+     * This is used by the parsing logic
+     */
+    extractProfileImageUrl(content) {
+        const trimmedContent = content.trim();
+        return trimmedContent || null;
+    }
+}
+/**
+ * Singleton instance of the META IMAGE commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new MetaImageCommitmentDefinition();
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * META LINK commitment definition
+ *
+ * The `META LINK` commitment represents the link to the person from whom the agent is created.
+ * This commitment is special because it doesn't affect the system message,
+ * but is handled separately in the parsing logic for profile display.
+ *
+ * Example usage in agent source:
+ *
+ * ```
+ * META LINK https://twitter.com/username
+ * META LINK https://linkedin.com/in/profile
+ * META LINK https://github.com/username
+ * ```
+ *
+ * Multiple `META LINK` commitments can be used when there are multiple sources:
+ *
+ * ```book
+ * META LINK https://twitter.com/username
+ * META LINK https://linkedin.com/in/profile
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class MetaLinkCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('META LINK');
+    }
+    /**
+     * Short one-line description of META LINK.
+     */
+    get description() {
+        return 'Provide profile/source links for the person the agent models.';
+    }
+    /**
+     * Markdown documentation for META LINK commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # META LINK
+
+            Represents a profile or source link for the person the agent is modeled after.
+
+            ## Key behaviors
+
+            - Does not modify the agent's behavior or responses.
+            - Multiple \`META LINK\` commitments can be used for different social profiles.
+            - Used for attribution and crediting the original person.
+            - Displayed in user interfaces for transparency.
+
+            ## Examples
+
+            \`\`\`book
+            Expert Consultant
+
+            META LINK https://twitter.com/expertname
+            META LINK https://linkedin.com/in/expertprofile
+            PERSONA You are Dr. Smith, a renowned expert in artificial intelligence
+            KNOWLEDGE Extensive background in machine learning and neural networks
+            \`\`\`
+
+            \`\`\`book
+            Open Source Developer
+
+            META LINK https://github.com/developer
+            META LINK https://twitter.com/devhandle
+            PERSONA You are an experienced open source developer
+            ACTION Can help with code reviews and architecture decisions
+            STYLE Be direct and technical in explanations
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // META LINK doesn't modify the system message or model requirements
+        // It's handled separately in the parsing logic for profile link extraction
+        // This method exists for consistency with the CommitmentDefinition interface
+        return requirements;
+    }
+    /**
+     * Extracts the profile link URL from the content
+     * This is used by the parsing logic
+     */
+    extractProfileLinkUrl(content) {
+        const trimmedContent = content.trim();
+        return trimmedContent || null;
+    }
+    /**
+     * Validates if the provided content is a valid URL
+     */
+    isValidUrl(content) {
+        try {
+            new URL(content.trim());
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+/**
+ * Singleton instance of the META LINK commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new MetaLinkCommitmentDefinition();
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * MODEL commitment definition
+ *
+ * The MODEL commitment specifies which AI model to use and can also set
+ * model-specific parameters like temperature, topP, and topK.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * MODEL gpt-4
+ * MODEL claude-3-opus temperature=0.3
+ * MODEL gpt-3.5-turbo temperature=0.8 topP=0.9
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class ModelCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('MODEL');
+    }
+    /**
+     * Short one-line description of MODEL.
+     */
+    get description() {
+        return 'Select the AI model and optional decoding parameters.';
+    }
+    /**
+     * Markdown documentation for MODEL commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # MODEL
+
+            Specifies which AI model to use and optional decoding parameters.
+
+            ## Key behaviors
+
+            - Only one \`MODEL\` commitment should be used per agent.
+            - If multiple are specified, the last one takes precedence.
+            - Parameters control the randomness and creativity of responses.
+
+            ## Supported parameters
+
+            - \`temperature\`: Controls randomness (0.0 = deterministic, 1.0+ = creative)
+            - \`topP\` (aka \`top_p\`): Nucleus sampling parameter
+            - \`topK\` (aka \`top_k\`): Top-k sampling parameter
+
+            ## Examples
+
+            \`\`\`book
+            Precise Assistant
+
+            PERSONA You are a precise and accurate assistant
+            MODEL gpt-4 temperature=0.1
+            RULE Always provide factual information
+            \`\`\`
+
+            \`\`\`book
+            Creative Writer
+
+            PERSONA You are a creative writing assistant
+            MODEL claude-3-opus temperature=0.8 topP=0.9
+            STYLE Be imaginative and expressive
+            ACTION Can help with storytelling and character development
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Parse the model specification
+        const parts = trimmedContent.split(/\s+/);
+        const modelName = parts[0];
+        if (!modelName) {
+            return requirements;
+        }
+        // Start with the model name
+        const updatedRequirements = {
+            ...requirements,
+            modelName,
+        };
+        // Parse additional parameters
+        const result = { ...updatedRequirements };
+        for (let i = 1; i < parts.length; i++) {
+            const param = parts[i];
+            if (param && param.includes('=')) {
+                const [key, value] = param.split('=');
+                if (key && value) {
+                    const numValue = parseFloat(value);
+                    if (!isNaN(numValue)) {
+                        switch (key.toLowerCase()) {
+                            case 'temperature':
+                                result.temperature = numValue;
+                                break;
+                            case 'topp':
+                            case 'top_p':
+                                result.topP = numValue;
+                                break;
+                            case 'topk':
+                            case 'top_k':
+                                result.topK = Math.round(numValue);
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Singleton instance of the MODEL commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new ModelCommitmentDefinition();
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * NOTE commitment definition
+ *
+ * The NOTE commitment is used to add comments to the agent source without making any changes
+ * to the system message or agent model requirements. It serves as a documentation mechanism
+ * for developers to add explanatory comments, reminders, or annotations directly in the agent source.
+ *
+ * Key features:
+ * - Makes no changes to the system message
+ * - Makes no changes to agent model requirements
+ * - Content is preserved in metadata.NOTE for debugging and inspection
+ * - Multiple NOTE commitments are aggregated together
+ * - Comments (# NOTE) are removed from the final system message
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * NOTE This agent was designed for customer support scenarios
+ * NOTE Remember to update the knowledge base monthly
+ * NOTE Performance optimized for quick response times
+ * ```
+ *
+ * The above notes will be stored in metadata but won't affect the agent's behavior.
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class NoteCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('NOTE');
+    }
+    /**
+     * Short one-line description of NOTE.
+     */
+    get description() {
+        return 'Add developer-facing notes without changing behavior or output.';
+    }
+    /**
+     * Markdown documentation for NOTE commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # NOTE
+
+            Adds comments for documentation without changing agent behavior.
+
+            ## Key behaviors
+
+            - Does not modify the agent's behavior or responses.
+            - Multiple \`NOTE\` commitments are aggregated for debugging.
+            - Useful for documenting design decisions and reminders.
+            - Content is preserved in metadata for inspection.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Bot
+
+            NOTE This agent was designed for customer support scenarios
+            NOTE Remember to update the knowledge base monthly
+            PERSONA You are a helpful customer support representative
+            KNOWLEDGE Company policies and procedures
+            RULE Always be polite and professional
+            \`\`\`
+
+            \`\`\`book
+            Research Assistant
+
+            NOTE Performance optimized for quick response times
+            NOTE Uses RAG for accessing latest research papers
+            PERSONA You are a knowledgeable research assistant
+            ACTION Can help with literature reviews and citations
+            STYLE Present information in academic format
+            \`\`\`
+        `);
+    }
+    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) {
+            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,
+            metadata: updatedMetadata,
+        };
+    }
+}
+/**
+ * Singleton instance of the NOTE commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new NoteCommitmentDefinition();
+/**
+ * [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * PERSONA commitment definition
+ *
+ * The PERSONA commitment modifies the agent's personality and character in the system message.
+ * It defines who the agent is, their background, expertise, and personality traits.
+ *
+ * Key features:
+ * - Multiple PERSONA commitments are automatically merged into one
+ * - Content is placed at the beginning of the system message
+ * - Original content with comments is preserved in metadata.PERSONA
+ * - Comments (# PERSONA) are removed from the final system message
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * PERSONA You are a helpful programming assistant with expertise in TypeScript and React
+ * PERSONA You have deep knowledge of modern web development practices
+ * ```
+ *
+ * The above will be merged into a single persona section at the beginning of the system message.
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class PersonaCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('PERSONA');
+    }
+    /**
+     * Short one-line description of PERSONA.
+     */
+    get description() {
+        return 'Define who the agent is: background, expertise, and personality.';
+    }
+    /**
+     * Markdown documentation for PERSONA commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # PERSONA
+
+            Defines who the agent is, their background, expertise, and personality traits.
+
+            ## Key behaviors
+
+            - Multiple \`PERSONA\` commitments are merged together.
+            - If they are in conflict, the last one takes precedence.
+            - You can write persona content in multiple lines.
+
+            ## Examples
+
+            \`\`\`book
+            Programming Assistant
+
+            PERSONA You are a helpful programming assistant with expertise in TypeScript and React
+            PERSONA You have deep knowledge of modern web development practices
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        var _a, _b;
+        // The PERSONA commitment aggregates all persona content and places it at the beginning
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Get existing persona content from metadata
+        const existingPersonaContent = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.PERSONA) || '';
+        // Merge the new content with existing persona content
+        // When multiple PERSONA commitments exist, they are merged into one
+        const mergedPersonaContent = existingPersonaContent
+            ? `${existingPersonaContent}\n${trimmedContent}`
+            : trimmedContent;
+        // Store the merged persona content in metadata for debugging and inspection
+        const updatedMetadata = {
+            ...requirements.metadata,
+            PERSONA: mergedPersonaContent,
+        };
+        // Get the agent name from metadata (which should contain the first line of agent source)
+        // If not available, extract from current system message as fallback
+        let agentName = (_b = requirements.metadata) === null || _b === void 0 ? void 0 : _b.agentName;
+        if (!agentName) {
+            // Fallback: extract from current system message
+            const currentMessage = requirements.systemMessage.trim();
+            const basicFormatMatch = currentMessage.match(/^You are (.+)$/);
+            if (basicFormatMatch && basicFormatMatch[1]) {
+                agentName = basicFormatMatch[1];
+            }
+            else {
+                agentName = 'AI Agent'; // Final fallback
+            }
+        }
+        // Remove any existing persona content from the system message
+        // (this handles the case where we're processing multiple PERSONA commitments)
+        const currentMessage = requirements.systemMessage.trim();
+        let cleanedMessage = currentMessage;
+        // Check if current message starts with persona content or is just the basic format
+        const basicFormatRegex = /^You are .+$/;
+        const isBasicFormat = basicFormatRegex.test(currentMessage) && !currentMessage.includes('\n');
+        if (isBasicFormat) {
+            // Replace the basic format entirely
+            cleanedMessage = '';
+        }
+        else if (currentMessage.startsWith('# PERSONA')) {
+            // Remove existing persona section by finding where it ends
+            const lines = currentMessage.split('\n');
+            let personaEndIndex = lines.length;
+            // Find the end of the PERSONA section (next comment or end of message)
+            for (let i = 1; i < lines.length; i++) {
+                const line = lines[i].trim();
+                if (line.startsWith('#') && !line.startsWith('# PERSONA')) {
+                    personaEndIndex = i;
+                    break;
+                }
+            }
+            // Keep everything after the PERSONA section
+            cleanedMessage = lines.slice(personaEndIndex).join('\n').trim();
+        }
+        // Create new system message with persona at the beginning
+        // Format: "You are {agentName}\n{personaContent}"
+        // The # PERSONA comment will be removed later by removeCommentsFromSystemMessage
+        const personaSection = `# PERSONA\nYou are ${agentName}\n${mergedPersonaContent}`; // <- TODO: Use spaceTrim
+        const newSystemMessage = cleanedMessage ? `${personaSection}\n\n${cleanedMessage}` : personaSection;
+        return {
+            ...requirements,
+            systemMessage: newSystemMessage,
+            metadata: updatedMetadata,
+        };
+    }
+}
+/**
+ * Singleton instance of the PERSONA commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new PersonaCommitmentDefinition();
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * RULE commitment definition
+ *
+ * The RULE/RULES commitment adds behavioral constraints and guidelines that the agent must follow.
+ * These are specific instructions about what the agent should or shouldn't do.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * RULE Always ask for clarification if the user's request is ambiguous
+ * RULES Never provide medical advice, always refer to healthcare professionals
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class RuleCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'RULE') {
+        super(type);
+    }
+    /**
+     * Short one-line description of RULE/RULES.
+     */
+    get description() {
+        return 'Add behavioral rules the agent must follow.';
+    }
+    /**
+     * Markdown documentation for RULE/RULES commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # ${this.type}
+
+            Adds behavioral constraints and guidelines that the agent must follow.
+
+            ## Key behaviors
+
+            - Multiple \`RULE\` and \`RULES\` commitments are applied sequentially.
+            - All rules are treated equally regardless of singular/plural form.
+            - Rules define what the agent must or must not do.
+
+            ## Examples
+
+            \`\`\`book
+            Customer Support Agent
+
+            PERSONA You are a helpful customer support representative
+            RULE Always ask for clarification if the user's request is ambiguous
+            RULE Be polite and professional in all interactions
+            RULES Never provide medical or legal advice
+            STYLE Maintain a friendly and helpful tone
+            \`\`\`
+
+            \`\`\`book
+            Educational Tutor
+
+            PERSONA You are a patient and knowledgeable tutor
+            RULE Break down complex concepts into simple steps
+            RULE Always encourage students and celebrate their progress
+            RULE If you don't know something, admit it and suggest resources
+            SAMPLE When explaining math: "Let's work through this step by step..."
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add rule to the system message
+        const ruleSection = `Rule: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, ruleSection, '\n\n');
+    }
+}
+/**
+ * Singleton instances of the RULE commitment definitions
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new RuleCommitmentDefinition('RULE');
+/**
+ * Singleton instances of the RULE commitment definitions
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new RuleCommitmentDefinition('RULES');
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * SAMPLE commitment definition
+ *
+ * The SAMPLE/EXAMPLE commitment provides examples of how the agent should respond
+ * or behave in certain situations. These examples help guide the agent's responses.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * SAMPLE When asked about pricing, respond: "Our basic plan starts at $10/month..."
+ * EXAMPLE For code questions, always include working code snippets
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class SampleCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type = 'SAMPLE') {
+        super(type);
+    }
+    /**
+     * Short one-line description of SAMPLE/EXAMPLE.
+     */
+    get description() {
+        return 'Provide example responses to guide behavior.';
+    }
+    /**
+     * Markdown documentation for SAMPLE/EXAMPLE commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # ${this.type}
+
+            Provides examples of how the agent should respond or behave in certain situations.
+
+            ## Key behaviors
+
+            - Multiple \`SAMPLE\` and \`EXAMPLE\` commitments are applied sequentially.
+            - Both terms work identically and can be used interchangeably.
+            - Examples help guide the agent's response patterns and style.
+
+            ## Examples
+
+            \`\`\`book
+            Sales Assistant
+
+            PERSONA You are a knowledgeable sales representative
+            SAMPLE When asked about pricing, respond: "Our basic plan starts at $10/month..."
+            SAMPLE For feature comparisons, create a clear comparison table
+            RULE Always be honest about limitations
+            \`\`\`
+
+            \`\`\`book
+            Code Reviewer
+
+            PERSONA You are an experienced software engineer
+            EXAMPLE For code questions, always include working code snippets
+            EXAMPLE When suggesting improvements: "Here's a more efficient approach..."
+            RULE Explain the reasoning behind your suggestions
+            STYLE Be constructive and encouraging in feedback
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add example to the system message
+        const exampleSection = `Example: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, exampleSection, '\n\n');
+    }
+}
+/**
+ * Singleton instances of the SAMPLE commitment definitions
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new SampleCommitmentDefinition('SAMPLE');
+/**
+ * Singleton instances of the SAMPLE commitment definitions
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new SampleCommitmentDefinition('EXAMPLE');
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * STYLE commitment definition
+ *
+ * The STYLE commitment defines how the agent should format and present its responses.
+ * This includes tone, writing style, formatting preferences, and communication patterns.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * STYLE Write in a professional but friendly tone, use bullet points for lists
+ * STYLE Always provide code examples when explaining programming concepts
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class StyleCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('STYLE');
+    }
+    /**
+     * Short one-line description of STYLE.
+     */
+    get description() {
+        return 'Control the tone and writing style of responses.';
+    }
+    /**
+     * Markdown documentation for STYLE commitment.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # STYLE
+
+            Defines how the agent should format and present its responses (tone, writing style, formatting).
+
+            ## Key behaviors
+
+            - Multiple \`STYLE\` commitments are applied sequentially.
+            - Later style instructions can override earlier ones.
+            - Style affects both tone and presentation format.
+
+            ## Examples
+
+            \`\`\`book
+            Technical Writer
+
+            PERSONA You are a technical documentation expert
+            STYLE Write in a professional but friendly tone, use bullet points for lists
+            STYLE Always provide code examples when explaining programming concepts
+            FORMAT Use markdown formatting with clear headings
+            \`\`\`
+
+            \`\`\`book
+            Creative Assistant
+
+            PERSONA You are a creative writing helper
+            STYLE Be enthusiastic and encouraging in your responses
+            STYLE Use vivid metaphors and analogies to explain concepts
+            STYLE Keep responses conversational and engaging
+            RULE Always maintain a positive and supportive tone
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add style instructions to the system message
+        const styleSection = `Style: ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, styleSection, '\n\n');
+    }
+}
+/**
+ * Singleton instance of the STYLE commitment definition
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+new StyleCommitmentDefinition();
+/**
+ * [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Placeholder commitment definition for commitments that are not yet implemented
+ *
+ * This commitment simply adds its content 1:1 into the system message,
+ * preserving the original behavior until proper implementation is added.
+ *
+ * @public exported from `@promptbook/core`
+ */
+class NotYetImplementedCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor(type) {
+        super(type);
+    }
+    /**
+     * Short one-line description of a placeholder commitment.
+     */
+    get description() {
+        return 'Placeholder commitment that appends content verbatim to the system message.';
+    }
+    /**
+     * Markdown documentation available at runtime.
+     */
+    get documentation() {
+        return spaceTrim(`
+            # ${this.type}
+
+            This commitment is not yet fully implemented.
+
+            ## Key behaviors
+
+            - Content is appended directly to the system message.
+            - No special processing or validation is performed.
+            - Behavior preserved until proper implementation is added.
+
+            ## Status
+
+            - **Status:** Placeholder implementation
+            - **Effect:** Appends content prefixed by commitment type
+            - **Future:** Will be replaced with specialized logic
+
+            ## Examples
+
+            \`\`\`book
+            Example Agent
+
+            PERSONA You are a helpful assistant
+            ${this.type} Your content here
+            RULE Always be helpful
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return requirements;
+        }
+        // Add the commitment content 1:1 to the system message
+        const commitmentLine = `${this.type} ${trimmedContent}`;
+        return this.appendToSystemMessage(requirements, commitmentLine, '\n\n');
+    }
+}
+
+// Import all commitment definition classes
+/**
+ * Registry of all available commitment definitions
+ * This array contains instances of all commitment definitions
+ * This is the single source of truth for all commitments in the system
+ *
+ * @private Use functions to access commitments instead of this array directly
+ */
+const COMMITMENT_REGISTRY = [
+    // Fully implemented commitments
+    new PersonaCommitmentDefinition(),
+    new KnowledgeCommitmentDefinition(),
+    new StyleCommitmentDefinition(),
+    new RuleCommitmentDefinition('RULE'),
+    new RuleCommitmentDefinition('RULES'),
+    new SampleCommitmentDefinition('SAMPLE'),
+    new SampleCommitmentDefinition('EXAMPLE'),
+    new FormatCommitmentDefinition(),
+    new ModelCommitmentDefinition(),
+    new ActionCommitmentDefinition(),
+    new MetaImageCommitmentDefinition(),
+    new MetaLinkCommitmentDefinition(),
+    new NoteCommitmentDefinition(),
+    // Not yet implemented commitments (using placeholder)
+    new NotYetImplementedCommitmentDefinition('EXPECT'),
+    new NotYetImplementedCommitmentDefinition('SCENARIO'),
+    new NotYetImplementedCommitmentDefinition('SCENARIOS'),
+    new NotYetImplementedCommitmentDefinition('BEHAVIOUR'),
+    new NotYetImplementedCommitmentDefinition('BEHAVIOURS'),
+    new NotYetImplementedCommitmentDefinition('AVOID'),
+    new NotYetImplementedCommitmentDefinition('AVOIDANCE'),
+    new NotYetImplementedCommitmentDefinition('GOAL'),
+    new NotYetImplementedCommitmentDefinition('GOALS'),
+    new NotYetImplementedCommitmentDefinition('CONTEXT'),
+];
+/**
+ * Gets a commitment definition by its type
+ * @param type The commitment type to look up
+ * @returns The commitment definition or null if not found
+ *
+ * @public exported from `@promptbook/core`
+ */
+function getCommitmentDefinition(type) {
+    return COMMITMENT_REGISTRY.find((commitmentDefinition) => commitmentDefinition.type === type) || null;
+}
+/**
+ * Gets all available commitment definitions
+ * @returns Array of all commitment definitions
+ *
+ * @public exported from `@promptbook/core`
+ */
+function getAllCommitmentDefinitions() {
+    return $deepFreeze([...COMMITMENT_REGISTRY]);
+}
+/**
+ * Gets all available commitment types
+ * @returns Array of all commitment types
+ *
+ * @public exported from `@promptbook/core`
+ */
+function getAllCommitmentTypes() {
+    return $deepFreeze(COMMITMENT_REGISTRY.map((commitmentDefinition) => commitmentDefinition.type));
+}
+/**
+ * Checks if a commitment type is supported
+ * @param type The commitment type to check
+ * @returns True if the commitment type is supported
+ *
+ * @public exported from `@promptbook/core`
+ */
+function isCommitmentSupported(type) {
+    return COMMITMENT_REGISTRY.some((commitmentDefinition) => commitmentDefinition.type === type);
+}
+/**
+ * TODO: !!!! Maybe create through standardized $register
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */
+
+/**
+ * Parses agent source using the new commitment system with multiline support
+ * This function replaces the hardcoded commitment parsing in the original parseAgentSource
+ *
+ * @private
+ */
+function parseAgentSourceWithCommitments(agentSource) {
+    var _a, _b, _c;
+    if (!agentSource || !agentSource.trim()) {
+        return {
+            agentName: null,
+            commitments: [],
+            nonCommitmentLines: [],
+        };
+    }
+    const lines = agentSource.split('\n');
+    const agentName = (((_a = lines[0]) === null || _a === void 0 ? void 0 : _a.trim()) || null);
+    const commitments = [];
+    const nonCommitmentLines = [];
+    // Always add the first line (agent name) to non-commitment lines
+    if (lines[0] !== undefined) {
+        nonCommitmentLines.push(lines[0]);
+    }
+    // Parse commitments with multiline support
+    let currentCommitment = null;
+    // Process lines starting from the second line (skip agent name)
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined) {
+            continue;
+        }
+        // Check if this line starts a new commitment
+        let foundNewCommitment = false;
+        for (const definition of COMMITMENT_REGISTRY) {
+            const typeRegex = definition.createTypeRegex();
+            const match = typeRegex.exec(line.trim());
+            if (match && ((_b = match.groups) === null || _b === void 0 ? void 0 : _b.type)) {
+                // Save the previous commitment if it exists
+                if (currentCommitment) {
+                    const fullContent = currentCommitment.contentLines.join('\n');
+                    commitments.push({
+                        type: currentCommitment.type,
+                        content: spaceTrim(fullContent),
+                        originalLine: currentCommitment.originalStartLine,
+                        lineNumber: currentCommitment.startLineNumber,
+                    });
+                }
+                // Extract the initial content from the commitment line
+                const fullRegex = definition.createRegex();
+                const fullMatch = fullRegex.exec(line.trim());
+                const initialContent = ((_c = fullMatch === null || fullMatch === void 0 ? void 0 : fullMatch.groups) === null || _c === void 0 ? void 0 : _c.contents) || '';
+                // Start a new commitment
+                currentCommitment = {
+                    type: definition.type,
+                    startLineNumber: i + 1,
+                    originalStartLine: line,
+                    contentLines: initialContent ? [initialContent] : [],
+                };
+                foundNewCommitment = true;
+                break;
+            }
+        }
+        if (!foundNewCommitment) {
+            if (currentCommitment) {
+                // This line belongs to the current commitment
+                currentCommitment.contentLines.push(line);
+            }
+            else {
+                // This line is not part of any commitment
+                nonCommitmentLines.push(line);
+            }
+        }
+    }
+    // Don't forget to save the last commitment if it exists
+    if (currentCommitment) {
+        const fullContent = currentCommitment.contentLines.join('\n');
+        commitments.push({
+            type: currentCommitment.type,
+            content: spaceTrim(fullContent),
+            originalLine: currentCommitment.originalStartLine,
+            lineNumber: currentCommitment.startLineNumber,
+        });
+    }
+    return {
+        agentName,
+        commitments,
+        nonCommitmentLines,
+    };
+}
+/**
+ * Extracts basic information from agent source using the new commitment system
+ * This maintains compatibility with the original parseAgentSource interface
+ *
+ * @private
+ */
+function parseAgentSourceBasicInfo(agentSource) {
+    const parseResult = parseAgentSourceWithCommitments(agentSource);
+    // Find PERSONA and META IMAGE commitments
+    let personaDescription = null;
+    let profileImageUrl;
+    for (const commitment of parseResult.commitments) {
+        if (commitment.type === 'PERSONA' && !personaDescription) {
+            personaDescription = commitment.content;
+        }
+        else if (commitment.type === 'META IMAGE' && !profileImageUrl) {
+            profileImageUrl = commitment.content;
+        }
+    }
+    // Generate gravatar fallback if no profile image specified
+    if (!profileImageUrl) {
+        profileImageUrl = generateGravatarUrl(parseResult.agentName);
+    }
+    return {
+        agentName: parseResult.agentName,
+        personaDescription,
+        profileImageUrl,
+    };
+}
+
+/**
+ * Parses agent source string into its components
+ */
+// Cache for parsed agent sources to prevent repeated parsing
+const parsedAgentSourceCache = new Map();
+/**
+ * Parses basic information from agent source
+ *
+ * There are 2 similar functions:
+ * - `parseAgentSource` which is a lightweight parser for agent source, it parses basic information and its purpose is to be quick and synchronous. The commitments there are hardcoded.
+ * - `createAgentModelRequirements` which is an asynchronous function that creates model requirements it applies each commitment one by one and works asynchronously.
+ *
+ * @public exported from `@promptbook/core`
+ */
+function parseAgentSource(agentSource) {
+    // Check if we already parsed this agent source
+    if (parsedAgentSourceCache.has(agentSource)) {
+        return parsedAgentSourceCache.get(agentSource);
+    }
+    // Use the new commitment-based parsing system
+    const result = parseAgentSourceBasicInfo(agentSource);
+    // Cache the result
+    parsedAgentSourceCache.set(agentSource, result);
+    return result;
+}
+
+/**
+ * Type guard to check if a string is a valid agent source
+ *
+ * @public exported from `@promptbook/core`
+ */
+function isValidBook(value) {
+    // Basic validation - agent source should have at least a name (first line)
+    return typeof value === 'string' /* && value.trim().length > 0 */;
+}
+/**
+ * Validates and converts a string to agent source branded type
+ * This function should be used when you have a string that you know represents agent source
+ * but need to convert it to the branded type for type safety
+ *
+ * @public exported from `@promptbook/core`
+ */
+function validateBook(source) {
+    if (!isValidBook(source)) {
+        throw new Error('Invalid agent source: must be a string');
+    }
+    return source;
+}
+/**
+ * Default book
+ *
+ * @public exported from `@promptbook/core`
+ */
+const DEFAULT_BOOK = validateBook(spaceTrim$1(`
+        AI Avatar
+
+        PERSONA A friendly AI assistant that helps you with your tasks
+    `));
+
+/**
+ * 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: '!!!!DEFAULT_MODEL_ID',
+        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 model requirements
+ */
+
+/**
+ * Removes comment lines (lines starting with #) from a system message
+ * This is used to clean up the final system message before sending it to the AI model
+ * while preserving the original content with comments in metadata
+ *
+ * @param systemMessage The system message that may contain comment lines
+ * @returns The system message with comment lines removed
+ *
+ * @private - TODO: [🧠] Maybe should be public?
+ */
+function removeCommentsFromSystemMessage(systemMessage) {
+    if (!systemMessage) {
+        return systemMessage;
+    }
+    const lines = systemMessage.split('\n');
+    const filteredLines = lines.filter((line) => {
+        const trimmedLine = line.trim();
+        // Remove lines that start with # (comments)
+        return !trimmedLine.startsWith('#');
+    });
+    return filteredLines.join('\n').trim();
+}
+
+/**
+ * Creates agent model requirements using the new commitment system
+ * This function uses a reduce-like pattern where each commitment applies its changes
+ * to build the final requirements starting from a basic empty model
+ *
+ * @private
+ */
+async function createAgentModelRequirementsWithCommitments(agentSource, modelName) {
+    // Parse the agent source to extract commitments
+    const parseResult = parseAgentSourceWithCommitments(agentSource);
+    // Start with basic agent model requirements
+    let requirements = createBasicAgentModelRequirements(parseResult.agentName);
+    // Store the agent name in metadata so commitments can access it
+    requirements = {
+        ...requirements,
+        metadata: {
+            ...requirements.metadata,
+            agentName: parseResult.agentName,
+        },
+    };
+    // Override model name if provided
+    if (modelName) {
+        requirements = {
+            ...requirements,
+            modelName,
+        };
+    }
+    // Apply each commitment in order using reduce-like pattern
+    for (const commitment of parseResult.commitments) {
+        const definition = getCommitmentDefinition(commitment.type);
+        if (definition) {
+            try {
+                requirements = definition.applyToAgentModelRequirements(requirements, commitment.content);
+            }
+            catch (error) {
+                console.warn(`Failed to apply commitment ${commitment.type}:`, error);
+                // Continue with other commitments even if one fails
+            }
+        }
+    }
+    // Handle MCP servers (extract from original agent source)
+    const mcpServers = extractMcpServers(agentSource);
+    if (mcpServers.length > 0) {
+        requirements = {
+            ...requirements,
+            mcpServers,
+        };
+    }
+    // Add non-commitment lines to system message if they exist
+    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
+        .join('\n')
+        .trim();
+    if (nonCommitmentContent) {
+        requirements = {
+            ...requirements,
+            systemMessage: requirements.systemMessage + '\n\n' + nonCommitmentContent,
+        };
+    }
+    // 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);
+    return {
+        ...requirements,
+        systemMessage: cleanedSystemMessage,
+    };
+}
+/**
+ * Cache for expensive createAgentModelRequirementsWithCommitments calls
+ * @private
+ */
+const modelRequirementsCache = new Map();
+/**
+ * @private - TODO: Maybe should be public
+ */
+const CACHE_SIZE_LIMIT = 100;
+/**
+ * Cached version of createAgentModelRequirementsWithCommitments
+ * This maintains the same caching behavior as the original function
+ *
+ * @private
+ */
+async function createAgentModelRequirementsWithCommitmentsCached(agentSource, modelName) {
+    // Create cache key
+    const cacheKey = `${agentSource}|${modelName || 'default'}`;
+    // Check cache first
+    if (modelRequirementsCache.has(cacheKey)) {
+        return modelRequirementsCache.get(cacheKey);
+    }
+    // Limit cache size to prevent memory leaks
+    if (modelRequirementsCache.size >= CACHE_SIZE_LIMIT) {
+        const firstKey = modelRequirementsCache.keys().next().value;
+        if (firstKey) {
+            modelRequirementsCache.delete(firstKey);
+        }
+    }
+    // Create requirements
+    const requirements = await createAgentModelRequirementsWithCommitments(agentSource, modelName);
+    // Cache the result
+    modelRequirementsCache.set(cacheKey, requirements);
+    return requirements;
+}
+
+// TODO: Remove or use:
+//const CACHE_SIZE_LIMIT = 100; // Prevent memory leaks by limiting cache size
+/**
+ * Creates model requirements for an agent based on its source
+ * Results are cached to improve performance for repeated calls with the same agentSource and modelName
+ *
+ * There are 2 similar functions:
+ * - `parseAgentSource` which is a lightweight parser for agent source, it parses basic information and its purpose is to be quick and synchronous. The commitments there are hardcoded.
+ * - `createAgentModelRequirements` which is an asynchronous function that creates model requirements it applies each commitment one by one and works asynchronously.
+ *
+ * @public exported from `@promptbook/core`
+ */
+async function createAgentModelRequirements(agentSource, modelName = '!!!!DEFAULT_MODEL_ID') {
+    // Use the new commitment-based system
+    return createAgentModelRequirementsWithCommitmentsCached(agentSource, modelName);
+}
+/**
+ * Extracts MCP servers from agent source
+ *
+ * @param agentSource The agent source string that may contain MCP lines
+ * @returns Array of MCP server identifiers
+ *
+ * @private TODO: [🧠] Maybe should be public
+ */
+function extractMcpServers(agentSource) {
+    if (!agentSource) {
+        return [];
+    }
+    const lines = agentSource.split('\n');
+    const mcpRegex = /^\s*MCP\s+(.+)$/i;
+    const mcpServers = [];
+    // Look for MCP lines
+    for (const line of lines) {
+        const match = line.match(mcpRegex);
+        if (match && match[1]) {
+            mcpServers.push(match[1].trim());
+        }
+    }
+    return mcpServers;
+}
+
+/**
+ * Converts PipelineCollection to serialized JSON
+ *
+ * Note: Functions `collectionToJson` and `createCollectionFromJson` are complementary
+ *
+ * @public exported from `@promptbook/core`
+ */
+async function collectionToJson(collection) {
+    const pipelineUrls = await collection.listPipelines();
+    const promptbooks = await Promise.all(pipelineUrls.map((url) => collection.getPipelineByUrl(url)));
+    return promptbooks;
+}
+/**
+ * TODO: [🧠] Maybe clear `sourceFile` or clear when exposing through API or remote server
+ */
+
+/**
+ * Checks if value is valid email
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function isValidEmail(email) {
+    if (typeof email !== 'string') {
+        return false;
+    }
+    if (email.split('\n').length > 1) {
+        return false;
+    }
+    return /^.+@.+\..+$/.test(email);
+}
+
+/**
+ * Tests if given string is valid URL.
+ *
+ * Note: This does not check if the file exists only if the path is valid
+ * @public exported from `@promptbook/utils`
+ */
+function isValidFilePath(filename) {
+    if (typeof filename !== 'string') {
+        return false;
+    }
+    if (filename.split('\n').length > 1) {
+        return false;
+    }
+    if (filename.split(' ').length >
+        5 /* <- TODO: [🧠][🈷] Make some better non-arbitrary way how to distinct filenames from informational texts */) {
+        return false;
+    }
+    const filenameSlashes = filename.split('\\').join('/');
+    // Absolute Unix path: /hello.txt
+    if (/^(\/)/i.test(filenameSlashes)) {
+        // console.log(filename, 'Absolute Unix path: /hello.txt');
+        return true;
+    }
+    // Absolute Windows path: /hello.txt
+    if (/^([A-Z]{1,2}:\/?)\//i.test(filenameSlashes)) {
+        // console.log(filename, 'Absolute Windows path: /hello.txt');
+        return true;
+    }
+    // Relative path: ./hello.txt
+    if (/^(\.\.?\/)+/i.test(filenameSlashes)) {
+        // console.log(filename, 'Relative path: ./hello.txt');
+        return true;
+    }
+    // Allow paths like foo/hello
+    if (/^[^/]+\/[^/]+/i.test(filenameSlashes)) {
+        // console.log(filename, 'Allow paths like foo/hello');
+        return true;
+    }
+    // Allow paths like hello.book
+    if (/^[^/]+\.[^/]+$/i.test(filenameSlashes)) {
+        // console.log(filename, 'Allow paths like hello.book');
+        return true;
+    }
+    return false;
+}
+/**
+ * TODO: [🍏] Implement for MacOs
+ */
+
+/**
+ * Tests if given string is valid URL.
+ *
+ * Note: Dataurl are considered perfectly valid.
+ * Note: There are two similar functions:
+ * - `isValidUrl` which tests any URL
+ * - `isValidPipelineUrl` *(this one)* which tests just promptbook URL
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function isValidUrl(url) {
+    if (typeof url !== 'string') {
+        return false;
+    }
+    try {
+        if (url.startsWith('blob:')) {
+            url = url.replace(/^blob:/, '');
+        }
+        const urlObject = new URL(url /* because fail is handled */);
+        if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
     }
-    // Case 3: Handle standard errors - keep them up to consumer
-    if (whatWasThrown instanceof Error) {
-        return;
+}
+
+/**
+ * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
+ *
+ * @public exported from `@promptbook/core`
+ */
+class ParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ParseError';
+        Object.setPrototypeOf(this, ParseError.prototype);
     }
-    // Case 4: Handle non-standard errors - wrap them into `WrappedError` and throw
-    throw new WrappedError(whatWasThrown);
 }
+/**
+ * TODO: Maybe split `ParseError` and `ApplyError`
+ */
 
 /**
  * Function isValidJsonString will tell you if the string is valid JSON or not
@@ -829,7 +2872,7 @@ function pipelineJsonToString(pipelineJson) {
         pipelineString += '\n\n';
         pipelineString += '```' + contentLanguage;
         pipelineString += '\n';
-        pipelineString += spaceTrim(content);
+        pipelineString += spaceTrim$1(content);
         //                   <- TODO: [main] !!3 Escape
         //                   <- TODO: [🧠] Some clear strategy how to spaceTrim the blocks
         pipelineString += '\n';
@@ -873,33 +2916,6 @@ function orderJson(options) {
     return orderedValue;
 }
 
-/**
- * Freezes the given object and all its nested objects recursively
- *
- * Note: `$` is used to indicate that this function is not a pure function - it mutates given object
- * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
- *
- * @returns The same object as the input, but deeply frozen
- * @public exported from `@promptbook/utils`
- */
-function $deepFreeze(objectValue) {
-    if (Array.isArray(objectValue)) {
-        return Object.freeze(objectValue.map((item) => $deepFreeze(item)));
-    }
-    const propertyNames = Object.getOwnPropertyNames(objectValue);
-    for (const propertyName of propertyNames) {
-        const value = objectValue[propertyName];
-        if (value && typeof value === 'object') {
-            $deepFreeze(value);
-        }
-    }
-    Object.freeze(objectValue);
-    return objectValue;
-}
-/**
- * TODO: [🧠] Is there a way how to meaningfully test this utility
- */
-
 /**
  * Checks if the value is [🚉] serializable as JSON
  * If not, throws an UnexpectedError with a rich error message and tracking
@@ -950,7 +2966,7 @@ function checkSerializableAsJson(options) {
     }
     else if (typeof value === 'object') {
         if (value instanceof Date) {
-            throw new UnexpectedError(spaceTrim((block) => `
+            throw new UnexpectedError(spaceTrim$1((block) => `
                         \`${name}\` is Date
 
                         Use \`string_date_iso8601\` instead
@@ -969,7 +2985,7 @@ function checkSerializableAsJson(options) {
             throw new UnexpectedError(`${name} is RegExp`);
         }
         else if (value instanceof Error) {
-            throw new UnexpectedError(spaceTrim((block) => `
+            throw new UnexpectedError(spaceTrim$1((block) => `
                         \`${name}\` is unserialized Error
 
                         Use function \`serializeError\`
@@ -992,7 +3008,7 @@ function checkSerializableAsJson(options) {
             }
             catch (error) {
                 assertsError(error);
-                throw new UnexpectedError(spaceTrim((block) => `
+                throw new UnexpectedError(spaceTrim$1((block) => `
                             \`${name}\` is not serializable
 
                             ${block(error.stack || error.message)}
@@ -1024,7 +3040,7 @@ function checkSerializableAsJson(options) {
         }
     }
     else {
-        throw new UnexpectedError(spaceTrim((block) => `
+        throw new UnexpectedError(spaceTrim$1((block) => `
                     \`${name}\` is unknown type
 
                     Additional message for \`${name}\`:
@@ -1311,7 +3327,7 @@ function validatePipeline(pipeline) {
             if (!(error instanceof PipelineLogicError)) {
                 throw error;
             }
-            console.error(spaceTrim$1((block) => `
+            console.error(spaceTrim((block) => `
                         Pipeline is not valid but logic errors are temporarily disabled via \`IS_PIPELINE_LOGIC_VALIDATED\`
 
                         ${block(error.message)}
@@ -1338,7 +3354,7 @@ function validatePipeline_InnerFunction(pipeline) {
     })();
     if (pipeline.pipelineUrl !== undefined && !isValidPipelineUrl(pipeline.pipelineUrl)) {
         // <- Note: [🚲]
-        throw new PipelineLogicError(spaceTrim$1((block) => `
+        throw new PipelineLogicError(spaceTrim((block) => `
                     Invalid promptbook URL "${pipeline.pipelineUrl}"
 
                     ${block(pipelineIdentification)}
@@ -1346,7 +3362,7 @@ function validatePipeline_InnerFunction(pipeline) {
     }
     if (pipeline.bookVersion !== undefined && !isValidPromptbookVersion(pipeline.bookVersion)) {
         // <- Note: [🚲]
-        throw new PipelineLogicError(spaceTrim$1((block) => `
+        throw new PipelineLogicError(spaceTrim((block) => `
                     Invalid Promptbook Version "${pipeline.bookVersion}"
 
                     ${block(pipelineIdentification)}
@@ -1355,7 +3371,7 @@ function validatePipeline_InnerFunction(pipeline) {
     // TODO: [🧠] Maybe do here some proper JSON-schema / ZOD checking
     if (!Array.isArray(pipeline.parameters)) {
         // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
-        throw new ParseError(spaceTrim$1((block) => `
+        throw new ParseError(spaceTrim((block) => `
                     Pipeline is valid JSON but with wrong structure
 
                     \`PipelineJson.parameters\` expected to be an array, but got ${typeof pipeline.parameters}
@@ -1366,7 +3382,7 @@ function validatePipeline_InnerFunction(pipeline) {
     // TODO: [🧠] Maybe do here some proper JSON-schema / ZOD checking
     if (!Array.isArray(pipeline.tasks)) {
         // TODO: [🧠] what is the correct error tp throw - maybe PromptbookSchemaError
-        throw new ParseError(spaceTrim$1((block) => `
+        throw new ParseError(spaceTrim((block) => `
                     Pipeline is valid JSON but with wrong structure
 
                     \`PipelineJson.tasks\` expected to be an array, but got ${typeof pipeline.tasks}
@@ -1392,7 +3408,7 @@ function validatePipeline_InnerFunction(pipeline) {
     // Note: Check each parameter individually
     for (const parameter of pipeline.parameters) {
         if (parameter.isInput && parameter.isOutput) {
-            throw new PipelineLogicError(spaceTrim$1((block) => `
+            throw new PipelineLogicError(spaceTrim((block) => `
 
                         Parameter \`{${parameter.name}}\` can not be both input and output
 
@@ -1403,7 +3419,7 @@ function validatePipeline_InnerFunction(pipeline) {
         if (!parameter.isInput &&
             !parameter.isOutput &&
             !pipeline.tasks.some((task) => task.dependentParameterNames.includes(parameter.name))) {
-            throw new PipelineLogicError(spaceTrim$1((block) => `
+            throw new PipelineLogicError(spaceTrim((block) => `
                         Parameter \`{${parameter.name}}\` is created but not used
 
                         You can declare {${parameter.name}} as output parameter by adding in the header:
@@ -1415,7 +3431,7 @@ function validatePipeline_InnerFunction(pipeline) {
         }
         // Note: Testing that parameter is either input or result of some task
         if (!parameter.isInput && !pipeline.tasks.some((task) => task.resultingParameterName === parameter.name)) {
-            throw new PipelineLogicError(spaceTrim$1((block) => `
+            throw new PipelineLogicError(spaceTrim((block) => `
                         Parameter \`{${parameter.name}}\` is declared but not defined
 
                         You can do one of these:
@@ -1431,14 +3447,14 @@ function validatePipeline_InnerFunction(pipeline) {
     // Note: Checking each task individually
     for (const task of pipeline.tasks) {
         if (definedParameters.has(task.resultingParameterName)) {
-            throw new PipelineLogicError(spaceTrim$1((block) => `
+            throw new PipelineLogicError(spaceTrim((block) => `
                         Parameter \`{${task.resultingParameterName}}\` is defined multiple times
 
                         ${block(pipelineIdentification)}
                     `));
         }
         if (RESERVED_PARAMETER_NAMES.includes(task.resultingParameterName)) {
-            throw new PipelineLogicError(spaceTrim$1((block) => `
+            throw new PipelineLogicError(spaceTrim((block) => `
                         Parameter name {${task.resultingParameterName}} is reserved, please use different name
 
                         ${block(pipelineIdentification)}
@@ -1448,7 +3464,7 @@ function validatePipeline_InnerFunction(pipeline) {
         if (task.jokerParameterNames && task.jokerParameterNames.length > 0) {
             if (!task.format &&
                 !task.expectations /* <- TODO: Require at least 1 -> min <- expectation to use jokers */) {
-                throw new PipelineLogicError(spaceTrim$1((block) => `
+                throw new PipelineLogicError(spaceTrim((block) => `
                             Joker parameters are used for {${task.resultingParameterName}} but no expectations are defined
 
                             ${block(pipelineIdentification)}
@@ -1456,7 +3472,7 @@ function validatePipeline_InnerFunction(pipeline) {
             }
             for (const joker of task.jokerParameterNames) {
                 if (!task.dependentParameterNames.includes(joker)) {
-                    throw new PipelineLogicError(spaceTrim$1((block) => `
+                    throw new PipelineLogicError(spaceTrim((block) => `
                                 Parameter \`{${joker}}\` is used for {${task.resultingParameterName}} as joker but not in \`dependentParameterNames\`
 
                                 ${block(pipelineIdentification)}
@@ -1467,21 +3483,21 @@ function validatePipeline_InnerFunction(pipeline) {
         if (task.expectations) {
             for (const [unit, { min, max }] of Object.entries(task.expectations)) {
                 if (min !== undefined && max !== undefined && min > max) {
-                    throw new PipelineLogicError(spaceTrim$1((block) => `
+                    throw new PipelineLogicError(spaceTrim((block) => `
                                 Min expectation (=${min}) of ${unit} is higher than max expectation (=${max})
 
                                 ${block(pipelineIdentification)}
                             `));
                 }
                 if (min !== undefined && min < 0) {
-                    throw new PipelineLogicError(spaceTrim$1((block) => `
+                    throw new PipelineLogicError(spaceTrim((block) => `
                                 Min expectation of ${unit} must be zero or positive
 
                                 ${block(pipelineIdentification)}
                             `));
                 }
                 if (max !== undefined && max <= 0) {
-                    throw new PipelineLogicError(spaceTrim$1((block) => `
+                    throw new PipelineLogicError(spaceTrim((block) => `
                                 Max expectation of ${unit} must be positive
 
                                 ${block(pipelineIdentification)}
@@ -1503,7 +3519,7 @@ function validatePipeline_InnerFunction(pipeline) {
     while (unresovedTasks.length > 0) {
         if (loopLimit-- < 0) {
             // Note: Really UnexpectedError not LimitReachedError - this should not happen and be caught below
-            throw new UnexpectedError(spaceTrim$1((block) => `
+            throw new UnexpectedError(spaceTrim((block) => `
                         Loop limit reached during detection of circular dependencies in \`validatePipeline\`
 
                         ${block(pipelineIdentification)}
@@ -1513,7 +3529,7 @@ function validatePipeline_InnerFunction(pipeline) {
         if (currentlyResovedTasks.length === 0) {
             throw new PipelineLogicError(
             // TODO: [🐎] DRY
-            spaceTrim$1((block) => `
+            spaceTrim((block) => `
 
                         Can not resolve some parameters:
                         Either you are using a parameter that is not defined, or there are some circular dependencies.
@@ -1677,7 +3693,7 @@ class SimplePipelineCollection {
         for (const pipeline of pipelines) {
             // TODO: [👠] DRY
             if (pipeline.pipelineUrl === undefined) {
-                throw new PipelineUrlError(spaceTrim$1(`
+                throw new PipelineUrlError(spaceTrim(`
                         Pipeline with name "${pipeline.title}" does not have defined URL
 
                         File:
@@ -1699,7 +3715,7 @@ class SimplePipelineCollection {
                 pipelineJsonToString(unpreparePipeline(pipeline)) !==
                     pipelineJsonToString(unpreparePipeline(this.collection.get(pipeline.pipelineUrl)))) {
                 const existing = this.collection.get(pipeline.pipelineUrl);
-                throw new PipelineUrlError(spaceTrim$1(`
+                throw new PipelineUrlError(spaceTrim(`
                         Pipeline with URL ${pipeline.pipelineUrl} is already in the collection 🍎
 
                         Conflicting files:
@@ -1731,13 +3747,13 @@ class SimplePipelineCollection {
         const pipeline = this.collection.get(url);
         if (!pipeline) {
             if (this.listPipelines().length === 0) {
-                throw new NotFoundError(spaceTrim$1(`
+                throw new NotFoundError(spaceTrim(`
                             Pipeline with url "${url}" not found
 
                             No pipelines available
                         `));
             }
-            throw new NotFoundError(spaceTrim$1((block) => `
+            throw new NotFoundError(spaceTrim((block) => `
                         Pipeline with url "${url}" not found
 
                         Available pipelines:
@@ -1867,7 +3883,7 @@ function createSubcollection(collection, predicate) {
     }
     async function getPipelineByUrl(url) {
         if (!predicate(url)) {
-            throw new NotFoundError(await spaceTrim$1(async (block) => `
+            throw new NotFoundError(await spaceTrim(async (block) => `
                         Promptbook with url "${url}" not found or not accessible
 
                         Available promptbooks:
@@ -1902,7 +3918,7 @@ var PipelineCollection = [{title:"Prepare Knowledge from Markdown",pipelineUrl:"
  */
 class MissingToolsError extends Error {
     constructor(message) {
-        super(spaceTrim$1((block) => `
+        super(spaceTrim((block) => `
                     ${block(message)}
 
                     Note: You have probably forgot to provide some tools for pipeline execution or preparation
@@ -2071,7 +4087,7 @@ class LimitReachedError extends Error {
  */
 class NotYetImplementedError extends Error {
     constructor(message) {
-        super(spaceTrim$1((block) => `
+        super(spaceTrim((block) => `
                     ${block(message)}
 
                     Note: This feature is not implemented yet but it will be soon.
@@ -2121,19 +4137,6 @@ class PipelineExecutionError extends Error {
  * TODO: [🧠][🌂] Add id to all errors
  */
 
-/**
- * Error thrown when a fetch request fails
- *
- * @public exported from `@promptbook/core`
- */
-class PromptbookFetchError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'PromptbookFetchError';
-        Object.setPrototypeOf(this, PromptbookFetchError.prototype);
-    }
-}
-
 /**
  * Index of all custom errors
  *
@@ -2205,7 +4208,7 @@ function serializeError(error) {
     const { name, message, stack } = error;
     const { id } = error;
     if (!Object.keys(ALL_ERRORS).includes(name)) {
-        console.error(spaceTrim((block) => `
+        console.error(spaceTrim$1((block) => `
 
                     Cannot serialize error with name "${name}"
 
@@ -2238,7 +4241,7 @@ function jsonParse(value) {
     }
     else if (typeof value !== 'string') {
         console.error('Can not parse JSON from non-string value.', { text: value });
-        throw new Error(spaceTrim(`
+        throw new Error(spaceTrim$1(`
                     Can not parse JSON from non-string value.
 
                     The value type: ${typeof value}
@@ -2252,7 +4255,7 @@ function jsonParse(value) {
         if (!(error instanceof Error)) {
             throw error;
         }
-        throw new Error(spaceTrim((block) => `
+        throw new Error(spaceTrim$1((block) => `
                     ${block(error.message)}
 
                     The expected JSON text:
@@ -2305,7 +4308,7 @@ function deserializeError(error) {
         message = `${name}: ${message}`;
     }
     if (stack !== undefined && stack !== '') {
-        message = spaceTrim((block) => `
+        message = spaceTrim$1((block) => `
                 ${block(message)}
 
                 Original stack trace:
@@ -2342,11 +4345,11 @@ function assertsTaskSuccessful(executionResult) {
         throw deserializeError(errors[0]);
     }
     else {
-        throw new PipelineExecutionError(spaceTrim$1((block) => `
+        throw new PipelineExecutionError(spaceTrim((block) => `
                     Multiple errors occurred during Promptbook execution
 
                     ${block(errors
-            .map(({ name, stack, message }, index) => spaceTrim$1((block) => `
+            .map(({ name, stack, message }, index) => spaceTrim((block) => `
                                         ${name} ${index + 1}:
                                         ${block(stack || message)}
                                     `))
@@ -2364,7 +4367,7 @@ function assertsTaskSuccessful(executionResult) {
  * @private internal helper function
  */
 function createTask(options) {
-    const { taskType, taskProcessCallback } = options;
+    const { taskType, taskProcessCallback, tldrProvider } = options;
     let { title } = options;
     // TODO: [🐙] DRY
     const taskId = `${taskType.toLowerCase().substring(0, 4)}-${$randomToken(8 /* <- TODO: To global config + Use Base58 to avoid similar char conflicts   */)}`;
@@ -2437,6 +4440,78 @@ function createTask(options) {
             return status;
             // <- Note: [1] --||--
         },
+        get tldr() {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            // Use custom tldr provider if available
+            if (tldrProvider) {
+                return tldrProvider(createdAt, status, currentValue, errors, warnings);
+            }
+            // Fallback to default implementation
+            const cv = currentValue;
+            // If explicit percent is provided, use it
+            let percentRaw = (_f = (_d = (_b = (_a = cv === null || cv === void 0 ? void 0 : cv.tldr) === null || _a === void 0 ? void 0 : _a.percent) !== null && _b !== void 0 ? _b : (_c = cv === null || cv === void 0 ? void 0 : cv.usage) === null || _c === void 0 ? void 0 : _c.percent) !== null && _d !== void 0 ? _d : (_e = cv === null || cv === void 0 ? void 0 : cv.progress) === null || _e === void 0 ? void 0 : _e.percent) !== null && _f !== void 0 ? _f : cv === null || cv === void 0 ? void 0 : cv.percent;
+            // Simulate progress if not provided
+            if (typeof percentRaw !== 'number') {
+                // Simulate progress: evenly split across subtasks, based on elapsed time
+                const now = new Date();
+                const elapsedMs = now.getTime() - createdAt.getTime();
+                const totalMs = DEFAULT_TASK_SIMULATED_DURATION_MS;
+                // If subtasks are defined, split progress evenly
+                const subtaskCount = Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks) ? cv.subtasks.length : 1;
+                const completedSubtasks = Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks)
+                    ? cv.subtasks.filter((s) => s.done || s.completed).length
+                    : 0;
+                // Progress from completed subtasks
+                const subtaskProgress = subtaskCount > 0 ? completedSubtasks / subtaskCount : 0;
+                // Progress from elapsed time for current subtask
+                const timeProgress = Math.min(elapsedMs / totalMs, 1);
+                // Combine: completed subtasks + time progress for current subtask
+                percentRaw = Math.min(subtaskProgress + (1 / subtaskCount) * timeProgress, 1);
+                if (status === 'FINISHED')
+                    percentRaw = 1;
+                if (status === 'ERROR')
+                    percentRaw = 0;
+            }
+            // Clamp to [0,1]
+            let percent = Number(percentRaw) || 0;
+            if (percent < 0)
+                percent = 0;
+            if (percent > 1)
+                percent = 1;
+            // Build a short message: prefer explicit tldr.message, then common summary/message fields, then errors/warnings, then status
+            const messageFromResult = (_k = (_j = (_h = (_g = cv === null || cv === void 0 ? void 0 : cv.tldr) === null || _g === void 0 ? void 0 : _g.message) !== null && _h !== void 0 ? _h : cv === null || cv === void 0 ? void 0 : cv.message) !== null && _j !== void 0 ? _j : cv === null || cv === void 0 ? void 0 : cv.summary) !== null && _k !== void 0 ? _k : cv === null || cv === void 0 ? void 0 : cv.statusMessage;
+            let message = messageFromResult;
+            if (!message) {
+                // If subtasks, show current subtask
+                if (Array.isArray(cv === null || cv === void 0 ? void 0 : cv.subtasks) && cv.subtasks.length > 0) {
+                    const current = cv.subtasks.find((s) => !s.done && !s.completed);
+                    if (current && current.title) {
+                        message = `Working on ${current.title}`;
+                    }
+                }
+                if (!message) {
+                    if (errors.length) {
+                        message = errors[errors.length - 1].message || 'Error';
+                    }
+                    else if (warnings.length) {
+                        message = warnings[warnings.length - 1].message || 'Warning';
+                    }
+                    else if (status === 'FINISHED') {
+                        message = 'Finished';
+                    }
+                    else if (status === 'ERROR') {
+                        message = 'Error';
+                    }
+                    else {
+                        message = 'Running';
+                    }
+                }
+            }
+            return {
+                percent: percent,
+                message,
+            };
+        },
         get createdAt() {
             return createdAt;
             // <- Note: [1] --||--
@@ -2716,7 +4791,7 @@ function extractVariablesFromJavascript(script) {
     }
     catch (error) {
         assertsError(error);
-        throw new ParseError(spaceTrim$1((block) => `
+        throw new ParseError(spaceTrim((block) => `
                     Can not extract variables from the script
                     ${block(error.stack || error.message)}
 
@@ -2899,7 +4974,7 @@ const CsvFormatParser = {
                 const { value, outputParameterName, settings, mapCallback, onProgress } = options;
                 const csv = csvParse(value, settings);
                 if (csv.errors.length !== 0) {
-                    throw new CsvFormatError(spaceTrim((block) => `
+                    throw new CsvFormatError(spaceTrim$1((block) => `
                                 CSV parsing error
 
                                 Error(s) from CSV parsing:
@@ -2944,7 +5019,7 @@ const CsvFormatParser = {
                 const { value, settings, mapCallback, onProgress } = options;
                 const csv = csvParse(value, settings);
                 if (csv.errors.length !== 0) {
-                    throw new CsvFormatError(spaceTrim((block) => `
+                    throw new CsvFormatError(spaceTrim$1((block) => `
                                 CSV parsing error
 
                                 Error(s) from CSV parsing:
@@ -3154,7 +5229,7 @@ function mapAvailableToExpectedParameters(options) {
     }
     // Phase 2️⃣: Non-matching mapping
     if (expectedParameterNames.size !== availableParametersNames.size) {
-        throw new PipelineExecutionError(spaceTrim((block) => `
+        throw new PipelineExecutionError(spaceTrim$1((block) => `
                     Can not map available parameters to expected parameters
 
                     Mapped parameters:
@@ -3207,14 +5282,14 @@ class MultipleLlmExecutionTools {
             if (description === undefined) {
                 return headLine;
             }
-            return spaceTrim((block) => `
+            return spaceTrim$1((block) => `
                         ${headLine}
                         
                           ${ /* <- Note: Indenting the description: */block(description)}
                     `);
         })
             .join('\n\n');
-        return spaceTrim((block) => `
+        return spaceTrim$1((block) => `
                 Multiple LLM Providers:
 
                 ${block(innerModelsTitlesAndDescriptions)}
@@ -3305,7 +5380,7 @@ class MultipleLlmExecutionTools {
             //     1) OpenAI throw PipelineExecutionError: Parameter `{knowledge}` is not defined
             //     2) AnthropicClaude throw PipelineExecutionError: Parameter `{knowledge}` is not defined
             //     3) ...
-            spaceTrim((block) => `
+            spaceTrim$1((block) => `
                           All execution tools failed:
 
                           ${block(errors
@@ -3318,7 +5393,7 @@ class MultipleLlmExecutionTools {
             throw new PipelineExecutionError(`You have not provided any \`LlmExecutionTools\``);
         }
         else {
-            throw new PipelineExecutionError(spaceTrim((block) => `
+            throw new PipelineExecutionError(spaceTrim$1((block) => `
                           You have not provided any \`LlmExecutionTools\` that support model variant "${prompt.modelRequirements.modelVariant}"
 
                           Available \`LlmExecutionTools\`:
@@ -3351,7 +5426,7 @@ class MultipleLlmExecutionTools {
  */
 function joinLlmExecutionTools(...llmExecutionTools) {
     if (llmExecutionTools.length === 0) {
-        const warningMessage = spaceTrim(`
+        const warningMessage = spaceTrim$1(`
             You have not provided any \`LlmExecutionTools\`
             This means that you won't be able to execute any prompts that require large language models like GPT-4 or Anthropic's Claude.
 
@@ -4063,7 +6138,7 @@ function validatePromptResult(options) {
                     }
                     catch (error) {
                         keepUnused(error);
-                        throw new ExpectError(spaceTrim$1((block) => `
+                        throw new ExpectError(spaceTrim((block) => `
                                     Expected valid JSON string
 
                                     The expected JSON text:
@@ -4112,7 +6187,7 @@ function validatePromptResult(options) {
  */
 async function executeAttempts(options) {
     const { jokerParameterNames, priority, maxAttempts, // <- Note: [💂]
-    preparedContent, parameters, task, preparedPipeline, tools, $executionReport, pipelineIdentification, maxExecutionAttempts, } = options;
+    preparedContent, parameters, task, preparedPipeline, tools, $executionReport, pipelineIdentification, maxExecutionAttempts, onProgress, } = options;
     const $ongoingTaskResult = {
         $result: null,
         $resultString: null,
@@ -4128,7 +6203,7 @@ async function executeAttempts(options) {
         const jokerParameterName = jokerParameterNames[jokerParameterNames.length + attemptIndex];
         // TODO: [🧠][🍭] JOKERS, EXPECTATIONS, POSTPROCESSING and FOREACH
         if (isJokerAttempt && !jokerParameterName) {
-            throw new UnexpectedError(spaceTrim$1((block) => `
+            throw new UnexpectedError(spaceTrim((block) => `
                         Joker not found in attempt ${attemptIndex}
 
                         ${block(pipelineIdentification)}
@@ -4139,7 +6214,7 @@ async function executeAttempts(options) {
         $ongoingTaskResult.$expectError = null;
         if (isJokerAttempt) {
             if (parameters[jokerParameterName] === undefined) {
-                throw new PipelineExecutionError(spaceTrim$1((block) => `
+                throw new PipelineExecutionError(spaceTrim((block) => `
                             Joker parameter {${jokerParameterName}} not defined
 
                             ${block(pipelineIdentification)}
@@ -4197,7 +6272,7 @@ async function executeAttempts(options) {
                                     $ongoingTaskResult.$resultString = $ongoingTaskResult.$completionResult.content;
                                     break variant;
                                 case 'EMBEDDING':
-                                    throw new PipelineExecutionError(spaceTrim$1((block) => `
+                                    throw new PipelineExecutionError(spaceTrim((block) => `
                                                 Embedding model can not be used in pipeline
 
                                                 This should be catched during parsing
@@ -4208,7 +6283,7 @@ async function executeAttempts(options) {
                                     break variant;
                                 // <- case [🤖]:
                                 default:
-                                    throw new PipelineExecutionError(spaceTrim$1((block) => `
+                                    throw new PipelineExecutionError(spaceTrim((block) => `
                                                 Unknown model variant "${task.modelRequirements.modelVariant}"
 
                                                 ${block(pipelineIdentification)}
@@ -4219,14 +6294,14 @@ async function executeAttempts(options) {
                         break;
                     case 'SCRIPT_TASK':
                         if (arrayableToArray(tools.script).length === 0) {
-                            throw new PipelineExecutionError(spaceTrim$1((block) => `
+                            throw new PipelineExecutionError(spaceTrim((block) => `
                                         No script execution tools are available
 
                                         ${block(pipelineIdentification)}
                                     `));
                         }
                         if (!task.contentLanguage) {
-                            throw new PipelineExecutionError(spaceTrim$1((block) => `
+                            throw new PipelineExecutionError(spaceTrim((block) => `
                                         Script language is not defined for SCRIPT TASK "${task.name}"
 
                                         ${block(pipelineIdentification)}
@@ -4257,7 +6332,7 @@ async function executeAttempts(options) {
                             throw $ongoingTaskResult.$scriptPipelineExecutionErrors[0];
                         }
                         else {
-                            throw new PipelineExecutionError(spaceTrim$1((block) => `
+                            throw new PipelineExecutionError(spaceTrim((block) => `
                                         Script execution failed ${$ongoingTaskResult.$scriptPipelineExecutionErrors.length}x
 
                                         ${block(pipelineIdentification)}
@@ -4271,7 +6346,7 @@ async function executeAttempts(options) {
                         break taskType;
                     case 'DIALOG_TASK':
                         if (tools.userInterface === undefined) {
-                            throw new PipelineExecutionError(spaceTrim$1((block) => `
+                            throw new PipelineExecutionError(spaceTrim((block) => `
                                         User interface tools are not available
 
                                         ${block(pipelineIdentification)}
@@ -4289,7 +6364,7 @@ async function executeAttempts(options) {
                         break taskType;
                     // <- case: [🅱]
                     default:
-                        throw new PipelineExecutionError(spaceTrim$1((block) => `
+                        throw new PipelineExecutionError(spaceTrim((block) => `
                                     Unknown execution type "${task.taskType}"
 
                                     ${block(pipelineIdentification)}
@@ -4356,6 +6431,10 @@ async function executeAttempts(options) {
                 result: $ongoingTaskResult.$resultString,
                 error: error,
             });
+            // Report failed attempt
+            onProgress({
+                errors: [error],
+            });
         }
         finally {
             if (!isJokerAttempt &&
@@ -4380,7 +6459,7 @@ async function executeAttempts(options) {
         if ($ongoingTaskResult.$expectError !== null && attemptIndex === maxAttempts - 1) {
             // Note: Create a summary of all failures
             const failuresSummary = $ongoingTaskResult.$failedResults
-                .map((failure) => spaceTrim$1((block) => {
+                .map((failure) => spaceTrim((block) => {
                 var _a, _b;
                 return `
                             Attempt ${failure.attemptIndex + 1}:
@@ -4390,14 +6469,14 @@ async function executeAttempts(options) {
                             Result:
                             ${block(failure.result === null
                     ? 'null'
-                    : spaceTrim$1(failure.result)
+                    : spaceTrim(failure.result)
                         .split('\n')
                         .map((line) => `> ${line}`)
                         .join('\n'))}
                         `;
             }))
                 .join('\n\n---\n\n');
-            throw new PipelineExecutionError(spaceTrim$1((block) => {
+            throw new PipelineExecutionError(spaceTrim((block) => {
                 var _a;
                 return `
                         LLM execution failed ${maxExecutionAttempts}x
@@ -4417,7 +6496,7 @@ async function executeAttempts(options) {
         }
     }
     if ($ongoingTaskResult.$resultString === null) {
-        throw new UnexpectedError(spaceTrim$1((block) => `
+        throw new UnexpectedError(spaceTrim((block) => `
                     Something went wrong and prompt result is null
 
                     ${block(pipelineIdentification)}
@@ -4444,7 +6523,7 @@ async function executeFormatSubvalues(options) {
         return /* not await */ executeAttempts(options);
     }
     if (jokerParameterNames.length !== 0) {
-        throw new UnexpectedError(spaceTrim((block) => `
+        throw new UnexpectedError(spaceTrim$1((block) => `
                     JOKER parameters are not supported together with FOREACH command
 
                     [🧞‍♀️] This should be prevented in \`validatePipeline\`
@@ -4457,7 +6536,7 @@ async function executeFormatSubvalues(options) {
     if (formatDefinition === undefined) {
         throw new UnexpectedError(
         // <- TODO: [🧠][🧐] Should be formats fixed per promptbook version or behave as plugins (=> change UnexpectedError)
-        spaceTrim((block) => `
+        spaceTrim$1((block) => `
                     Unsupported format "${task.foreach.formatName}"
 
                     Available formats:
@@ -4474,7 +6553,7 @@ async function executeFormatSubvalues(options) {
     if (subvalueParser === undefined) {
         throw new UnexpectedError(
         // <- TODO: [🧠][🧐] Should be formats fixed per promptbook version or behave as plugins (=> change UnexpectedError)
-        spaceTrim((block) => `
+        spaceTrim$1((block) => `
                     Unsupported subformat name "${task.foreach.subformatName}" for format "${task.foreach.formatName}"
 
                     Available subformat names for format "${formatDefinition.formatName}":
@@ -4514,7 +6593,7 @@ async function executeFormatSubvalues(options) {
                 if (!(error instanceof PipelineExecutionError)) {
                     throw error;
                 }
-                const highLevelError = new PipelineExecutionError(spaceTrim((block) => `
+                const highLevelError = new PipelineExecutionError(spaceTrim$1((block) => `
                             ${error.message}
 
                             This is error in FOREACH command when mapping ${formatDefinition.formatName} ${subvalueParser.subvalueName} data (${index + 1}/${length})
@@ -4538,7 +6617,7 @@ async function executeFormatSubvalues(options) {
                     ...options,
                     priority: priority + index,
                     parameters: allSubparameters,
-                    pipelineIdentification: spaceTrim((block) => `
+                    pipelineIdentification: spaceTrim$1((block) => `
                             ${block(pipelineIdentification)}
                             Subparameter index: ${index}
                         `),
@@ -4547,7 +6626,7 @@ async function executeFormatSubvalues(options) {
             }
             catch (error) {
                 if (length > BIG_DATASET_TRESHOLD) {
-                    console.error(spaceTrim((block) => `
+                    console.error(spaceTrim$1((block) => `
                               ${error.message}
 
                               This is error in FOREACH command when processing ${formatDefinition.formatName} ${subvalueParser.subvalueName} data (${index + 1}/${length})
@@ -4725,7 +6804,7 @@ async function getReservedParametersForTask(options) {
     // Note: Doublecheck that ALL reserved parameters are defined:
     for (const parameterName of RESERVED_PARAMETER_NAMES) {
         if (reservedParameters[parameterName] === undefined) {
-            throw new UnexpectedError(spaceTrim$1((block) => `
+            throw new UnexpectedError(spaceTrim((block) => `
                         Reserved parameter {${parameterName}} is not defined
 
                         ${block(pipelineIdentification)}
@@ -4751,7 +6830,7 @@ async function executeTask(options) {
     const dependentParameterNames = new Set(currentTask.dependentParameterNames);
     // TODO: [👩🏾‍🤝‍👩🏻] Use here `mapAvailableToExpectedParameters`
     if (difference(union(difference(usedParameterNames, dependentParameterNames), difference(dependentParameterNames, usedParameterNames)), new Set(RESERVED_PARAMETER_NAMES)).size !== 0) {
-        throw new UnexpectedError(spaceTrim$1((block) => `
+        throw new UnexpectedError(spaceTrim((block) => `
                     Dependent parameters are not consistent with used parameters:
 
                     Dependent parameters:
@@ -4795,7 +6874,7 @@ async function executeTask(options) {
         else if (!definedParameterNames.has(parameterName) && usedParameterNames.has(parameterName)) {
             // Houston, we have a problem
             // Note: Checking part is also done in `validatePipeline`, but it’s good to doublecheck
-            throw new UnexpectedError(spaceTrim$1((block) => `
+            throw new UnexpectedError(spaceTrim((block) => `
                         Parameter \`{${parameterName}}\` is NOT defined
                         BUT used in task "${currentTask.title || currentTask.name}"
 
@@ -4863,7 +6942,7 @@ function filterJustOutputParameters(options) {
     for (const parameter of preparedPipeline.parameters.filter(({ isOutput }) => isOutput)) {
         if (parametersToPass[parameter.name] === undefined) {
             // [4]
-            $warnings.push(new PipelineExecutionError(spaceTrim$1((block) => `
+            $warnings.push(new PipelineExecutionError(spaceTrim((block) => `
                             Parameter \`{${parameter.name}}\` should be an output parameter, but it was not generated during pipeline execution
 
                             ${block(pipelineIdentification)}
@@ -4948,7 +7027,7 @@ async function executePipeline(options) {
     for (const parameterName of Object.keys(inputParameters)) {
         const parameter = preparedPipeline.parameters.find(({ name }) => name === parameterName);
         if (parameter === undefined) {
-            warnings.push(new PipelineExecutionError(spaceTrim$1((block) => `
+            warnings.push(new PipelineExecutionError(spaceTrim((block) => `
                             Extra parameter {${parameterName}} is being passed which is not part of the pipeline.
 
                             ${block(pipelineIdentification)}
@@ -4963,7 +7042,7 @@ async function executePipeline(options) {
             // TODO: [🧠] This should be also non-critical error
             return exportJson({
                 name: 'pipelineExecutorResult',
-                message: spaceTrim$1((block) => `
+                message: spaceTrim((block) => `
                         Unsuccessful PipelineExecutorResult (with extra parameter {${parameter.name}}) PipelineExecutorResult
 
                         ${block(pipelineIdentification)}
@@ -4972,7 +7051,7 @@ async function executePipeline(options) {
                 value: {
                     isSuccessful: false,
                     errors: [
-                        new PipelineExecutionError(spaceTrim$1((block) => `
+                        new PipelineExecutionError(spaceTrim((block) => `
                                     Parameter \`{${parameter.name}}\` is passed as input parameter but it is not input
 
                                     ${block(pipelineIdentification)}
@@ -4999,7 +7078,7 @@ async function executePipeline(options) {
         while (unresovedTasks.length > 0) {
             if (loopLimit-- < 0) {
                 // Note: Really UnexpectedError not LimitReachedError - this should be catched during validatePipeline
-                throw new UnexpectedError(spaceTrim$1((block) => `
+                throw new UnexpectedError(spaceTrim((block) => `
                             Loop limit reached during resolving parameters pipeline execution
 
                             ${block(pipelineIdentification)}
@@ -5009,7 +7088,7 @@ async function executePipeline(options) {
             if (!currentTask && resolving.length === 0) {
                 throw new UnexpectedError(
                 // TODO: [🐎] DRY
-                spaceTrim$1((block) => `
+                spaceTrim((block) => `
                             Can not resolve some parameters:
 
                             ${block(pipelineIdentification)}
@@ -5049,7 +7128,7 @@ async function executePipeline(options) {
                     tools,
                     onProgress(newOngoingResult) {
                         if (isReturned) {
-                            throw new UnexpectedError(spaceTrim$1((block) => `
+                            throw new UnexpectedError(spaceTrim((block) => `
                                         Can not call \`onProgress\` after pipeline execution is finished
 
                                         ${block(pipelineIdentification)}
@@ -5065,7 +7144,7 @@ async function executePipeline(options) {
                         }
                     },
                     $executionReport: executionReport,
-                    pipelineIdentification: spaceTrim$1((block) => `
+                    pipelineIdentification: spaceTrim((block) => `
                             ${block(pipelineIdentification)}
                             Task name: ${currentTask.name}
                             Task title: ${currentTask.title}
@@ -5174,7 +7253,7 @@ function createPipelineExecutor(options) {
         preparedPipeline = pipeline;
     }
     else if (isNotPreparedWarningSuppressed !== true) {
-        console.warn(spaceTrim$1((block) => `
+        console.warn(spaceTrim((block) => `
                     Pipeline is not prepared
 
                     ${block(pipelineIdentification)}
@@ -5198,7 +7277,7 @@ function createPipelineExecutor(options) {
             inputParameters,
             tools,
             onProgress,
-            pipelineIdentification: spaceTrim$1((block) => `
+            pipelineIdentification: spaceTrim((block) => `
                     ${block(pipelineIdentification)}
                     ${runCount === 1 ? '' : `Run #${runCount}`}
                 `),
@@ -5237,6 +7316,71 @@ function createPipelineExecutor(options) {
                 updateOngoingResult(newOngoingResult);
             });
         },
+        tldrProvider(createdAt, status, currentValue, errors) {
+            var _a;
+            // Better progress estimation based on pipeline structure
+            const cv = currentValue;
+            // Handle finished/error states
+            if (status === 'FINISHED') {
+                return {
+                    percent: 1,
+                    message: 'Finished',
+                };
+            }
+            if (status === 'ERROR') {
+                const errorMessage = errors.length > 0 ? errors[errors.length - 1].message : 'Error';
+                return {
+                    percent: 0,
+                    message: errorMessage,
+                };
+            }
+            // Calculate progress based on pipeline tasks
+            const totalTasks = pipeline.tasks.length;
+            let completedTasks = 0;
+            let currentTaskName = '';
+            // Check execution report for completed tasks
+            if ((_a = cv === null || cv === void 0 ? void 0 : cv.executionReport) === null || _a === void 0 ? void 0 : _a.promptExecutions) {
+                const executedTaskTitles = new Set(cv.executionReport.promptExecutions.map((execution) => execution.prompt.title));
+                // Count completed tasks by matching titles
+                const completedTasksByTitle = pipeline.tasks.filter(task => executedTaskTitles.has(task.title));
+                completedTasks = completedTasksByTitle.length;
+                // Find current task being executed (first task not yet completed)
+                const remainingTasks = pipeline.tasks.filter(task => !executedTaskTitles.has(task.title));
+                if (remainingTasks.length > 0) {
+                    currentTaskName = remainingTasks[0].name;
+                }
+            }
+            // Calculate progress percentage
+            let percent = totalTasks > 0 ? completedTasks / totalTasks : 0;
+            // Add time-based progress for current task (assuming 5 minutes total)
+            if (completedTasks < totalTasks) {
+                const elapsedMs = new Date().getTime() - createdAt.getTime();
+                const totalMs = 5 * 60 * 1000; // 5 minutes
+                const timeProgress = Math.min(elapsedMs / totalMs, 1);
+                // Add partial progress for current task
+                percent += (1 / totalTasks) * timeProgress;
+            }
+            // Clamp to [0,1]
+            percent = Math.min(Math.max(percent, 0), 1);
+            // Generate message
+            let message = '';
+            if (currentTaskName) {
+                // Find the task to get its title
+                const currentTask = pipeline.tasks.find(task => task.name === currentTaskName);
+                const taskTitle = (currentTask === null || currentTask === void 0 ? void 0 : currentTask.title) || currentTaskName;
+                message = `Working on task ${taskTitle}`;
+            }
+            else if (completedTasks === 0) {
+                message = 'Starting pipeline execution';
+            }
+            else {
+                message = `Processing pipeline (${completedTasks}/${totalTasks} tasks completed)`;
+            }
+            return {
+                percent,
+                message,
+            };
+        },
     });
     //        <- TODO: Make types such as there is no need to do `as` for `createTask`
     return pipelineExecutor;
@@ -5609,14 +7753,14 @@ function $registeredScrapersMessage(availableScrapers) {
         return { ...metadata, isMetadataAviailable, isInstalled, isAvailableInTools };
     });
     if (metadata.length === 0) {
-        return spaceTrim(`
+        return spaceTrim$1(`
             **No scrapers are available**
 
             This is a unexpected behavior, you are probably using some broken version of Promptbook
             At least there should be available the metadata of the scrapers
         `);
     }
-    return spaceTrim((block) => `
+    return spaceTrim$1((block) => `
             Available scrapers are:
             ${block(metadata
         .map(({ packageName, className, isMetadataAviailable, isInstalled, mimeTypes, isAvailableInBrowser, isAvailableInTools, }, i) => {
@@ -5835,37 +7979,6 @@ function titleToName(value) {
     return value;
 }
 
-/**
- * The built-in `fetch' function with a lightweight error handling wrapper as default fetch function used in Promptbook scrapers
- *
- * @public exported from `@promptbook/core`
- */
-const promptbookFetch = async (urlOrRequest, init) => {
-    try {
-        return await fetch(urlOrRequest, init);
-    }
-    catch (error) {
-        assertsError(error);
-        let url;
-        if (typeof urlOrRequest === 'string') {
-            url = urlOrRequest;
-        }
-        else if (urlOrRequest instanceof Request) {
-            url = urlOrRequest.url;
-        }
-        throw new PromptbookFetchError(spaceTrim((block) => `
-                    Can not fetch "${url}"
-
-                    Fetch error:
-                    ${block(error.message)}
-
-                `));
-    }
-};
-/**
- * TODO: [🧠] Maybe rename because it is not used only for scrapers but also in `$getCompiledBook`
- */
-
 /**
  * Factory function that creates a handler for processing knowledge sources.
  * Provides standardized processing of different types of knowledge sources
@@ -5992,7 +8105,7 @@ async function makeKnowledgeSourceHandler(knowledgeSource, tools, options) {
         const fileExtension = getFileExtension(filename);
         const mimeType = extensionToMimeType(fileExtension || '');
         if (!(await isFileExisting(filename, tools.fs))) {
-            throw new NotFoundError(spaceTrim((block) => `
+            throw new NotFoundError(spaceTrim$1((block) => `
                           Can not make source handler for file which does not exist:
 
                           File:
@@ -6079,7 +8192,7 @@ async function prepareKnowledgePieces(knowledgeSources, tools, options) {
                     // <- TODO: [🪓] Here should be no need for spreading new array, just `partialPieces = partialPiecesUnchecked`
                     break;
                 }
-                console.warn(spaceTrim((block) => `
+                console.warn(spaceTrim$1((block) => `
                             Cannot scrape knowledge from source despite the scraper \`${scraper.metadata.className}\` supports the mime type "${sourceHandler.mimeType}".
 
                             The source:
@@ -6095,7 +8208,7 @@ async function prepareKnowledgePieces(knowledgeSources, tools, options) {
                 // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
             }
             if (partialPieces === null) {
-                throw new KnowledgeScrapeError(spaceTrim((block) => `
+                throw new KnowledgeScrapeError(spaceTrim$1((block) => `
                             Cannot scrape knowledge
 
                             The source:
@@ -6174,7 +8287,7 @@ async function prepareTasks(pipeline, tools, options) {
         if (task.taskType === 'PROMPT_TASK' &&
             knowledgePiecesCount > 0 &&
             !dependentParameterNames.includes('knowledge')) {
-            preparedContent = spaceTrim$1(`
+            preparedContent = spaceTrim(`
                     {content}
 
                     ## Knowledge
@@ -6433,7 +8546,7 @@ const knowledgeCommandParser = {
      */
     parse(input) {
         const { args } = input;
-        const knowledgeSourceContent = spaceTrim(args[0] || '');
+        const knowledgeSourceContent = spaceTrim$1(args[0] || '');
         if (knowledgeSourceContent === '') {
             throw new ParseError(`Source is not defined`);
         }
@@ -6577,7 +8690,7 @@ const sectionCommandParser = {
         normalized = normalized.split('DIALOGUE').join('DIALOG');
         const taskTypes = SectionTypes.filter((sectionType) => normalized.includes(sectionType.split('_TASK').join('')));
         if (taskTypes.length !== 1) {
-            throw new ParseError(spaceTrim((block) => `
+            throw new ParseError(spaceTrim$1((block) => `
                         Unknown section type "${normalized}"
 
                         Supported section types are:
@@ -6597,7 +8710,7 @@ const sectionCommandParser = {
      */
     $applyToTaskJson(command, $taskJson, $pipelineJson) {
         if ($taskJson.isSectionTypeSet === true) {
-            throw new ParseError(spaceTrim(`
+            throw new ParseError(spaceTrim$1(`
                     Section type is already defined in the section.
                     It can be defined only once.
                 `));
@@ -6945,7 +9058,7 @@ const expectCommandParser = {
     /**
      * Description of the FORMAT command
      */
-    description: spaceTrim(`
+    description: spaceTrim$1(`
         Expect command describes the desired output of the task *(after post-processing)*
         It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.
     `),
@@ -7019,7 +9132,7 @@ const expectCommandParser = {
         }
         catch (error) {
             assertsError(error);
-            throw new ParseError(spaceTrim((block) => `
+            throw new ParseError(spaceTrim$1((block) => `
                             Invalid FORMAT command
                             ${block(error.message)}:
                         `));
@@ -7204,7 +9317,7 @@ function validateParameterName(parameterName) {
         if (!(error instanceof ParseError)) {
             throw error;
         }
-        throw new ParseError(spaceTrim((block) => `
+        throw new ParseError(spaceTrim$1((block) => `
                     ${block(error.message)}
 
                     Tried to validate parameter name:
@@ -7263,7 +9376,7 @@ const foreachCommandParser = {
         const assignSign = args[3];
         const formatDefinition = FORMAT_DEFINITIONS.find((formatDefinition) => [formatDefinition.formatName, ...(formatDefinition.aliases || [])].includes(formatName));
         if (formatDefinition === undefined) {
-            throw new ParseError(spaceTrim((block) => `
+            throw new ParseError(spaceTrim$1((block) => `
                         Unsupported format "${formatName}"
 
                         Available formats:
@@ -7275,7 +9388,7 @@ const foreachCommandParser = {
         }
         const subvalueParser = formatDefinition.subvalueParsers.find((subvalueParser) => [subvalueParser.subvalueName, ...(subvalueParser.aliases || [])].includes(subformatName));
         if (subvalueParser === undefined) {
-            throw new ParseError(spaceTrim((block) => `
+            throw new ParseError(spaceTrim$1((block) => `
                         Unsupported subformat name "${subformatName}" for format "${formatName}"
 
                         Available subformat names for format "${formatDefinition.formatName}":
@@ -7323,7 +9436,7 @@ const foreachCommandParser = {
                 outputSubparameterName = 'newLine';
             }
             else {
-                throw new ParseError(spaceTrim(`
+                throw new ParseError(spaceTrim$1(`
                         FOREACH ${formatName} ${subformatName} must specify output subparameter
 
                         Correct example:
@@ -7399,7 +9512,7 @@ const formatCommandParser = {
     /**
      * Description of the FORMAT command
      */
-    description: spaceTrim(`
+    description: spaceTrim$1(`
         Format command describes the desired output of the task (after post-processing)
         It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.
     `),
@@ -7771,7 +9884,7 @@ const formfactorCommandParser = {
         const formfactorNameCandidate = args[0].toUpperCase();
         const formfactor = FORMFACTOR_DEFINITIONS.find((definition) => [definition.name, ...{ aliasNames: [], ...definition }.aliasNames].includes(formfactorNameCandidate));
         if (formfactor === undefined) {
-            throw new ParseError(spaceTrim((block) => `
+            throw new ParseError(spaceTrim$1((block) => `
                         Unknown formfactor name "${formfactorNameCandidate}"
 
                         Available formfactors:
@@ -7790,7 +9903,7 @@ const formfactorCommandParser = {
      */
     $applyToPipelineJson(command, $pipelineJson) {
         if ($pipelineJson.formfactorName !== undefined && $pipelineJson.formfactorName !== command.formfactorName) {
-            throw new ParseError(spaceTrim(`
+            throw new ParseError(spaceTrim$1(`
                     Redefinition of \`FORMFACTOR\` in the pipeline head
 
                     You have used:
@@ -7933,7 +10046,7 @@ const modelCommandParser = {
      */
     parse(input) {
         const { args, normalized } = input;
-        const availableVariantsMessage = spaceTrim((block) => `
+        const availableVariantsMessage = spaceTrim$1((block) => `
               Available variants are:
               ${block(MODEL_VARIANTS.map((variantName) => `- ${variantName}${variantName !== 'EMBEDDING' ? '' : ' (Not available in pipeline)'}`).join('\n'))}
           `);
@@ -7955,14 +10068,14 @@ const modelCommandParser = {
                 // <- Note: [🤖]
             }
             else if (normalized.startsWith('MODEL_VARIANT_EMBED')) {
-                spaceTrim((block) => `
+                spaceTrim$1((block) => `
                         Embedding model can not be used in pipeline
 
                         ${block(availableVariantsMessage)}
                     `);
             }
             else {
-                throw new ParseError(spaceTrim((block) => `
+                throw new ParseError(spaceTrim$1((block) => `
                             Unknown model variant in command:
 
                             ${block(availableVariantsMessage)}
@@ -7977,7 +10090,7 @@ const modelCommandParser = {
             };
         }
         else {
-            throw new ParseError(spaceTrim((block) => `
+            throw new ParseError(spaceTrim$1((block) => `
                     Unknown model key in command.
 
                     Supported model keys are:
@@ -8004,7 +10117,7 @@ const modelCommandParser = {
                 // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
             }
             else {
-                throw new ParseError(spaceTrim(`
+                throw new ParseError(spaceTrim$1(`
                         Redefinition of \`MODEL ${command.key}\` in the pipeline head
 
                         You have used:
@@ -8036,7 +10149,7 @@ const modelCommandParser = {
                 // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
             }
             else {
-                throw new ParseError(spaceTrim(`
+                throw new ParseError(spaceTrim$1(`
                               Redefinition of MODEL \`${command.key}\` in the task "${$taskJson.title || $taskJson.name}"
 
                               You have used:
@@ -8046,7 +10159,7 @@ const modelCommandParser = {
             }
         }
         if (command.value === ($pipelineJson.defaultModelRequirements || {})[command.key]) {
-            console.log(spaceTrim(`
+            console.log(spaceTrim$1(`
                     Setting MODEL \`${command.key}\` in the task "${$taskJson.title || $taskJson.name}" to the same value as in the pipeline head
 
                     In pipeline head:
@@ -8129,7 +10242,7 @@ const parameterCommandParser = {
         // <- TODO: When [🥶] fixed, change to:
         //        >   const parameterDescriptionRaw = rawArgs.split(parameterNameRaw).join('').trim();
         if (parameterDescriptionRaw && parameterDescriptionRaw.match(/\{(?<embeddedParameterName>[a-z0-9_]+)\}/im)) {
-            throw new ParseError(spaceTrim((block) => `
+            throw new ParseError(spaceTrim$1((block) => `
                         Parameter \`{${parameterNameRaw}}\` can not contain another parameter in description
 
                         The description:
@@ -8311,7 +10424,7 @@ function $applyToTaskJson(command, $taskJson, $pipelineJson) {
         persona.description = personaDescription;
         return;
     }
-    console.warn(spaceTrim(`
+    console.warn(spaceTrim$1(`
 
             Persona "${personaName}" is defined multiple times with different description:
 
@@ -8322,7 +10435,7 @@ function $applyToTaskJson(command, $taskJson, $pipelineJson) {
             ${personaDescription}
 
         `));
-    persona.description += spaceTrim('\n\n' + personaDescription);
+    persona.description += spaceTrim$1('\n\n' + personaDescription);
 }
 
 /**
@@ -8687,7 +10800,7 @@ const COMMANDS = [
 function getParserForCommand(command) {
     const commandParser = COMMANDS.find((commandParser) => commandParser.name === command.type);
     if (commandParser === undefined) {
-        throw new UnexpectedError(spaceTrim$1((block) => `
+        throw new UnexpectedError(spaceTrim((block) => `
                     Command ${command.type} parser is not found
 
                     ${block(JSON.stringify(command, null, 4)
@@ -8763,7 +10876,7 @@ function parseCommand(raw, usagePlace) {
         .map(removeMarkdownFormatting)
         .map((item) => item.trim());
     if (items.length === 0 || items[0] === '') {
-        throw new ParseError(spaceTrim$1((block) => `
+        throw new ParseError(spaceTrim((block) => `
                         Malformed command:
                         - ${raw}
 
@@ -8799,7 +10912,7 @@ function parseCommand(raw, usagePlace) {
             return command;
         }
     }
-    throw new ParseError(spaceTrim$1((block) => `
+    throw new ParseError(spaceTrim((block) => `
                   Malformed or unknown command:
                   - ${raw}
 
@@ -8850,7 +10963,7 @@ function parseCommandVariant(input) {
                 if (!(error instanceof ParseError)) {
                     throw error;
                 }
-                throw new ParseError(spaceTrim$1((block) => `
+                throw new ParseError(spaceTrim((block) => `
                               Invalid ${commandName} command:
 
                               Your command:
@@ -9124,7 +11237,7 @@ const SUPPORTED_SCRIPT_LANGUAGES = ['javascript', 'typescript', 'python'];
  * @public exported from `@promptbook/markdown-utils`
  */
 function removeMarkdownComments(content) {
-    return spaceTrim$1(content.replace(/<!--(.*?)-->/gs, ''));
+    return spaceTrim(content.replace(/<!--(.*?)-->/gs, ''));
 }
 
 /**
@@ -9135,7 +11248,7 @@ function removeMarkdownComments(content) {
  */
 function isFlatPipeline(pipelineString) {
     pipelineString = removeMarkdownComments(pipelineString);
-    pipelineString = spaceTrim(pipelineString);
+    pipelineString = spaceTrim$1(pipelineString);
     const isMarkdownBeginningWithHeadline = pipelineString.startsWith('# ');
     //const isLastLineReturnStatement = pipelineString.split('\n').pop()!.split('`').join('').startsWith('->');
     const isBacktickBlockUsed = pipelineString.includes('```');
@@ -9173,19 +11286,19 @@ function deflatePipeline(pipelineString) {
         returnStatement = `-> {${DEFAULT_BOOK_OUTPUT_PARAMETER_NAME}}`;
         pipelineStringLines.push(potentialReturnStatement);
     }
-    const prompt = spaceTrim(pipelineStringLines.join('\n'));
+    const prompt = spaceTrim$1(pipelineStringLines.join('\n'));
     let quotedPrompt;
     if (prompt.split('\n').length <= 1) {
         quotedPrompt = `> ${prompt}`;
     }
     else {
-        quotedPrompt = spaceTrim((block) => `
+        quotedPrompt = spaceTrim$1((block) => `
                 \`\`\`
                 ${block(prompt.split('`').join('\\`'))}
                 \`\`\`
             `);
     }
-    pipelineString = validatePipelineString(spaceTrim((block) => `
+    pipelineString = validatePipelineString(spaceTrim$1((block) => `
                 # ${DEFAULT_BOOK_TITLE}
 
                 ## Prompt
@@ -9249,7 +11362,7 @@ function extractAllListItemsFromMarkdown(markdown) {
 function extractOneBlockFromMarkdown(markdown) {
     const codeBlocks = extractAllBlocksFromMarkdown(markdown);
     if (codeBlocks.length !== 1) {
-        throw new ParseError(spaceTrim((block) => `
+        throw new ParseError(spaceTrim$1((block) => `
                     There should be exactly 1 code block in task section, found ${codeBlocks.length} code blocks
 
                     ${block(codeBlocks.map((block, i) => `Block ${i + 1}:\n${block.content}`).join('\n\n\n'))}
@@ -9274,7 +11387,7 @@ function parseMarkdownSection(value) {
     }
     const title = lines[0].replace(/^#+\s*/, '');
     const level = (_b = (_a = lines[0].match(/^#+/)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
-    const content = spaceTrim(lines.slice(1).join('\n'));
+    const content = spaceTrim$1(lines.slice(1).join('\n'));
     if (level < 1 || level > 6) {
         throw new ParseError('Markdown section must have heading level between 1 and 6');
     }
@@ -9302,7 +11415,7 @@ function splitMarkdownIntoSections(markdown) {
         if (buffer.length === 0) {
             return;
         }
-        let section = spaceTrim(buffer.join('\n'));
+        let section = spaceTrim$1(buffer.join('\n'));
         if (section === '') {
             return;
         }
@@ -9377,7 +11490,7 @@ function flattenMarkdown(markdown) {
         flattenedMarkdown += `## ${title}` + `\n\n`;
         flattenedMarkdown += content + `\n\n`; // <- [🧠] Maybe 3 new lines?
     }
-    return spaceTrim(flattenedMarkdown);
+    return spaceTrim$1(flattenedMarkdown);
 }
 /**
  * TODO: [🏛] This can be part of markdown builder
@@ -9439,7 +11552,7 @@ function parsePipeline(pipelineString) {
     if (pipelineString.startsWith('#!')) {
         const [shebangLine, ...restLines] = pipelineString.split('\n');
         if (!(shebangLine || '').includes('ptbk')) {
-            throw new ParseError(spaceTrim$1((block) => `
+            throw new ParseError(spaceTrim((block) => `
                         It seems that you try to parse a book file which has non-standard shebang line for book files:
                         Shebang line must contain 'ptbk'
 
@@ -9455,7 +11568,7 @@ function parsePipeline(pipelineString) {
         pipelineString = validatePipelineString(restLines.join('\n'));
     }
     pipelineString = removeMarkdownComments(pipelineString);
-    pipelineString = spaceTrim$1(pipelineString);
+    pipelineString = spaceTrim(pipelineString);
     // <- TODO: [😧] `spaceTrim` should preserve discriminated type *(or at lease `PipelineString`)*
     pipelineString = deflatePipeline(pipelineString);
     // ==============
@@ -9467,7 +11580,7 @@ function parsePipeline(pipelineString) {
     // ==============
     // Note: 1️⃣◽4️⃣ Check markdown structure
     if (pipelineHead === undefined) {
-        throw new UnexpectedError(spaceTrim$1((block) => `
+        throw new UnexpectedError(spaceTrim((block) => `
                     Pipeline head is not defined
 
                     ${block(getPipelineIdentification())}
@@ -9476,7 +11589,7 @@ function parsePipeline(pipelineString) {
                 `));
     }
     if (pipelineHead.level !== 1) {
-        throw new UnexpectedError(spaceTrim$1((block) => `
+        throw new UnexpectedError(spaceTrim((block) => `
                     Pipeline head is not h1
 
                     ${block(getPipelineIdentification())}
@@ -9485,7 +11598,7 @@ function parsePipeline(pipelineString) {
                 `));
     }
     if (!pipelineSections.every((section) => section.level === 2)) {
-        throw new UnexpectedError(spaceTrim$1((block) => `
+        throw new UnexpectedError(spaceTrim((block) => `
                     Not every pipeline section is h2
 
                     ${block(getPipelineIdentification())}
@@ -9498,7 +11611,7 @@ function parsePipeline(pipelineString) {
     const defineParam = (parameterCommand) => {
         const { parameterName, parameterDescription, isInput, isOutput } = parameterCommand;
         if (RESERVED_PARAMETER_NAMES.includes(parameterName)) {
-            throw new ParseError(spaceTrim$1((block) => `
+            throw new ParseError(spaceTrim((block) => `
                         Parameter name {${parameterName}} is reserved and cannot be used as resulting parameter name
 
                         ${block(getPipelineIdentification())}
@@ -9509,7 +11622,7 @@ function parsePipeline(pipelineString) {
             existingParameter.description &&
             existingParameter.description !== parameterDescription &&
             parameterDescription) {
-            throw new ParseError(spaceTrim$1((block) => `
+            throw new ParseError(spaceTrim((block) => `
                         Parameter \`{${parameterName}}\` is defined multiple times with different description:
 
                         ${block(getPipelineIdentification())}
@@ -9547,7 +11660,7 @@ function parsePipeline(pipelineString) {
     description = description.split(/^>.*$/gm).join('');
     //Note: Remove lists and return statement - TODO: [🎾] Make util  (exported from `@promptbool/utils`)
     description = description.split(/^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm).join('');
-    description = spaceTrim$1(description);
+    description = spaceTrim(description);
     if (description === '') {
         description = undefined;
     }
@@ -9558,7 +11671,7 @@ function parsePipeline(pipelineString) {
         const command = parseCommand(listItem, 'PIPELINE_HEAD');
         const commandParser = getParserForCommand(command);
         if (commandParser.isUsedInPipelineHead !== true /* <- Note: [🦦][4] */) {
-            throw new ParseError(spaceTrim$1((block) => `
+            throw new ParseError(spaceTrim((block) => `
                         Command \`${command.type}\` is not allowed in the head of the pipeline ONLY at the pipeline task
 
                         ${block(getPipelineIdentification())}
@@ -9572,7 +11685,7 @@ function parsePipeline(pipelineString) {
             if (!(error instanceof ParseError)) {
                 throw error;
             }
-            throw new ParseError(spaceTrim$1((block) => `
+            throw new ParseError(spaceTrim((block) => `
                         Command ${command.type} failed to apply to the pipeline
 
                         The error:
@@ -9625,7 +11738,7 @@ function parsePipeline(pipelineString) {
         description = description.split(/^>.*$/gm).join('');
         //Note: Remove lists and return statement - TODO: [🎾]
         description = description.split(/^(?:(?:-)|(?:\d\))|(?:`?->))\s+.*$/gm).join('');
-        description = spaceTrim$1(description);
+        description = spaceTrim(description);
         if (description === '') {
             description = undefined;
         }
@@ -9659,7 +11772,7 @@ function parsePipeline(pipelineString) {
         for (const { listItem, command } of commands) {
             const commandParser = getParserForCommand(command);
             if (commandParser.isUsedInPipelineTask !== true /* <- Note: [🦦][4] */) {
-                throw new ParseError(spaceTrim$1((block) => `
+                throw new ParseError(spaceTrim((block) => `
                             Command \`${command.type}\` is not allowed in the task of the promptbook ONLY at the pipeline head
 
                             ${block(getPipelineIdentification())}
@@ -9674,7 +11787,7 @@ function parsePipeline(pipelineString) {
                 if (!(error instanceof ParseError)) {
                     throw error;
                 }
-                throw new ParseError(spaceTrim$1((block) => `
+                throw new ParseError(spaceTrim((block) => `
                             Command \`${command.type}\` failed to apply to the task
 
                             The error:
@@ -9705,14 +11818,14 @@ function parsePipeline(pipelineString) {
         // TODO: [🍧] Should be done in SECTION command
         if ($taskJson.taskType === 'SCRIPT_TASK') {
             if (!language) {
-                throw new ParseError(spaceTrim$1((block) => `
+                throw new ParseError(spaceTrim((block) => `
                             You must specify the language of the script in the \`SCRIPT\` task
 
                             ${block(getPipelineIdentification())}
                         `));
             }
             if (!SUPPORTED_SCRIPT_LANGUAGES.includes(language)) {
-                throw new ParseError(spaceTrim$1((block) => `
+                throw new ParseError(spaceTrim((block) => `
                             Script language ${language} is not supported.
 
                             Supported languages are:
@@ -9874,7 +11987,7 @@ function addAutoGeneratedSection(content, options) {
     const warningLine = `<!-- ${GENERATOR_WARNING} -->`;
     const sectionRegex = new RegExp(`<!--${sectionName}-->([\\s\\S]*?)<!--/${sectionName}-->`, 'g');
     const sectionMatch = content.match(sectionRegex);
-    const contentToInsert = spaceTrim$1((block) => `
+    const contentToInsert = spaceTrim((block) => `
             <!--${sectionName}-->
             ${block(warningLine)}
             ${block(sectionContent)}
@@ -9887,7 +12000,7 @@ function addAutoGeneratedSection(content, options) {
     const placeForSection = removeMarkdownComments(content).match(/^##.*$/im);
     if (placeForSection !== null) {
         const [heading] = placeForSection;
-        return content.replace(heading, spaceTrim$1((block) => `
+        return content.replace(heading, spaceTrim((block) => `
                     ${block(contentToInsert)}
 
                     ${block(heading)}
@@ -9896,7 +12009,7 @@ function addAutoGeneratedSection(content, options) {
     console.warn(`No place where to put the section <!--${sectionName}-->, using the end of the file`);
     // <- TODO: [🏮] Some standard way how to transform errors into warnings and how to handle non-critical fails during the tasks
     // <- TODO: [🏮] Some better way how to get warnings from pipeline parsing / logic
-    return spaceTrim$1((block) => `
+    return spaceTrim((block) => `
             ${block(content)}
 
             ${block(contentToInsert)}
@@ -9972,7 +12085,7 @@ function renderPromptbookMermaid(pipelineJson, options) {
         .filter(([MERMAID_NAME]) => (inputAndIntermediateParametersMermaid + outputParametersMermaid).includes(MERMAID_NAME))
         .map(([MERMAID_NAME, title]) => `${MERMAID_NAME}((${title})):::${MERMAID_NAME}`)
         .join('\n');
-    const promptbookMermaid = spaceTrim$1((block) => `
+    const promptbookMermaid = spaceTrim((block) => `
 
             %% 🔮 Tip: Open this on GitHub or in the VSCode website to see the Mermaid graph visually
 
@@ -10028,7 +12141,7 @@ async function prettifyPipelineString(pipelineString, options) {
                 return { href: `#${task.name}`, title: task.title };
             },
         });
-        const promptbookMermaidBlock = spaceTrim$1((block) => `
+        const promptbookMermaidBlock = spaceTrim((block) => `
                 \`\`\`mermaid
                 ${block(promptbookMermaid)}
                 \`\`\`
@@ -10066,7 +12179,7 @@ class CallbackInterfaceTools {
     async promptDialog(options) {
         const answer = await this.options.callback(options);
         if (this.options.isVerbose) {
-            console.info(spaceTrim$1((block) => `
+            console.info(spaceTrim((block) => `
                         📖 ${block(options.promptTitle)}
                         👤 ${block(answer)}
                     `));
@@ -10205,7 +12318,7 @@ function countWorkingDuration(items) {
 function executionReportJsonToString(executionReportJson, options) {
     var _a, _b, _c, _d, _e, _f;
     const { taxRate, chartsWidth } = { ...ExecutionReportStringOptionsDefaults, ...(options || {}) };
-    let executionReportString = spaceTrim$1((block) => `
+    let executionReportString = spaceTrim((block) => `
             # ${executionReportJson.title || 'Execution report'}
 
             ${block(executionReportJson.description || '')}
@@ -10327,7 +12440,7 @@ function executionReportJsonToString(executionReportJson, options) {
         if (just(true)) {
             executionReportString +=
                 '\n\n\n\n' +
-                    spaceTrim$1((block) => {
+                    spaceTrim((block) => {
                         var _a;
                         return `
 
@@ -10346,7 +12459,7 @@ function executionReportJsonToString(executionReportJson, options) {
                 executionReportString += '*No result*';
             }
             else if (typeof promptExecution.result.content === 'string') {
-                executionReportString += spaceTrim$1((block) => `
+                executionReportString += spaceTrim((block) => `
                           \`\`\`
                           ${block(escapeMarkdownBlock(promptExecution.result.content))}
                           \`\`\`
@@ -10359,7 +12472,7 @@ function executionReportJsonToString(executionReportJson, options) {
         if (promptExecution.error && promptExecution.error.message) {
             executionReportString +=
                 '\n\n\n\n' +
-                    spaceTrim$1((block) => `
+                    spaceTrim((block) => `
 
                         ### Error
 
@@ -10435,7 +12548,7 @@ function usageToHuman(usage) {
         // Note: For negligible usage, we report at least something
         reportItems.push('Negligible');
     }
-    return spaceTrim((block) => `
+    return spaceTrim$1((block) => `
             Usage:
             ${block(reportItems.map((item) => `- ${item}`).join('\n'))}
         `);
@@ -10680,13 +12793,13 @@ function $registeredLlmToolsMessage() {
     });
     const usedEnvMessage = `Unknown \`.env\` file` ;
     if (metadata.length === 0) {
-        return spaceTrim((block) => `
+        return spaceTrim$1((block) => `
                 No LLM providers are available.
 
                 ${block(usedEnvMessage)}
           `);
     }
-    return spaceTrim((block) => `
+    return spaceTrim$1((block) => `
 
             ${block(usedEnvMessage)}
 
@@ -10732,7 +12845,7 @@ function $registeredLlmToolsMessage() {
                 morePieces.push(`Not configured`); // <- Note: Can not be configured via environment variables
             }
         }
-        let providerMessage = spaceTrim(`
+        let providerMessage = spaceTrim$1(`
                                 ${i + 1}) **${title}** \`${className}\` from \`${packageName}\`
                                     ${morePieces.join('; ')}
                             `);
@@ -10778,7 +12891,7 @@ function createLlmToolsFromConfiguration(configuration, options = {}) {
             .find(({ packageName, className }) => llmConfiguration.packageName === packageName && llmConfiguration.className === className);
         if (registeredItem === undefined) {
             // console.log('$llmToolsRegister.list()', $llmToolsRegister.list());
-            throw new Error(spaceTrim((block) => `
+            throw new Error(spaceTrim$1((block) => `
                         There is no constructor for LLM provider \`${llmConfiguration.className}\` from \`${llmConfiguration.packageName}\`
                         Running in ${!$isRunningInBrowser() ? '' : 'browser environment'}${!$isRunningInNode() ? '' : 'node environment'}${!$isRunningInWebWorker() ? '' : 'worker environment'}
 
@@ -10915,7 +13028,7 @@ function cacheLlmTools(llmTools, options = {}) {
         let normalizedContent = content;
         normalizedContent = normalizedContent.replace(/\s+/g, ' ');
         normalizedContent = normalizedContent.split('\r\n').join('\n');
-        normalizedContent = spaceTrim(normalizedContent);
+        normalizedContent = spaceTrim$1(normalizedContent);
         // Note: Do not need to save everything in the cache, just the relevant parameters
         const relevantParameterNames = extractParameterNames(content);
         const relevantParameters = Object.fromEntries(Object.entries(parameters).filter(([key]) => relevantParameterNames.has(key)));
@@ -11595,7 +13708,7 @@ function isValidPipelineString(pipelineString) {
  */
 function prompt(strings, ...values) {
     if (values.length === 0) {
-        return spaceTrim(strings.join(''));
+        return spaceTrim$1(strings.join(''));
     }
     const stringsWithHiddenParameters = strings.map((stringsItem) => 
     // TODO: [0] DRY
@@ -11606,7 +13719,7 @@ function prompt(strings, ...values) {
     let pipelineString = stringsWithHiddenParameters.reduce((result, stringsItem, i) => placeholderParameterNames[i] === undefined
         ? `${result}${stringsItem}`
         : `${result}${stringsItem}{${placeholderParameterNames[i]}}`, '');
-    pipelineString = spaceTrim(pipelineString);
+    pipelineString = spaceTrim$1(pipelineString);
     try {
         pipelineString = templateParameters(pipelineString, parameters);
     }
@@ -11615,7 +13728,7 @@ function prompt(strings, ...values) {
             throw error;
         }
         console.error({ pipelineString, parameters, placeholderParameterNames, error });
-        throw new UnexpectedError(spaceTrim((block) => `
+        throw new UnexpectedError(spaceTrim$1((block) => `
                     Internal error in prompt template literal
                   
                     ${block(JSON.stringify({ strings, values }, null, 4))}}
@@ -11649,18 +13762,28 @@ function prompt(strings, ...values) {
  * @public exported from `@promptbook/core`
  */
 function book(strings, ...values) {
-    const pipelineString = prompt(strings, ...values);
-    if (!isValidPipelineString(pipelineString)) {
+    const bookString = prompt(strings, ...values);
+    if (!isValidPipelineString(bookString)) {
         // TODO: Make the CustomError for this
-        throw new Error(spaceTrim(`
+        throw new Error(spaceTrim$1(`
                 The string is not a valid pipeline string
 
                 book\`
-                    ${pipelineString}
+                    ${bookString}
                 \`
             `));
     }
-    return pipelineString;
+    if (!isValidBook(bookString)) {
+        // TODO: Make the CustomError for this
+        throw new Error(spaceTrim$1(`
+                The string is not a valid book
+
+                book\`
+                    ${bookString}
+                \`
+            `));
+    }
+    return bookString;
 }
 /**
  * TODO: [🧠][🈴] Where is the best location for this file
@@ -11990,5 +14113,5 @@ class PrefixStorage {
     }
 }
 
-export { $llmToolsMetadataRegister, $llmToolsRegister, $scrapersMetadataRegister, $scrapersRegister, ADMIN_EMAIL, ADMIN_GITHUB_NAME, AbstractFormatError, AuthenticationError, BIG_DATASET_TRESHOLD, BOOK_LANGUAGE_VERSION, BlackholeStorage, BoilerplateError, BoilerplateFormfactorDefinition, CLAIM, CLI_APP_ID, CallbackInterfaceTools, ChatbotFormfactorDefinition, CollectionError, CompletionFormfactorDefinition, CsvFormatError, CsvFormatParser, 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_REQUESTS_PER_MINUTE, DEFAULT_PIPELINE_COLLECTION_BASE_FILENAME, DEFAULT_PROMPT_TASK_TITLE, DEFAULT_REMOTE_SERVER_URL, DEFAULT_SCRAPE_CACHE_DIRNAME, DEFAULT_TASK_TITLE, EXPECTATION_UNITS, EnvironmentMismatchError, ExecutionReportStringOptionsDefaults, ExpectError, FAILED_VALUE_PLACEHOLDER, FORMFACTOR_DEFINITIONS, 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, NotFoundError, NotYetImplementedError, ORDER_OF_PIPELINE_JSON, PENDING_VALUE_PLACEHOLDER, PLAYGROUND_APP_ID, PROMPTBOOK_ENGINE_VERSION, PROMPTBOOK_ERRORS, ParseError, PipelineExecutionError, PipelineLogicError, PipelineUrlError, PrefixStorage, PromptbookFetchError, REMOTE_SERVER_URLS, RESERVED_PARAMETER_NAMES, SET_IS_VERBOSE, SectionTypes, SheetsFormfactorDefinition, TaskTypes, TextFormatParser, TranslatorFormfactorDefinition, UNCERTAIN_USAGE, UNCERTAIN_ZERO_VALUE, UnexpectedError, WrappedError, ZERO_USAGE, ZERO_VALUE, _AnthropicClaudeMetadataRegistration, _AzureOpenAiMetadataRegistration, _BoilerplateScraperMetadataRegistration, _DeepseekMetadataRegistration, _DocumentScraperMetadataRegistration, _GoogleMetadataRegistration, _LegacyDocumentScraperMetadataRegistration, _MarkdownScraperMetadataRegistration, _MarkitdownScraperMetadataRegistration, _OllamaMetadataRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiCompatibleMetadataRegistration, _OpenAiMetadataRegistration, _PdfScraperMetadataRegistration, _WebsiteScraperMetadataRegistration, addUsage, book, cacheLlmTools, collectionToJson, compilePipeline, computeCosineSimilarity, countUsage, createCollectionFromJson, createCollectionFromPromise, createCollectionFromUrl, createLlmToolsFromConfiguration, createPipelineExecutor, createSubcollection, embeddingVectorToString, executionReportJsonToString, extractParameterNamesFromTask, filterModels, getPipelineInterface, identificationToPromptbookToken, isPassingExpectations, isPipelineImplementingInterface, isPipelineInterfacesEqual, isPipelinePrepared, isValidPipelineString, joinLlmExecutionTools, limitTotalUsage, makeKnowledgeSourceHandler, migratePipeline, parsePipeline, pipelineJsonToString, prepareKnowledgePieces, preparePersona, preparePipeline, prettifyPipelineString, promptbookFetch, promptbookTokenToIdentification, unpreparePipeline, usageToHuman, usageToWorktime, validatePipeline, validatePipelineString };
+export { $llmToolsMetadataRegister, $llmToolsRegister, $scrapersMetadataRegister, $scrapersRegister, ADMIN_EMAIL, ADMIN_GITHUB_NAME, AbstractFormatError, AuthenticationError, BIG_DATASET_TRESHOLD, BOOK_LANGUAGE_VERSION, BlackholeStorage, BoilerplateError, BoilerplateFormfactorDefinition, CLAIM, CLI_APP_ID, CallbackInterfaceTools, ChatbotFormfactorDefinition, CollectionError, CompletionFormfactorDefinition, CsvFormatError, CsvFormatParser, 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_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, EXPECTATION_UNITS, EnvironmentMismatchError, ExecutionReportStringOptionsDefaults, ExpectError, FAILED_VALUE_PLACEHOLDER, FORMFACTOR_DEFINITIONS, 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, NotFoundError, NotYetImplementedCommitmentDefinition, NotYetImplementedError, ORDER_OF_PIPELINE_JSON, PENDING_VALUE_PLACEHOLDER, PLAYGROUND_APP_ID, PROMPTBOOK_ENGINE_VERSION, PROMPTBOOK_ERRORS, ParseError, PipelineExecutionError, PipelineLogicError, PipelineUrlError, PrefixStorage, PromptbookFetchError, REMOTE_SERVER_URLS, RESERVED_PARAMETER_NAMES, SET_IS_VERBOSE, SectionTypes, SheetsFormfactorDefinition, TaskTypes, TextFormatParser, TranslatorFormfactorDefinition, UNCERTAIN_USAGE, UNCERTAIN_ZERO_VALUE, UnexpectedError, WrappedError, ZERO_USAGE, ZERO_VALUE, _AnthropicClaudeMetadataRegistration, _AzureOpenAiMetadataRegistration, _BoilerplateScraperMetadataRegistration, _DeepseekMetadataRegistration, _DocumentScraperMetadataRegistration, _GoogleMetadataRegistration, _LegacyDocumentScraperMetadataRegistration, _MarkdownScraperMetadataRegistration, _MarkitdownScraperMetadataRegistration, _OllamaMetadataRegistration, _OpenAiAssistantMetadataRegistration, _OpenAiCompatibleMetadataRegistration, _OpenAiMetadataRegistration, _PdfScraperMetadataRegistration, _WebsiteScraperMetadataRegistration, addUsage, book, cacheLlmTools, collectionToJson, compilePipeline, computeCosineSimilarity, countUsage, createAgentModelRequirements, createBasicAgentModelRequirements, createCollectionFromJson, createCollectionFromPromise, createCollectionFromUrl, createEmptyAgentModelRequirements, createLlmToolsFromConfiguration, createPipelineExecutor, createSubcollection, embeddingVectorToString, executionReportJsonToString, extractParameterNamesFromTask, filterModels, getAllCommitmentDefinitions, getAllCommitmentTypes, getCommitmentDefinition, getPipelineInterface, identificationToPromptbookToken, isCommitmentSupported, isPassingExpectations, isPipelineImplementingInterface, isPipelineInterfacesEqual, isPipelinePrepared, isValidBook, isValidPipelineString, joinLlmExecutionTools, limitTotalUsage, makeKnowledgeSourceHandler, migratePipeline, parseAgentSource, parsePipeline, pipelineJsonToString, prepareKnowledgePieces, preparePersona, preparePipeline, prettifyPipelineString, promptbookFetch, promptbookTokenToIdentification, unpreparePipeline, usageToHuman, usageToWorktime, validateBook, validatePipeline, validatePipelineString };
 //# sourceMappingURL=index.es.js.map