@promptbook/cli 0.112.0-81 → 0.112.0-84

package/apps/agents-server/src/database/sqlite/resolveAgentsServerSqliteDatabasePath.ts

@@ -0,0 +1,13 @@
+import { isAbsolute, join, resolve } from 'path';
+import { AGENTS_SERVER_SQLITE_PATH_ENV_NAME } from '../agentsServerDatabaseMode';
+
+/**
+ * Resolves the SQLite database path used by the standalone backend.
+ */
+export function resolveAgentsServerSqliteDatabasePath(): string {
+    const configuredPath = process.env[AGENTS_SERVER_SQLITE_PATH_ENV_NAME]?.trim();
+    const fallbackPath = join(process.cwd(), '.promptbook', 'agents-server.sqlite');
+    const databasePath = configuredPath || fallbackPath;
+
+    return isAbsolute(databasePath) ? databasePath : resolve(process.cwd(), databasePath);
+}

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

@@ -1,6 +1,7 @@
 import { NEXT_PUBLIC_SITE_URL, SUPABASE_TABLE_PREFIX } from '@/config';
 import { headers } from 'next/headers';
 import { cache } from 'react';
+import { isAgentsServerSqliteMode } from '../database/agentsServerDatabaseMode';
 import { resolveInternalServerOrigin } from '../utils/resolveInternalServerOrigin';
 import { createServerPublicUrl, listRegisteredServersUsingServiceRole } from '../utils/serverRegistry';
 import { resolveServerSelection } from '../utils/serverSelection';
@@ -35,9 +36,26 @@ const getCachedProvidedServer = cache(async (): Promise<ProvidedServer> => {
     const headersList = await headers();
     const requestHost = headersList.get('host');
     const xPromptbookServer = headersList.get('x-promptbook-server');
+
+    if (isAgentsServerSqliteMode()) {
+        return {
+            id: null,
+            publicUrl: resolveFallbackPublicUrl(requestHost),
+            tablePrefix: SUPABASE_TABLE_PREFIX,
+        };
+    }
+
+    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 +118,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/apps/agents-server/src/utils/serverRegistry.ts

@@ -1,6 +1,7 @@
 import { createClient, type SupabaseClient } from '@supabase/supabase-js';
 import { spaceTrim } from 'spacetrim';
 import { DatabaseError } from '../../../../src/errors/DatabaseError';
+import { isAgentsServerSqliteMode } from '../database/agentsServerDatabaseMode';
 
 /**
  * Supported `_Server.environment` values.
@@ -126,6 +127,10 @@ export async function listRegisteredServers(supabase: Pick<SupabaseClient, 'from
 export async function listRegisteredServersUsingServiceRole(options?: {
     readonly forceRefresh?: boolean;
 }): Promise<Array<ServerRecord>> {
+    if (isAgentsServerSqliteMode()) {
+        return [];
+    }
+
     const shouldReuseCache =
         !options?.forceRefresh &&
         cachedServerRegistry !== null &&
@@ -299,6 +304,14 @@ export function isServerEnvironment(value: string): value is ServerEnvironment {
  * @returns Shared untyped Supabase client.
  */
 export function getServerRegistryClient(): SupabaseClient {
+    if (isAgentsServerSqliteMode()) {
+        throw new DatabaseError(
+            spaceTrim(`
+                Cannot create a Supabase server-registry client while Agents Server is using SQLite.
+            `),
+        );
+    }
+
     if (cachedServerRegistryClient) {
         return cachedServerRegistryClient;
     }

package/apps/agents-server/src/utils/userChat/finalizeUserChatJob.ts

@@ -1,6 +1,10 @@
 import { $getTableName } from '@/src/database/$getTableName';
 import { $provideClientSql } from '@/src/database/$provideClientSql';
+import { isAgentsServerSqliteMode } from '@/src/database/agentsServerDatabaseMode';
+import type { UserChatJobRow } from './UserChatJobRow';
 import type { UserChatJobRecord, UserChatJobStatus } from './UserChatJobRecord';
+import { mapUserChatJobRow } from './mapUserChatJobRow';
+import { provideUserChatJobTable } from './provideUserChatJobTable';
 
 /**
  * Final status values accepted when finishing one durable job.
@@ -17,6 +21,10 @@ export async function finalizeUserChatJob(options: {
     failureReason?: string | null;
     failureDetails?: string | null;
 }): Promise<UserChatJobRecord | null> {
+    if (isAgentsServerSqliteMode()) {
+        return finalizeUserChatJobViaSupabaseQuery(options);
+    }
+
     const nowIso = new Date().toISOString();
     try {
         const sql = await $provideClientSql();
@@ -74,6 +82,40 @@ export async function finalizeUserChatJob(options: {
     }
 }
 
+/**
+ * Persists the final job state through the shared table adapter when PostgreSQL-only raw SQL is unavailable.
+ */
+async function finalizeUserChatJobViaSupabaseQuery(options: {
+    jobId: string;
+    status: FinalUserChatJobStatus;
+    provider?: string | null;
+    failureReason?: string | null;
+    failureDetails?: string | null;
+}): Promise<UserChatJobRecord | null> {
+    const nowIso = new Date().toISOString();
+    const userChatJobTable = await provideUserChatJobTable();
+    const { data, error } = await userChatJobTable
+        .update({
+            status: options.status,
+            updatedAt: nowIso,
+            completedAt: nowIso,
+            lastHeartbeatAt: nowIso,
+            leaseExpiresAt: nowIso,
+            provider: options.provider ?? null,
+            failureReason: options.failureReason ?? null,
+            failureDetails: options.failureDetails ?? null,
+        })
+        .eq('id', options.jobId)
+        .select('*')
+        .maybeSingle();
+
+    if (error) {
+        throw new Error(`Failed to finalize user chat job "${options.jobId}": ${error.message}`);
+    }
+
+    return data ? mapUserChatJobRow(data as UserChatJobRow) : null;
+}
+
 /**
  * Quotes one trusted internal SQL identifier.
  *

package/apps/agents-server/src/utils/userChatTimeout/userChatTimeoutStore/claimNextDueUserChatTimeout.ts

@@ -1,8 +1,10 @@
 import { $provideClientSql } from '@/src/database/$provideClientSql';
+import { isAgentsServerSqliteMode } from '@/src/database/agentsServerDatabaseMode';
 import type { UserChatTimeoutRecord, UserChatTimeoutRow } from '../UserChatTimeoutRecord';
 import { USER_CHAT_TIMEOUT_LEASE_DURATION_MS } from './USER_CHAT_TIMEOUT_LEASE_DURATION_MS';
 import { getUserChatTimeoutTableName } from './getUserChatTimeoutTableName';
 import { mapUserChatTimeoutRow } from './mapUserChatTimeoutRow';
+import { provideUserChatTimeoutTable } from './provideUserChatTimeoutTable';
 import { quoteIdentifier } from './quoteIdentifier';
 import { rethrowUnlessMissingUserChatTimeoutRelation } from './rethrowUnlessMissingUserChatTimeoutRelation';
 
@@ -16,6 +18,10 @@ export async function claimNextDueUserChatTimeout(
         preferredTimeoutId?: string;
     } = {},
 ): Promise<UserChatTimeoutRecord | null> {
+    if (isAgentsServerSqliteMode()) {
+        return claimNextDueUserChatTimeoutViaSupabaseQuery(options);
+    }
+
     const sql = await $provideClientSql();
     const tableIdentifier = quoteIdentifier(await getUserChatTimeoutTableName());
     const values: Array<unknown> = [USER_CHAT_TIMEOUT_LEASE_DURATION_MS];
@@ -60,3 +66,60 @@ export async function claimNextDueUserChatTimeout(
 
     return claimedRows[0] ? mapUserChatTimeoutRow(claimedRows[0]) : null;
 }
+
+/**
+ * Claims a due timeout through the shared table adapter when PostgreSQL-only raw SQL is unavailable.
+ */
+async function claimNextDueUserChatTimeoutViaSupabaseQuery(
+    options: {
+        preferredTimeoutId?: string;
+    } = {},
+): Promise<UserChatTimeoutRecord | null> {
+    const userChatTimeoutTable = await provideUserChatTimeoutTable();
+    const now = new Date();
+    const nowIso = now.toISOString();
+    const leaseExpiresAt = new Date(now.getTime() + USER_CHAT_TIMEOUT_LEASE_DURATION_MS).toISOString();
+    let candidateQuery = userChatTimeoutTable
+        .select('*')
+        .eq('status', 'QUEUED')
+        .is('cancelRequestedAt', null)
+        .is('pausedAt', null)
+        .lte('dueAt', nowIso)
+        .order('dueAt', { ascending: true })
+        .order('createdAt', { ascending: true })
+        .limit(1);
+
+    if (options.preferredTimeoutId) {
+        candidateQuery = candidateQuery.eq('id', options.preferredTimeoutId);
+    }
+
+    const { data: candidates, error: candidateError } = await candidateQuery;
+    if (candidateError) {
+        throw new Error(`Failed to load due user chat timeouts: ${candidateError.message}`);
+    }
+
+    const candidate = (candidates || [])[0] as UserChatTimeoutRow | undefined;
+    if (!candidate) {
+        return null;
+    }
+
+    const { data, error } = await userChatTimeoutTable
+        .update({
+            status: 'RUNNING',
+            updatedAt: nowIso,
+            startedAt: candidate.startedAt || nowIso,
+            leaseExpiresAt,
+            attemptCount: candidate.attemptCount + 1,
+            failureReason: null,
+        })
+        .eq('id', candidate.id)
+        .eq('status', 'QUEUED')
+        .select('*')
+        .maybeSingle();
+
+    if (error) {
+        throw new Error(`Failed to claim user chat timeout "${candidate.id}": ${error.message}`);
+    }
+
+    return data ? mapUserChatTimeoutRow(data as UserChatTimeoutRow) : null;
+}

package/apps/agents-server/src/utils/userChatTimeout/userChatTimeoutStore/recoverExpiredRunningUserChatTimeouts.ts

@@ -1,5 +1,7 @@
 import { $provideClientSql } from '@/src/database/$provideClientSql';
+import { isAgentsServerSqliteMode } from '@/src/database/agentsServerDatabaseMode';
 import { getUserChatTimeoutTableName } from './getUserChatTimeoutTableName';
+import { provideUserChatTimeoutTable } from './provideUserChatTimeoutTable';
 import { quoteIdentifier } from './quoteIdentifier';
 import { rethrowUnlessMissingUserChatTimeoutRelation } from './rethrowUnlessMissingUserChatTimeoutRelation';
 
@@ -9,6 +11,10 @@ import { rethrowUnlessMissingUserChatTimeoutRelation } from './rethrowUnlessMiss
  * @private function of userChatTimeoutStore
  */
 export async function recoverExpiredRunningUserChatTimeouts(): Promise<number> {
+    if (isAgentsServerSqliteMode()) {
+        return recoverExpiredRunningUserChatTimeoutsViaSupabaseQuery();
+    }
+
     const sql = await $provideClientSql();
     const tableIdentifier = quoteIdentifier(await getUserChatTimeoutTableName());
     let recoveredRows: Array<{ id: string }>;
@@ -49,3 +55,44 @@ export async function recoverExpiredRunningUserChatTimeouts(): Promise<number> {
 
     return recoveredRows.length;
 }
+
+/**
+ * Recovers expired timeout leases through the shared table adapter when raw PostgreSQL is unavailable.
+ */
+async function recoverExpiredRunningUserChatTimeoutsViaSupabaseQuery(): Promise<number> {
+    const userChatTimeoutTable = await provideUserChatTimeoutTable();
+    const nowIso = new Date().toISOString();
+    const { data, error } = await userChatTimeoutTable
+        .select('id, cancelRequestedAt, failureReason')
+        .eq('status', 'RUNNING')
+        .not('leaseExpiresAt', 'is', null)
+        .lt('leaseExpiresAt', nowIso);
+
+    if (error) {
+        throw new Error(`Failed to load expired running user chat timeouts: ${error.message}`);
+    }
+
+    let recoveredCount = 0;
+    for (const row of data || []) {
+        const timeoutRow = row as { id: string; cancelRequestedAt: string | null; failureReason: string | null };
+        const isCancelled = timeoutRow.cancelRequestedAt !== null;
+        const updateResult = await userChatTimeoutTable
+            .update({
+                status: isCancelled ? 'CANCELLED' : 'QUEUED',
+                updatedAt: nowIso,
+                startedAt: isCancelled ? undefined : null,
+                completedAt: isCancelled ? nowIso : null,
+                leaseExpiresAt: null,
+                failureReason: isCancelled ? timeoutRow.failureReason || 'Timeout was cancelled.' : timeoutRow.failureReason,
+            })
+            .eq('id', timeoutRow.id);
+
+        if (updateResult.error) {
+            throw new Error(`Failed to recover expired user chat timeout "${timeoutRow.id}": ${updateResult.error.message}`);
+        }
+
+        recoveredCount++;
+    }
+
+    return recoveredCount;
+}

package/apps/agents-server/src/utils/validateApiKey.ts

@@ -1,6 +1,6 @@
-import { createClient } from '@supabase/supabase-js';
 import { NextRequest } from 'next/server';
 import { $getTableName } from '../database/$getTableName';
+import { $provideSupabaseForServer } from '../database/$provideSupabaseForServer';
 
 /**
  * Result of Api key validation.
@@ -56,24 +56,8 @@ export async function validateApiKey(request: NextRequest): Promise<ApiKeyValida
         };
     }
 
-    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
-    const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
-
-    if (!supabaseUrl || !supabaseKey) {
-        console.error('Supabase configuration missing for API key validation');
-        return {
-            isValid: false,
-            error: 'Server configuration error',
-        };
-    }
-
     try {
-        const supabase = createClient(supabaseUrl, supabaseKey, {
-            auth: {
-                persistSession: false,
-                autoRefreshToken: false,
-            },
-        });
+        const supabase = $provideSupabaseForServer();
 
         const { data, error } = await supabase
             .from(await $getTableName(`ApiTokens`))

package/esm/apps/agents-server/src/database/agentsServerDatabaseMode.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Environment variable selecting the Agents Server database backend.
+ */
+export declare const AGENTS_SERVER_DATABASE_ENV_NAME = "PTBK_AGENTS_SERVER_DATABASE";
+/**
+ * Environment variable pointing to the standalone SQLite database file.
+ */
+export declare const AGENTS_SERVER_SQLITE_PATH_ENV_NAME = "PTBK_AGENTS_SERVER_SQLITE_PATH";
+/**
+ * Supported Agents Server database backends.
+ */
+export type AgentsServerDatabaseMode = 'supabase' | 'sqlite';
+/**
+ * Resolves the configured Agents Server database backend.
+ */
+export declare function resolveAgentsServerDatabaseMode(): AgentsServerDatabaseMode;
+/**
+ * Returns whether the Agents Server is using the local SQLite backend.
+ */
+export declare function isAgentsServerSqliteMode(): boolean;

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-84';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2469,9 +2469,11 @@ const AGENTS_SERVER_ENV_DOCUMENTATION_BASE_URL = 'https://github.com/webgptorg/p
  */
 const AGENTS_SERVER_ENV_CREATED_COMMENT = '# Created by `ptbk agents-server init` command';
 /**
- * Variables required for a local Agents Server backed by a Supabase project.
+ * Variables required for a local Agents Server backed by Supabase or standalone SQLite.
  */
 const REQUIRED_AGENTS_SERVER_ENV_VARIABLES = [
+    createAgentsServerEnvVariable('PTBK_AGENTS_SERVER_DATABASE', 'supabase'),
+    createAgentsServerEnvVariable('PTBK_AGENTS_SERVER_SQLITE_PATH', '.promptbook/agents-server.sqlite'),
     createAgentsServerEnvVariable('OPENAI_API_KEY', ''),
     createAgentsServerEnvVariable('POSTGRES_URL', ''),
     createAgentsServerEnvVariable('NEXT_PUBLIC_SUPABASE_URL', ''),
@@ -35830,6 +35832,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.
  *
@@ -35854,6 +35868,18 @@ const AGENTS_SERVER_PROJECT_ENV_FILE_NAME = '.env';
  * @private internal constant of `ptbk agents-server`
  */
 const PTBK_AGENTS_SERVER_AGENT_ROOT_ENV = 'PTBK_AGENTS_SERVER_AGENT_ROOT';
+/**
+ * Public database mode environment name consumed by the Agents Server app.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const PTBK_AGENTS_SERVER_DATABASE_ENV = 'PTBK_AGENTS_SERVER_DATABASE';
+/**
+ * Local SQLite file environment name consumed by the Agents Server app.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const PTBK_AGENTS_SERVER_SQLITE_PATH_ENV = 'PTBK_AGENTS_SERVER_SQLITE_PATH';
 /**
  * Entropy size for the local-only token shared by the CLI pump and the Next app.
  *
@@ -36023,11 +36049,15 @@ function forwardChildOutput(chunk, options) {
  * Creates the subprocess environment for Next and its internal local runner bridge.
  */
 function createAgentsServerChildEnvironment(port, agentRootPath) {
+    const launchWorkingDirectory = process.cwd();
     return {
         ...process.env,
         PORT: String(port),
         NEXT_PUBLIC_SITE_URL: process.env.NEXT_PUBLIC_SITE_URL || `http://localhost:${port}`,
         [PTBK_AGENTS_SERVER_AGENT_ROOT_ENV]: agentRootPath,
+        [PTBK_AGENTS_SERVER_SQLITE_PATH_ENV]: process.env[PTBK_AGENTS_SERVER_SQLITE_PATH_ENV] ||
+            join(launchWorkingDirectory, '.promptbook', 'agents-server.sqlite'),
+        [PTBK_AGENTS_SERVER_DATABASE_ENV]: process.env[PTBK_AGENTS_SERVER_DATABASE_ENV] || 'supabase',
         // Next loads app-local `.env` values after the CLI has prepared this bridge environment.
         PTBK_AGENTS_SERVER_USER_CHAT_WORKER_TOKEN: process.env.PTBK_AGENTS_SERVER_USER_CHAT_WORKER_TOKEN ||
             randomBytes(LOCAL_USER_CHAT_WORKER_TOKEN_BYTE_LENGTH).toString('hex'),
@@ -36062,10 +36092,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 +36123,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`.