@promptbook/cli 0.112.0-81 → 0.112.0-82

package/src/version.ts

@@ -16,11 +16,11 @@ export const BOOK_LANGUAGE_VERSION: string_semantic_version = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.112.0-81';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.112.0-82';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.112.0-79`).
+ * It follows semantic versioning (e.g., `0.112.0-81`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1123,3 +1123,4 @@
 0.112.0-78
 0.112.0-79
 0.112.0-81
+0.112.0-82

package/umd/index.umd.js

@@ -60,7 +60,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-81';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-82';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -35832,6 +35832,18 @@
      * @private internal constant of `ptbk agents-server`
      */
     const USER_CHAT_JOB_WORKER_POLL_INTERVAL_MS = 2000;
+    /**
+     * Number of identical worker failures suppressed before logging a repeated summary.
+     *
+     * @private internal constant of `ptbk agents-server`
+     */
+    const USER_CHAT_JOB_WORKER_REPEATED_ERROR_LOG_INTERVAL = 10;
+    /**
+     * Maximum worker response body length shown in foreground diagnostics.
+     *
+     * @private internal constant of `ptbk agents-server`
+     */
+    const USER_CHAT_JOB_WORKER_ERROR_BODY_MAX_LENGTH = 2000;
     /**
      * HTTP status used by an idle internal worker tick with no job to process.
      *
@@ -36064,10 +36076,16 @@
             }
             isTickRunning = true;
             triggerUserChatJobWorkerTick(options)
+                .then(() => {
+                clearUserChatJobWorkerError(options.state);
+            })
                 .catch((error) => {
                 const message = error instanceof Error ? error.message : String(error);
-                logRunnerEvent(options.logStreams.runner, `User chat worker tick failed: ${message}`);
-                addUiError(options.state, message);
+                reportUserChatJobWorkerError({
+                    logStream: options.logStreams.runner,
+                    message,
+                    state: options.state,
+                });
             })
                 .finally(() => {
                 isTickRunning = false;
@@ -36089,8 +36107,87 @@
             body: '{}',
         });
         if (!response.ok && response.status !== HTTP_NO_CONTENT_STATUS_CODE) {
-            throw new Error(`Internal user chat worker returned ${response.status} ${response.statusText}.`);
+            const details = await readUserChatJobWorkerErrorDetails(response);
+            throw new Error(createUserChatJobWorkerErrorMessage(response, details));
+        }
+    }
+    /**
+     * Reports worker failures while suppressing identical repeated foreground noise.
+     */
+    function reportUserChatJobWorkerError(options) {
+        const previousError = options.state.lastUserChatJobWorkerError;
+        if ((previousError === null || previousError === void 0 ? void 0 : previousError.message) === options.message) {
+            const repeatCount = previousError.repeatCount + 1;
+            options.state.lastUserChatJobWorkerError = {
+                message: options.message,
+                repeatCount,
+            };
+            if (repeatCount % USER_CHAT_JOB_WORKER_REPEATED_ERROR_LOG_INTERVAL !== 0) {
+                return;
+            }
+            const repeatedMessage = `User chat worker tick is still failing after ${repeatCount} attempts: ${options.message}`;
+            logRunnerEvent(options.logStream, repeatedMessage);
+            addUiError(options.state, repeatedMessage);
+            return;
+        }
+        options.state.lastUserChatJobWorkerError = {
+            message: options.message,
+            repeatCount: 1,
+        };
+        logRunnerEvent(options.logStream, `User chat worker tick failed: ${options.message}`);
+        addUiError(options.state, options.message);
+    }
+    /**
+     * Resets repeated-error suppression after a successful worker tick.
+     */
+    function clearUserChatJobWorkerError(state) {
+        state.lastUserChatJobWorkerError = undefined;
+    }
+    /**
+     * Reads a worker error payload so foreground logs show the route-level reason.
+     */
+    async function readUserChatJobWorkerErrorDetails(response) {
+        const body = await response.text().catch(() => '');
+        const trimmedBody = body.trim();
+        if (!trimmedBody) {
+            return null;
+        }
+        const parsedMessage = parseUserChatJobWorkerErrorMessage(trimmedBody);
+        return truncateUserChatJobWorkerErrorDetails(parsedMessage || trimmedBody);
+    }
+    /**
+     * Extracts a readable error message from the worker route JSON response.
+     */
+    function parseUserChatJobWorkerErrorMessage(body) {
+        try {
+            const parsedBody = JSON.parse(body);
+            const errorMessage = typeof parsedBody.error === 'string' ? parsedBody.error : undefined;
+            const fallbackMessage = typeof parsedBody.message === 'string' ? parsedBody.message : undefined;
+            return errorMessage || fallbackMessage || null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    /**
+     * Builds the foreground worker failure message from HTTP status and route details.
+     */
+    function createUserChatJobWorkerErrorMessage(response, details) {
+        const statusText = response.statusText ? ` ${response.statusText}` : '';
+        const statusMessage = `${response.status}${statusText}`;
+        if (!details) {
+            return `Internal user chat worker returned ${statusMessage}.`;
+        }
+        return `Internal user chat worker returned ${statusMessage}: ${details}`;
+    }
+    /**
+     * Keeps foreground worker diagnostics bounded when a route returns a large payload.
+     */
+    function truncateUserChatJobWorkerErrorDetails(details) {
+        if (details.length <= USER_CHAT_JOB_WORKER_ERROR_BODY_MAX_LENGTH) {
+            return details;
         }
+        return `${details.slice(0, USER_CHAT_JOB_WORKER_ERROR_BODY_MAX_LENGTH)}...`;
     }
     /**
      * Creates file streams for service output persisted below `./logs`.