@promptbook/pdf 0.100.0-8 → 0.100.0

package/umd/index.umd.js

@@ -1,14 +1,15 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs/promises'), require('spacetrim'), require('crypto-js'), require('crypto-js/enc-hex'), require('path'), require('prettier'), require('prettier/parser-html'), require('crypto'), require('rxjs'), require('waitasecond'), require('crypto-js/sha256'), require('mime-types'), require('papaparse')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'fs/promises', 'spacetrim', 'crypto-js', 'crypto-js/enc-hex', 'path', 'prettier', 'prettier/parser-html', 'crypto', 'rxjs', 'waitasecond', 'crypto-js/sha256', 'mime-types', 'papaparse'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-pdf"] = {}, global.promises, global.spaceTrim, global.cryptoJs, global.hexEncoder, global.path, global.prettier, global.parserHtml, global.crypto, global.rxjs, global.waitasecond, global.sha256, global.mimeTypes, global.papaparse));
-})(this, (function (exports, promises, spaceTrim, cryptoJs, hexEncoder, path, prettier, parserHtml, crypto, rxjs, waitasecond, sha256, mimeTypes, papaparse) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs/promises'), require('spacetrim'), require('crypto-js'), require('crypto-js/enc-hex'), require('path'), require('prettier/parser-html'), require('prettier/parser-markdown'), require('prettier/standalone'), require('crypto'), require('rxjs'), require('waitasecond'), require('crypto-js/sha256'), require('mime-types'), require('papaparse')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'fs/promises', 'spacetrim', 'crypto-js', 'crypto-js/enc-hex', 'path', 'prettier/parser-html', 'prettier/parser-markdown', 'prettier/standalone', 'crypto', 'rxjs', 'waitasecond', 'crypto-js/sha256', 'mime-types', 'papaparse'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-pdf"] = {}, global.promises, global.spaceTrim, global.cryptoJs, global.hexEncoder, global.path, global.parserHtml, global.parserMarkdown, global.standalone, global.crypto, global.rxjs, global.waitasecond, global.sha256, global.mimeTypes, global.papaparse));
+})(this, (function (exports, promises, spaceTrim, cryptoJs, hexEncoder, path, parserHtml, parserMarkdown, standalone, crypto, rxjs, waitasecond, sha256, mimeTypes, papaparse) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
     var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim);
     var hexEncoder__default = /*#__PURE__*/_interopDefaultLegacy(hexEncoder);
     var parserHtml__default = /*#__PURE__*/_interopDefaultLegacy(parserHtml);
+    var parserMarkdown__default = /*#__PURE__*/_interopDefaultLegacy(parserMarkdown);
     var sha256__default = /*#__PURE__*/_interopDefaultLegacy(sha256);
 
     // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
@@ -25,7 +26,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-8';
+    const PROMPTBOOK_ENGINE_VERSION = '0.100.0';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -217,6 +218,19 @@
      * @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
+    /**
+     * API request timeout in milliseconds
+     * Can be overridden via API_REQUEST_TIMEOUT environment variable
+     *
+     * @public exported from `@promptbook/core`
+     */
+    parseInt(process.env.API_REQUEST_TIMEOUT || '90000');
     /**
      * Indicates whether pipeline logic validation is enabled. When true, the pipeline logic is checked for consistency.
      *
@@ -1031,9 +1045,9 @@
      */
     function prettifyMarkdown(content) {
         try {
-            return prettier.format(content, {
+            return standalone.format(content, {
                 parser: 'markdown',
-                plugins: [parserHtml__default["default"]],
+                plugins: [parserMarkdown__default["default"], parserHtml__default["default"]],
                 // TODO: DRY - make some import or auto-copy of .prettierrc
                 endOfLine: 'lf',
                 tabWidth: 4,
@@ -2535,6 +2549,7 @@
         const errors = [];
         const warnings = [];
         let currentValue = {};
+        let customTldr = null;
         const partialResultSubject = new rxjs.Subject();
         // <- Note: Not using `BehaviorSubject` because on error we can't access the last value
         const finalResultPromise = /* not await */ taskProcessCallback((newOngoingResult) => {
@@ -2545,6 +2560,9 @@
             Object.assign(currentValue, newOngoingResult);
             // <- TODO: assign deep
             partialResultSubject.next(newOngoingResult);
+        }, (tldrInfo) => {
+            customTldr = tldrInfo;
+            updatedAt = new Date();
         });
         finalResultPromise
             .catch((error) => {
@@ -2598,6 +2616,78 @@
                 return status;
                 // <- Note: [1] --||--
             },
+            get tldr() {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                // Use custom tldr if available
+                if (customTldr) {
+                    return customTldr;
+                }
+                // 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] --||--
@@ -2846,6 +2936,76 @@
      * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
      */
 
+    /**
+     * Predefined profiles for LLM providers to maintain consistency across the application
+     * These profiles represent each provider as a virtual persona in chat interfaces
+     *
+     * @private !!!!
+     */
+    const LLM_PROVIDER_PROFILES = {
+        OPENAI: {
+            name: 'OPENAI',
+            fullname: 'OpenAI GPT',
+            color: '#10a37f', // OpenAI's signature green
+            // Note: avatarSrc could be added when we have provider logos available
+        },
+        ANTHROPIC: {
+            name: 'ANTHROPIC',
+            fullname: 'Anthropic Claude',
+            color: '#d97706', // Anthropic's orange/amber color
+        },
+        AZURE_OPENAI: {
+            name: 'AZURE_OPENAI',
+            fullname: 'Azure OpenAI',
+            color: '#0078d4', // Microsoft Azure blue
+        },
+        GOOGLE: {
+            name: 'GOOGLE',
+            fullname: 'Google Gemini',
+            color: '#4285f4', // Google blue
+        },
+        DEEPSEEK: {
+            name: 'DEEPSEEK',
+            fullname: 'DeepSeek',
+            color: '#7c3aed', // Purple color for DeepSeek
+        },
+        OLLAMA: {
+            name: 'OLLAMA',
+            fullname: 'Ollama',
+            color: '#059669', // Emerald green for local models
+        },
+        REMOTE: {
+            name: 'REMOTE',
+            fullname: 'Remote Server',
+            color: '#6b7280', // Gray for remote/proxy connections
+        },
+        MOCKED_ECHO: {
+            name: 'MOCKED_ECHO',
+            fullname: 'Echo (Test)',
+            color: '#8b5cf6', // Purple for test/mock tools
+        },
+        MOCKED_FAKE: {
+            name: 'MOCKED_FAKE',
+            fullname: 'Fake LLM (Test)',
+            color: '#ec4899', // Pink for fake/test tools
+        },
+        VERCEL: {
+            name: 'VERCEL',
+            fullname: 'Vercel AI',
+            color: '#000000', // Vercel's black
+        },
+        MULTIPLE: {
+            name: 'MULTIPLE',
+            fullname: 'Multiple Providers',
+            color: '#6366f1', // Indigo for combined/multiple providers
+        },
+    };
+    /**
+     * TODO: Refactor this - each profile must be alongside the provider definition
+     * TODO: Unite `AvatarProfileProps` and `ChatParticipant`
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
     /**
      * Multiple LLM Execution Tools is a proxy server that uses multiple execution tools internally and exposes the executor interface externally.
      *
@@ -2871,7 +3031,7 @@
                 }
                 return spaceTrim__default["default"]((block) => `
                         ${headLine}
-                        
+
                           ${ /* <- Note: Indenting the description: */block(description)}
                     `);
             })
@@ -2882,6 +3042,9 @@
                 ${block(innerModelsTitlesAndDescriptions)}
             `);
         }
+        get profile() {
+            return LLM_PROVIDER_PROFILES.MULTIPLE;
+        }
         /**
          * Check the configuration of all execution tools
          */
@@ -2926,25 +3089,22 @@
             const errors = [];
             llm: for (const llmExecutionTools of this.llmExecutionTools) {
                 try {
-                    variant: switch (prompt.modelRequirements.modelVariant) {
+                    switch (prompt.modelRequirements.modelVariant) {
                         case 'CHAT':
                             if (llmExecutionTools.callChatModel === undefined) {
                                 continue llm;
                             }
                             return await llmExecutionTools.callChatModel(prompt);
-                            break variant;
                         case 'COMPLETION':
                             if (llmExecutionTools.callCompletionModel === undefined) {
                                 continue llm;
                             }
                             return await llmExecutionTools.callCompletionModel(prompt);
-                            break variant;
                         case 'EMBEDDING':
                             if (llmExecutionTools.callEmbeddingModel === undefined) {
                                 continue llm;
                             }
                             return await llmExecutionTools.callEmbeddingModel(prompt);
-                            break variant;
                         // <- case [🤖]:
                         default:
                             throw new UnexpectedError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
@@ -3097,7 +3257,7 @@
         const result = await preparePersonaExecutor({
             availableModels /* <- Note: Passing as JSON */,
             personaDescription,
-        }).asPromise();
+        }).asPromise({ isCrashedOnError: true });
         const { outputParameters } = result;
         const { modelsRequirements: modelsRequirementsJson } = outputParameters;
         let modelsRequirementsUnchecked = jsonParse(modelsRequirementsJson);
@@ -3861,7 +4021,7 @@
             });
             const result = await prepareTitleExecutor({
                 book: sources.map(({ content }) => content).join('\n\n'),
-            }).asPromise();
+            }).asPromise({ isCrashedOnError: true });
             const { outputParameters } = result;
             const { title: titleRaw } = outputParameters;
             if (isVerbose) {
@@ -4955,7 +5115,7 @@
      */
     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,
@@ -5199,6 +5359,10 @@
                     result: $ongoingTaskResult.$resultString,
                     error: error,
                 });
+                // Report failed attempt
+                onProgress({
+                    errors: [error],
+                });
             }
             finally {
                 if (!isJokerAttempt &&
@@ -6072,15 +6236,74 @@
                 });
             });
         };
-        const pipelineExecutor = (inputParameters) => createTask({
-            taskType: 'EXECUTION',
-            title: pipeline.title,
-            taskProcessCallback(updateOngoingResult) {
-                return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
-                    updateOngoingResult(newOngoingResult);
-                });
-            },
-        });
+        const pipelineExecutor = (inputParameters) => {
+            const startTime = new Date().getTime();
+            return createTask({
+                taskType: 'EXECUTION',
+                title: pipeline.title,
+                taskProcessCallback(updateOngoingResult, updateTldr) {
+                    return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
+                        var _a, _b;
+                        updateOngoingResult(newOngoingResult);
+                        // Calculate and update tldr based on pipeline progress
+                        const cv = newOngoingResult;
+                        // Calculate progress based on parameters resolved vs total parameters
+                        const totalParameters = pipeline.parameters.filter(p => !p.isInput).length;
+                        let resolvedParameters = 0;
+                        let currentTaskTitle = '';
+                        // Get the resolved parameters from output parameters
+                        if (cv === null || cv === void 0 ? void 0 : cv.outputParameters) {
+                            // Count how many output parameters have non-empty values
+                            resolvedParameters = Object.values(cv.outputParameters).filter(value => value !== undefined && value !== null && String(value).trim() !== '').length;
+                        }
+                        // Try to determine current task from execution report
+                        if (((_a = cv === null || cv === void 0 ? void 0 : cv.executionReport) === null || _a === void 0 ? void 0 : _a.promptExecutions) && cv.executionReport.promptExecutions.length > 0) {
+                            const lastExecution = cv.executionReport.promptExecutions[cv.executionReport.promptExecutions.length - 1];
+                            if ((_b = lastExecution === null || lastExecution === void 0 ? void 0 : lastExecution.prompt) === null || _b === void 0 ? void 0 : _b.title) {
+                                currentTaskTitle = lastExecution.prompt.title;
+                            }
+                        }
+                        // Calculate base progress percentage
+                        let percent = totalParameters > 0 ? resolvedParameters / totalParameters : 0;
+                        // Add time-based progress for current task if we haven't completed all parameters
+                        if (resolvedParameters < totalParameters) {
+                            const elapsedMs = new Date().getTime() - startTime;
+                            const estimatedTotalMs = totalParameters * 30 * 1000; // Estimate 30 seconds per parameter
+                            const timeProgress = Math.min(elapsedMs / estimatedTotalMs, 0.9); // Cap at 90% for time-based progress
+                            // If we have time progress but no parameter progress, show time progress
+                            if (percent === 0 && timeProgress > 0) {
+                                percent = Math.min(timeProgress, 0.1); // Show some progress but not more than 10%
+                            }
+                            else if (percent < 1) {
+                                // Add partial progress for current task
+                                const taskProgress = totalParameters > 0 ? (1 / totalParameters) * 0.5 : 0; // 50% of task progress
+                                percent = Math.min(percent + taskProgress, 0.95); // Cap at 95% until fully complete
+                            }
+                        }
+                        // Clamp to [0,1]
+                        percent = Math.min(Math.max(percent, 0), 1);
+                        // Generate message
+                        let message = '';
+                        if (currentTaskTitle) {
+                            message = `Executing: ${currentTaskTitle}`;
+                        }
+                        else if (resolvedParameters === 0) {
+                            message = 'Starting pipeline execution';
+                        }
+                        else if (resolvedParameters < totalParameters) {
+                            message = `Processing pipeline (${resolvedParameters}/${totalParameters} parameters resolved)`;
+                        }
+                        else {
+                            message = 'Completing pipeline execution';
+                        }
+                        updateTldr({
+                            percent: percent,
+                            message,
+                        });
+                    });
+                },
+            });
+        };
         //        <- TODO: Make types such as there is no need to do `as` for `createTask`
         return pipelineExecutor;
     }
@@ -6165,7 +6388,9 @@
                 },
             });
             const knowledgeContent = await source.asText();
-            const result = await prepareKnowledgeFromMarkdownExecutor({ knowledgeContent }).asPromise();
+            const result = await prepareKnowledgeFromMarkdownExecutor({ knowledgeContent }).asPromise({
+                isCrashedOnError: true,
+            });
             const { outputParameters } = result;
             const { knowledgePieces: knowledgePiecesRaw } = outputParameters;
             const knowledgeTextPieces = (knowledgePiecesRaw || '').split('\n---\n');
@@ -6189,12 +6414,16 @@
               ];
               */
                 try {
-                    const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise();
+                    const titleResult = await prepareTitleExecutor({ knowledgePieceContent }).asPromise({
+                        isCrashedOnError: true,
+                    });
                     const { title: titleRaw = 'Untitled' } = titleResult.outputParameters;
                     title = spaceTrim__default["default"](titleRaw) /* <- TODO: Maybe do in pipeline */;
                     name = titleToName(title);
                     // --- Keywords
-                    const keywordsResult = await prepareKeywordsExecutor({ knowledgePieceContent }).asPromise();
+                    const keywordsResult = await prepareKeywordsExecutor({ knowledgePieceContent }).asPromise({
+                        isCrashedOnError: true,
+                    });
                     const { keywords: keywordsRaw = '' } = keywordsResult.outputParameters;
                     keywords = (keywordsRaw || '')
                         .split(',')