@promptbook/cli 0.113.0-9 → 0.114.0-0

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

@@ -0,0 +1,152 @@
+import { after } from 'next/server';
+import { cancelScheduledUserChatTimeout, getUserChatTimeoutById } from '@/src/utils/userChatTimeout';
+import {
+    getUserChatJobById,
+    persistUserChatJobTerminalState,
+    requestUserChatJobCancellation,
+    triggerUserChatJobWorker,
+} from '@/src/utils/userChat';
+import { runWithRegisteredServerContext } from '../tools/mapRegisteredServerContexts';
+
+/**
+ * Outcome of one admin-requested cancellation of a durable chat task.
+ *
+ * - `CANCELLED` — the task was queued/running and its cancellation was requested.
+ * - `ALREADY_FINISHED` — the task exists but already reached a terminal state.
+ * - `NOT_CANCELLABLE` — the task exists but its cancellation could not be persisted.
+ * - `NOT_FOUND` — no durable chat job or timeout matched the id.
+ *
+ * @private internal admin utility of Agents Server
+ */
+export type CancelAdminChatTaskOutcome = 'CANCELLED' | 'ALREADY_FINISHED' | 'NOT_CANCELLABLE' | 'NOT_FOUND';
+
+/**
+ * Inputs required to cancel one durable chat task on behalf of an administrator.
+ *
+ * @private internal admin utility of Agents Server
+ */
+export type CancelAdminChatTaskByIdOptions = {
+    /**
+     * Global id of the durable chat job or timeout to cancel.
+     */
+    taskId: string;
+
+    /**
+     * Human-readable actor recorded in the cancellation audit log.
+     */
+    actor: string;
+
+    /**
+     * Required operator-supplied reason recorded in the cancellation audit log.
+     */
+    reason: string;
+
+    /**
+     * Request origin used to wake the durable chat worker for running jobs.
+     */
+    requestOrigin: string;
+
+    /**
+     * Owning server domain for a VPS-wide task action.
+     */
+    serverDomain?: string | null;
+};
+
+/**
+ * Requests admin cancellation for one queued or running durable chat task.
+ *
+ * The function resolves the task as either a durable chat-completion job or a scheduled chat
+ * timeout, mirrors the single-task admin cancel semantics (immediately finalizing queued jobs
+ * and waking the worker for running jobs), and reports the resulting outcome to the caller.
+ *
+ * @param options - Task id, audit metadata, and request origin.
+ * @returns The cancellation outcome for the resolved task.
+ * @private internal admin utility of Agents Server
+ */
+export async function cancelAdminChatTaskById(options: CancelAdminChatTaskByIdOptions): Promise<CancelAdminChatTaskOutcome> {
+    if (options.serverDomain) {
+        const result = await runWithRegisteredServerContext(options.serverDomain, () =>
+            cancelAdminChatTaskByIdInCurrentServer(options),
+        );
+        return result ?? 'NOT_FOUND';
+    }
+
+    return cancelAdminChatTaskByIdInCurrentServer(options);
+}
+
+/**
+ * Requests cancellation against the server context already active for the current operation.
+ *
+ * @param options - Task id, audit metadata, and request origin.
+ * @returns The cancellation outcome for the resolved task.
+ *
+ * @private function of `cancelAdminChatTaskById`
+ */
+async function cancelAdminChatTaskByIdInCurrentServer(
+    options: CancelAdminChatTaskByIdOptions,
+): Promise<CancelAdminChatTaskOutcome> {
+    const { taskId, actor, reason, requestOrigin } = options;
+    const job = await getUserChatJobById(taskId);
+
+    if (job) {
+        if (job.status === 'COMPLETED' || job.status === 'FAILED' || job.status === 'CANCELLED') {
+            return 'ALREADY_FINISHED';
+        }
+
+        console.info('[admin-chat-task] cancel', {
+            actor,
+            taskId,
+            reason,
+            kind: 'CHAT_COMPLETION',
+            status: job.status,
+        });
+
+        const cancellationRequestedJob = await requestUserChatJobCancellation(taskId);
+        if (!cancellationRequestedJob) {
+            return 'NOT_CANCELLABLE';
+        }
+
+        if (job.status === 'QUEUED') {
+            await persistUserChatJobTerminalState({
+                job: cancellationRequestedJob,
+                status: 'CANCELLED',
+                failureReason: 'Chat generation was cancelled by an administrator before it started.',
+            });
+        } else {
+            after(() =>
+                triggerUserChatJobWorker({
+                    origin: requestOrigin,
+                    preferredJobId: taskId,
+                }).catch((error) =>
+                    console.error('[admin-chat-task] failed to wake worker after cancellation request', error),
+                ),
+            );
+        }
+
+        return 'CANCELLED';
+    }
+
+    const timeout = await getUserChatTimeoutById(taskId);
+    if (!timeout) {
+        return 'NOT_FOUND';
+    }
+
+    if (timeout.status === 'COMPLETED' || timeout.status === 'FAILED' || timeout.status === 'CANCELLED') {
+        return 'ALREADY_FINISHED';
+    }
+
+    console.info('[admin-chat-task] cancel', {
+        actor,
+        taskId,
+        reason,
+        kind: 'CHAT_TIMEOUT',
+        status: timeout.status,
+    });
+
+    const cancelledTimeout = await cancelScheduledUserChatTimeout(taskId);
+    if (!cancelledTimeout) {
+        return 'NOT_CANCELLABLE';
+    }
+
+    return 'CANCELLED';
+}

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

@@ -0,0 +1,199 @@
+import { cancelAdminChatTaskById } from '@/src/utils/cancelAdminChatTaskById';
+import { getAdminChatTasks } from '@/src/utils/getAdminChatTasksResponse/getAdminChatTasks';
+import { getVpsAdminChatTasksResponse } from '@/src/utils/getVpsAdminChatTasksResponse';
+import type { AdminChatTaskRecord } from '@/src/utils/chatTasksAdmin';
+import type { ParsedAdminChatTaskQuery } from '@/src/utils/getAdminChatTasksResponse/parseAdminChatTaskQuery';
+
+/**
+ * Number of active task rows loaded per page while collecting bulk cancellation targets.
+ *
+ * @private internal constant of `cancelAllActiveAdminChatTasks`
+ */
+const BULK_ADMIN_CHAT_TASK_PAGE_SIZE = 200;
+
+/**
+ * Hard cap for one bulk cancellation run.
+ *
+ * The cap protects runtime latency and prevents one admin action from cancelling an unbounded
+ * number of tasks in a single request.
+ *
+ * @private internal constant of `cancelAllActiveAdminChatTasks`
+ */
+const MAX_BULK_ADMIN_CHAT_TASK_CANCEL_TARGETS = 2_000;
+
+/**
+ * Summary returned after bulk-cancelling every active durable chat task.
+ *
+ * @private internal admin utility of Agents Server
+ */
+export type CancelAllActiveAdminChatTasksSummary = {
+    /**
+     * Number of active tasks that were selected for cancellation.
+     */
+    matchedCount: number;
+
+    /**
+     * Number of tasks whose cancellation was actually requested.
+     */
+    cancelledCount: number;
+
+    /**
+     * Whether more active tasks existed than the per-run cap allowed to cancel.
+     */
+    hasMore: boolean;
+};
+
+/**
+ * Inputs required to bulk-cancel every active durable chat task on behalf of an administrator.
+ *
+ * @private internal admin utility of Agents Server
+ */
+export type CancelAllActiveAdminChatTasksOptions = {
+    /**
+     * Human-readable actor recorded in the cancellation audit log.
+     */
+    actor: string;
+
+    /**
+     * Required operator-supplied reason recorded in the cancellation audit log.
+     */
+    reason: string;
+
+    /**
+     * Request origin used to wake the durable chat worker for running jobs.
+     */
+    requestOrigin: string;
+
+    /**
+     * Whether active tasks should be collected across every registered server on the VPS.
+     */
+    isVpsWide?: boolean;
+};
+
+/**
+ * Cancels every active (queued or running) durable chat task across all users.
+ *
+ * The active task ids are collected up front so cancellations do not shift the pagination window,
+ * then each task is cancelled by reusing the single-task admin cancellation flow.
+ *
+ * @param options - Audit metadata and request origin.
+ * @returns Summary counters describing how many active tasks were matched and cancelled.
+ * @private internal admin utility of Agents Server
+ */
+export async function cancelAllActiveAdminChatTasks(
+    options: CancelAllActiveAdminChatTasksOptions,
+): Promise<CancelAllActiveAdminChatTasksSummary> {
+    const collectedActiveTasks = await collectActiveAdminChatTasks(options.isVpsWide ?? false);
+    let cancelledCount = 0;
+
+    for (const task of collectedActiveTasks.tasks) {
+        const outcome = await cancelAdminChatTaskById({
+            taskId: task.id,
+            actor: options.actor,
+            reason: options.reason,
+            requestOrigin: options.requestOrigin,
+            serverDomain: task.serverDomain,
+        });
+
+        if (outcome === 'CANCELLED') {
+            cancelledCount += 1;
+        }
+    }
+
+    return {
+        matchedCount: collectedActiveTasks.tasks.length,
+        cancelledCount,
+        hasMore: collectedActiveTasks.hasMore,
+    };
+}
+
+/**
+ * Collects one bounded snapshot of active durable chat tasks for bulk cancellation.
+ *
+ * @returns The collected tasks and whether the per-run cap truncated them.
+ * @private function of `cancelAllActiveAdminChatTasks`
+ */
+async function collectActiveAdminChatTasks(isVpsWide: boolean): Promise<{
+    tasks: Array<AdminChatTaskRecord>;
+    hasMore: boolean;
+}> {
+    const collectedTasks: Array<AdminChatTaskRecord> = [];
+    let page = 1;
+    let totalActiveTaskCount = 0;
+
+    while (collectedTasks.length < MAX_BULK_ADMIN_CHAT_TASK_CANCEL_TARGETS) {
+        const activeTasks = isVpsWide
+            ? await getVpsAdminChatTasksResponse(createActiveAdminChatTaskSearchParams(page))
+            : {
+                  status: 200 as const,
+                  response: {
+                      ...(await getAdminChatTasks(createActiveAdminChatTaskQuery(page))),
+                      generatedAt: new Date().toISOString(),
+                  },
+              };
+
+        if (activeTasks.status !== 200) {
+            break;
+        }
+
+        const activeTaskPage = activeTasks.response;
+        totalActiveTaskCount = activeTaskPage.total;
+
+        if (activeTaskPage.items.length === 0) {
+            break;
+        }
+
+        collectedTasks.push(...activeTaskPage.items);
+
+        if (collectedTasks.length >= totalActiveTaskCount) {
+            break;
+        }
+
+        page += 1;
+    }
+
+    const cappedTasks = collectedTasks.slice(0, MAX_BULK_ADMIN_CHAT_TASK_CANCEL_TARGETS);
+
+    return {
+        tasks: cappedTasks,
+        hasMore: totalActiveTaskCount > cappedTasks.length,
+    };
+}
+
+/**
+ * Converts the normalized active-task query into the URL-search format used by the VPS listing.
+ *
+ * @param page - One-based page number.
+ * @returns Search parameters for the VPS-wide task listing.
+ *
+ * @private function of `cancelAllActiveAdminChatTasks`
+ */
+function createActiveAdminChatTaskSearchParams(page: number): URLSearchParams {
+    const searchParams = new URLSearchParams();
+    const query = createActiveAdminChatTaskQuery(page);
+
+    for (const [key, value] of Object.entries(query)) {
+        searchParams.set(key, String(value));
+    }
+
+    return searchParams;
+}
+
+/**
+ * Builds the admin task query used to page through active durable chat tasks.
+ *
+ * @param page - One-based page number to load.
+ * @returns Parsed admin task query scoped to the active view.
+ * @private function of `cancelAllActiveAdminChatTasks`
+ */
+function createActiveAdminChatTaskQuery(page: number): ParsedAdminChatTaskQuery {
+    return {
+        page,
+        pageSize: BULK_ADMIN_CHAT_TASK_PAGE_SIZE,
+        view: 'active',
+        search: '',
+        sortBy: 'default',
+        sortOrder: 'desc',
+        timeWindowHours: 24,
+    };
+}

package/apps/agents-server/src/utils/chat/createChatHistoryRecorder.ts

@@ -23,7 +23,7 @@ type ChatHistoryInsertError = {
 /**
  * Source value for chat-history records.
  */
-export type ChatHistorySource = NonNullable<ChatHistoryInsert['source']>;
+export type ChatHistorySource = NonNullable<ChatHistoryInsert['source']> | 'EMAIL';
 
 /**
  * Actor type value for chat-history records.
@@ -35,9 +35,12 @@ export type ChatHistoryActorType = NonNullable<ChatHistoryInsert['actorType']>;
  */
 export type CreateChatHistoryRecorderOptions = {
     /**
-     * HTTP request that carries telemetry headers and URL.
+     * Optional HTTP request that carries telemetry headers and URL.
+     *
+     * Server-side callers (for example durable chat-job workers) have no request,
+     * telemetry columns stay `null` for them.
      */
-    request: Request;
+    request?: Request | null;
     /**
      * Agent route identifier (`agentName` or `permanentId`).
      */
@@ -62,6 +65,10 @@ export type CreateChatHistoryRecorderOptions = {
      * Optional database user id responsible for the call.
      */
     userId?: number | null;
+    /**
+     * Optional id of the canonical `UserChat` the recorded messages belong to.
+     */
+    chatId?: string | null;
     /**
      * When false, recorder computes hashes but skips DB writes.
      */
@@ -84,6 +91,10 @@ export type RecordChatHistoryMessageOptions = {
      * Optional usage tracking statistics.
      */
     usage?: ChatHistoryInsert['usage'];
+    /**
+     * Optional id of the durable chat-completion task (`UserChatJob`) linked to this message.
+     */
+    taskId?: string | null;
 };
 
 /**
@@ -94,7 +105,7 @@ export type RecordChatHistoryMessage = (options: RecordChatHistoryMessageOptions
 /**
  * Optional columns that may be missing on partially migrated databases.
  */
-const CHAT_HISTORY_OPTIONAL_COLUMNS = ['source', 'apiKey', 'actorType', 'usage', 'userId'] as const;
+const CHAT_HISTORY_OPTIONAL_COLUMNS = ['source', 'apiKey', 'actorType', 'usage', 'userId', 'chatId', 'taskId'] as const;
 
 /**
  * Optional chat-history columns that may be unavailable before migrations are applied.
@@ -108,26 +119,32 @@ export async function createChatHistoryRecorder(
     options: CreateChatHistoryRecorderOptions,
 ): Promise<RecordChatHistoryMessage> {
     const {
-        request,
+        request = null,
         agentIdentifier,
         agentHash,
         source,
         apiKey = null,
         actorType,
         userId = null,
+        chatId = null,
         isEnabled = true,
     } = options;
     const supabase = $provideSupabaseForServer();
     const tableName = await $getTableName('ChatHistory');
-    const userAgent = request.headers.get('user-agent');
-    const ip = resolveIpAddress(request);
-    const language = request.headers.get('accept-language');
+    const userAgent = request ? request.headers.get('user-agent') : null;
+    const ip = request ? resolveIpAddress(request) : null;
+    const language = request ? request.headers.get('accept-language') : null;
     const platform = resolvePlatform(userAgent);
     const resolvedActorType = actorType ?? inferActorType({ request, apiKey });
     const canonicalAgentName = isEnabled ? await resolveCanonicalAgentName(agentIdentifier) : null;
     const agentNameForInsert = canonicalAgentName || agentIdentifier;
 
-    return async ({ message, previousMessageHash = null, usage = null }: RecordChatHistoryMessageOptions): Promise<string> => {
+    return async ({
+        message,
+        previousMessageHash = null,
+        usage = null,
+        taskId = null,
+    }: RecordChatHistoryMessageOptions): Promise<string> => {
         const messageHash = computeHash(message);
         if (!isEnabled) {
             return messageHash;
@@ -141,16 +158,18 @@ export async function createChatHistoryRecorder(
             agentHash,
             message,
             promptbookEngineVersion: PROMPTBOOK_ENGINE_VERSION,
-            url: request.url,
+            url: request ? request.url : null,
             ip,
             userAgent,
             language,
             platform,
-            source,
+            source: source as ChatHistoryInsert['source'],
             apiKey,
             actorType: resolvedActorType,
             usage,
             userId,
+            chatId,
+            taskId,
         };
 
         const { error } = await supabase.from(tableName).insert(row);
@@ -231,7 +250,7 @@ function resolvePlatform(userAgent: string | null): string | null {
  * Infers actor type from request auth context.
  */
 function inferActorType(options: {
-    request: Request;
+    request: Request | null;
     apiKey: string | null;
 }): ChatHistoryActorType {
     const { request, apiKey } = options;
@@ -239,7 +258,7 @@ function inferActorType(options: {
         return 'API_KEY';
     }
 
-    const cookieHeader = request.headers.get('cookie') || '';
+    const cookieHeader = request?.headers.get('cookie') || '';
     if (/(^|;\s*)(sessionToken|adminToken)=/.test(cookieHeader)) {
         return 'TEAM_MEMBER';
     }

package/apps/agents-server/src/utils/chat/resolveCitationSourceLabel.ts

@@ -1,4 +1,15 @@
 import { JSDOM } from 'jsdom';
+import {
+    createCitationSourceSignatureFallbackLabel,
+    createCitationUrlSnippet,
+    resolveCitationSourceDisplay,
+    resolveCitationSourceSignatureFromBytes,
+    resolveCitationSourceSignatureFromContentType,
+    resolveRawCitationSourceSignature,
+    type CitationSourceDisplay,
+    type CitationSourceKind,
+    type CitationSourceSignature,
+} from '../../../../../src/book-components/Chat/utils/resolveCitationSourceDisplay';
 
 /**
  * Citation metadata accepted by the Agents Server source-label resolver.
@@ -109,6 +120,14 @@ export async function resolveCitationSourceLabel(citation: CitationSourceLabelPa
         return null;
     }
 
+    const targetDisplay = resolveCitationSourceDisplay({
+        id: 'citation-label-target',
+        source: targetUrl,
+    });
+    if (isUrlSnippetSufficientForTarget(targetDisplay)) {
+        return targetDisplay.label;
+    }
+
     const response = await fetch(targetUrl, {
         headers: {
             'User-Agent': SOURCE_LABEL_USER_AGENT,
@@ -123,6 +142,15 @@ export async function resolveCitationSourceLabel(citation: CitationSourceLabelPa
 
     const bytes = await readResponseSnippet(response, MAX_SOURCE_LABEL_BYTES);
     const contentType = response.headers.get('content-type')?.toLowerCase() || '';
+    const fetchedSignature =
+        resolveCitationSourceSignatureFromContentType(contentType) ||
+        resolveCitationSourceSignatureFromBytes(bytes) ||
+        resolveRawCitationSourceSignature(new TextDecoder('utf-8', { fatal: false }).decode(bytes));
+
+    if (fetchedSignature && isUrlSnippetSufficientForFetchedSource(fetchedSignature, targetDisplay.extension)) {
+        return createCitationUrlSnippet(targetUrl) || createCitationSourceSignatureFallbackLabel(fetchedSignature);
+    }
+
     const isPdf = contentType.includes('application/pdf') || targetUrl.toLowerCase().split('?')[0]?.endsWith('.pdf');
 
     if (isPdf || startsWithPdfSignature(bytes)) {
@@ -137,6 +165,55 @@ export async function resolveCitationSourceLabel(citation: CitationSourceLabelPa
     return extractCitationLabelFromHtml(text) || extractCitationLabelFromPlainText(text);
 }
 
+/**
+ * Returns whether the target already has enough file-like URL information for a label.
+ *
+ * @param targetDisplay - Display metadata resolved from the target URL itself.
+ * @returns True when fetching metadata would likely produce unreadable binary/structured payload text.
+ *
+ * @private utility of Agents Server chat citation labels
+ */
+function isUrlSnippetSufficientForTarget(targetDisplay: CitationSourceDisplay): boolean {
+    return isUrlSnippetSufficientForKind(targetDisplay.kind, targetDisplay.extension);
+}
+
+/**
+ * Returns whether fetched content should be labelled by URL snippet rather than decoded body text.
+ *
+ * @param signature - Source signature resolved from response headers or bytes.
+ * @param extension - Target URL extension when known.
+ * @returns True when body text should not become the visible chip label.
+ *
+ * @private utility of Agents Server chat citation labels
+ */
+function isUrlSnippetSufficientForFetchedSource(
+    signature: CitationSourceSignature,
+    extension: string | undefined,
+): boolean {
+    return isUrlSnippetSufficientForKind(signature.kind, extension);
+}
+
+/**
+ * Returns whether a source kind is not useful to inspect for title text.
+ *
+ * @param kind - Source kind.
+ * @param extension - Target URL extension when known.
+ * @returns True when a compact URL snippet is the best label.
+ *
+ * @private utility of Agents Server chat citation labels
+ */
+function isUrlSnippetSufficientForKind(kind: CitationSourceKind, extension: string | undefined): boolean {
+    if (kind === 'json' || kind === 'image') {
+        return true;
+    }
+
+    if (kind !== 'document') {
+        return kind !== 'plain-text' && kind !== 'website';
+    }
+
+    return Boolean(extension && !['md', 'markdown', 'pdf', 'txt'].includes(extension));
+}
+
 /**
  * Extracts a title from an HTML document.
  *

package/apps/agents-server/src/utils/chatExport/renderHtmlToPdfOnServer.ts

@@ -1,86 +1,5 @@
-import { createServerChromiumLaunchOptions } from '@/src/tools/createServerChromiumLaunchOptions';
-import { chromium } from 'playwright';
-
 /**
- * URL protocols that can be allowed through the PDF renderer request
- * interception because they cannot reach a server-side network destination.
+ * Backward-compatible chat-export entry point for the shared standalone HTML
+ * PDF renderer.
  */
-const CHAT_EXPORT_PDF_ALLOWED_REQUEST_PROTOCOLS = new Set(['about:', 'data:']);
-
-/**
- * Browser viewport used while rendering standalone HTML exports to PDF.
- */
-const CHAT_EXPORT_PDF_VIEWPORT = {
-    width: 1280,
-    height: 1600,
-} as const;
-
-/**
- * Page margins applied to every exported PDF page.
- */
-const CHAT_EXPORT_PDF_MARGIN = {
-    top: '0.5in',
-    right: '0.5in',
-    bottom: '0.5in',
-    left: '0.5in',
-} as const;
-
-/**
- * Prints standalone HTML into a PDF using a short-lived headless Chromium instance.
- *
- * @param html - Fully rendered standalone HTML document.
- * @returns PDF bytes ready for an HTTP response.
- */
-export async function renderHtmlToPdfOnServer(html: string): Promise<Buffer> {
-    const browser = await chromium.launch(await createServerChromiumLaunchOptions());
-
-    try {
-        const page = await browser.newPage();
-
-        try {
-            await page.route('**/*', async (route) => {
-                const requestUrl = route.request().url();
-
-                if (isAllowedPdfRendererRequestUrl(requestUrl)) {
-                    await route.continue();
-                    return;
-                }
-
-                await route.abort('blockedbyclient');
-            });
-            await page.setViewportSize(CHAT_EXPORT_PDF_VIEWPORT);
-            await page.emulateMedia({ media: 'print' });
-            await page.setContent(html, { waitUntil: 'load' });
-            await page.evaluate(async () => {
-                await document.fonts?.ready;
-            });
-
-            return await page.pdf({
-                format: 'Letter',
-                margin: CHAT_EXPORT_PDF_MARGIN,
-                printBackground: true,
-                preferCSSPageSize: true,
-            });
-        } finally {
-            await page.close();
-        }
-    } finally {
-        await browser.close();
-    }
-}
-
-/**
- * Returns whether a Playwright request can proceed while rendering a chat export PDF.
- *
- * @param requestUrl - URL reported by Playwright for one intercepted request.
- * @returns Whether the request cannot reach an external or internal network host.
- *
- * @private internal helper of `renderHtmlToPdfOnServer`
- */
-function isAllowedPdfRendererRequestUrl(requestUrl: string): boolean {
-    try {
-        return CHAT_EXPORT_PDF_ALLOWED_REQUEST_PROTOCOLS.has(new URL(requestUrl).protocol);
-    } catch {
-        return false;
-    }
-}
+export { renderHtmlToPdfOnServer } from '../pdf/renderHtmlToPdfOnServer';

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

@@ -32,7 +32,7 @@ export const CHAT_FEEDBACK_MODE_OPTIONS: ReadonlyArray<{
 /**
  * Default feedback mode used when metadata is missing or invalid.
  */
-const DEFAULT_CHAT_FEEDBACK_MODE: ChatFeedbackMode = 'stars';
+export const DEFAULT_CHAT_FEEDBACK_MODE: ChatFeedbackMode = 'off';
 
 /**
  * Normalizes one raw feedback-mode value from metadata.