@promptbook/cli 0.112.0-81 → 0.112.0-82

package/apps/agents-server/src/tools/$provideServer.ts

@@ -35,9 +35,18 @@ const getCachedProvidedServer = cache(async (): Promise<ProvidedServer> => {
     const headersList = await headers();
     const requestHost = headersList.get('host');
     const xPromptbookServer = headersList.get('x-promptbook-server');
+
+    if (isLocalDevelopmentHost(requestHost)) {
+        return {
+            id: null,
+            publicUrl: resolveFallbackPublicUrl(requestHost),
+            tablePrefix: SUPABASE_TABLE_PREFIX,
+        };
+    }
+
     const registeredServers = await listRegisteredServersUsingServiceRole();
 
-    if (registeredServers.length === 0 || isLocalDevelopmentHost(requestHost)) {
+    if (registeredServers.length === 0) {
         return {
             id: null,
             publicUrl: resolveFallbackPublicUrl(requestHost),
@@ -100,5 +109,14 @@ function isLocalDevelopmentHost(host: string | null): boolean {
         return false;
     }
 
-    return host.startsWith('127.0.0.1') || host.startsWith('localhost');
+    const normalizedHost = host.trim().toLowerCase();
+
+    return (
+        normalizedHost === 'localhost' ||
+        normalizedHost.startsWith('localhost:') ||
+        normalizedHost === '127.0.0.1' ||
+        normalizedHost.startsWith('127.0.0.1:') ||
+        normalizedHost === '[::1]' ||
+        normalizedHost.startsWith('[::1]:')
+    );
 }

package/esm/index.es.js

@@ -58,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -35830,6 +35830,18 @@ async function withCurrentWorkingDirectory(directoryPath, callback) {
  * @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.
  *
@@ -36062,10 +36074,16 @@ function startUserChatJobWorkerPump(options) {
         }
         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;
@@ -36087,8 +36105,87 @@ async function triggerUserChatJobWorkerTick(options) {
         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`.