@noodleseed/one 0.170.0 → 0.171.0

package/node_modules/@noodle-borg/assistant-gateway/dist/channel-coordinator.d.ts

@@ -0,0 +1,145 @@
+import type { ChannelStore, ChannelTransaction } from './channel-store.js';
+import { type ChannelBinding, type ChannelConfigure, type ChannelEvent, type ChannelInbound, type ChannelLimitsInput } from './channel-types.js';
+import type { TenantRef } from './tenant-ref.js';
+export interface ChannelBlock {
+    readonly participantId: string;
+    readonly actor: string;
+    readonly reason: 'operator';
+    readonly until: number | null;
+}
+export declare function requireChannel(tx: ChannelTransaction, id: string): Promise<ChannelBinding>;
+export declare function channelBlocked(tx: ChannelTransaction, id: string, participant: string, now: number): Promise<boolean>;
+export declare function requireChannelLive(tx: ChannelTransaction, id: string): Promise<ChannelBinding>;
+/** Sole authority for channel state. HTTP adapters authenticate tenants before obtaining a binding id. */
+export declare class ChannelCoordinator {
+    readonly store: ChannelStore;
+    readonly now: () => number;
+    constructor(store: ChannelStore, now?: () => number);
+    get(tenant: TenantRef): Promise<{
+        id: string;
+        tenant: TenantRef;
+        provider: "360dialog";
+        phoneNumberId: string;
+        apiKeySecret: string;
+        webhookSecret: string;
+        deploymentId: string;
+        capabilities: readonly import("./channel-types.js").ChannelCapability[];
+        supportEmail: string;
+        revision: number;
+        generation: number;
+        state: "paused" | "enabled" | "disconnected";
+        limits: import("./channel-types.js").ChannelLimits;
+        createdAt: number;
+        updatedAt: number;
+        actor: string;
+        readyRevision?: number | undefined;
+        readyAt?: number | undefined;
+    } | undefined>;
+    internal(id: string): Promise<ChannelBinding>;
+    bindingPage(after?: string): Promise<{
+        ids: string[];
+        after?: string;
+    }>;
+    configure(input: ChannelConfigure, actor: string, key: string, revision: number): Promise<{
+        id: string;
+        tenant: TenantRef;
+        provider: "360dialog";
+        phoneNumberId: string;
+        apiKeySecret: string;
+        webhookSecret: string;
+        deploymentId: string;
+        capabilities: readonly import("./channel-types.js").ChannelCapability[];
+        supportEmail: string;
+        revision: number;
+        generation: number;
+        state: "paused" | "enabled" | "disconnected";
+        limits: import("./channel-types.js").ChannelLimits;
+        createdAt: number;
+        updatedAt: number;
+        actor: string;
+        readyRevision?: number | undefined;
+        readyAt?: number | undefined;
+    }>;
+    checkCredentials(id: string, digest: string): Promise<void>;
+    markReady(id: string, revision: number): Promise<void>;
+    setState(id: string, state: ChannelBinding['state'], actor: string, key: string, revision: number): Promise<{
+        id: string;
+        tenant: TenantRef;
+        provider: "360dialog";
+        phoneNumberId: string;
+        apiKeySecret: string;
+        webhookSecret: string;
+        deploymentId: string;
+        capabilities: readonly import("./channel-types.js").ChannelCapability[];
+        supportEmail: string;
+        revision: number;
+        generation: number;
+        state: "paused" | "enabled" | "disconnected";
+        limits: import("./channel-types.js").ChannelLimits;
+        createdAt: number;
+        updatedAt: number;
+        actor: string;
+        readyRevision?: number | undefined;
+        readyAt?: number | undefined;
+    }>;
+    block(id: string, participantId: string, actor: string, key: string, until: number | null): Promise<void>;
+    unblock(id: string, participantId: string, actor: string, key: string): Promise<void>;
+    blocks(id: string, after?: string): Promise<ChannelBlock[]>;
+    events(id: string, after?: string): Promise<ChannelEvent[]>;
+    forget(id: string, participantId: string, actor: string, key: string): Promise<void>;
+    updateLimits(id: string, input: ChannelLimitsInput, actor: string, key: string, revision: number): Promise<{
+        id: string;
+        tenant: TenantRef;
+        provider: "360dialog";
+        phoneNumberId: string;
+        apiKeySecret: string;
+        webhookSecret: string;
+        deploymentId: string;
+        capabilities: readonly import("./channel-types.js").ChannelCapability[];
+        supportEmail: string;
+        revision: number;
+        generation: number;
+        state: "paused" | "enabled" | "disconnected";
+        limits: import("./channel-types.js").ChannelLimits;
+        createdAt: number;
+        updatedAt: number;
+        actor: string;
+        readyRevision?: number | undefined;
+        readyAt?: number | undefined;
+    }>;
+    cooldown(id: string, participantId: string): Promise<{
+        participantId: string;
+        until: number | null;
+    }>;
+    clearCooldown(id: string, participantId: string, actor: string, key: string): Promise<void>;
+    expireHistory(id: string, retentionMs: number): Promise<void>;
+    claimTool(id: string, participantId: string, name: string): Promise<boolean>;
+    event(id: string, eventId: string): Promise<ChannelEvent | undefined>;
+    fail(id: string, eventId: string, lease: string, code: string): Promise<void>;
+    receive(id: string, messages: readonly ChannelInbound[], retentionMs?: number): Promise<Pick<ChannelEvent, "state" | "id" | "code" | "participantId">[]>;
+    claim(id: string, retentionMs?: number): Promise<import("./channel-work.js").ChannelWork | undefined>;
+    renew(id: string, eventId: string, lease: string): Promise<void>;
+    complete(id: string, eventId: string, lease: string, reply: string, retentionMs?: number, code?: string): Promise<void>;
+    assertSend(id: string, eventId: string, lease: string): Promise<void>;
+    prepareSend(id: string): Promise<import("./channel-work.js").ChannelWork | undefined>;
+    sent(id: string, eventId: string, lease: string, result: {
+        state: 'accepted' | 'unknown' | 'failed';
+        providerMessageId?: string;
+        code?: string;
+    }): Promise<void>;
+    reserveSpend(id: string, attempt: string, maximumMicroUsd: number): Promise<void>;
+    settleSpend(id: string, attempt: string, actualMicroUsd: number): Promise<void>;
+    usage(id: string): Promise<{
+        resetAt: number;
+        admittedToday: number;
+        newParticipantsToday: number;
+        pending: number;
+        oldestPendingAt: number | null;
+        unknownSends: number;
+        day: string;
+        dailyMicroUsd: number;
+        reservedMicroUsd: number;
+        spentMicroUsd: number;
+    }>;
+}
+//# sourceMappingURL=channel-coordinator.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/channel-coordinator.js

@@ -0,0 +1,378 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { receiveChannelMessages } from './channel-inbox.js';
+import { channelUsage, reserveChannelSpend, settleChannelSpend } from './channel-spend.js';
+import { CHANNEL_REGISTRY, CHANNEL_RETENTION_MS, ChannelError, channelDigest, channelLimits, channelRow, channelTenantKey, channelValue, publicChannelBinding, writeChannelEvent, } from './channel-types.js';
+import { assertChannelSend, claimChannelTurn, completeChannelTurn, prepareChannelSend, renewChannelTurn, updateChannelSend, } from './channel-work.js';
+export async function requireChannel(tx, id) {
+    const binding = await channelValue(tx, id, 'binding');
+    if (!binding)
+        throw new ChannelError('channel_not_found');
+    return binding;
+}
+export async function channelBlocked(tx, id, participant, now) {
+    const block = await channelValue(tx, id, `block:${participant}`);
+    return !!block && (block.until === null || block.until > now);
+}
+export async function requireChannelLive(tx, id) {
+    const binding = await requireChannel(tx, id);
+    if (binding.state !== 'enabled')
+        throw new ChannelError('channel_paused');
+    return binding;
+}
+async function mutation(tx, id, key, input, now, work) {
+    if (!key || key.length > 200)
+        throw new ChannelError('idempotency_key_invalid');
+    const recordId = `mutation:${channelDigest(key)}`;
+    const fingerprint = channelDigest(JSON.stringify(input));
+    const old = await channelValue(tx, id, recordId);
+    if (old) {
+        if (old.fingerprint !== fingerprint)
+            throw new ChannelError('idempotency_conflict');
+        return old.result;
+    }
+    const result = await work();
+    await tx.put(id, channelRow(recordId, 'mutation', { fingerprint, result }, now, {
+        expiresAt: now + CHANNEL_RETENTION_MS,
+    }));
+    return result;
+}
+/** Sole authority for channel state. HTTP adapters authenticate tenants before obtaining a binding id. */
+export class ChannelCoordinator {
+    store;
+    now;
+    constructor(store, now = Date.now) {
+        this.store = store;
+        this.now = now;
+    }
+    async get(tenant) {
+        const id = await this.store.transaction([CHANNEL_REGISTRY], (tx) => channelValue(tx, CHANNEL_REGISTRY, channelTenantKey(tenant)));
+        return id ? publicChannelBinding(await this.internal(id)) : undefined;
+    }
+    async internal(id) {
+        return this.store.transaction([id], (tx) => requireChannel(tx, id));
+    }
+    async bindingPage(after) {
+        return this.store.transaction([CHANNEL_REGISTRY], async (tx) => {
+            const rows = await tx.list(CHANNEL_REGISTRY, {
+                kind: 'binding',
+                limit: 100,
+                ...(after ? { after } : {}),
+            });
+            const last = rows.at(-1)?.id;
+            return {
+                ids: rows.map((row) => row.value),
+                ...(rows.length === 100 && last ? { after: last } : {}),
+            };
+        });
+    }
+    async configure(input, actor, key, revision) {
+        const tenantKey = channelTenantKey(input.tenant);
+        const priorId = await this.store.transaction([CHANNEL_REGISTRY], (tx) => channelValue(tx, CHANNEL_REGISTRY, tenantKey));
+        const prior = priorId ? await this.internal(priorId) : undefined;
+        const sameAsset = prior?.phoneNumberId === input.phoneNumberId;
+        const id = sameAsset ? prior.id : randomUUID();
+        return this.store.transaction([CHANNEL_REGISTRY, id, ...(priorId ? [priorId] : [])], (tx) => mutation(tx, id, key, { input, revision, actor }, this.now(), async () => {
+            if ((await channelValue(tx, CHANNEL_REGISTRY, tenantKey)) !== priorId)
+                throw new ChannelError('revision_conflict');
+            const existing = priorId
+                ? await channelValue(tx, priorId, 'binding')
+                : undefined;
+            if ((existing?.revision ?? 0) !== revision)
+                throw new ChannelError('revision_conflict');
+            if (existing && !sameAsset && existing.state !== 'disconnected')
+                throw new ChannelError('asset_change_requires_disconnect');
+            const assetKey = `asset:${channelDigest(input.phoneNumberId)}`;
+            const owner = await channelValue(tx, CHANNEL_REGISTRY, assetKey);
+            if (owner && owner !== id)
+                throw new ChannelError('asset_in_use');
+            const now = this.now();
+            const binding = {
+                ...input,
+                id,
+                provider: '360dialog',
+                revision: revision + 1,
+                generation: (existing?.generation ?? 0) + 1,
+                state: 'paused',
+                indexKey: sameAsset ? prior.indexKey : randomBytes(32).toString('base64'),
+                limits: channelLimits(input.limits ?? (sameAsset ? prior.limits : undefined)),
+                actor,
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+            };
+            await tx.put(CHANNEL_REGISTRY, channelRow(tenantKey, 'binding', id, now));
+            await tx.put(CHANNEL_REGISTRY, channelRow(assetKey, 'asset', id, now));
+            await tx.put(id, channelRow('binding', 'binding', binding, now));
+            return publicChannelBinding(binding);
+        }));
+    }
+    async checkCredentials(id, digest) {
+        const changed = await this.store.transaction([id], async (tx) => {
+            const binding = await requireChannel(tx, id);
+            if (binding.credentialDigest === digest)
+                return false;
+            const changed = binding.credentialDigest !== undefined;
+            await tx.put(id, channelRow('binding', 'binding', {
+                ...binding,
+                credentialDigest: digest,
+                ...(changed
+                    ? {
+                        state: 'paused',
+                        generation: binding.generation + 1,
+                        revision: binding.revision + 1,
+                        readyAt: undefined,
+                        readyRevision: undefined,
+                    }
+                    : {}),
+            }, this.now()));
+            return changed;
+        });
+        if (changed)
+            throw new ChannelError('credentials_changed');
+    }
+    async markReady(id, revision) {
+        await this.store.transaction([id], async (tx) => {
+            const binding = await requireChannel(tx, id);
+            if (binding.revision !== revision)
+                throw new ChannelError('revision_conflict');
+            await tx.put(id, channelRow('binding', 'binding', { ...binding, readyAt: this.now(), readyRevision: revision }, this.now()));
+        });
+    }
+    async setState(id, state, actor, key, revision) {
+        return this.store.transaction([CHANNEL_REGISTRY, id], (tx) => mutation(tx, id, key, { state, actor, revision }, this.now(), async () => {
+            const binding = await requireChannel(tx, id);
+            if (binding.revision !== revision)
+                throw new ChannelError('revision_conflict');
+            if (state === 'enabled' &&
+                (binding.readyRevision !== revision || this.now() - (binding.readyAt ?? 0) > 300_000))
+                throw new ChannelError('not_ready');
+            if (state === 'enabled' &&
+                (await channelValue(tx, CHANNEL_REGISTRY, `asset:${channelDigest(binding.phoneNumberId)}`)) !== id)
+                throw new ChannelError('asset_not_owned');
+            if (state === 'disconnected') {
+                const assetKey = `asset:${channelDigest(binding.phoneNumberId)}`;
+                if ((await channelValue(tx, CHANNEL_REGISTRY, assetKey)) === id)
+                    await tx.remove(CHANNEL_REGISTRY, assetKey);
+            }
+            const updated = {
+                ...binding,
+                state,
+                revision: revision + 1,
+                generation: binding.generation + 1,
+                actor,
+                updatedAt: this.now(),
+                readyAt: undefined,
+                readyRevision: undefined,
+            };
+            await tx.put(id, channelRow('binding', 'binding', updated, this.now()));
+            return publicChannelBinding(updated);
+        }));
+    }
+    async block(id, participantId, actor, key, until) {
+        if (!/^p_[a-f0-9]{64}$/.test(participantId) ||
+            (until !== null && (!Number.isSafeInteger(until) || until <= this.now())))
+            throw new ChannelError('block_invalid');
+        await this.store.transaction([id], (tx) => mutation(tx, id, key, { participantId, actor, until }, this.now(), async () => {
+            await requireChannel(tx, id);
+            const block = { participantId, actor, reason: 'operator', until };
+            await tx.put(id, channelRow(`block:${participantId}`, 'block', block, this.now(), until === null ? {} : { expiresAt: until + CHANNEL_RETENTION_MS }));
+            return null;
+        }));
+    }
+    async unblock(id, participantId, actor, key) {
+        await this.store.transaction([id], (tx) => mutation(tx, id, key, { participantId, actor, action: 'unblock' }, this.now(), async () => {
+            await requireChannel(tx, id);
+            await tx.remove(id, `block:${participantId}`);
+            return null;
+        }));
+    }
+    async blocks(id, after) {
+        return this.store.transaction([id], async (tx) => {
+            await requireChannel(tx, id);
+            return (await tx.list(id, {
+                kind: 'block',
+                limit: 100,
+                ...(after ? { after: `block:${after}` } : {}),
+            })).map((row) => row.value);
+        });
+    }
+    async events(id, after) {
+        return this.store.transaction([id], async (tx) => {
+            await requireChannel(tx, id);
+            return (await tx.list(id, { kind: 'event', limit: 100, ...(after ? { after } : {}) })).map((row) => row.value);
+        });
+    }
+    async forget(id, participantId, actor, key) {
+        await this.store.transaction([id], (tx) => mutation(tx, id, key, { participantId, actor, action: 'forget' }, this.now(), async () => {
+            await requireChannel(tx, id);
+            await tx.remove(id, participantId);
+            // Bounded pages retain minimal replay evidence but erase every message body and reply.
+            let after;
+            for (;;) {
+                const rows = await tx.list(id, {
+                    kind: 'event',
+                    limit: 1000,
+                    ...(after ? { after } : {}),
+                });
+                for (const row of rows) {
+                    const event = row.value;
+                    if (event.participantId === participantId) {
+                        const { text: _text, reply: _reply, ...minimal } = event;
+                        await tx.put(id, {
+                            ...row,
+                            state: 'cancelled',
+                            value: { ...minimal, state: 'cancelled', code: 'forgotten' },
+                            updatedAt: this.now(),
+                        });
+                    }
+                }
+                if (rows.length < 1000)
+                    break;
+                after = rows.at(-1).id;
+            }
+            return null;
+        }));
+    }
+    async updateLimits(id, input, actor, key, revision) {
+        return this.store.transaction([id], (tx) => mutation(tx, id, key, { input, actor, revision }, this.now(), async () => {
+            const binding = await requireChannel(tx, id);
+            if (binding.revision !== revision)
+                throw new ChannelError('revision_conflict');
+            const next = {
+                ...binding,
+                limits: channelLimits({ ...binding.limits, ...input }),
+                revision: revision + 1,
+                actor,
+                updatedAt: this.now(),
+            };
+            await tx.put(id, channelRow('binding', 'binding', next, this.now()));
+            return publicChannelBinding(next);
+        }));
+    }
+    async cooldown(id, participantId) {
+        return this.store.transaction([id], async (tx) => {
+            await requireChannel(tx, id);
+            const participant = await channelValue(tx, id, participantId);
+            return {
+                participantId,
+                until: participant?.cooldownUntil && participant.cooldownUntil > this.now()
+                    ? participant.cooldownUntil
+                    : null,
+            };
+        });
+    }
+    async clearCooldown(id, participantId, actor, key) {
+        await this.store.transaction([id], (tx) => mutation(tx, id, key, { participantId, actor, action: 'clear-cooldown' }, this.now(), async () => {
+            await requireChannel(tx, id);
+            const row = await tx.get(id, participantId);
+            if (row) {
+                const { cooldownUntil: _until, ...participant } = row.value;
+                await tx.put(id, {
+                    ...row,
+                    value: { ...participant, strikes: [] },
+                    updatedAt: this.now(),
+                });
+            }
+            return null;
+        }));
+    }
+    async expireHistory(id, retentionMs) {
+        await this.store.transaction([id], async (tx) => {
+            await requireChannel(tx, id);
+            const now = this.now(), cutoff = now - Math.min(retentionMs, CHANNEL_RETENTION_MS);
+            for (const kind of ['event', 'participant']) {
+                const key = `purge:${kind}`;
+                const cursor = await channelValue(tx, id, key);
+                const rows = await tx.list(id, { kind, limit: 100, ...(cursor ? { after: cursor } : {}) });
+                for (const row of rows) {
+                    if (kind === 'event') {
+                        const event = row.value;
+                        if (event.receivedAt > cutoff || (!event.text && !event.reply))
+                            continue;
+                        const { text: _text, reply: _reply, ...minimal } = event;
+                        const state = ['queued', 'running', 'reply', 'sending'].includes(event.state)
+                            ? 'expired'
+                            : event.state;
+                        await tx.put(id, { ...row, state, value: { ...minimal, state }, updatedAt: now });
+                    }
+                    else {
+                        const person = row.value;
+                        if (person.lastInboundAt <= cutoff)
+                            await tx.remove(id, row.id);
+                        else
+                            await tx.put(id, {
+                                ...row,
+                                value: { ...person, history: person.history.filter((item) => item.at > cutoff) },
+                                expiresAt: Math.min(row.expiresAt ?? Infinity, person.lastInboundAt + retentionMs),
+                            });
+                    }
+                }
+                const last = rows.at(-1)?.id;
+                if (rows.length === 100 && last)
+                    await tx.put(id, channelRow(key, 'mutation', last, now));
+                else
+                    await tx.remove(id, key);
+            }
+        });
+    }
+    async claimTool(id, participantId, name) {
+        return this.store.transaction([id], async (tx) => {
+            await requireChannelLive(tx, id);
+            const row = await tx.get(id, participantId);
+            if (!row)
+                throw new ChannelError('context_expired');
+            const participant = row.value;
+            if (participant.modelToolUses?.includes(name))
+                return false;
+            await tx.put(id, {
+                ...row,
+                value: { ...participant, modelToolUses: [...(participant.modelToolUses ?? []), name] },
+            });
+            return true;
+        });
+    }
+    async event(id, eventId) {
+        return this.store.transaction([id], async (tx) => {
+            await requireChannel(tx, id);
+            return channelValue(tx, id, eventId);
+        });
+    }
+    async fail(id, eventId, lease, code) {
+        await this.store.transaction([id], async (tx) => {
+            const event = await channelValue(tx, id, eventId);
+            if (!event || event.lease !== lease || event.state !== 'running')
+                return;
+            await writeChannelEvent(tx, id, { ...event, state: 'failed', code }, this.now());
+        });
+    }
+    receive(id, messages, retentionMs = CHANNEL_RETENTION_MS) {
+        return receiveChannelMessages(this.store, id, messages, this.now(), retentionMs);
+    }
+    claim(id, retentionMs = CHANNEL_RETENTION_MS) {
+        return claimChannelTurn(this.store, id, this.now(), retentionMs);
+    }
+    renew(id, eventId, lease) {
+        return renewChannelTurn(this.store, id, eventId, lease, this.now());
+    }
+    complete(id, eventId, lease, reply, retentionMs = CHANNEL_RETENTION_MS, code) {
+        return completeChannelTurn(this.store, id, eventId, lease, reply, this.now(), retentionMs, code);
+    }
+    assertSend(id, eventId, lease) {
+        return assertChannelSend(this.store, id, eventId, lease, this.now());
+    }
+    prepareSend(id) {
+        return prepareChannelSend(this.store, id, this.now());
+    }
+    sent(id, eventId, lease, result) {
+        return updateChannelSend(this.store, id, eventId, lease, result, this.now());
+    }
+    reserveSpend(id, attempt, maximumMicroUsd) {
+        return reserveChannelSpend(this.store, id, attempt, maximumMicroUsd, this.now());
+    }
+    settleSpend(id, attempt, actualMicroUsd) {
+        return settleChannelSpend(this.store, id, attempt, actualMicroUsd, this.now());
+    }
+    usage(id) {
+        return channelUsage(this.store, id, this.now());
+    }
+}
+//# sourceMappingURL=channel-coordinator.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/channel-inbox.js

@@ -0,0 +1,160 @@
+import { channelBlocked, requireChannel } from './channel-coordinator.js';
+import { CHANNEL_DAY_MS, CHANNEL_RETENTION_MS, ChannelError, channelDigest, channelParticipantId, channelRow, channelValue, writeChannelEvent, } from './channel-types.js';
+export async function channelCounter(tx, scope, key, now, period, add = 0) {
+    const bucket = Math.floor(now / period);
+    const id = `counter:${key}:${period}:${bucket}`;
+    const value = ((await channelValue(tx, scope, id)) ?? 0) + add;
+    if (add)
+        await tx.put(scope, channelRow(id, 'counter', value, now, { expiresAt: (bucket + 2) * period }));
+    return value;
+}
+async function refusal(tx, binding, message, participant, pending, now) {
+    if (binding.state !== 'enabled')
+        return 'channel_paused';
+    if (await channelBlocked(tx, binding.id, participant, now))
+        return 'blocked';
+    if (message.eventAt < now - CHANNEL_RETENTION_MS || message.eventAt > now + 60_000)
+        return 'timestamp_invalid';
+    const record = await channelValue(tx, binding.id, participant);
+    if (record?.cooldownUntil && record.cooldownUntil > now)
+        return 'cooldown';
+    if (pending.length >= binding.limits.pending ||
+        pending.filter((event) => event.participantId === participant).length >=
+            binding.limits.pendingPerParticipant)
+        return 'queue_full';
+    for (const [key, period, maximum] of [
+        [participant, 60_000, binding.limits.perMinute],
+        [participant, 3_600_000, binding.limits.perHour],
+        [participant, CHANNEL_DAY_MS, binding.limits.perDay],
+        ['all', CHANNEL_DAY_MS, binding.limits.channelPerDay],
+        ...(!record ? [['new', CHANNEL_DAY_MS, binding.limits.newParticipantsPerDay]] : []),
+    ])
+        if ((await channelCounter(tx, binding.id, key, now, period)) >= maximum)
+            return period === 60_000 ? 'minute_limited' : 'rate_limited';
+    return undefined;
+}
+/** Returns content-free admission receipts; callback retries never recover or expose message bodies. */
+export async function receiveChannelMessages(store, id, messages, now, retentionMs = CHANNEL_RETENTION_MS) {
+    if (messages.length > 100)
+        throw new ChannelError('batch_too_large');
+    return store.transaction([id], async (tx) => {
+        const binding = await requireChannel(tx, id);
+        const pending = [];
+        for (const state of ['queued', 'running', 'reply', 'sending'])
+            pending.push(...(await tx.list(id, { kind: 'event', state, limit: 1000 })).map((row) => row.value));
+        const receipts = [];
+        for (const message of messages) {
+            if (!message.providerId ||
+                message.providerId.length > 512 ||
+                !message.address.value ||
+                message.address.value.length > 128 ||
+                !Number.isSafeInteger(message.eventAt))
+                throw new ChannelError('message_invalid');
+            const seenId = `seen:${channelDigest(message.providerId)}`;
+            const fingerprint = channelDigest(JSON.stringify(message));
+            const seen = await channelValue(tx, id, seenId);
+            if (seen) {
+                if (seen.fingerprint !== fingerprint)
+                    throw new ChannelError('event_conflict');
+                receipts.push(seen.receipt);
+                continue;
+            }
+            // Bound even rejected anonymous traffic. Retryable overload acknowledges no uncommitted event.
+            if ((await channelCounter(tx, id, 'ingress', now, CHANNEL_DAY_MS)) >= 10_000)
+                throw new ChannelError('ingress_capacity');
+            const participantId = channelParticipantId(binding, message.address);
+            const code = await refusal(tx, binding, message, participantId, pending, now);
+            const sequence = ((await channelValue(tx, id, 'sequence')) ?? 0) + 1;
+            await tx.put(id, channelRow('sequence', 'counter', sequence, now));
+            const eventId = `e_${String(sequence).padStart(20, '0')}`;
+            const unsupported = message.text === undefined || message.text.length > binding.limits.textCharacters;
+            let event = {
+                id: eventId,
+                participantId,
+                providerId: message.providerId,
+                eventAt: Math.min(now, message.eventAt),
+                receivedAt: now,
+                generation: binding.generation,
+                deploymentId: binding.deploymentId,
+                attempts: 0,
+                state: code ? 'refused' : unsupported ? 'reply' : 'queued',
+                ...(code ? { code } : {}),
+                ...(!code && !unsupported ? { text: message.text } : {}),
+                ...(!code && unsupported
+                    ? {
+                        reply: `Please send a text message of up to ${binding.limits.textCharacters} characters. For help, contact ${binding.supportEmail}.`,
+                    }
+                    : {}),
+            };
+            if (code === 'minute_limited') {
+                const row = await tx.get(id, participantId);
+                if (row) {
+                    const participant = row.value;
+                    const strikes = [...participant.strikes.filter((at) => at > now - 600_000), now].slice(-3);
+                    await tx.put(id, {
+                        ...row,
+                        value: {
+                            ...participant,
+                            strikes,
+                            ...(strikes.length >= 3 ? { cooldownUntil: now + 600_000 } : {}),
+                        },
+                        updatedAt: now,
+                    });
+                }
+            }
+            if (!code) {
+                const stored = await channelValue(tx, id, participantId);
+                const old = stored && stored.lastInboundAt > now - retentionMs ? stored : undefined;
+                const sameDeployment = old?.deploymentId === binding.deploymentId;
+                const participant = {
+                    ...old,
+                    deploymentId: binding.deploymentId,
+                    modelToolUses: sameDeployment ? (old?.modelToolUses ?? []) : [],
+                    id: participantId,
+                    address: message.address,
+                    lastInboundAt: Math.max(old?.lastInboundAt ?? 0, event.eventAt),
+                    history: (sameDeployment ? (old?.history ?? []) : []).filter((entry) => entry.at > now - retentionMs),
+                    strikes: old?.strikes ?? [],
+                };
+                await tx.put(id, channelRow(participantId, 'participant', participant, now, {
+                    expiresAt: now + CHANNEL_RETENTION_MS,
+                }));
+                for (const period of [60_000, 3_600_000, CHANNEL_DAY_MS])
+                    await channelCounter(tx, id, participantId, now, period, 1);
+                await channelCounter(tx, id, 'all', now, CHANNEL_DAY_MS, 1);
+                if (!old)
+                    await channelCounter(tx, id, 'new', now, CHANNEL_DAY_MS, 1);
+                pending.push(event);
+            }
+            if (code &&
+                ['minute_limited', 'rate_limited', 'cooldown'].includes(code) &&
+                pending.length < binding.limits.pending &&
+                pending.filter((item) => item.participantId === participantId).length <
+                    binding.limits.pendingPerParticipant) {
+                const person = await channelValue(tx, id, participantId);
+                if (person &&
+                    person.lastInboundAt + CHANNEL_DAY_MS > now &&
+                    (await channelCounter(tx, id, `notice:${participantId}`, now, 3_600_000)) < 1 &&
+                    (await channelCounter(tx, id, 'notices', now, CHANNEL_DAY_MS)) < 100) {
+                    event = {
+                        ...event,
+                        state: 'reply',
+                        reply: 'Please wait before sending another question. This assistant has reached a temporary limit.',
+                    };
+                    await channelCounter(tx, id, `notice:${participantId}`, now, 3_600_000, 1);
+                    await channelCounter(tx, id, 'notices', now, CHANNEL_DAY_MS, 1);
+                    pending.push(event);
+                }
+            }
+            await writeChannelEvent(tx, id, event, now);
+            const receipt = { id: eventId, participantId, state: event.state, ...(code ? { code } : {}) };
+            await tx.put(id, channelRow(seenId, 'mutation', { fingerprint, receipt }, now, {
+                expiresAt: now + CHANNEL_RETENTION_MS,
+            }));
+            await channelCounter(tx, id, 'ingress', now, CHANNEL_DAY_MS, 1);
+            receipts.push(receipt);
+        }
+        return receipts;
+    });
+}
+//# sourceMappingURL=channel-inbox.js.map