@promptbook/legacy-documents 0.100.0-45 → 0.100.0-47

package/esm/typings/src/_packages/components.index.d.ts

@@ -11,6 +11,8 @@ import type { BookEditorProps } from '../book-components/BookEditor/BookEditor';
 import { BookEditor } from '../book-components/BookEditor/BookEditor';
 import { DEFAULT_BOOK_FONT_CLASS } from '../book-components/BookEditor/config';
 import { Chat } from '../book-components/Chat/Chat/Chat';
+import type { ChatMessage } from '../book-components/Chat/interfaces/ChatMessage';
+import type { ChatParticipant } from '../book-components/Chat/interfaces/ChatParticipant';
 export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION };
 export type { AvatarChipProps };
 export { AvatarChip };
@@ -24,3 +26,5 @@ export type { BookEditorProps };
 export { BookEditor };
 export { DEFAULT_BOOK_FONT_CLASS };
 export { Chat };
+export type { ChatMessage };
+export type { ChatParticipant };

package/esm/typings/src/_packages/core.index.d.ts

@@ -49,6 +49,7 @@ import { DEFAULT_IS_AUTO_INSTALLED } from '../config';
 import { DEFAULT_TASK_SIMULATED_DURATION_MS } from '../config';
 import { DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME } from '../config';
 import { DEFAULT_MAX_REQUESTS_PER_MINUTE } from '../config';
+import { API_REQUEST_TIMEOUT } from '../config';
 import { PROMPTBOOK_LOGO_URL } from '../config';
 import { MODEL_TRUST_LEVELS } from '../constants';
 import { MODEL_ORDERS } from '../constants';
@@ -212,6 +213,7 @@ export { DEFAULT_IS_AUTO_INSTALLED };
 export { DEFAULT_TASK_SIMULATED_DURATION_MS };
 export { DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME };
 export { DEFAULT_MAX_REQUESTS_PER_MINUTE };
+export { API_REQUEST_TIMEOUT };
 export { PROMPTBOOK_LOGO_URL };
 export { MODEL_TRUST_LEVELS };
 export { MODEL_ORDERS };

package/esm/typings/src/_packages/types.index.d.ts

@@ -17,9 +17,7 @@ import type { AvatarProfileProps } from '../book-components/AvatarProfile/Avatar
 import type { AvatarProfileFromSourceProps } from '../book-components/AvatarProfile/AvatarProfile/AvatarProfileFromSource';
 import type { BookEditorProps } from '../book-components/BookEditor/BookEditor';
 import type { ChatMessage } from '../book-components/Chat/interfaces/ChatMessage';
-import type { UserChatMessage } from '../book-components/Chat/interfaces/ChatMessage';
-import type { PromptbookPersonaChatMessage } from '../book-components/Chat/interfaces/ChatMessage';
-import type { CompleteChatMessage } from '../book-components/Chat/interfaces/ChatMessage';
+import type { ChatParticipant } from '../book-components/Chat/interfaces/ChatParticipant';
 import type { PipelineCollection } from '../collection/PipelineCollection';
 import type { Command } from '../commands/_common/types/Command';
 import type { CommandParser } from '../commands/_common/types/CommandParser';
@@ -344,9 +342,7 @@ export type { AvatarProfileProps };
 export type { AvatarProfileFromSourceProps };
 export type { BookEditorProps };
 export type { ChatMessage };
-export type { UserChatMessage };
-export type { PromptbookPersonaChatMessage };
-export type { CompleteChatMessage };
+export type { ChatParticipant };
 export type { PipelineCollection };
 export type { Command };
 export type { CommandParser };

package/esm/typings/src/book-2.0/commitments/_misc/AgentModelRequirements.d.ts

@@ -1,4 +1,4 @@
-import { TODO_any } from "../../../_packages/types.index";
+import type { TODO_any } from '../../../utils/organization/TODO_any';
 /**
  * Model requirements for an agent
  *

package/esm/typings/src/book-components/Chat/Chat/Chat.d.ts

@@ -1,6 +1,7 @@
 import type { CSSProperties, ReactNode } from 'react';
 import type { Promisable } from 'type-fest';
 import type { ChatMessage } from '../interfaces/ChatMessage';
+import type { ChatParticipant } from '../interfaces/ChatParticipant';
 /**
  * @deprecated use `isComplete` instead
  * @private util of `<Chat />`
@@ -11,11 +12,11 @@ interface ChatProps {
      * Optional callback to create a new agent from the template.
      * If provided, renders the [Use this template] button.
      */
-    onUseTemplate?: () => void;
+    onUseTemplate?(): void;
     /**
      * Messages to render - they are rendered as they are
      */
-    readonly messages: Array<ChatMessage>;
+    readonly messages: ReadonlyArray<ChatMessage>;
     /**
      * Called every time the user types or dictated a message
      */
@@ -38,10 +39,6 @@ interface ChatProps {
      * The language code to use for voice recognition
      */
     readonly voiceLanguage?: string;
-    /**
-     * Avatars for each user
-     */
-    readonly avatars?: Partial<Record<ChatMessage['from'], string>>;
     /**
      * Optional placeholder message for the textarea
      *
@@ -105,10 +102,7 @@ interface ChatProps {
      * Optional mapping of participant IDs (message.from) to display metadata for exports.
      * Keys should match ChatMessage.from values (e.g., 'USER', 'AGENT_{id}', etc.)
      */
-    readonly participants?: Record<string, {
-        name: string;
-        avatarUrl?: string;
-    }>;
+    readonly participants?: ReadonlyArray<ChatParticipant>;
 }
 /**
  * Renders a chat with messages and input for new messages

package/esm/typings/src/book-components/Chat/interfaces/ChatMessage.d.ts

@@ -1,30 +1,16 @@
-export type ChatMessage = UserChatMessage | PromptbookPersonaChatMessage;
-export interface UserChatMessage {
-    id: string;
-    date: Date;
-    from: 'USER';
-    content: string;
-    isComplete: boolean;
-    expectedAnswer?: string;
-    isVoiceCall?: boolean;
-}
-export interface PromptbookPersonaChatMessage {
+import type { string_markdown } from '../../../types/typeAliases';
+import type { string_name } from '../../../types/typeAliases';
+/**
+ * A message in the chat
+ *
+ * @public exported from `@promptbook/components`
+ */
+export type ChatMessage = {
     id: string;
     date: Date;
-    from: 'PROMPTBOOK_PERSONA';
-    avatar?: string | {
-        src: string;
-        width?: number;
-        height?: number;
-    };
-    content: string;
-    isComplete: boolean;
+    from: string_name;
+    content: string_markdown;
+    isComplete?: boolean;
     expectedAnswer?: string;
     isVoiceCall?: boolean;
-}
-export interface CompleteChatMessage {
-    isComplete: true;
-}
-/**
- * TODO: [🧠] ACRY Rename PROMPTBOOK_PERSONA + USER, Teacher, teacher to sth else
- */
+};

package/esm/typings/src/book-components/Chat/interfaces/ChatParticipant.d.ts

@@ -0,0 +1,30 @@
+import type { string_name } from '../../../types/typeAliases';
+import type { string_person_fullname } from '../../../types/typeAliases';
+import type { string_url_image } from '../../../types/typeAliases';
+/**
+ * A participant in the chat
+ *
+ * @public exported from `@promptbook/components`
+ */
+export type ChatParticipant = {
+    /**
+     * Identifies the participant by their name, same as `message.from`
+     */
+    name: string_name;
+    /**
+     * Full name of the participant
+     */
+    fullname: string_person_fullname;
+    /**
+     * Am I the participant? (i.e. is this the user)
+     */
+    isMe?: boolean;
+    /**
+     * Profile picture
+     */
+    avatarSrc?: string_url_image;
+    /**
+     * Color associated with the participant
+     */
+    color: string;
+};

package/esm/typings/src/book-components/Chat/utils/exportChatHistory.d.ts

@@ -1,11 +1,9 @@
 import type { ChatMessage } from '../interfaces/ChatMessage';
+import type { ChatParticipant } from '../interfaces/ChatParticipant';
 import type { ExportFormat } from './ExportFormat';
 /**
  * Exports chat messages in the specified format
  *
  * @private utility of `<Chat/>` component
  */
-export declare function exportChatHistory(messages: ChatMessage[], format: ExportFormat, headerMarkdown?: string, participants?: Record<string, {
-    name: string;
-    avatarUrl?: string;
-}>): Promise<void>;
+export declare function exportChatHistory(messages: ChatMessage[], format: ExportFormat, headerMarkdown?: string, participants?: ReadonlyArray<ChatParticipant>): Promise<void>;

package/esm/typings/src/book-components/Chat/utils/generatePdfContent.d.ts

@@ -1,10 +1,8 @@
 import type { ChatMessage } from '../interfaces/ChatMessage';
+import type { ChatParticipant } from '../interfaces/ChatParticipant';
 /**
  * Generates PDF content using HTML and triggers print dialog
  *
  * @private utility of `<Chat/>` component
  */
-export declare function generatePdfContent(messages: ChatMessage[], shareUrl: string, qrDataUrl?: string | null, headerMarkdown?: string, participants?: Record<string, {
-    name: string;
-    avatarUrl?: string;
-}>): void;
+export declare function generatePdfContent(messages: ChatMessage[], shareUrl: string, qrDataUrl?: string | null, headerMarkdown?: string, participants?: ReadonlyArray<ChatParticipant>): void;

package/esm/typings/src/book-components/Chat/utils/messagesToHtml.d.ts

@@ -1,10 +1,8 @@
 import type { ChatMessage } from '../interfaces/ChatMessage';
+import type { ChatParticipant } from '../interfaces/ChatParticipant';
 /**
  * Converts chat messages to HTML format
  *
  * @private utility of `<Chat/>` component
  */
-export declare function messagesToHtml(messages: ChatMessage[], shareUrl: string, qrDataUrl?: string | null, headerMarkdown?: string, participants?: Record<string, {
-    name: string;
-    avatarUrl?: string;
-}>): string;
+export declare function messagesToHtml(messages: ChatMessage[], shareUrl: string, qrDataUrl?: string | null, headerMarkdown?: string, participants?: ReadonlyArray<ChatParticipant>): string;

package/esm/typings/src/book-components/Chat/utils/messagesToMarkdown.d.ts

@@ -1,10 +1,8 @@
 import type { ChatMessage } from '../interfaces/ChatMessage';
+import type { ChatParticipant } from '../interfaces/ChatParticipant';
 /**
  * Converts chat messages to Markdown format
  *
  * @private utility of `<Chat/>` component
  */
-export declare function messagesToMarkdown(messages: ChatMessage[], shareUrl: string, qrDataUrl?: string | null, headerMarkdown?: string, participants?: Record<string, {
-    name: string;
-    avatarUrl?: string;
-}>): string;
+export declare function messagesToMarkdown(messages: ChatMessage[], shareUrl: string, qrDataUrl?: string | null, headerMarkdown?: string, participants?: ReadonlyArray<ChatParticipant>): string;

package/esm/typings/src/book-components/Chat/utils/messagesToText.d.ts

@@ -1,10 +1,8 @@
 import type { ChatMessage } from '../interfaces/ChatMessage';
+import type { ChatParticipant } from '../interfaces/ChatParticipant';
 /**
  * Converts chat messages to plain text format
  *
  * @private utility of `<Chat/>` component
  */
-export declare function messagesToText(messages: ChatMessage[], shareUrl: string, headerMarkdown?: string, participants?: Record<string, {
-    name: string;
-    avatarUrl?: string;
-}>): string;
+export declare function messagesToText(messages: ChatMessage[], shareUrl: string, headerMarkdown?: string, participants?: ReadonlyArray<ChatParticipant>): string;

package/esm/typings/src/config.d.ts

@@ -301,6 +301,13 @@ export declare const DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME = "getPipelin
  * @public exported from `@promptbook/core`
  */
 export declare const DEFAULT_MAX_REQUESTS_PER_MINUTE = 60;
+/**
+ * API request timeout in milliseconds
+ * Can be overridden via API_REQUEST_TIMEOUT environment variable
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare const API_REQUEST_TIMEOUT: number;
 /**
  * URL of the Promptbook logo
  *

package/esm/typings/src/execution/ExecutionTask.d.ts

@@ -110,6 +110,14 @@ export type AbstractTask<TTaskResult extends AbstractTaskResult> = {
      * Gets a promise that resolves with the task result
      */
     asPromise(options?: {
+        /**
+         * Do the task throws on error
+         *
+         * - If `true` when error occurs the returned promise will rejects
+         * - If `false` the promise will resolve with object with all listed errors and warnings and partial result
+         *
+         * @default true
+         */
         readonly isCrashedOnError?: boolean;
     }): Promise<TTaskResult>;
     /**

package/esm/typings/src/llm-providers/openai/OpenAiCompatibleExecutionTools.d.ts

@@ -82,6 +82,14 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
      * Default model for completion variant.
      */
     protected abstract getDefaultEmbeddingModel(): AvailableModel;
+    /**
+     * Makes a request with retry logic for network errors like ECONNRESET
+     */
+    private makeRequestWithRetry;
+    /**
+     * Determines if an error is retryable (network-related errors)
+     */
+    private isRetryableNetworkError;
 }
 /**
  * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`

package/esm/typings/src/playground/permanent/error-handling-playground.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+export {};
+/**
+ * Note: [⚫] Code in this file should never be published in any package
+ */

package/esm/typings/src/utils/organization/preserve.d.ts

@@ -0,0 +1,21 @@
+import type { really_any } from './really_any';
+/**
+ * Does nothing, but preserves the function in the bundle
+ * Compiler is tricked into thinking the function is used
+ *
+ * @param value any function to preserve
+ * @returns nothing
+ * @private within the repository
+ */
+export declare function $preserve(...value: Array<really_any>): void;
+/**
+ * DO NOT USE THIS FUNCTION
+ * Only purpose of this function is to trick the compiler and javascript engine
+ * that `_preserved` array can be used in the future and should not be garbage collected
+ *
+ * @private internal for `preserve`
+ */
+export declare function __DO_NOT_USE_getPreserved(): Array<really_any>;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.100.0-44`).
+ * It follows semantic versioning (e.g., `0.100.0-46`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/legacy-documents",
-    "version": "0.100.0-45",
+    "version": "0.100.0-47",
     "description": "Promptbook: Run AI apps in plain human language across multiple models and platforms",
     "private": false,
     "sideEffects": false,
@@ -95,14 +95,13 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/legacy-documents.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.100.0-45"
+        "@promptbook/core": "0.100.0-47"
     },
     "dependencies": {
         "colors": "1.4.0",
         "crypto": "1.0.1",
         "crypto-js": "4.2.0",
         "papaparse": "5.4.1",
-        "prettier": "2.8.1",
         "rxjs": "7.8.1",
         "spacetrim": "0.11.59",
         "waitasecond": "1.11.83"

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs/promises'), require('path'), require('spacetrim'), require('child_process'), require('colors'), require('waitasecond'), require('crypto-js'), require('crypto-js/enc-hex'), require('prettier'), require('prettier/parser-html'), require('crypto'), require('rxjs'), require('crypto-js/sha256'), require('mime-types'), require('papaparse')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'fs/promises', 'path', 'spacetrim', 'child_process', 'colors', 'waitasecond', 'crypto-js', 'crypto-js/enc-hex', 'prettier', 'prettier/parser-html', 'crypto', 'rxjs', 'crypto-js/sha256', 'mime-types', 'papaparse'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-legacy-documents"] = {}, global.promises, global.path, global.spaceTrim, global.child_process, global.colors, global.waitasecond, global.cryptoJs, global.hexEncoder, global.prettier, global.parserHtml, global.crypto, global.rxjs, global.sha256, global.mimeTypes, global.papaparse));
-})(this, (function (exports, promises, path, spaceTrim, child_process, colors, waitasecond, cryptoJs, hexEncoder, prettier, parserHtml, crypto, rxjs, sha256, mimeTypes, papaparse) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs/promises'), require('path'), require('spacetrim'), require('child_process'), require('colors'), require('waitasecond'), require('crypto-js'), require('crypto-js/enc-hex'), require('prettier/parser-html'), require('prettier/parser-markdown'), require('prettier/standalone'), require('crypto'), require('rxjs'), require('crypto-js/sha256'), require('mime-types'), require('papaparse')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'fs/promises', 'path', 'spacetrim', 'child_process', 'colors', 'waitasecond', 'crypto-js', 'crypto-js/enc-hex', 'prettier/parser-html', 'prettier/parser-markdown', 'prettier/standalone', 'crypto', 'rxjs', 'crypto-js/sha256', 'mime-types', 'papaparse'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-legacy-documents"] = {}, global.promises, global.path, global.spaceTrim, global.child_process, global.colors, global.waitasecond, global.cryptoJs, global.hexEncoder, global.parserHtml, global.parserMarkdown, global.standalone, global.crypto, global.rxjs, global.sha256, global.mimeTypes, global.papaparse));
+})(this, (function (exports, promises, path, spaceTrim, child_process, colors, waitasecond, cryptoJs, hexEncoder, parserHtml, parserMarkdown, standalone, crypto, rxjs, sha256, mimeTypes, papaparse) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -10,6 +10,7 @@
     var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
     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
@@ -26,7 +27,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-45';
+    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-47';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -224,6 +225,13 @@
      * @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.
      *
@@ -1215,9 +1223,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,
@@ -3339,7 +3347,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);
@@ -4093,7 +4101,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) {
@@ -6308,64 +6316,74 @@
                 });
             });
         };
-        const pipelineExecutor = (inputParameters) => createTask({
-            taskType: 'EXECUTION',
-            title: pipeline.title,
-            taskProcessCallback(updateOngoingResult, updateTldr) {
-                return pipelineExecutorWithCallback(inputParameters, async (newOngoingResult) => {
-                    var _a;
-                    updateOngoingResult(newOngoingResult);
-                    // Calculate and update tldr based on pipeline progress
-                    const cv = newOngoingResult;
-                    // 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;
+        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;
                         }
-                    }
-                    // 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() - new Date().getTime(); // Will be overridden by actual elapsed time in task
-                        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)`;
-                    }
-                    updateTldr({
-                        percent: percent,
-                        message,
+                        // 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;
     }
@@ -6450,7 +6468,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');
@@ -6474,12 +6494,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(',')