@noodleseed/one 0.175.1 → 0.177.0

package/node_modules/@noodle-borg/service/dist/routes/business-information-paths.js

@@ -27,6 +27,22 @@ export function parseSolutionInstallationPath(pathname) {
                 ...(connectionAction === undefined ? {} : { connectionAction }),
             };
     }
+    const conversations = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/conversations(?:\/(export|forget|cv_[A-Za-z0-9_-]{8,64}))?$/.exec(pathname);
+    if (conversations !== null) {
+        const org = decoded(conversations, 1), installationId = decoded(conversations, 2), segment = conversations[3];
+        return org === undefined || installationId === undefined
+            ? undefined
+            : {
+                org,
+                installationId,
+                action: 'conversations',
+                ...(segment === undefined
+                    ? { conversationAction: 'list' }
+                    : segment === 'export' || segment === 'forget'
+                        ? { conversationAction: segment }
+                        : { conversationAction: 'show', conversationId: segment }),
+            };
+    }
     const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|record-lifecycle|channels|operations\/coordination(?:\/resolve)?|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
     if (application !== null) {
         const org = decoded(application, 1);

package/node_modules/@noodle-borg/service/dist/routes/whatsapp-meta.js

@@ -0,0 +1,130 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { ChannelError, recordChannelDelivery } from '@noodle-borg/assistant-gateway/portable';
+import { readBodyBuffer, sendJson } from '@noodle-borg/transport-http';
+import { z } from 'zod';
+import { parseWhatsAppWebhook } from '../channels/360dialog.js';
+/**
+ * Meta webhook endpoint contract, read 2026-09-22
+ * (https://developers.facebook.com/documentation/business-messaging/whatsapp/webhooks/create-webhook-endpoint):
+ * the GET handshake carries `hub.mode=subscribe`, `hub.challenge` and `hub.verify_token`, and a valid
+ * one is answered 200 with the challenge; every POST carries `X-Hub-Signature-256: sha256=<hex>`, an
+ * HMAC-SHA256 of the payload keyed by the app secret. Anything but 200 is retried for up to seven
+ * days (https://developers.facebook.com/docs/whatsapp/cloud-api/guides/set-up-webhooks), so after a
+ * valid signature only a retryable failure answers otherwise.
+ */
+const SIGNATURE_HEADER = 'x-hub-signature-256';
+const RETRYABLE = new Set([
+    'ingress_capacity',
+    'channel_unavailable',
+    'history_policy_unavailable',
+]);
+const envelope = z.object({
+    object: z.literal('whatsapp_business_account'),
+    entry: z
+        .array(z.object({
+        id: z.string().max(64),
+        changes: z.array(z.object({ field: z.string().max(128), value: z.unknown() })).max(100),
+    }))
+        .max(100),
+});
+const routed = z.object({ metadata: z.object({ phone_number_id: z.string().min(1).max(512) }) });
+function same(actual, expected) {
+    const left = Buffer.from(actual), right = Buffer.from(expected);
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+export function verifyMetaSignature(raw, header, appSecret) {
+    if (typeof header !== 'string' || !/^sha256=[a-f0-9]{64}$/i.test(header))
+        return false;
+    const expected = createHmac('sha256', appSecret).update(raw).digest();
+    const actual = Buffer.from(header.slice(7), 'hex');
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function handshake(res, url, verifyToken) {
+    const token = url.searchParams.get('hub.verify_token');
+    const challenge = url.searchParams.get('hub.challenge');
+    if (url.searchParams.get('hub.mode') !== 'subscribe' ||
+        token === null ||
+        challenge === null ||
+        !/^[\x21-\x7e]{1,1024}$/.test(challenge) ||
+        !same(token, verifyToken)) {
+        sendJson(res, 403, { error: 'forbidden' });
+        return;
+    }
+    res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+    res.end(challenge);
+}
+export async function metaWebhook(req, res, url, runtime) {
+    const meta = runtime.options.meta;
+    if (!meta)
+        return sendJson(res, 404, { error: 'not_found' });
+    if (req.method === 'GET')
+        return handshake(res, url, meta.verifyToken);
+    if (req.method !== 'POST')
+        return sendJson(res, 405, { error: 'method_not_allowed' });
+    const body = await readBodyBuffer(req, 1 << 20);
+    if (!body.ok)
+        return sendJson(res, 413, { error: 'webhook_invalid' });
+    // The signature covers the exact bytes Meta sent; nothing is parsed before it verifies.
+    if (!verifyMetaSignature(body.buffer, req.headers[SIGNATURE_HEADER], meta.appSecret))
+        return sendJson(res, 401, { error: 'unauthorized' });
+    // Content-free: a code and never a header, body, phone number or asset id.
+    const skip = (code) => runtime.deps.logger?.warn('assistant.channel.webhook', { provider: 'meta', code });
+    let parsed;
+    try {
+        const result = envelope.safeParse(JSON.parse(body.buffer.toString('utf8')));
+        if (result.success)
+            parsed = result.data;
+    }
+    catch {
+        parsed = undefined;
+    }
+    if (!parsed) {
+        skip('webhook_invalid');
+        return sendJson(res, 200, { ok: true });
+    }
+    const groups = new Map();
+    let count = 0;
+    for (const entry of parsed.entry)
+        for (const change of entry.changes) {
+            // System notifications carry no phone number and take no part in conversations.
+            if (++count > 100 || change.field !== 'messages')
+                continue;
+            const target = routed.safeParse(change.value);
+            if (!target.success) {
+                skip('webhook_invalid');
+                continue;
+            }
+            const phone = target.data.metadata.phone_number_id;
+            groups.set(phone, [...(groups.get(phone) ?? []), { waba: entry.id, change }]);
+        }
+    if (count > 100)
+        skip('batch_too_large');
+    for (const [phoneNumberId, group] of groups) {
+        try {
+            const id = await runtime.channels.bindingForAsset(phoneNumberId);
+            if (!id)
+                throw new ChannelError('binding_unknown');
+            const binding = await runtime.channels.internal(id);
+            if (binding.provider !== 'meta')
+                throw new ChannelError('provider_mismatch');
+            // Defense in depth: the number must arrive under the WABA the operator bound it to.
+            const changes = group.filter((item) => item.waba === binding.wabaId);
+            if (changes.length !== group.length)
+                skip('waba_mismatch');
+            if (changes.length === 0)
+                continue;
+            const batch = parseWhatsAppWebhook({ object: parsed.object, entry: [{ changes: changes.map((item) => item.change) }] }, phoneNumberId);
+            await runtime.channels.receive(id, batch.messages, await runtime.retention(binding));
+            for (const status of batch.statuses)
+                await recordChannelDelivery(runtime.channels.store, id, status.providerMessageId, status.state, runtime.channels.now());
+        }
+        catch (error) {
+            if (!(error instanceof ChannelError) || RETRYABLE.has(error.code))
+                throw error;
+            skip(error.code);
+        }
+    }
+    sendJson(res, 200, { ok: true });
+    runtime.options.worker.wake();
+}
+//# sourceMappingURL=whatsapp-meta.js.map

package/node_modules/@noodle-borg/service/dist/routes/whatsapp.js

@@ -2,7 +2,9 @@ import { ChannelError, channelParticipantId, recordChannelDelivery, } from '@noo
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import * as wire from '@noodle-borg/wire-contracts';
 import { parseWhatsAppWebhook, verifyWhatsAppWebhookSecret, WHATSAPP_CALLBACK_HEADER, } from '../channels/360dialog.js';
+import { WHATSAPP_META_CALLBACK_PATH } from '../channels/meta-cloud.js';
 import { authorizeTenantControl, developerGrantRouteAccess } from './control-plane.js';
+import { metaWebhook } from './whatsapp-meta.js';
 const participant = /^p_[a-f0-9]{64}$/;
 const eventId = /^e_[0-9_]+$/;
 function eventView(event) {
@@ -32,7 +34,8 @@ async function body(req, schema) {
 export function dispatchWhatsAppRoutes(req, res, url, runtime, grants) {
     const callback = /^\/v1\/channels\/whatsapp\/webhooks\/([a-z0-9-]+)$/.exec(url.pathname);
     const operator = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/channels\/whatsapp(?:\/(.*))?$/.exec(url.pathname);
-    if (!callback && !operator)
+    const meta = url.pathname === WHATSAPP_META_CALLBACK_PATH;
+    if (!callback && !operator && !meta)
         return false;
     res.setHeader('Cache-Control', 'no-store');
     if (!runtime) {
@@ -42,13 +45,15 @@ export function dispatchWhatsAppRoutes(req, res, url, runtime, grants) {
         });
         return true;
     }
-    const run = Promise.resolve().then(() => callback
-        ? webhook(req, res, callback[1], runtime)
-        : operate(req, res, url, {
-            org: decodeURIComponent(operator[1]),
-            app: decodeURIComponent(operator[2]),
-            env: decodeURIComponent(operator[3]),
-        }, operator[4] ?? '', runtime, grants));
+    const run = Promise.resolve().then(() => meta
+        ? metaWebhook(req, res, url, runtime)
+        : callback
+            ? webhook(req, res, callback[1], runtime)
+            : operate(req, res, url, {
+                org: decodeURIComponent(operator[1]),
+                app: decodeURIComponent(operator[2]),
+                env: decodeURIComponent(operator[3]),
+            }, operator[4] ?? '', runtime, grants));
     void run.catch((error) => {
         const code = error instanceof ChannelError ? error.code : 'channel_unavailable';
         const status = code === 'channel_not_found'
@@ -73,8 +78,12 @@ async function webhook(req, res, id, runtime) {
     if (req.method !== 'POST')
         return sendJson(res, 405, { error: 'method_not_allowed' });
     const binding = await runtime.channels.internal(id);
+    // Meta numbers share the signed app callback; only 360dialog has a per-binding address.
+    if (binding.provider !== '360dialog')
+        return sendJson(res, 404, { error: 'not_found' });
     const { webhookSecret } = await runtime.provider(binding);
-    if (!verifyWhatsAppWebhookSecret(req.headers[WHATSAPP_CALLBACK_HEADER], webhookSecret))
+    if (!webhookSecret ||
+        !verifyWhatsAppWebhookSecret(req.headers[WHATSAPP_CALLBACK_HEADER], webhookSecret))
         return sendJson(res, 401, { error: 'unauthorized' });
     const input = await readJsonBody(req, 1 << 20);
     if (!input.ok)

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

@@ -0,0 +1,24 @@
+import { randomBytes } from 'node:crypto';
+import { ApplicationActivity } from './application-activity.js';
+import { ApplicationConversations } from './conversation-history/operator.js';
+/** Installation history projections over the optional durable stores the service was given. */
+export function createHistoryProjections(options, moduleHost) {
+    const activity = options.operationEvidence === undefined
+        ? undefined
+        : new ApplicationActivity({
+            ...options.operationEvidence,
+            allowance: async (org, request) => moduleHost.resolveActivityHistoryAllowance?.(org, request),
+        });
+    const history = options.conversationHistory;
+    const conversations = history === undefined
+        ? undefined
+        : new ApplicationConversations({
+            store: history.store,
+            identityKey: history.identityKey ?? randomBytes(32).toString('hex'),
+            ...(options.clock === undefined
+                ? {}
+                : { now: () => options.clock?.().getTime() ?? Date.now() }),
+        });
+    return { activity, conversations };
+}
+//# sourceMappingURL=service-history-projections.js.map

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

@@ -6,7 +6,6 @@ import { capabilityOperatorRoute } from '@noodle-borg/managed-capabilities';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
 import { applySecurityHeaders, createMcpRouter, enforceHttps, noopLogger, sendJson, } from '@noodle-borg/transport-http';
 import { AnonymousConsumerLimiter, createAdmissionGate } from './admission.js';
-import { ApplicationActivity } from './application-activity.js';
 import { createApplicationServingRuntime } from './application-runtime-target.js';
 import { createArchivePreflight } from './archive-preflight.js';
 import { ArchiveSweeper, resolveArchiveRetentionDays } from './archive-sweeper.js';
@@ -55,6 +54,7 @@ import { handleRollback } from './routes/rollback.js';
 import { createServicePrincipalDispatcher } from './routes/service-principals-dispatch.js';
 import { createServiceProbeDispatcher } from './routes/service-probes.js';
 import { dispatchWhatsAppRoutes } from './routes/whatsapp.js';
+import { createHistoryProjections } from './service-history-projections.js';
 import { servicePrincipalDataPlaneHooks } from './service-principal-data-plane.js';
 import { InMemoryAlertRuleStore } from './store/alert-rules.js';
 import { StdoutAuditSink } from './store/audit.js';
@@ -95,12 +95,7 @@ export function createServiceHandler(registry, options = {}) {
     activeAudit = audit;
     const { publicTenantRouting } = mcp.mcpRoutingOptions(options, controlPlane);
     const resolveEndpointOptions = (org) => mcp.endpointUrlOptionsForOrg(options, controlPlane, org);
-    const activity = options.operationEvidence === undefined
-        ? undefined
-        : new ApplicationActivity({
-            ...options.operationEvidence,
-            allowance: async (org, request) => moduleHost.resolveActivityHistoryAllowance?.(org, request),
-        });
+    const { activity, conversations } = createHistoryProjections(options, moduleHost);
     const withIntentMode = createIntentTargetResolver(intentSettings, intentPreviewOrgs);
     const { activateInstallation, readInstallationActivation, resolveRuntimeTarget, businessOnboarding, } = createApplicationServingRuntime(registry, providerOptions, controlPlane, audit, activity);
     const runtimeTarget = async (target) => target === undefined ? undefined : resolveRuntimeTarget(target);
@@ -314,6 +309,7 @@ export function createServiceHandler(registry, options = {}) {
                 activateInstallation,
                 readInstallationActivation,
                 ...(activity === undefined ? {} : { activity }),
+                ...(conversations === undefined ? {} : { conversations }),
                 ...(options.connectionRuntime === undefined
                     ? {}
                     : {

package/node_modules/@noodle-borg/transport-http/dist/index.d.ts

@@ -3,7 +3,7 @@ export { type AccessMode, type AdmissionCategory, type AdmissionContext, type Ad
 export { bearerToken } from './identity-authorization.js';
 export { createLogger, type LogFields, type Logger, type LoggerOptions, type LogLevel, type LogSink, noopLogger, stderrSink, stdoutSink, } from './logging.js';
 export { resolveTrustedPublicOrg, resolveTrustedTenantMcpResource, type TrustedPublicOrg, type TrustedPublicRef, type TrustedPublicRouting, type TrustedTenantMcpResource, trustedPublicMcpRef, trustedPublicOrgWellKnownRef, } from './public-routing.js';
-export { readBody, readDeployBody, readJsonBody } from './request-body.js';
+export { readBody, readBodyBuffer, readDeployBody, readJsonBody } from './request-body.js';
 export { sendJson } from './responses.js';
 export { type RunningServer, type ServeOptions, serveHttp } from './serve.js';
 export type { HostedToolAuthorizationObservation, HostedToolAuthorizationObserver, ServicePrincipalToolAuthorizationObservation, } from './service-principal-authorization.js';

package/node_modules/@noodle-borg/transport-http/dist/index.js

@@ -3,7 +3,7 @@ export { createMcpHttpHandler, createMcpRouter, } from './handler.js';
 export { bearerToken } from './identity-authorization.js';
 export { createLogger, noopLogger, stderrSink, stdoutSink, } from './logging.js';
 export { resolveTrustedPublicOrg, resolveTrustedTenantMcpResource, trustedPublicMcpRef, trustedPublicOrgWellKnownRef, } from './public-routing.js';
-export { readBody, readDeployBody, readJsonBody } from './request-body.js';
+export { readBody, readBodyBuffer, readDeployBody, readJsonBody } from './request-body.js';
 export { sendJson } from './responses.js';
 export { serveHttp } from './serve.js';
 export { preflightServicePrincipalToolCall, sendServicePrincipalToolDenial, } from './service-principal-authorization.js';

package/node_modules/@noodle-borg/transport-http/dist/request-body.d.ts

@@ -7,6 +7,15 @@ export declare function readBody(req: IncomingMessage, max: number): Promise<{
     receivedBytes: number;
     maxBytes: number;
 }>;
+/** The exact request bytes, bounded; for callers that must verify a signature before parsing. */
+export declare function readBodyBuffer(req: IncomingMessage, max: number): Promise<{
+    ok: true;
+    buffer: Buffer;
+} | {
+    ok: false;
+    receivedBytes: number;
+    maxBytes: number;
+}>;
 export declare function readDeployBody(req: IncomingMessage, max: number): Promise<{
     ok: true;
     text: string;

package/node_modules/@noodle-borg/transport-http/dist/request-body.js

@@ -3,7 +3,8 @@ export async function readBody(req, max) {
     const body = await readBodyBuffer(req, max);
     return body.ok ? { ok: true, text: body.buffer.toString('utf8') } : body;
 }
-async function readBodyBuffer(req, max) {
+/** The exact request bytes, bounded; for callers that must verify a signature before parsing. */
+export async function readBodyBuffer(req, max) {
     const chunks = [];
     let size = 0;
     for await (const chunk of req) {

package/node_modules/@noodle-borg/wire-contracts/dist/conversation-history.d.ts

@@ -0,0 +1,347 @@
+import { z } from 'zod';
+/**
+ * Staff projection of durable conversation history (ADR 0241). Server output is strict; the tolerant
+ * `*ClientResponseSchema` variants let older clients ignore additive fields.
+ */
+export declare const ConversationIdSchema: z.ZodString;
+export declare const ConversationChannelSchema: z.ZodEnum<{
+    whatsapp: "whatsapp";
+    website: "website";
+}>;
+export declare const ConversationSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        whatsapp: "whatsapp";
+        website: "website";
+    }>;
+    subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"anonymous">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"customer">;
+        ref: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"participant">;
+        ref: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    startedAt: z.ZodISODateTime;
+    lastMessageAt: z.ZodISODateTime;
+    itemCount: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ConversationItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    text: z.ZodString;
+    at: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"outcome">;
+    interactionId: z.ZodString;
+    tool: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+        declined: "declined";
+        cancelled: "cancelled";
+    }>;
+    at: z.ZodISODateTime;
+}, z.core.$strict>], "kind">;
+export declare const ConversationDetailSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            user: "user";
+        }>;
+        text: z.ZodString;
+        at: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"outcome">;
+        interactionId: z.ZodString;
+        tool: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            succeeded: "succeeded";
+            declined: "declined";
+            cancelled: "cancelled";
+        }>;
+        at: z.ZodISODateTime;
+    }, z.core.$strict>], "kind">>;
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        whatsapp: "whatsapp";
+        website: "website";
+    }>;
+    subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"anonymous">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"customer">;
+        ref: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"participant">;
+        ref: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    startedAt: z.ZodISODateTime;
+    lastMessageAt: z.ZodISODateTime;
+    itemCount: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ConversationListResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        conversations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            channel: z.ZodEnum<{
+                whatsapp: "whatsapp";
+                website: "website";
+            }>;
+            subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"anonymous">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"customer">;
+                ref: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"participant">;
+                ref: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            startedAt: z.ZodISODateTime;
+            lastMessageAt: z.ZodISODateTime;
+            itemCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ConversationShowResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        conversation: z.ZodObject<{
+            items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                role: z.ZodEnum<{
+                    assistant: "assistant";
+                    user: "user";
+                }>;
+                text: z.ZodString;
+                at: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"outcome">;
+                interactionId: z.ZodString;
+                tool: z.ZodString;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    succeeded: "succeeded";
+                    declined: "declined";
+                    cancelled: "cancelled";
+                }>;
+                at: z.ZodISODateTime;
+            }, z.core.$strict>], "kind">>;
+            id: z.ZodString;
+            channel: z.ZodEnum<{
+                whatsapp: "whatsapp";
+                website: "website";
+            }>;
+            subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"anonymous">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"customer">;
+                ref: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"participant">;
+                ref: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            startedAt: z.ZodISODateTime;
+            lastMessageAt: z.ZodISODateTime;
+            itemCount: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ConversationExportResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        conversations: z.ZodArray<z.ZodObject<{
+            items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                role: z.ZodEnum<{
+                    assistant: "assistant";
+                    user: "user";
+                }>;
+                text: z.ZodString;
+                at: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"outcome">;
+                interactionId: z.ZodString;
+                tool: z.ZodString;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    succeeded: "succeeded";
+                    declined: "declined";
+                    cancelled: "cancelled";
+                }>;
+                at: z.ZodISODateTime;
+            }, z.core.$strict>], "kind">>;
+            id: z.ZodString;
+            channel: z.ZodEnum<{
+                whatsapp: "whatsapp";
+                website: "website";
+            }>;
+            subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"anonymous">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"customer">;
+                ref: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"participant">;
+                ref: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            startedAt: z.ZodISODateTime;
+            lastMessageAt: z.ZodISODateTime;
+            itemCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ConversationForgetRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    conversationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    subject: z.ZodObject<{
+        kind: z.ZodEnum<{
+            customer: "customer";
+            participant: "participant";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type ConversationForgetRequest = z.infer<typeof ConversationForgetRequestSchema>;
+export declare const ConversationForgetResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        forgotten: z.ZodObject<{
+            conversations: z.ZodNumber;
+            items: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ConversationListClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        conversations: z.ZodArray<z.ZodObject<{
+            subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"anonymous">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"customer">;
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"participant">;
+                ref: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            id: z.ZodString;
+            channel: z.ZodEnum<{
+                whatsapp: "whatsapp";
+                website: "website";
+            }>;
+            startedAt: z.ZodISODateTime;
+            lastMessageAt: z.ZodISODateTime;
+            itemCount: z.ZodNumber;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ConversationShowClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        conversation: z.ZodObject<{
+            items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                role: z.ZodEnum<{
+                    assistant: "assistant";
+                    user: "user";
+                }>;
+                text: z.ZodString;
+                at: z.ZodISODateTime;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"outcome">;
+                interactionId: z.ZodString;
+                tool: z.ZodString;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    succeeded: "succeeded";
+                    declined: "declined";
+                    cancelled: "cancelled";
+                }>;
+                at: z.ZodISODateTime;
+            }, z.core.$strip>], "kind">>;
+            subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"anonymous">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"customer">;
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"participant">;
+                ref: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            id: z.ZodString;
+            channel: z.ZodEnum<{
+                whatsapp: "whatsapp";
+                website: "website";
+            }>;
+            startedAt: z.ZodISODateTime;
+            lastMessageAt: z.ZodISODateTime;
+            itemCount: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ConversationExportClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        conversations: z.ZodArray<z.ZodObject<{
+            items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                role: z.ZodEnum<{
+                    assistant: "assistant";
+                    user: "user";
+                }>;
+                text: z.ZodString;
+                at: z.ZodISODateTime;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"outcome">;
+                interactionId: z.ZodString;
+                tool: z.ZodString;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    succeeded: "succeeded";
+                    declined: "declined";
+                    cancelled: "cancelled";
+                }>;
+                at: z.ZodISODateTime;
+            }, z.core.$strip>], "kind">>;
+            subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"anonymous">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"customer">;
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"participant">;
+                ref: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            id: z.ZodString;
+            channel: z.ZodEnum<{
+                whatsapp: "whatsapp";
+                website: "website";
+            }>;
+            startedAt: z.ZodISODateTime;
+            lastMessageAt: z.ZodISODateTime;
+            itemCount: z.ZodNumber;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ConversationForgetClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        forgotten: z.ZodObject<{
+            conversations: z.ZodNumber;
+            items: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=conversation-history.d.ts.map