@noodleseed/one 0.177.0 → 0.178.0

package/node_modules/@noodle-borg/service/dist/application-history-settings.js

@@ -0,0 +1,108 @@
+import { authenticatedSurfaceOf, messagingSurfaceOf, publicSurfaceOf, } from '@noodle-borg/assistant-gateway/portable';
+import { ALL_CONVERSATION_SOURCES, } from './conversation-history/contracts.js';
+const WIRE_SOURCES = {
+    websiteVisitors: 'website_visitors',
+    signedInCustomers: 'signed_in_customers',
+    whatsapp: 'whatsapp',
+};
+/**
+ * The surfaces the served application declared `history: false` on (ADR 0241 decision 11), so staff
+ * see which conversation options the application has disabled rather than the business.
+ */
+export function historyDisabledSurfaces(assistant) {
+    return [
+        ...(publicSurfaceOf(assistant)?.history === false ? ['publicWebsite'] : []),
+        ...(authenticatedSurfaceOf(assistant)?.history === false
+            ? ['authenticatedWebsite']
+            : []),
+        ...(messagingSurfaceOf(assistant)?.history === false ? ['publicMessaging'] : []),
+    ];
+}
+/** A setting created lazily on first read never opts in: only new installations record by default. */
+export function lazyHistorySetting(allowance) {
+    return {
+        days: allowance.defaultDays,
+        conversationDays: null,
+        sources: ALL_CONVERSATION_SOURCES,
+    };
+}
+/** A newly created installation records conversations from day one (ADR 0241 decisions 7 and 8). */
+export function newInstallationHistorySetting(allowance) {
+    return { ...lazyHistorySetting(allowance), conversationDays: allowance.defaultDays };
+}
+export function historySettingsProjection(setting, allowance, revision, canEdit) {
+    const days = setting.conversationDays;
+    return {
+        revision,
+        canEdit,
+        activity: {
+            retentionDays: Math.min(setting.days, allowance.maximumDays),
+            maximumDays: allowance.maximumDays,
+            defaultDays: allowance.defaultDays,
+        },
+        conversations: {
+            state: days === null ? 'not_enabled' : days === 0 ? 'off' : 'on',
+            ...(days ? { retentionDays: Math.min(days, allowance.maximumDays) } : {}),
+            sources: {
+                websiteVisitors: setting.sources.website_visitors,
+                signedInCustomers: setting.sources.signed_in_customers,
+                whatsapp: setting.sources.whatsapp,
+            },
+        },
+    };
+}
+/** Days currently recorded: never-opted-in and Off both keep nothing new. */
+function recordedDays(setting, maximumDays) {
+    return Math.min(setting.conversationDays ?? 0, maximumDays);
+}
+/**
+ * Applies a change, or returns undefined when a requested duration exceeds the plan maximum. `shortened` is the
+ * new conversation duration when the change shortens or turns off recorded conversation history.
+ */
+export function planHistorySettingsChange(current, change, maximumDays) {
+    const conversationDays = change.conversations === undefined
+        ? current.conversationDays
+        : change.conversations === 'off'
+            ? 0
+            : change.conversations.retentionDays;
+    // Only requested durations meet the cap: a value stored before a downgrade stays, read as clamped.
+    if ((change.activityDays ?? 0) > maximumDays ||
+        (typeof change.conversations === 'object' && change.conversations.retentionDays > maximumDays))
+        return undefined;
+    const days = change.activityDays ?? current.days;
+    const sources = { ...current.sources };
+    const changed = [];
+    for (const [wire, source] of Object.entries(WIRE_SOURCES)) {
+        const value = change.sources?.[wire];
+        if (value === undefined || value === sources[source])
+            continue;
+        sources[source] = value;
+        changed.push(wire);
+    }
+    const next = { days, conversationDays, sources };
+    const before = recordedDays(current, maximumDays);
+    const after = recordedDays(next, maximumDays);
+    return {
+        next,
+        ...(before > 0 && after < before ? { shortened: after } : {}),
+        audit: {
+            activityDays: days,
+            conversationDays: conversationDays === null
+                ? 'not_enabled'
+                : conversationDays === 0
+                    ? 'off'
+                    : conversationDays,
+            sourcesChanged: changed.length === 0 ? 'none' : changed.join(','),
+        },
+    };
+}
+/** The capture policy for a stored setting; absent until an Owner/Admin or a new installation opts in. */
+export function conversationPolicyFromSetting(setting, allowance) {
+    return {
+        maximumDays: allowance.maximumDays,
+        ...(setting?.conversationDays === null || setting === undefined
+            ? {}
+            : { conversationDays: setting.conversationDays, sources: { ...setting.sources } }),
+    };
+}
+//# sourceMappingURL=application-history-settings.js.map

package/node_modules/@noodle-borg/service/dist/assistant-composition.js

@@ -1,8 +1,11 @@
+import { randomBytes } from 'node:crypto';
 import { ConversationCapture } from './conversation-history/capture.js';
+import { CustomerConversations } from './conversation-history/customer.js';
 /** Browser and messaging resolve model, execution and tenant policy from one composition. */
 export function assistantRouteDependencies(options, core) {
+    const { conversationPolicy, ...route } = core;
     return {
-        ...core,
+        ...route,
         ...(options.publicEmbeds ? { publicEmbeds: options.publicEmbeds } : {}),
         ...(options.elevations ? { elevations: options.elevations } : {}),
         ...(options.elevationCoordinator ? { elevationCoordinator: options.elevationCoordinator } : {}),
@@ -16,10 +19,16 @@ export function assistantRouteDependencies(options, core) {
         ...(options.clock ? { clock: options.clock } : {}),
         ...(options.conversationHistory
             ? {
-                conversations: new ConversationCapture(options.conversationHistory.store, options.conversationHistory.policy, {
+                conversations: new ConversationCapture(options.conversationHistory.store, conversationPolicy, {
                     now: () => (options.clock?.() ?? new Date()).getTime(),
                     ...(core.logger ? { logger: core.logger } : {}),
                 }),
+                customerConversations: new CustomerConversations({
+                    store: options.conversationHistory.store,
+                    policy: conversationPolicy,
+                    identityKey: options.conversationHistory.identityKey ?? randomBytes(32).toString('hex'),
+                    now: () => (options.clock?.() ?? new Date()).getTime(),
+                }),
             }
             : {}),
     };

package/node_modules/@noodle-borg/service/dist/channels/composition.js

@@ -28,7 +28,7 @@ export function createWhatsAppRuntime(options, deps, history) {
                         throw new Error('history policy unavailable');
                     const installation = (await history.installations?.listInstallations(tenant.org))?.find((item) => item.scope.app === tenant.app && item.scope.env === tenant.env);
                     return installation && history.activity
-                        ? Math.min(allowance.maximumDays, (await history.activity.settings(installation.scope, false)).projection
+                        ? Math.min(allowance.maximumDays, (await history.activity.settings(installation.scope, false)).projection.activity
                             .retentionDays)
                         : allowance.maximumDays;
                 },
@@ -36,4 +36,13 @@ export function createWhatsAppRuntime(options, deps, history) {
             : {}),
     }, deps);
 }
+/** What business routes may do with WhatsApp: read its projection and erase a participant's memory. */
+export function whatsappBusinessRoutes(whatsapp) {
+    return whatsapp
+        ? {
+            readWhatsApp: whatsapp.projection.bind(whatsapp),
+            forgetWhatsApp: whatsapp.forgetParticipant.bind(whatsapp),
+        }
+        : {};
+}
 //# sourceMappingURL=composition.js.map

package/node_modules/@noodle-borg/service/dist/channels/provider.js

@@ -29,16 +29,16 @@ export async function boundedJson(response) {
 }
 const sendState = z.enum(['AVAILABLE', 'LIMITED', 'BLOCKED']);
 /**
- * Health errors that block only business-initiated conversations. 141006 reads "There is an error
- * with the payment method. This will block business initiated conversations." (observed on a WABA
- * with no payment method, 2026-09-22). Channels only reply inside the customer service window,
- * where non-template messages are free (https://developers.facebook.com/docs/whatsapp/pricing/).
+ * 141006 reads "There is an error with the payment method" (observed on a WABA with no payment
+ * method, 2026-09-22). Meta requires a business to "first attach a payment method ... before they
+ * can begin messaging" (Embedded Signup overview and business customer support, read 2026-09-22),
+ * so the block stands; it is only named so readiness can say what to fix.
  */
-const REPLY_SAFE_BLOCKS = new Set([141006]);
+const PAYMENT_BLOCKS = new Set([141006]);
 /**
- * Parse a Cloud API health read. The aggregate `can_send_message` is BLOCKED when any entity is;
- * it is downgraded to LIMITED only when the phone number itself can send and every blocked entity
- * names nothing but reply-safe errors.
+ * Parse a Cloud API health read. The aggregate `can_send_message` is authoritative. When the phone
+ * number itself can send and every blocked entity names only payment errors, the block carries
+ * `payment_method_required`.
  */
 export async function cloudApiHealth(response) {
     if (!response.ok)
@@ -66,20 +66,20 @@ export async function cloudApiHealth(response) {
         throw new ChannelError('provider_response_invalid');
     const { can_send_message: aggregate, entities = [] } = parsed.data.health_status;
     const phone = entities.find((entity) => entity.entity_type === 'PHONE_NUMBER');
-    const replySafe = aggregate === 'BLOCKED' &&
+    const paymentOnly = aggregate === 'BLOCKED' &&
         phone !== undefined &&
         phone.can_send_message !== 'BLOCKED' &&
         entities
             .filter((entity) => entity.can_send_message === 'BLOCKED')
             .every(({ errors = [] }) => {
-            return (errors.length > 0 && errors.every((error) => REPLY_SAFE_BLOCKS.has(error.error_code)));
+            return errors.length > 0 && errors.every((error) => PAYMENT_BLOCKS.has(error.error_code));
         });
-    const status = replySafe ? 'LIMITED' : aggregate;
     return {
         phoneNumberId: parsed.data.id,
         // LIMITED meets provider messaging requirements; provider limits still govern each send.
-        canSend: status !== 'BLOCKED',
-        status,
+        canSend: aggregate !== 'BLOCKED',
+        status: aggregate,
+        ...(paymentOnly ? { reason: 'payment_method_required' } : {}),
     };
 }
 export async function cloudApiSetBlocked(request, phone, blocked) {

package/node_modules/@noodle-borg/service/dist/channels/runtime.js

@@ -1,6 +1,8 @@
+import { randomUUID } from 'node:crypto';
 import { beginChannelProviderBlock, CHANNEL_RETENTION_MS, ChannelCoordinator, ChannelError, channelDigest, channelProviderBlocks, collectionSpecFor, finishChannelProviderBlock, messagingSurfaceOf, projectArtifactForSurface, resolveInvocationContextSnapshot, WHATSAPP_CONFIRMATION_EXPIRY_MS, withAssistantTurnExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { guardedFetch } from '@noodle-borg/connector-http';
 import { executePreparedTool, prepareToolForConfirmation } from '@noodle-borg/runtime';
+import { messagingSurfaceHistory } from '../conversation-history/capture.js';
 import { runAgentTurn } from '../routes/assistant-agent.js';
 import { resolveAssistantKnowledge } from '../routes/assistant-knowledge.js';
 import { resolveAssistantModelBinding } from '../routes/assistant-model-binding.js';
@@ -124,7 +126,9 @@ export class WhatsAppRuntime {
             if (health.phoneNumberId !== binding.phoneNumberId)
                 throw new ChannelError('asset_mismatch');
             if (!health.canSend)
-                throw new ChannelError('provider_messaging_blocked');
+                throw new ChannelError(health.reason === 'payment_method_required'
+                    ? 'provider_payment_method_required'
+                    : 'provider_messaging_blocked');
             return health.status === 'LIMITED' ? 'provider_messaging_limited' : undefined;
         });
         await check('webhook', async () => {
@@ -188,6 +192,20 @@ export class WhatsAppRuntime {
             };
         }
     }
+    /**
+     * Erases one participant's working memory on the tenant's binding (ADR 0241): their context and every
+     * message body and reply, keeping content-free controls. False when the tenant has no binding or the
+     * reference cannot name a participant, which never reaches the channel store.
+     */
+    async forgetParticipant(tenant, participantId, actor) {
+        if (!/^p_[a-f0-9]{64}$/.test(participantId))
+            return false;
+        const binding = await this.channels.get(tenant);
+        if (!binding)
+            return false;
+        await this.channels.forget(binding.id, participantId, actor, `history-forget:${randomUUID()}`);
+        return true;
+    }
     async providerBlock(id, participantId, blocked, actor, key, protectedPhone) {
         const operation = await beginChannelProviderBlock(this.channels.store, id, participantId, blocked ? 'blocked' : 'unblocked', actor, key, this.channels.now(), protectedPhone);
         if (!operation)
@@ -280,11 +298,14 @@ export class WhatsAppRuntime {
                     ...(send.event.buttons === undefined ? {} : { buttons: send.event.buttons }),
                 });
                 await this.channels.sent(id, send.event.id, send.event.lease, result);
-                // Content-free delivery evidence: no address, text or credential.
+                // Content-free delivery evidence: no address, text or credential. A wamid base64-encodes
+                // the recipient's phone number, so only a short digest of it is logged.
                 this.deps.logger?.info('assistant.channel.reply', {
                     provider: send.binding.provider,
                     bindingId: id,
-                    providerMessageId: result.providerMessageId,
+                    providerMessageRef: result.providerMessageId === undefined
+                        ? undefined
+                        : channelDigest(result.providerMessageId).slice(0, 16),
                     state: result.state,
                     code: result.code,
                 });
@@ -423,8 +444,13 @@ export class WhatsAppRuntime {
                 });
                 if (failure || !text.trim())
                     throw new ChannelError(failure ?? 'answer_unavailable');
+                // WhatsApp has no footer, so a recorded channel states its window here (ADR 0241 decision 17).
+                const days = participant.history.length === 0
+                    ? ((await this.deps.conversations?.retentionDays(binding.tenant, 'whatsapp', messagingSurfaceHistory(artifact.server.assistant))) ?? 0)
+                    : 0;
+                const kept = days > 0 ? ` Chats are kept for ${days} ${days === 1 ? 'day' : 'days'}.` : '';
                 const disclosure = participant.history.length === 0
-                    ? `I’m ${artifact.server.branding?.name ?? artifact.server.title}’s AI assistant.\n\n`
+                    ? `I’m ${artifact.server.branding?.name ?? artifact.server.title}’s AI assistant.${kept}\n\n`
                     : '';
                 answer = disclosure + text.trim();
             }
@@ -441,7 +467,7 @@ export class WhatsAppRuntime {
                 user: scrub(heard),
                 assistant: scrub(bounded),
                 receivedAt: event.receivedAt,
-            });
+            }, messagingSurfaceHistory(artifact.server.assistant));
         }
         catch (error) {
             const code = error instanceof ChannelError ? error.code : 'answer_failed';

package/node_modules/@noodle-borg/service/dist/conversation-history/capture.js

@@ -1,6 +1,35 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { authenticatedSurfaceOf, messagingSurfaceOf, publicSurfaceOf, surfaceBindingForOrigin, } from '@noodle-borg/assistant-gateway/portable';
 import { maskPaymentCards } from '../payment-card.js';
 import { CHANNEL_CONVERSATION_GAP_MS, effectiveConversationDays, } from './contracts.js';
+/** The session wire contract's bound on a stated window; the stored setting never exceeds it. */
+const MAX_NOTICE_DAYS = 365;
+/**
+ * The surface a web session is bound to, read from the served assistant. A record minted before
+ * `boundSurface` existed derives it as the session target does; an unreadable assistant never records,
+ * because nothing proves this caller may be kept.
+ */
+export function sessionSurfaceHistory(assistant, session) {
+    if (assistant === undefined)
+        return { historyDisabled: true };
+    const binding = session.boundSurface ??
+        (session.publicEmbedId !== undefined
+            ? 'public'
+            : surfaceBindingForOrigin(assistant, session.origin).kind);
+    return websiteSurfaceHistory(assistant, binding);
+}
+/** The website surface a mint binds to; a pre-surfaces or unowned binding declares nothing. */
+export function websiteSurfaceHistory(assistant, binding) {
+    const surface = binding === 'public'
+        ? publicSurfaceOf(assistant)
+        : binding === 'authenticated'
+            ? authenticatedSurfaceOf(assistant)
+            : undefined;
+    return { historyDisabled: surface?.history === false };
+}
+export function messagingSurfaceHistory(assistant) {
+    return { historyDisabled: messagingSurfaceOf(assistant)?.history === false };
+}
 /**
  * Records what the customer saw beside each existing working-memory write. Capture is best-effort by
  * contract: a failure is logged as scalars and never fails or delays the customer's turn.
@@ -17,7 +46,7 @@ export class ConversationCapture {
         this.#logger = options.logger;
     }
     /** Visible rows only: narration carries tool output and untagged rows fail closed. */
-    recordSessionTurn(session, rows) {
+    recordSessionTurn(session, rows, surface) {
         const at = this.#now();
         const items = rows
             .filter((row) => row.kind === 'visible' && row.content.trim())
@@ -27,10 +56,10 @@ export class ConversationCapture {
             text: maskPaymentCards(row.content),
             at,
         }));
-        return this.#recordSession(session, items);
+        return this.#recordSession(session, items, surface);
     }
-    recordSessionOutcome(session, outcome) {
-        return this.#recordSession(session, [{ kind: 'outcome', ...outcome, at: this.#now() }]);
+    recordSessionOutcome(session, outcome, surface) {
+        return this.#recordSession(session, [{ kind: 'outcome', ...outcome, at: this.#now() }], surface);
     }
     /** Sign-in moves the conversation in progress to the verified customer (ADR 0241 decision 4). */
     reownSession(session) {
@@ -41,7 +70,29 @@ export class ConversationCapture {
             await this.store.reown(session.tenant, sessionConversationId(session.id), subject);
         });
     }
-    recordChannelTurn(turn) {
+    /**
+     * The window every channel states to the person it records (ADR 0241 decision 17); 0 means this
+     * source or surface is not recorded. Never throws: a notice must not fail a session or a reply.
+     */
+    async retentionDays(tenant, source, surface) {
+        if (surface.historyDisabled)
+            return 0;
+        try {
+            const days = effectiveConversationDays(await this.policy(tenant), source);
+            return Number.isInteger(days) && days <= MAX_NOTICE_DAYS ? days : 0;
+        }
+        catch {
+            this.#logger?.warn('assistant.history.policy_failed', {
+                org: tenant.org,
+                app: tenant.app,
+                env: tenant.env,
+            });
+            return 0;
+        }
+    }
+    recordChannelTurn(turn, surface) {
+        if (surface.historyDisabled)
+            return Promise.resolve();
         return this.#guard(turn.tenant, async () => {
             const days = effectiveConversationDays(await this.policy(turn.tenant), 'whatsapp');
             if (days === 0)
@@ -55,9 +106,9 @@ export class ConversationCapture {
             ].filter((item) => item.text.trim()), days);
         });
     }
-    #recordSession(session, items) {
+    #recordSession(session, items, surface) {
         const subject = sessionSubject(session);
-        if (!subject || items.length === 0)
+        if (surface.historyDisabled || !subject || items.length === 0)
             return Promise.resolve();
         return this.#guard(session.tenant, async () => {
             const source = subject.kind === 'anonymous' ? 'website_visitors' : 'signed_in_customers';
@@ -96,4 +147,9 @@ function sessionSubject(session) {
 function sessionConversationId(sessionId) {
     return `cv_${createHash('sha256').update(sessionId).digest('base64url').slice(0, 22)}`;
 }
+/** The additive session-response notice (ADR 0241 decision 17); empty for an unrecorded caller. */
+export async function sessionHistoryNotice(conversations, tenant, source, surface) {
+    const retentionDays = (await conversations?.retentionDays(tenant, source, surface)) ?? 0;
+    return retentionDays > 0 ? { history: { retentionDays } } : {};
+}
 //# sourceMappingURL=capture.js.map

package/node_modules/@noodle-borg/service/dist/conversation-history/contracts.js

@@ -5,6 +5,19 @@
 export const CONVERSATION_DAY_MS = 86_400_000;
 /** A WhatsApp conversation ends after this much silence, matching the provider's service window. */
 export const CHANNEL_CONVERSATION_GAP_MS = CONVERSATION_DAY_MS;
+export const ALL_CONVERSATION_SOURCES = {
+    website_visitors: true,
+    signed_in_customers: true,
+    whatsapp: true,
+};
+/**
+ * The latest expiry a shorter window allows an item from `at`; Off (0 days) ends every item now. The
+ * stored expiry becomes the lesser of this and its own, so a window never lengthens history.
+ */
+export function conversationExpiryBound(at, input) {
+    return input.days === 0 ? input.now : at + input.days * CONVERSATION_DAY_MS;
+}
+export const CONVERSATION_NOTE_LIMIT = 100;
 /** Days to keep a new item from this source; 0 means capture nothing. */
 export function effectiveConversationDays(policy, source) {
     if (policy?.conversationDays === undefined || policy.sources?.[source] === false)

package/node_modules/@noodle-borg/service/dist/conversation-history/customer.js

@@ -0,0 +1,118 @@
+import { createHmac } from 'node:crypto';
+import { canonicalJson } from '@noodle-borg/compiler';
+import { ASSISTANT_CONVERSATION_PREVIEW_MAXIMUM, AssistantConversationForgetUserRequestSchema, AssistantConversationListRequestSchema, AssistantConversationListResponseSchema, ConversationForgetResponseSchema, } from '@noodle-borg/wire-contracts';
+import { ConversationHistoryError, conversationReadBound, decodeConversationCursor, encodeConversationCursor, } from './operator.js';
+const DEFAULT_PAGE = 20;
+/**
+ * The customer-backend projection of conversation history (ADR 0241 decision 12). An embed client lists
+ * or forgets one of its own verified users by the `user.id` its session exchange sent, which capture
+ * stored as the customer subject reference. Audit details are counts only, never text or the user id.
+ */
+export class CustomerConversations {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async list(client, body) {
+        const parsed = AssistantConversationListRequestSchema.safeParse(body);
+        if (!parsed.success)
+            throw new ConversationHistoryError('conversation_invalid');
+        const { user, cursor } = parsed.data;
+        const limit = parsed.data.limit ?? DEFAULT_PAGE;
+        const subject = customer(user.id);
+        const binding = this.#hash({
+            purpose: 'assistant-client-conversations-v1',
+            client: client.id,
+            tenant: client.tenant,
+            ref: subject.ref,
+            limit,
+        });
+        const after = decodeConversationCursor(cursor, binding);
+        const now = this.options.now?.() ?? Date.now();
+        const policy = await this.options.policy(client.tenant).catch(() => {
+            throw new ConversationHistoryError('conversation_unavailable');
+        });
+        // A business that has not opted in records nothing, so it has nothing to list.
+        if (policy !== undefined && !Number.isInteger(policy.maximumDays))
+            throw new ConversationHistoryError('conversation_unavailable');
+        const notBefore = policy === undefined ? now + 1 : conversationReadBound(policy, now);
+        const rows = await this.options.store.list(client.tenant, {
+            now,
+            notBefore,
+            limit: limit + 1,
+            channel: 'website',
+            subject,
+            ...(after ? { after } : {}),
+        });
+        const page = rows.slice(0, limit);
+        const read = await Promise.all(page.map((row) => this.options.store.read(client.tenant, row.id, now, notBefore)));
+        // A conversation purged or forgotten between list and read simply drops out of the page.
+        const conversations = read
+            .filter((conversation) => conversation?.subject.kind === 'customer' && conversation.subject.ref === subject.ref)
+            .map(row);
+        const last = page.at(-1);
+        return {
+            response: AssistantConversationListResponseSchema.parse({
+                ok: true,
+                data: {
+                    conversations,
+                    ...(rows.length > limit && last
+                        ? { nextCursor: encodeConversationCursor(binding, last) }
+                        : {}),
+                },
+            }),
+            audit: { eventType: 'conversation.listed', details: { count: conversations.length } },
+        };
+    }
+    /** Erasure never consults the recording policy: a business that stopped recording can still forget. */
+    async forgetUser(client, body) {
+        const parsed = AssistantConversationForgetUserRequestSchema.safeParse(body);
+        if (!parsed.success)
+            throw new ConversationHistoryError('conversation_invalid');
+        const forgotten = await this.options.store.forgetSubject(client.tenant, customer(parsed.data.user.id));
+        return {
+            response: ConversationForgetResponseSchema.parse({ ok: true, data: { forgotten } }),
+            audit: {
+                eventType: 'conversation.forgotten',
+                details: {
+                    conversations: forgotten.conversations,
+                    items: forgotten.items,
+                    kind: 'customer',
+                },
+            },
+        };
+    }
+    #hash(value) {
+        return createHmac('sha256', this.options.identityKey)
+            .update(canonicalJson(value))
+            .digest('hex');
+    }
+}
+function customer(ref) {
+    return { kind: 'customer', ref };
+}
+function row(conversation) {
+    const preview = previewOf(conversation);
+    return {
+        id: conversation.id,
+        channel: conversation.channel,
+        startedAt: new Date(conversation.startedAt).toISOString(),
+        lastMessageAt: new Date(conversation.lastMessageAt).toISOString(),
+        ...(preview ? { preview } : {}),
+    };
+}
+/** The first visible question, whitespace-collapsed and cut without splitting a surrogate pair. */
+function previewOf(conversation) {
+    const first = conversation.items.find((item) => item.kind === 'message' && item.role === 'user');
+    if (first?.kind !== 'message')
+        return undefined;
+    let text = first.text.replace(/\s+/g, ' ').trim();
+    if (text.length > ASSISTANT_CONVERSATION_PREVIEW_MAXIMUM) {
+        text = text.slice(0, ASSISTANT_CONVERSATION_PREVIEW_MAXIMUM);
+        if (/[\uD800-\uDBFF]$/.test(text))
+            text = text.slice(0, -1);
+        text = text.trimEnd();
+    }
+    return text || undefined;
+}
+//# sourceMappingURL=customer.js.map