@promptbook/cli 0.112.0-132 → 0.112.0-134

package/apps/agents-server/src/utils/localization/formatServerLanguageHumanReadableDate.ts

@@ -0,0 +1,70 @@
+import moment from 'moment';
+import type { ServerLanguageCode } from '../../languages/ServerLanguageRegistry';
+import { createServerLanguageMoment } from './createServerLanguageMoment';
+
+/**
+ * Default fallback for missing date values.
+ *
+ * @private internal constant of `formatServerLanguageHumanReadableDate`
+ */
+const DEFAULT_FALLBACK_LABEL = 'N/A';
+
+/**
+ * Default localized exact-date format appended when requested.
+ *
+ * @private internal constant of `formatServerLanguageHumanReadableDate`
+ */
+const DEFAULT_EXACT_DATE_FORMAT = 'L LT';
+
+/**
+ * Options for localized human-readable date formatting.
+ *
+ * @private internal type of `formatServerLanguageHumanReadableDate`
+ */
+type FormatServerLanguageHumanReadableDateOptions = {
+    /**
+     * Text returned when the date value is empty.
+     */
+    readonly fallbackLabel?: string;
+
+    /**
+     * Whether to append the localized exact timestamp after the relative label.
+     */
+    readonly isExactDateIncluded?: boolean;
+};
+
+/**
+ * Formats one timestamp for the active Agents Server language.
+ *
+ * @param value - Date-like value, usually an ISO timestamp from the database.
+ * @param language - Active Agents Server language code.
+ * @param options - Formatting options.
+ * @returns Localized relative date label, with optional exact timestamp.
+ * @private internal utility for Agents Server UI.
+ */
+export function formatServerLanguageHumanReadableDate(
+    value: moment.MomentInput | null | undefined,
+    language: ServerLanguageCode,
+    options: FormatServerLanguageHumanReadableDateOptions = {},
+): string {
+    const fallbackLabel = options.fallbackLabel ?? DEFAULT_FALLBACK_LABEL;
+
+    if (value === null || value === undefined || value === '') {
+        return fallbackLabel;
+    }
+
+    const localizedMoment =
+        typeof value === 'string'
+            ? moment(value, moment.ISO_8601, true).locale(language)
+            : createServerLanguageMoment(value, language);
+    if (!localizedMoment.isValid()) {
+        return typeof value === 'string' ? value : fallbackLabel;
+    }
+
+    const relativeLabel = localizedMoment.fromNow();
+    if (!options.isExactDateIncluded) {
+        return relativeLabel;
+    }
+
+    return `${relativeLabel} (${localizedMoment.format(DEFAULT_EXACT_DATE_FORMAT)})`;
+}

package/apps/agents-server/src/utils/localization/getRequestServerLanguage.ts

@@ -0,0 +1,32 @@
+import { cookies } from 'next/headers';
+import { getMetadataMap } from '../../database/getMetadata';
+import {
+    IS_SERVER_LANGUAGE_ENFORCED_METADATA_KEY,
+    parseServerLanguageEnforcedMetadata,
+    resolveServerLanguageCode,
+    SERVER_LANGUAGE_COOKIE_NAME,
+    SERVER_LANGUAGE_METADATA_KEY,
+    type ServerLanguageCode,
+} from '../../languages/ServerLanguageRegistry';
+
+/**
+ * Resolves the active Agents Server UI language for the current server-rendered request.
+ *
+ * @returns Active server language code derived from metadata and the language override cookie.
+ * @private internal utility for server-rendered Agents Server UI.
+ */
+export async function getRequestServerLanguage(): Promise<ServerLanguageCode> {
+    const [metadata, cookieStore] = await Promise.all([
+        getMetadataMap([SERVER_LANGUAGE_METADATA_KEY, IS_SERVER_LANGUAGE_ENFORCED_METADATA_KEY]),
+        cookies(),
+    ]);
+
+    const cookieLanguage = cookieStore.get(SERVER_LANGUAGE_COOKIE_NAME)?.value || null;
+    const rawServerLanguage = metadata[SERVER_LANGUAGE_METADATA_KEY];
+    const isServerLanguageEnforced = parseServerLanguageEnforcedMetadata(
+        metadata[IS_SERVER_LANGUAGE_ENFORCED_METADATA_KEY],
+    );
+    const preferredLanguageSource = isServerLanguageEnforced ? rawServerLanguage : cookieLanguage || rawServerLanguage;
+
+    return resolveServerLanguageCode(preferredLanguageSource);
+}

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

@@ -27,6 +27,7 @@ import type { ChatMessage, ChatPrompt, LlmToolDefinition, ToolCall } from '@prom
 import { resolveTeamInternalAgentAccessToken } from '../../../../../src/commitments/_common/teamInternalAgentAccess';
 import type { ChatPromptResult } from '../../../../../src/execution/PromptResult';
 import { createUserChatMessagePrompt } from './createUserChatMessagePrompt';
+import type { UserChatProgressPhase } from './userChatProgressCard';
 import type { UserChatJobRecord } from './UserChatJobRecord';
 
 /**
@@ -53,6 +54,11 @@ type RunUserChatJobPromptSnapshotFactory = (
     },
 ) => NonNullable<ChatMessage['prompt']>;
 
+/**
+ * Reports one user-facing durable chat progress phase.
+ */
+type RunUserChatJobProgressReporter = (phase: UserChatProgressPhase) => Promise<void>;
+
 /**
  * Prepares the full agent/runtime context required to execute one durable user chat job.
  *
@@ -67,12 +73,18 @@ export async function createRunUserChatJobExecutionContext(options: {
     userMessageAttachments: ChatMessage['attachments'];
     thread: NonNullable<ChatPrompt['thread']>;
     promptContent: ChatPrompt['content'];
+    reportProgress?: RunUserChatJobProgressReporter;
 }) {
+    await options.reportProgress?.('reading_context');
+
     const [localServerUrl, collection, baseAgentReferenceResolver] = await Promise.all([
         resolveCurrentOrInternalServerOrigin(),
         $provideAgentCollectionForServer(),
         $provideAgentReferenceResolver(),
     ]);
+
+    await options.reportProgress?.('preparing_agent');
+
     const resolvedAgentContext = await resolveCachedServerAgentContext({
         collection,
         agentIdentifier: options.job.agentPermanentId,
@@ -91,6 +103,9 @@ export async function createRunUserChatJobExecutionContext(options: {
     const projectRepositories = extractProjectRepositoriesFromAgentSource(agentSource);
     const calendarConnections = extractUseCalendarConnectionsFromAgentSource(agentSource);
     const useEmailConfiguration = extractUseEmailConfigurationFromAgentSource(agentSource);
+
+    await options.reportProgress?.('checking_capabilities');
+
     const { projectGithubToken, calendarGoogleAccessToken, emailSmtpCredential } =
         await resolveRunUserChatJobCredentials({
             userId: options.job.userId,
@@ -164,6 +179,8 @@ export async function createRunUserChatJobExecutionContext(options: {
         });
     }
 
+    await options.reportProgress?.('starting_response');
+
     const agentKitResult = await agentKitCacheManager.getOrCreateAgentKitAgent(
         agentSource,
         resolvedAgentName,

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

@@ -4,7 +4,6 @@ import type { ChatPromptResult } from '../../../../../src/execution/PromptResult
 import { mergeToolCalls } from '../../../../../src/utils/toolCalls/mergeToolCalls';
 import { persistUserChatJobTerminalState } from './persistUserChatJobTerminalState';
 import { updateUserChatAssistantMessage } from './updateUserChatAssistantMessage';
-import { createRunningUserChatProgressCard } from './userChatProgressCard';
 import { USER_CHAT_JOB_ASSISTANT_MESSAGE_PERSIST_INTERVAL_MS } from './userChatJobRuntimeConstants';
 import type { UserChatJobRecord } from './UserChatJobRecord';
 
@@ -45,14 +44,6 @@ export function createRunUserChatJobPersistenceController(options: {
     let hasPendingAssistantMessageUpdate = false;
     let assistantMessageUpdateTimeout: ReturnType<typeof setTimeout> | null = null;
 
-    /**
-     * Creates a typed ISO timestamp for progress-card updates.
-     *
-     * @private function of `createRunUserChatJobPersistenceController`
-     */
-    const createProgressUpdatedAt = (): NonNullable<ChatMessage['progressCard']>['updatedAt'] =>
-        new Date().toISOString() as NonNullable<ChatMessage['progressCard']>['updatedAt'];
-
     /**
      * Queues one assistant-message mutation behind any earlier persistence work.
      *
@@ -141,12 +132,6 @@ export function createRunUserChatJobPersistenceController(options: {
                 lifecycleState: 'running',
                 lifecycleError: undefined,
                 isComplete: false,
-                progressCard: createRunningUserChatProgressCard({
-                    currentProgressCard: message.progressCard,
-                    content: latestContent,
-                    toolCalls: latestToolCalls,
-                    updatedAt: createProgressUpdatedAt(),
-                }),
                 prompt: options.createPromptSnapshot({
                     toolCalls: latestToolCalls,
                 }),
@@ -201,12 +186,6 @@ export function createRunUserChatJobPersistenceController(options: {
                     lifecycleState: 'running',
                     lifecycleError: undefined,
                     isComplete: false,
-                    progressCard: createRunningUserChatProgressCard({
-                        currentProgressCard: message.progressCard,
-                        content: latestContent,
-                        toolCalls: latestToolCalls,
-                        updatedAt: createProgressUpdatedAt(),
-                    }),
                     availableTools: options.availableTools,
                     prompt: options.createPromptSnapshot(),
                 }),

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

@@ -2,6 +2,7 @@ import { $getTableName } from '@/src/database/$getTableName';
 import { $provideClientSql } from '@/src/database/$provideClientSql';
 import { isAgentsServerSqliteMode } from '@/src/database/agentsServerDatabaseMode';
 import { $provideAgentsServerSqliteDatabase } from '@/src/database/sqlite/$provideAgentsServerSqliteDatabase';
+import { ensureLocalSqliteTableReadIndexes } from '@/src/database/sqlite/$provideLocalSqliteSupabase';
 import type { ListUserChatsOptions, UserChatRecord } from './UserChatRecord';
 import type { UserChatSource } from './UserChatSource';
 import type { UserChatRow } from './UserChatRow';
@@ -168,7 +169,10 @@ export async function listUserChatSummarySeeds(options: ListUserChatsOptions): P
  * @private function of `userChat`
  */
 async function listUserChatSummarySeedsViaSqlite(options: ListUserChatsOptions): Promise<Array<UserChatSummarySeed>> {
-    const userChatTableName = quoteIdentifier(await $getTableName('UserChat'));
+    const rawUserChatTableName = await $getTableName('UserChat');
+    ensureLocalSqliteTableReadIndexes(rawUserChatTableName);
+
+    const userChatTableName = quoteIdentifier(rawUserChatTableName);
     const shouldLoadExternalChats = options.viewerIsAdmin && options.includeExternalChats;
     const whereClause = shouldLoadExternalChats
         ? `

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

@@ -0,0 +1,31 @@
+import { createUserChatProgressCard, type UserChatProgressPhase } from './userChatProgressCard';
+import { updateUserChatAssistantMessage } from './updateUserChatAssistantMessage';
+
+/**
+ * Persists one durable chat progress phase onto the active assistant placeholder.
+ */
+export async function persistUserChatJobProgressCard(options: {
+    readonly userId: number;
+    readonly agentPermanentId: string;
+    readonly chatId: string;
+    readonly assistantMessageId: string;
+    readonly phase: UserChatProgressPhase;
+}): Promise<void> {
+    await updateUserChatAssistantMessage({
+        userId: options.userId,
+        agentPermanentId: options.agentPermanentId,
+        chatId: options.chatId,
+        assistantMessageId: options.assistantMessageId,
+        mutateMessage: (message) => {
+            const lifecycleState = options.phase === 'queued' ? 'queued' : 'running';
+
+            return {
+                ...message,
+                lifecycleState,
+                lifecycleError: undefined,
+                isComplete: false,
+                progressCard: createUserChatProgressCard(options.phase),
+            };
+        },
+    });
+}

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

@@ -1,13 +1,11 @@
 import type { UserChatJobRecord } from './UserChatJobRecord';
 import type { UserChatJobRow } from './UserChatJobRow';
 import type { Json } from '@/src/database/schema';
-import type { ChatMessage } from '@promptbook-local/types';
 import { withoutLocalUserChatJobMetadata } from '../localChatRunner/LocalUserChatJobMetadata';
 import { getUserChatJobById } from './getUserChatJobById';
 import { mapUserChatJobRow } from './mapUserChatJobRow';
 import { provideUserChatJobTable } from './provideUserChatJobTable';
 import { updateUserChatAssistantMessage } from './updateUserChatAssistantMessage';
-import { createQueuedUserChatProgressCard } from './userChatProgressCard';
 
 /**
  * Requeues one failed durable chat job and resets its assistant placeholder.
@@ -25,7 +23,6 @@ export async function retryUserChatJob(jobId: string): Promise<UserChatJobRecord
     }
 
     const nowIso = new Date().toISOString();
-    const progressUpdatedAt = nowIso as NonNullable<ChatMessage['progressCard']>['updatedAt'];
     const userChatJobTable = await provideUserChatJobTable();
     const { data, error } = await userChatJobTable
         .update({
@@ -70,7 +67,6 @@ export async function retryUserChatJob(jobId: string): Promise<UserChatJobRecord
             completedToolCalls: undefined,
             prompt: undefined,
             generationDurationMs: undefined,
-            progressCard: createQueuedUserChatProgressCard(progressUpdatedAt),
         }),
     });
 

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

@@ -20,7 +20,9 @@ import { finalizeUserChatJob } from './finalizeUserChatJob';
 import { getUserChat } from './getUserChat';
 import { heartbeatUserChatJob } from './heartbeatUserChatJob';
 import { persistUserChatJobTerminalState } from './persistUserChatJobTerminalState';
+import { persistUserChatJobProgressCard } from './persistUserChatJobProgressCard';
 import type { UserChatJobRecord } from './UserChatJobRecord';
+import type { UserChatProgressPhase } from './userChatProgressCard';
 import { createReplyAwareUserChatPromptContent, createReplyAwareUserChatPromptMessage } from './userChatReplies';
 import { resolvePromptThreadBeforeUserMessage } from './userChatMessageLifecycle';
 import { isUserChatNotFoundScopeError } from './UserChatScopeError';
@@ -107,6 +109,7 @@ export async function runUserChatJob(job: UserChatJobRecord): Promise<RunUserCha
         const executionContext = await createRunUserChatJobExecutionContext({
             job,
             ...startContext,
+            reportProgress: createRunUserChatJobProgressReporter(job),
         });
 
         return await executeRunUserChatJob({
@@ -122,6 +125,32 @@ export async function runUserChatJob(job: UserChatJobRecord): Promise<RunUserCha
     }
 }
 
+/**
+ * Creates a non-critical progress reporter for one durable chat job.
+ *
+ * @private function of `runUserChatJob`
+ */
+function createRunUserChatJobProgressReporter(
+    job: Pick<UserChatJobRecord, 'userId' | 'agentPermanentId' | 'chatId' | 'assistantMessageId' | 'id'>,
+): (phase: UserChatProgressPhase) => Promise<void> {
+    return async (phase) => {
+        await persistUserChatJobProgressCard({
+            userId: job.userId,
+            agentPermanentId: job.agentPermanentId,
+            chatId: job.chatId,
+            assistantMessageId: job.assistantMessageId,
+            phase,
+        }).catch((error) => {
+            console.warn('[user-chat-job] progress_update_failed', {
+                chatId: job.chatId,
+                jobId: job.id,
+                phase,
+                error,
+            });
+        });
+    };
+}
+
 /**
  * Loads and validates the chat/user/message snapshot required before one job can start.
  *

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

@@ -1,5 +1,5 @@
 import type { ChatMessage } from '../../../../../src/_packages/types.index';
-import { createQueuedUserChatProgressCard } from './userChatProgressCard';
+import { createUserChatProgressCard } from './userChatProgressCard';
 
 /**
  * Lifecycle states rendered on canonical server-owned chat messages.
@@ -46,7 +46,7 @@ export function createQueuedUserChatAssistantMessage(options: {
         isComplete: false,
         lifecycleState: 'queued',
         jobId: options.jobId,
-        progressCard: createQueuedUserChatProgressCard(options.createdAt),
+        progressCard: createUserChatProgressCard('queued'),
     };
 }