@noodleseed/one 0.170.0 → 0.171.0

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

@@ -0,0 +1,18 @@
+import type { ChannelStore } from './channel-store.js';
+export interface ChannelProviderBlock {
+    readonly participantId: string;
+    readonly desired: 'blocked' | 'unblocked';
+    readonly state: 'pending' | 'confirmed' | 'error' | 'unknown';
+    readonly actor: string;
+    readonly updatedAt: number;
+    readonly code?: string;
+}
+/** Explicit provider operations have their own evidence; local unblock never invokes this port. */
+export declare function beginChannelProviderBlock(store: ChannelStore, id: string, participantId: string, desired: ChannelProviderBlock['desired'], actor: string, key: string, now: number, protectedPhone?: string): Promise<{
+    address: import("./channel-types.js").ChannelAddress;
+    generation: number;
+    revision: `${string}-${string}-${string}-${string}-${string}`;
+} | undefined>;
+export declare function finishChannelProviderBlock(store: ChannelStore, id: string, participantId: string, revision: string, state: ChannelProviderBlock['state'], now: number, code?: string): Promise<void>;
+export declare function channelProviderBlocks(store: ChannelStore, id: string, now: number, after?: string): Promise<ChannelProviderBlock[]>;
+//# sourceMappingURL=channel-provider-blocks.d.ts.map

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

@@ -0,0 +1,69 @@
+import { randomUUID } from 'node:crypto';
+import { requireChannel } from './channel-coordinator.js';
+import { CHANNEL_DAY_MS, CHANNEL_RETENTION_MS, ChannelError, channelDigest, channelParticipantId, channelRow, channelValue, } from './channel-types.js';
+/** Explicit provider operations have their own evidence; local unblock never invokes this port. */
+export async function beginChannelProviderBlock(store, id, participantId, desired, actor, key, now, protectedPhone) {
+    return store.transaction([id], async (tx) => {
+        const binding = await requireChannel(tx, id);
+        const receipt = `provider-mutation:${channelDigest(key)}`;
+        const fingerprint = channelDigest(JSON.stringify([participantId, desired, actor]));
+        const prior = await channelValue(tx, id, receipt);
+        if (prior) {
+            if (prior.fingerprint !== fingerprint)
+                throw new ChannelError('idempotency_conflict');
+            return undefined;
+        }
+        const participant = await channelValue(tx, id, participantId);
+        const address = protectedPhone
+            ? { kind: 'phone', value: protectedPhone.replace(/^\+/, '') }
+            : participant?.address;
+        if (!address ||
+            address.kind !== 'phone' ||
+            channelParticipantId(binding, address) !== participantId)
+            throw new ChannelError('provider_recipient_unavailable');
+        if (desired === 'blocked' &&
+            (!participant || participant.lastInboundAt + CHANNEL_DAY_MS <= now))
+            throw new ChannelError('provider_block_window_closed');
+        const existing = await channelValue(tx, id, `provider-block:${participantId}`);
+        if (existing?.state === 'pending' && now - existing.updatedAt < 30_000)
+            throw new ChannelError('provider_operation_pending');
+        if (desired === 'unblocked' &&
+            (!existing || (existing.desired === 'unblocked' && existing.state === 'confirmed')))
+            throw new ChannelError('provider_block_not_owned');
+        const operationId = randomUUID();
+        await tx.put(id, channelRow(receipt, 'mutation', { fingerprint }, now, {
+            expiresAt: now + CHANNEL_RETENTION_MS,
+        }));
+        await tx.put(id, channelRow(`provider-block:${participantId}`, 'asset', { participantId, desired, state: 'pending', actor, updatedAt: now, operationId }, now));
+        return { address, generation: binding.generation, revision: operationId };
+    });
+}
+export async function finishChannelProviderBlock(store, id, participantId, revision, state, now, code) {
+    await store.transaction([id], async (tx) => {
+        const key = `provider-block:${participantId}`;
+        const prior = await channelValue(tx, id, key);
+        if (!prior || prior.operationId !== revision || prior.state !== 'pending')
+            throw new ChannelError('revision_conflict');
+        await tx.put(id, channelRow(key, 'asset', { ...prior, state, updatedAt: now, ...(code ? { code } : {}) }, now, prior.desired === 'unblocked' && state === 'confirmed'
+            ? { expiresAt: now + CHANNEL_RETENTION_MS }
+            : {}));
+    });
+}
+export async function channelProviderBlocks(store, id, now, after) {
+    return store.transaction([id], async (tx) => {
+        await requireChannel(tx, id);
+        return (await tx.list(id, {
+            kind: 'asset',
+            limit: 100,
+            ...(after ? { after: `provider-block:${after}` } : {}),
+        }))
+            .filter((row) => row.id.startsWith('provider-block:'))
+            .map((row) => {
+            const record = row.value;
+            return record.state === 'pending' && now - record.updatedAt >= 30_000
+                ? { ...record, state: 'unknown', code: 'provider_outcome_unknown' }
+                : record;
+        });
+    });
+}
+//# sourceMappingURL=channel-provider-blocks.js.map

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

@@ -0,0 +1,82 @@
+import { requireChannel, requireChannelLive } from './channel-coordinator.js';
+import { channelCounter } from './channel-inbox.js';
+import { CHANNEL_DAY_MS, CHANNEL_RETENTION_MS, ChannelError, channelDigest, channelRow, channelValue, } from './channel-types.js';
+const spendId = (attempt) => `spend:${channelDigest(attempt)}`;
+const dayId = (day) => `spend-day:${day}`;
+export async function reserveChannelSpend(store, id, attempt, maximum, now) {
+    if (!Number.isSafeInteger(maximum) || maximum <= 0)
+        throw new ChannelError('spend_bound_unverified');
+    await store.transaction([id], async (tx) => {
+        const binding = await requireChannelLive(tx, id);
+        const old = await channelValue(tx, id, spendId(attempt));
+        if (old)
+            throw new ChannelError('spend_attempt_reused');
+        const day = Math.floor(now / CHANNEL_DAY_MS);
+        const usage = (await channelValue(tx, id, dayId(day))) ?? { reserved: 0, spent: 0 };
+        if (usage.reserved + usage.spent + maximum > binding.limits.dailyMicroUsd)
+            throw new ChannelError('daily_spend_limit');
+        await tx.put(id, channelRow(spendId(attempt), 'spend', { maximum, day }, now, {
+            expiresAt: now + CHANNEL_RETENTION_MS,
+        }));
+        await tx.put(id, channelRow(dayId(day), 'spend', { ...usage, reserved: usage.reserved + maximum }, now, {
+            expiresAt: (day + 9) * CHANNEL_DAY_MS,
+        }));
+    });
+}
+export async function settleChannelSpend(store, id, attempt, actual, now) {
+    if (!Number.isSafeInteger(actual) || actual < 0)
+        throw new ChannelError('spend_usage_invalid');
+    await store.transaction([id], async (tx) => {
+        await requireChannel(tx, id);
+        const record = await channelValue(tx, id, spendId(attempt));
+        if (!record)
+            throw new ChannelError('spend_attempt_missing');
+        if (record.actual !== undefined) {
+            if (record.actual !== actual)
+                throw new ChannelError('spend_settlement_conflict');
+            return;
+        }
+        const usage = await channelValue(tx, id, dayId(record.day));
+        if (!usage)
+            throw new ChannelError('spend_attempt_missing');
+        await tx.put(id, channelRow(spendId(attempt), 'spend', { ...record, actual }, now, {
+            expiresAt: now + CHANNEL_RETENTION_MS,
+        }));
+        await tx.put(id, channelRow(dayId(record.day), 'spend', { reserved: usage.reserved - record.maximum, spent: usage.spent + actual }, now, { expiresAt: (record.day + 9) * CHANNEL_DAY_MS }));
+        // Record actual cost even when a deployment's declared bound was violated, then stop this channel.
+        if (actual > record.maximum) {
+            const binding = await requireChannel(tx, id);
+            await tx.put(id, channelRow('binding', 'binding', {
+                ...binding,
+                state: 'paused',
+                generation: binding.generation + 1,
+                revision: binding.revision + 1,
+            }, now));
+        }
+    });
+}
+export async function channelUsage(store, id, now) {
+    return store.transaction([id], async (tx) => {
+        const binding = await requireChannel(tx, id);
+        const day = Math.floor(now / CHANNEL_DAY_MS);
+        const usage = (await channelValue(tx, id, dayId(day))) ?? { reserved: 0, spent: 0 };
+        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));
+        return {
+            resetAt: (day + 1) * CHANNEL_DAY_MS,
+            admittedToday: await channelCounter(tx, id, 'all', now, CHANNEL_DAY_MS),
+            newParticipantsToday: await channelCounter(tx, id, 'new', now, CHANNEL_DAY_MS),
+            pending: pending.length,
+            oldestPendingAt: pending.length
+                ? Math.min(...pending.map((event) => event.receivedAt))
+                : null,
+            unknownSends: await tx.count(id, 'event', 'unknown', now),
+            day: new Date(day * CHANNEL_DAY_MS).toISOString().slice(0, 10),
+            dailyMicroUsd: binding.limits.dailyMicroUsd,
+            reservedMicroUsd: usage.reserved,
+            spentMicroUsd: usage.spent,
+        };
+    });
+}
+//# sourceMappingURL=channel-spend.js.map

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

@@ -0,0 +1,42 @@
+/** Private channel journal. Each binding is a transaction/lease authority, not a browser session. */
+export interface ChannelRow {
+    readonly id: string;
+    readonly kind: 'binding' | 'asset' | 'participant' | 'event' | 'counter' | 'spend' | 'block' | 'mutation';
+    readonly state?: string;
+    readonly updatedAt: number;
+    readonly expiresAt?: number;
+    readonly value: unknown;
+}
+export interface ChannelScan {
+    readonly kind: ChannelRow['kind'];
+    readonly state?: string;
+    readonly after?: string;
+    readonly limit: number;
+}
+export interface ChannelTransaction {
+    get(scope: string, id: string): Promise<ChannelRow | undefined>;
+    put(scope: string, row: ChannelRow): Promise<void>;
+    remove(scope: string, id: string): Promise<void>;
+    count(scope: string, kind: ChannelRow['kind'], state: string, now: number): Promise<number>;
+    list(scope: string, scan: ChannelScan): Promise<readonly ChannelRow[]>;
+}
+export interface ChannelStore {
+    readonly durable: boolean;
+    transaction<T>(locks: readonly string[], work: (tx: ChannelTransaction) => Promise<T>): Promise<T>;
+    prune(now: number, limit: number): Promise<number>;
+}
+/** Composition supplies authenticated encryption bound to both channel and record identity. */
+export interface ChannelCipher {
+    seal(scope: string, id: string, value: unknown): Promise<unknown>;
+    open(scope: string, id: string, sealed: unknown): Promise<unknown>;
+}
+export declare function channelScanLimit(limit: number): number;
+export declare function requireChannelLock(locks: readonly string[], scope: string): void;
+/** Isolated local development adapter; never an acknowledged hosted-message authority. */
+export declare class InMemoryChannelStore implements ChannelStore {
+    #private;
+    readonly durable = false;
+    transaction<T>(locks: readonly string[], work: (tx: ChannelTransaction) => Promise<T>): Promise<T>;
+    prune(now: number, limit: number): Promise<number>;
+}
+//# sourceMappingURL=channel-store.d.ts.map

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

@@ -0,0 +1,76 @@
+export function channelScanLimit(limit) {
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
+        throw new Error('invalid channel scan limit');
+    return limit;
+}
+export function requireChannelLock(locks, scope) {
+    if (!locks.includes(scope))
+        throw new Error('channel transaction requires scope lock');
+}
+/** Isolated local development adapter; never an acknowledged hosted-message authority. */
+export class InMemoryChannelStore {
+    durable = false;
+    #rows = new Map();
+    #tail = Promise.resolve();
+    async transaction(locks, work) {
+        const preceding = this.#tail;
+        let release = () => { };
+        this.#tail = new Promise((resolve) => {
+            release = resolve;
+        });
+        await preceding;
+        const rows = structuredClone(this.#rows);
+        const scoped = (scope) => {
+            requireChannelLock(locks, scope);
+            let result = rows.get(scope);
+            if (!result) {
+                result = new Map();
+                rows.set(scope, result);
+            }
+            return result;
+        };
+        try {
+            const result = await work({
+                get: async (scope, id) => structuredClone(scoped(scope).get(id)),
+                put: async (scope, row) => {
+                    scoped(scope).set(row.id, structuredClone(row));
+                },
+                remove: async (scope, id) => {
+                    scoped(scope).delete(id);
+                },
+                count: async (scope, kind, state, now) => [...scoped(scope).values()].filter((row) => row.kind === kind &&
+                    row.state === state &&
+                    (row.expiresAt === undefined || row.expiresAt > now)).length,
+                list: async (scope, scan) => [...scoped(scope).values()]
+                    .filter((row) => row.kind === scan.kind &&
+                    (scan.state === undefined || row.state === scan.state) &&
+                    (scan.after === undefined || row.id > scan.after))
+                    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+                    .slice(0, channelScanLimit(scan.limit))
+                    .map((row) => structuredClone(row)),
+            });
+            this.#rows = rows;
+            return result;
+        }
+        finally {
+            release();
+        }
+    }
+    async prune(now, limit) {
+        channelScanLimit(limit);
+        // Share the transaction lock with writes, including scopes first created concurrently.
+        const scopes = [...this.#rows.keys()];
+        return this.transaction(scopes, async (tx) => {
+            let removed = 0;
+            for (const scope of scopes)
+                for (const row of this.#rows.get(scope)?.values() ?? []) {
+                    if (removed < limit && row.expiresAt !== undefined && row.expiresAt <= now) {
+                        await tx.remove(scope, row.id);
+                        removed++;
+                    }
+                }
+            return removed;
+        });
+    }
+}
+//# sourceMappingURL=channel-store.js.map

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

@@ -0,0 +1,134 @@
+import type { ChannelRow, ChannelTransaction } from './channel-store.js';
+import type { TenantRef } from './tenant-ref.js';
+export declare const CHANNEL_DAY_MS = 86400000;
+export declare const CHANNEL_RETENTION_MS: number;
+export declare const CHANNEL_REGISTRY = "assistant-channels";
+export declare const CHANNEL_DEFAULT_LIMITS: Readonly<{
+    perMinute: 10;
+    perHour: 60;
+    perDay: 200;
+    channelPerDay: 1000;
+    newParticipantsPerDay: 200;
+    concurrent: 5;
+    pendingPerParticipant: 3;
+    pending: 100;
+    textCharacters: 4000;
+    dailyMicroUsd: 20000000;
+}>;
+export type ChannelLimits = {
+    -readonly [K in keyof typeof CHANNEL_DEFAULT_LIMITS]: number;
+};
+export type ChannelLimitsInput = {
+    [K in keyof ChannelLimits]?: number | undefined;
+};
+export type ChannelCapability = {
+    readonly kind: 'tool' | 'knowledge';
+    readonly name: string;
+};
+export interface ChannelBinding {
+    readonly id: string;
+    readonly tenant: TenantRef;
+    readonly provider: '360dialog';
+    readonly phoneNumberId: string;
+    readonly apiKeySecret: string;
+    readonly webhookSecret: string;
+    readonly deploymentId: string;
+    readonly capabilities: readonly ChannelCapability[];
+    readonly supportEmail: string;
+    readonly revision: number;
+    readonly generation: number;
+    readonly state: 'paused' | 'enabled' | 'disconnected';
+    /** Private, encrypted indexing seed. Never projected to an operator response or model. */
+    readonly indexKey: string;
+    readonly credentialDigest?: string;
+    readonly limits: ChannelLimits;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly actor: string;
+    readonly readyRevision?: number | undefined;
+    readonly readyAt?: number | undefined;
+}
+export type ChannelConfigure = Pick<ChannelBinding, 'tenant' | 'phoneNumberId' | 'apiKeySecret' | 'webhookSecret' | 'deploymentId' | 'capabilities' | 'supportEmail'> & {
+    readonly limits?: ChannelLimitsInput | undefined;
+};
+export interface ChannelAddress {
+    readonly kind: 'phone' | 'opaque';
+    readonly value: string;
+}
+export interface ChannelHistory {
+    readonly role: 'user' | 'assistant';
+    readonly content: string;
+    readonly at: number;
+}
+export interface ChannelParticipant {
+    readonly id: string;
+    readonly address: ChannelAddress;
+    readonly lastInboundAt: number;
+    readonly history: readonly ChannelHistory[];
+    readonly strikes: readonly number[];
+    readonly deploymentId?: string;
+    readonly modelToolUses?: readonly string[];
+    readonly cooldownUntil?: number;
+}
+export type ChannelEventState = 'queued' | 'running' | 'reply' | 'sending' | 'accepted' | 'delivered' | 'read' | 'refused' | 'expired' | 'failed' | 'cancelled' | 'unknown';
+export interface ChannelEvent {
+    readonly id: string;
+    readonly participantId: string;
+    readonly providerId: string;
+    readonly providerMessageId?: string;
+    readonly text?: string;
+    readonly reply?: string;
+    readonly eventAt: number;
+    readonly receivedAt: number;
+    readonly generation: number;
+    readonly deploymentId: string;
+    readonly state: ChannelEventState;
+    readonly attempts: number;
+    readonly lease?: string | undefined;
+    readonly leaseUntil?: number | undefined;
+    readonly turnDeadline?: number;
+    readonly code?: string;
+}
+export interface ChannelInbound {
+    readonly providerId: string;
+    readonly address: ChannelAddress;
+    readonly eventAt: number;
+    readonly text?: string;
+}
+export declare class ChannelError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function channelDigest(value: string): string;
+export declare function channelTenantKey(tenant: TenantRef): string;
+export declare function channelParticipantId(binding: ChannelBinding, address: ChannelAddress): string;
+export declare function sameChannelTenant(left: TenantRef, right: TenantRef): boolean;
+export declare function channelLimits(input?: ChannelLimitsInput): ChannelLimits;
+/** Row values are private, encrypted implementation records, never unchecked API payloads. */
+export declare function channelValue<T>(tx: ChannelTransaction, scope: string, id: string): Promise<T | undefined>;
+export declare function channelRow(id: string, kind: ChannelRow['kind'], value: unknown, now: number, options?: {
+    state?: string;
+    expiresAt?: number;
+}): ChannelRow;
+export declare function writeChannelEvent(tx: ChannelTransaction, scope: string, event: ChannelEvent, now: number): Promise<void>;
+export declare function publicChannelBinding(binding: ChannelBinding): {
+    id: string;
+    tenant: TenantRef;
+    provider: "360dialog";
+    phoneNumberId: string;
+    apiKeySecret: string;
+    webhookSecret: string;
+    deploymentId: string;
+    capabilities: readonly ChannelCapability[];
+    supportEmail: string;
+    revision: number;
+    generation: number;
+    state: "paused" | "enabled" | "disconnected";
+    limits: ChannelLimits;
+    createdAt: number;
+    updatedAt: number;
+    actor: string;
+    readyRevision?: number | undefined;
+    readyAt?: number | undefined;
+};
+//# sourceMappingURL=channel-types.d.ts.map

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

@@ -0,0 +1,72 @@
+import { createHash, createHmac } from 'node:crypto';
+export const CHANNEL_DAY_MS = 86_400_000;
+export const CHANNEL_RETENTION_MS = 7 * CHANNEL_DAY_MS;
+export const CHANNEL_REGISTRY = 'assistant-channels';
+export const CHANNEL_DEFAULT_LIMITS = Object.freeze({
+    perMinute: 10,
+    perHour: 60,
+    perDay: 200,
+    channelPerDay: 1000,
+    newParticipantsPerDay: 200,
+    concurrent: 5,
+    pendingPerParticipant: 3,
+    pending: 100,
+    textCharacters: 4000,
+    dailyMicroUsd: 20_000_000,
+});
+export class ChannelError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'ChannelError';
+    }
+}
+export function channelDigest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+export function channelTenantKey(tenant) {
+    return `tenant:${channelDigest(JSON.stringify([tenant.org, tenant.app, tenant.env]))}`;
+}
+export function channelParticipantId(binding, address) {
+    return `p_${createHmac('sha256', Buffer.from(binding.indexKey, 'base64'))
+        .update(JSON.stringify([binding.id, address.kind, address.value]))
+        .digest('hex')}`;
+}
+export function sameChannelTenant(left, right) {
+    return left.org === right.org && left.app === right.app && left.env === right.env;
+}
+export function channelLimits(input = {}) {
+    const limits = { ...CHANNEL_DEFAULT_LIMITS };
+    for (const key of Object.keys(input)) {
+        if (!(key in limits))
+            throw new ChannelError('limits_invalid');
+        const name = key;
+        const value = input[name];
+        if (value === undefined ||
+            !Number.isSafeInteger(value) ||
+            value < 0 ||
+            value > CHANNEL_DEFAULT_LIMITS[name])
+            throw new ChannelError('limits_invalid');
+        limits[name] = value;
+    }
+    return limits;
+}
+/** Row values are private, encrypted implementation records, never unchecked API payloads. */
+export async function channelValue(tx, scope, id) {
+    return (await tx.get(scope, id))?.value;
+}
+export function channelRow(id, kind, value, now, options = {}) {
+    return { id, kind, value, updatedAt: now, ...options };
+}
+export async function writeChannelEvent(tx, scope, event, now) {
+    await tx.put(scope, channelRow(event.id, 'event', event, now, {
+        state: event.state,
+        expiresAt: event.receivedAt + CHANNEL_RETENTION_MS,
+    }));
+}
+export function publicChannelBinding(binding) {
+    const { indexKey: _privateIndexKey, credentialDigest: _credentialDigest, ...visible } = binding;
+    return visible;
+}
+//# sourceMappingURL=channel-types.js.map

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

@@ -0,0 +1,20 @@
+import type { ChannelStore } from './channel-store.js';
+import { type ChannelBinding, type ChannelEvent, type ChannelParticipant } from './channel-types.js';
+export interface ChannelWork {
+    readonly binding: ChannelBinding;
+    readonly participant: ChannelParticipant;
+    readonly event: ChannelEvent;
+}
+export declare function claimChannelTurn(store: ChannelStore, id: string, now: number, retentionMs?: number): Promise<ChannelWork | undefined>;
+export declare function renewChannelTurn(store: ChannelStore, id: string, eventId: string, lease: string, now: number): Promise<void>;
+export declare function completeChannelTurn(store: ChannelStore, id: string, eventId: string, lease: string, reply: string, now: number, retentionMs?: number, code?: string): Promise<void>;
+export declare function prepareChannelSend(store: ChannelStore, id: string, now: number): Promise<ChannelWork | undefined>;
+export declare function updateChannelSend(store: ChannelStore, id: string, eventId: string, lease: string, result: {
+    state: 'accepted' | 'unknown' | 'failed';
+    providerMessageId?: string;
+    code?: string;
+}, now: number): Promise<void>;
+export declare function recordChannelDelivery(store: ChannelStore, id: string, providerMessageId: string, state: 'sent' | 'delivered' | 'read' | 'failed', now: number): Promise<void>;
+/** Last local fence before the adapter starts external IO; already dispatched work cannot be recalled. */
+export declare function assertChannelSend(store: ChannelStore, id: string, eventId: string, lease: string, now: number): Promise<void>;
+//# sourceMappingURL=channel-work.d.ts.map