@noodleseed/one 0.170.0 → 0.171.0

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

@@ -0,0 +1,159 @@
+import { randomUUID } from 'node:crypto';
+import { continuityDigest, continuityHandle, continuityMaxRestores, continuityWindowMs, } from './continuity-store.js';
+function toRecord(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        tenant: { org: row.org_slug, app: row.app_slug, env: row.environment },
+        context: {
+            embedId: row.embed_id,
+            originHash: row.origin_hash,
+            visitorHash: row.visitor_hash,
+        },
+        handleHash: row.handle_hash,
+        restoreCount: row.restore_count,
+        maxRestores: row.max_restores,
+        createdAt: row.created_at.toISOString(),
+        expiresAt: row.expires_at.toISOString(),
+        ...(row.claimed_at === null ? {} : { claimedAt: row.claimed_at.toISOString() }),
+    };
+}
+/**
+ * Durable continuity handles (ADR 0223, clauses 11-16).
+ *
+ * Its own table, deliberately not a second row kind in `assistant_elevations`. A display-only handle and
+ * an identity-transition ticket must not share storage, so that a defect in either cannot reach the
+ * other and a reader never has to work out which rows are dangerous.
+ *
+ * Two properties are enforced by the database rather than by application order, exactly as they are for
+ * elevations. A **partial unique index over unclaimed rows** keeps at most one live handle per session,
+ * so each turn's handle supersedes rather than accumulating one live key per turn. And the claim is a
+ * **single statement** — `UPDATE … WHERE claimed_at IS NULL … RETURNING` — because two backends racing
+ * one handle is precisely the case a read-then-write loses, and the loser would restore a second time.
+ *
+ * The refusal reasons are distinguished by re-reading the row *without* consuming it: a wrong-context
+ * probe must not spend the rightful visitor's handle, or reading someone's conversation becomes
+ * unnecessary and denying it becomes trivial.
+ */
+export class PostgresAssistantContinuityStore {
+    #pool;
+    constructor(pool) {
+        this.#pool = pool;
+    }
+    async ensureSchema() {
+        await this.#pool.query(`
+      CREATE TABLE IF NOT EXISTS assistant_continuity_handles (
+        id text PRIMARY KEY,
+        session_id text NOT NULL,
+        org_slug text NOT NULL,
+        app_slug text NOT NULL,
+        environment text NOT NULL,
+        embed_id text NOT NULL,
+        origin_hash text NOT NULL,
+        visitor_hash text NOT NULL,
+        handle_hash text NOT NULL,
+        restore_count integer NOT NULL DEFAULT 0,
+        max_restores integer NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        expires_at timestamptz NOT NULL,
+        claimed_at timestamptz
+      )
+    `);
+        await this.#pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS assistant_continuity_handle_key
+         ON assistant_continuity_handles (handle_hash)`);
+        await this.#pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS assistant_continuity_live_session_key
+         ON assistant_continuity_handles (session_id) WHERE claimed_at IS NULL`);
+        // Retention is part of this store rather than an afterthought: handles are short-lived and must be
+        // swept, not accumulated, and the sweep needs this index to stay cheap as the table grows.
+        await this.#pool.query(`CREATE INDEX IF NOT EXISTS assistant_continuity_expires_at_idx
+         ON assistant_continuity_handles (expires_at)`);
+    }
+    async issue(input) {
+        return this.#write({ ...input, restoreCount: 0 });
+    }
+    async claim(input) {
+        const hash = continuityDigest(input.handle);
+        const { rows } = await this.#pool.query(`UPDATE assistant_continuity_handles
+          SET claimed_at = $2, restore_count = restore_count + 1
+        WHERE handle_hash = $1
+          AND claimed_at IS NULL
+          AND expires_at > $2
+          AND embed_id = $3 AND origin_hash = $4 AND visitor_hash = $5
+        RETURNING *`, [
+            hash,
+            input.now.toISOString(),
+            input.context.embedId,
+            input.context.originHash,
+            input.context.visitorHash,
+        ]);
+        const claimed = rows[0];
+        if (!claimed)
+            return this.#explainRefusal(hash, input.context);
+        const record = toRecord(claimed);
+        if (record.restoreCount >= record.maxRestores)
+            return { ok: true, record };
+        const rotated = await this.#write({
+            sessionId: record.sessionId,
+            tenant: record.tenant,
+            context: record.context,
+            // Re-derive from the record so a rotation can never widen what the first issue clamped.
+            windowMs: Date.parse(record.expiresAt) - Date.parse(record.createdAt),
+            maxRestores: record.maxRestores,
+            restoreCount: record.restoreCount,
+            now: input.now,
+        });
+        return rotated === undefined
+            ? { ok: true, record }
+            : { ok: true, record, handle: rotated.handle };
+    }
+    /** Remove spent and expired rows. Callers may lag expiry: `claim` already refuses a stale handle. */
+    async sweepExpired(input) {
+        const { rowCount } = await this.#pool.query('DELETE FROM assistant_continuity_handles WHERE expires_at <= $1 OR claimed_at IS NOT NULL', [input.now.toISOString()]);
+        return rowCount ?? 0;
+    }
+    async #explainRefusal(hash, context) {
+        const { rows } = await this.#pool.query('SELECT * FROM assistant_continuity_handles WHERE handle_hash = $1', [hash]);
+        const row = rows[0];
+        if (!row || row.claimed_at !== null)
+            return { ok: false, reason: 'unknown' };
+        if (row.embed_id !== context.embedId ||
+            row.origin_hash !== context.originHash ||
+            row.visitor_hash !== context.visitorHash) {
+            return { ok: false, reason: 'context_mismatch' };
+        }
+        return { ok: false, reason: 'expired' };
+    }
+    async #write(input) {
+        const windowMs = continuityWindowMs(input.windowMs);
+        const maxRestores = continuityMaxRestores(input.maxRestores);
+        if (windowMs === 0 || maxRestores === 0)
+            return undefined;
+        // Delete before insert so the partial unique index cannot reject the supersede.
+        await this.#pool.query('DELETE FROM assistant_continuity_handles WHERE session_id = $1 AND claimed_at IS NULL', [input.sessionId]);
+        const handle = continuityHandle();
+        const { rows } = await this.#pool.query(`INSERT INTO assistant_continuity_handles
+         (id, session_id, org_slug, app_slug, environment, embed_id, origin_hash, visitor_hash,
+          handle_hash, restore_count, max_restores, created_at, expires_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+       RETURNING *`, [
+            `cont_${randomUUID().replaceAll('-', '')}`,
+            input.sessionId,
+            input.tenant.org,
+            input.tenant.app,
+            input.tenant.env,
+            input.context.embedId,
+            input.context.originHash,
+            input.context.visitorHash,
+            continuityDigest(handle),
+            input.restoreCount,
+            maxRestores,
+            input.now.toISOString(),
+            new Date(input.now.getTime() + windowMs).toISOString(),
+        ]);
+        const row = rows[0];
+        if (!row)
+            throw new Error('continuity insert returned no row');
+        return { record: toRecord(row), handle };
+    }
+}
+//# sourceMappingURL=postgres-continuity-store.js.map

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

@@ -0,0 +1,110 @@
+import { randomUUID } from 'node:crypto';
+import { ASSISTANT_ELEVATION_TTL_MS, elevationContinuation, elevationDigest, } from './elevation-store.js';
+function toRecord(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        tenant: { org: row.org_slug, app: row.app_slug, env: row.environment },
+        tool: row.tool,
+        claimableStateHandles: [...(row.claimable_state_handles ?? [])],
+        continuationHash: row.continuation_hash,
+        createdAt: row.created_at.toISOString(),
+        expiresAt: row.expires_at.toISOString(),
+        ...(row.claimed_at === null ? {} : { claimedAt: row.claimed_at.toISOString() }),
+    };
+}
+/**
+ * Durable elevation continuations.
+ *
+ * Two properties are load-bearing and both are enforced by the database rather than by application
+ * order. A **partial unique index over unclaimed rows** keeps at most one live elevation per session, so
+ * a model asking twice supersedes rather than accumulating keys to the same conversation. And the claim
+ * is a **single statement** — `UPDATE … WHERE claimed_at IS NULL … RETURNING` — because two backends
+ * racing the same continuation is exactly the case a read-then-write loses, and the loser would elevate
+ * a second time.
+ *
+ * The refusal reasons are distinguished by re-reading the row *without* consuming it: a tenant mismatch
+ * must not spend the rightful owner's continuation, or a probe becomes a denial of service.
+ */
+export class PostgresAssistantElevationStore {
+    #pool;
+    constructor(pool) {
+        this.#pool = pool;
+    }
+    async ensureSchema() {
+        await this.#pool.query(`
+      CREATE TABLE IF NOT EXISTS assistant_elevations (
+        id text PRIMARY KEY,
+        session_id text NOT NULL,
+        org_slug text NOT NULL,
+        app_slug text NOT NULL,
+        environment text NOT NULL,
+        tool text NOT NULL,
+        claimable_state_handles jsonb NOT NULL DEFAULT '[]'::jsonb,
+        continuation_hash text NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        expires_at timestamptz NOT NULL,
+        claimed_at timestamptz
+      )
+    `);
+        await this.#pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS assistant_elevations_continuation_key
+         ON assistant_elevations (continuation_hash)`);
+        await this.#pool.query(`
+      ALTER TABLE assistant_elevations
+        ADD COLUMN IF NOT EXISTS claimable_state_handles jsonb NOT NULL DEFAULT '[]'::jsonb
+    `);
+        await this.#pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS assistant_elevations_live_session_key
+         ON assistant_elevations (session_id) WHERE claimed_at IS NULL`);
+    }
+    async request(input) {
+        // Delete before insert so the partial unique index cannot reject the supersede.
+        await this.#pool.query('DELETE FROM assistant_elevations WHERE session_id = $1 AND claimed_at IS NULL', [input.sessionId]);
+        const continuation = elevationContinuation();
+        const { rows } = await this.#pool.query(`INSERT INTO assistant_elevations
+         (id, session_id, org_slug, app_slug, environment, tool, claimable_state_handles,
+          continuation_hash, created_at, expires_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8, $9, $10)
+       RETURNING *`, [
+            `elev_${randomUUID().replaceAll('-', '')}`,
+            input.sessionId,
+            input.tenant.org,
+            input.tenant.app,
+            input.tenant.env,
+            input.tool,
+            JSON.stringify([...(input.claimableStateHandles ?? [])].sort()),
+            elevationDigest(continuation),
+            input.now.toISOString(),
+            new Date(input.now.getTime() + ASSISTANT_ELEVATION_TTL_MS).toISOString(),
+        ]);
+        const row = rows[0];
+        if (!row)
+            throw new Error('elevation insert returned no row');
+        return { elevation: toRecord(row), continuation };
+    }
+    async claim(input) {
+        const hash = elevationDigest(input.continuation);
+        const { rows } = await this.#pool.query(`UPDATE assistant_elevations
+          SET claimed_at = $2
+        WHERE continuation_hash = $1
+          AND claimed_at IS NULL
+          AND expires_at > $2
+          AND org_slug = $3 AND app_slug = $4 AND environment = $5
+        RETURNING *`, [hash, input.now.toISOString(), input.tenant.org, input.tenant.app, input.tenant.env]);
+        const claimed = rows[0];
+        if (claimed)
+            return { ok: true, elevation: toRecord(claimed) };
+        // Nothing was spent. Re-read to say *why* without consuming anything, so a wrong-tenant probe
+        // cannot deny the rightful owner their elevation.
+        const { rows: existing } = await this.#pool.query('SELECT * FROM assistant_elevations WHERE continuation_hash = $1', [hash]);
+        const row = existing[0];
+        if (!row || row.claimed_at !== null)
+            return { ok: false, reason: 'unknown' };
+        if (row.org_slug !== input.tenant.org ||
+            row.app_slug !== input.tenant.app ||
+            row.environment !== input.tenant.env) {
+            return { ok: false, reason: 'tenant_mismatch' };
+        }
+        return { ok: false, reason: 'expired' };
+    }
+}
+//# sourceMappingURL=postgres-elevation-store.js.map

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

@@ -0,0 +1,134 @@
+import { newPublicEmbedId } from './in-memory-embed-store.js';
+function toRecord(row) {
+    return {
+        embedId: row.embed_id,
+        org: row.org_slug,
+        app: row.app_slug,
+        env: row.environment,
+        surfaceMode: row.surface_mode,
+        createdAt: row.created_at,
+        ...(row.revoked_at === null ? {} : { revokedAt: row.revoked_at }),
+        // `bigint` arrives as a string; null stays undefined so "no override" and "zero" never merge.
+        ...(row.turns_per_day === null ? {} : { turnsPerDay: Number(row.turns_per_day) }),
+        ...(row.mints_per_day === null ? {} : { mintsPerDay: Number(row.mints_per_day) }),
+        ...(row.mints_per_address_hour === null
+            ? {}
+            : { mintsPerAddressHour: Number(row.mints_per_address_hour) }),
+        ...(row.turns_per_address_hour === null
+            ? {}
+            : { turnsPerAddressHour: Number(row.turns_per_address_hour) }),
+        ...(row.bridge_tool_calls_per_session === null
+            ? {}
+            : { bridgeToolCallsPerSession: Number(row.bridge_tool_calls_per_session) }),
+        ...(row.bridge_tool_calls_per_day === null
+            ? {}
+            : { bridgeToolCallsPerDay: Number(row.bridge_tool_calls_per_day) }),
+    };
+}
+/**
+ * Durable public embed identifiers.
+ *
+ * The table has **no secret column** — see `embed-store.ts` for why that is the point rather than an
+ * omission. A partial unique index over live rows is what makes `ensure` idempotent under concurrency:
+ * two simultaneous deploys of the same tenant surface cannot mint two live ids, and a revoked row does
+ * not block a later one, so revoke-then-redeploy issues a genuinely new id instead of reviving the old.
+ */
+export class PostgresPublicEmbedStore {
+    #pool;
+    constructor(pool) {
+        this.#pool = pool;
+    }
+    async ensureSchema() {
+        await this.#pool.query(`
+      CREATE TABLE IF NOT EXISTS assistant_public_embeds (
+        embed_id text PRIMARY KEY,
+        org_slug text NOT NULL,
+        app_slug text NOT NULL,
+        environment text NOT NULL,
+        surface_mode text NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        revoked_at timestamptz
+      )
+    `);
+        await this.#pool.query('ALTER TABLE assistant_public_embeds ADD COLUMN IF NOT EXISTS turns_per_day bigint');
+        await this.#pool.query('ALTER TABLE assistant_public_embeds ADD COLUMN IF NOT EXISTS mints_per_day bigint');
+        await this.#pool.query('ALTER TABLE assistant_public_embeds ADD COLUMN IF NOT EXISTS mints_per_address_hour bigint');
+        await this.#pool.query('ALTER TABLE assistant_public_embeds ADD COLUMN IF NOT EXISTS turns_per_address_hour bigint');
+        // The bridge budgets became operator-settable after they shipped platform-only (ADR 0220);
+        // additive like every column above it, so an existing row simply keeps using the defaults.
+        await this.#pool.query('ALTER TABLE assistant_public_embeds ADD COLUMN IF NOT EXISTS bridge_tool_calls_per_session bigint');
+        await this.#pool.query('ALTER TABLE assistant_public_embeds ADD COLUMN IF NOT EXISTS bridge_tool_calls_per_day bigint');
+        await this.#pool.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS assistant_public_embeds_live
+        ON assistant_public_embeds (org_slug, app_slug, environment)
+        WHERE revoked_at IS NULL
+    `);
+    }
+    async ensure(input) {
+        // `DO NOTHING` plus a follow-up read rather than `DO UPDATE`: a redeploy must return the *existing*
+        // id untouched, including its original `created_at`, because that id is already in page source.
+        const inserted = await this.#pool.query(`INSERT INTO assistant_public_embeds
+         (embed_id, org_slug, app_slug, environment, surface_mode, created_at)
+       SELECT $1, $2, $3, $4, $5, $6
+       WHERE $7::boolean OR NOT EXISTS (SELECT 1 FROM assistant_public_embeds
+         WHERE org_slug = $2 AND app_slug = $3 AND environment = $4)
+       ON CONFLICT DO NOTHING
+       RETURNING *`, [
+            newPublicEmbedId(),
+            input.org,
+            input.app,
+            input.env,
+            input.surfaceMode,
+            input.now,
+            input.allowRevokedReplacement !== false,
+        ]);
+        const row = inserted.rows[0];
+        if (row !== undefined)
+            return toRecord(row);
+        const existing = await this.#pool.query(`SELECT * FROM assistant_public_embeds
+       WHERE org_slug = $1 AND app_slug = $2 AND environment = $3 AND revoked_at IS NULL`, [input.org, input.app, input.env]);
+        const found = existing.rows[0];
+        if (found === undefined)
+            throw new Error('public embed id could not be resolved after insert');
+        return toRecord(found);
+    }
+    async setBudget(embedId, budget, _now) {
+        // COALESCE on the parameter, not the column: passing null leaves that cap as it was, so raising
+        // turns cannot quietly clear a mint ceiling someone set separately.
+        const result = await this.#pool.query(`UPDATE assistant_public_embeds
+         SET turns_per_day = COALESCE($2::bigint, turns_per_day),
+             mints_per_day = COALESCE($3::bigint, mints_per_day),
+             mints_per_address_hour = COALESCE($4::bigint, mints_per_address_hour),
+             turns_per_address_hour = COALESCE($5::bigint, turns_per_address_hour),
+             bridge_tool_calls_per_session = COALESCE($6::bigint, bridge_tool_calls_per_session),
+             bridge_tool_calls_per_day = COALESCE($7::bigint, bridge_tool_calls_per_day)
+       WHERE embed_id = $1 AND revoked_at IS NULL
+       RETURNING *`, [
+            embedId,
+            budget.turnsPerDay ?? null,
+            budget.mintsPerDay ?? null,
+            budget.mintsPerAddressHour ?? null,
+            budget.turnsPerAddressHour ?? null,
+            budget.bridgeToolCallsPerSession ?? null,
+            budget.bridgeToolCallsPerDay ?? null,
+        ]);
+        const row = result.rows[0];
+        return row === undefined ? undefined : toRecord(row);
+    }
+    async lookup(embedId) {
+        const result = await this.#pool.query('SELECT * FROM assistant_public_embeds WHERE embed_id = $1 AND revoked_at IS NULL', [embedId]);
+        const row = result.rows[0];
+        return row === undefined ? undefined : toRecord(row);
+    }
+    async list(tenant, options) {
+        const result = await this.#pool.query(`SELECT * FROM assistant_public_embeds
+       WHERE org_slug = $1 AND app_slug = $2 AND environment = $3 AND ($4::boolean OR revoked_at IS NULL)
+       ORDER BY created_at`, [tenant.org, tenant.app, tenant.env, options?.includeRevoked === true]);
+        return result.rows.map(toRecord);
+    }
+    async revoke(embedId, now) {
+        const result = await this.#pool.query('UPDATE assistant_public_embeds SET revoked_at = $2 WHERE embed_id = $1 AND revoked_at IS NULL', [embedId, now]);
+        return (result.rowCount ?? 0) > 0;
+    }
+}
+//# sourceMappingURL=postgres-embed-store.js.map

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

@@ -0,0 +1,11 @@
+/** PostgreSQL assistant adapters for hosted service composition only. */
+export * from './postgres-assistant.js';
+export * from './postgres-assistant-appearance-store.js';
+export * from './postgres-assistant-elevation.js';
+export * from './postgres-assistant-interaction-writes.js';
+export * from './postgres-assistant-interactions.js';
+export * from './postgres-channel-store.js';
+export * from './postgres-continuity-store.js';
+export * from './postgres-elevation-store.js';
+export * from './postgres-embed-store.js';
+//# sourceMappingURL=postgres.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/public-surface.d.ts

@@ -39,4 +39,12 @@ export declare function surfaceBindingForOrigin(assistant: unknown, origin: stri
     readonly kind: 'pre-surfaces';
 };
 export declare function publicSurfaceOf(assistant: unknown): PublicSurface | undefined;
+export interface MessagingSurface {
+    readonly kind: 'messaging';
+    readonly channel: 'whatsapp';
+    readonly mode: 'public';
+    readonly capabilities: readonly SurfaceCapabilityRef[];
+    readonly instructions?: string;
+}
+export declare function messagingSurfaceOf(assistant: unknown): MessagingSurface | undefined;
 //# sourceMappingURL=public-surface.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/public-surface.js

@@ -4,6 +4,8 @@ export function authenticatedSurfaceOf(assistant) {
     if (!Array.isArray(surfaces))
         return undefined;
     for (const entry of surfaces) {
+        if (entry?.kind === 'messaging')
+            continue;
         const { mode, origins, capabilities, instructions } = entry;
         if (mode !== 'authenticated')
             continue;
@@ -42,6 +44,8 @@ export function publicSurfaceOf(assistant) {
     if (!Array.isArray(surfaces))
         return undefined;
     for (const entry of surfaces) {
+        if (entry?.kind === 'messaging')
+            continue;
         const { mode, origins, capabilities, instructions } = entry;
         // A mixed surface admits strangers exactly as a public one does — sign-in only widens what a visitor
         // reaches after elevation, so both provision an embed id and both project.
@@ -61,4 +65,23 @@ export function publicSurfaceOf(assistant) {
     }
     return undefined;
 }
+export function messagingSurfaceOf(assistant) {
+    const surfaces = assistant?.surfaces;
+    if (!Array.isArray(surfaces))
+        return undefined;
+    for (const entry of surfaces) {
+        if (entry?.kind !== 'messaging' || entry.channel !== 'whatsapp' || entry.mode !== 'public')
+            continue;
+        if (!Array.isArray(entry.capabilities))
+            return undefined;
+        return {
+            kind: 'messaging',
+            channel: 'whatsapp',
+            mode: 'public',
+            capabilities: entry.capabilities,
+            ...(typeof entry.instructions === 'string' ? { instructions: entry.instructions } : {}),
+        };
+    }
+    return undefined;
+}
 //# sourceMappingURL=public-surface.js.map

package/node_modules/@noodle-borg/authoring/dist/assistant.d.ts

@@ -162,6 +162,7 @@ export interface AssistantCapability {
  */
 export type AssistantSurfaceMode = 'authenticated' | 'public' | 'mixed';
 export interface AuthenticatedWebsiteAccess {
+    readonly kind?: 'website';
     readonly mode: 'authenticated';
     readonly origins: readonly string[];
     readonly instructions?: string;
@@ -199,6 +200,7 @@ export interface AssistantContinuityDeclaration {
     readonly maxRestores?: number;
 }
 export interface PublicWebsiteAccess {
+    readonly kind?: 'website';
     readonly mode: 'public' | 'mixed';
     readonly origins: readonly string[];
     readonly capabilities: readonly CapabilityRef[];
@@ -210,7 +212,19 @@ export interface PublicWebsiteAccess {
     /** @see PublicWebsiteInput.continuity */
     readonly continuity?: AssistantContinuityDeclaration;
 }
-export type AssistantAccess = AuthenticatedWebsiteAccess | PublicWebsiteAccess;
+export interface PublicMessagingInput {
+    readonly channel: 'whatsapp';
+    readonly capabilities: readonly CapabilityRef[];
+    readonly instructions?: string;
+}
+export interface PublicMessagingAccess extends Omit<PublicMessagingInput, 'capabilities'> {
+    readonly capabilities: readonly AssistantCapability[];
+    readonly kind: 'messaging';
+    readonly mode: 'public';
+}
+/** Public business capability intent. Provider assets and credentials are operator-owned. */
+export declare function publicMessaging(input: PublicMessagingInput): PublicMessagingAccess;
+export type AssistantAccess = AuthenticatedWebsiteAccess | PublicWebsiteAccess | PublicMessagingAccess;
 export interface AuthenticatedWebsiteInput {
     readonly origins: readonly (string | ConfigRef)[];
     /** Assistant-only behavior for this exact signed-in website audience. */
@@ -281,6 +295,7 @@ export interface EmbeddedAssistantOptions extends AssistantUiOptions {
 }
 /** One projected surface as it appears in compiled data. */
 export interface AssistantSurfaceConfig {
+    readonly kind?: 'website';
     readonly mode: AssistantSurfaceMode;
     readonly origins: readonly string[];
     readonly instructions?: string;
@@ -299,7 +314,7 @@ export interface AssistantSurfaceConfig {
 }
 export interface EmbeddedAssistantConfig extends AssistantUiOptions {
     readonly model: AssistantModel;
-    readonly surfaces: readonly AssistantSurfaceConfig[];
+    readonly surfaces: readonly (AssistantSurfaceConfig | PublicMessagingAccess)[];
     /**
      * Union of every surface's origins. Kept at the top level so the service's origin check and the
      * published session-exchange contract read on unchanged while surfaces are added.

package/node_modules/@noodle-borg/authoring/dist/assistant.js

@@ -1,4 +1,24 @@
 import { serializeSecretRef, serializeVariableRef } from './config.js';
+/** Public business capability intent. Provider assets and credentials are operator-owned. */
+export function publicMessaging(input) {
+    if (!input || !Array.isArray(input.capabilities)) {
+        throw new Error('publicMessaging requires an explicit capability allowlist');
+    }
+    for (const key of Object.keys(input)) {
+        if (!['channel', 'capabilities', 'instructions'].includes(key)) {
+            throw new Error(`publicMessaging does not accept ${key}`);
+        }
+    }
+    if (input.channel !== 'whatsapp')
+        throw new Error('Unsupported public messaging channel');
+    return {
+        kind: 'messaging',
+        mode: 'public',
+        channel: input.channel,
+        capabilities: normalizeCapabilities(input.capabilities),
+        ...(input.instructions === undefined ? {} : { instructions: input.instructions }),
+    };
+}
 export function authenticatedWebsite(input) {
     return {
         mode: 'authenticated',
@@ -49,22 +69,27 @@ export function embeddedAssistant(input) {
     const sessionClaims = surfaces.find((surface) => surface.mode === 'authenticated')?.sessionClaims;
     return {
         model: { ...model },
-        surfaces: surfaces.map((surface) => ({
-            mode: surface.mode,
-            origins: [...surface.origins],
-            ...(surface.instructions === undefined ? {} : { instructions: surface.instructions }),
-            ...(surface.capabilities
-                ? { capabilities: normalizeCapabilities(surface.capabilities) }
-                : {}),
-            ...(surface.mode === 'authenticated' && surface.sessionClaims
-                ? { sessionClaims: structuredClone(surface.sessionClaims) }
-                : {}),
-            ...(surface.webmcp === undefined ? {} : { webmcp: { ...surface.webmcp } }),
-            ...(surface.mode !== 'authenticated' && surface.continuity !== undefined
-                ? { continuity: { ...surface.continuity } }
-                : {}),
-        })),
-        allowedOrigins: surfaces.flatMap((surface) => [...surface.origins]),
+        surfaces: surfaces.map((surface) => surface.kind === 'messaging'
+            ? {
+                ...surface,
+                capabilities: normalizeCapabilities(surface.capabilities),
+            }
+            : {
+                mode: surface.mode,
+                origins: [...surface.origins],
+                ...(surface.instructions === undefined ? {} : { instructions: surface.instructions }),
+                ...(surface.capabilities
+                    ? { capabilities: normalizeCapabilities(surface.capabilities) }
+                    : {}),
+                ...(surface.mode === 'authenticated' && surface.sessionClaims
+                    ? { sessionClaims: structuredClone(surface.sessionClaims) }
+                    : {}),
+                ...(surface.webmcp === undefined ? {} : { webmcp: { ...surface.webmcp } }),
+                ...(surface.mode !== 'authenticated' && surface.continuity !== undefined
+                    ? { continuity: { ...surface.continuity } }
+                    : {}),
+            }),
+        allowedOrigins: surfaces.flatMap((surface) => surface.kind === 'messaging' ? [] : [...surface.origins]),
         ...structuredClone(ui),
         ...(suggestedPrompts ? { suggestedPrompts: [...suggestedPrompts] } : {}),
         ...(sessionClaims ? { sessionClaims: structuredClone(sessionClaims) } : {}),
@@ -109,15 +134,19 @@ function assertDistinctSurfaces(surfaces) {
     if (surfaces.length === 0) {
         throw new Error('embeddedAssistant requires at least one access surface');
     }
-    const publicSurfaces = surfaces.filter((surface) => surface.mode !== 'authenticated');
+    const websites = surfaces.filter((surface) => surface.kind !== 'messaging');
+    const messaging = surfaces.filter((surface) => surface.kind === 'messaging');
+    if (messaging.length > 1)
+        throw new Error('embeddedAssistant accepts only one whatsapp surface');
+    const publicSurfaces = websites.filter((surface) => surface.mode !== 'authenticated');
     if (publicSurfaces.length > 1) {
         throw new Error('embeddedAssistant accepts at most one public surface (public or mixed)');
     }
-    if (surfaces.length - publicSurfaces.length > 1) {
+    if (websites.length - publicSurfaces.length > 1) {
         throw new Error('embeddedAssistant accepts at most one authenticated surface');
     }
     const seen = new Set();
-    for (const surface of surfaces) {
+    for (const surface of websites) {
         for (const origin of surface.origins) {
             if (seen.has(origin)) {
                 throw new Error(`embeddedAssistant surfaces must not share an origin: ${origin}`);

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

@@ -2,7 +2,7 @@ import type { ConnectorFile, HttpConnectorDef } from '@noodle-borg/connector-def
 import { z } from 'zod';
 export type { PackagedAssetReference } from '@noodle-borg/compiler';
 export type { AgentCapabilityKind, AgentCapabilityRef, AgentExampleSource, AgentGuideSource, AgentWorkflowSource, AgentWorkflowStepSource, } from './agent-guide.js';
-export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, type AssistantModel, type AssistantPosition, type AssistantPresentationOptions, type AssistantPresentationTone, type AssistantSurfaceConfig, type AssistantSurfaceMode, type AssistantThemeMode, type AssistantUiOptions, type AuthenticatedWebsiteAccess, type AuthenticatedWebsiteInput, authenticatedWebsite, type CapabilityRef, type EmbeddedAssistantConfig, type EmbeddedAssistantOptions, embeddedAssistant, type NoodleManagedModel, noodleManaged, type OpenAICompatibleModel, type OpenAICompatibleModelInput, type OpenAICompatibleTransport, openAICompatible, type PublicWebsiteAccess, type PublicWebsiteInput, publicWebsite, } from './assistant.js';
+export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, type AssistantModel, type AssistantPosition, type AssistantPresentationOptions, type AssistantPresentationTone, type AssistantSurfaceConfig, type AssistantSurfaceMode, type AssistantThemeMode, type AssistantUiOptions, type AuthenticatedWebsiteAccess, type AuthenticatedWebsiteInput, authenticatedWebsite, type CapabilityRef, type EmbeddedAssistantConfig, type EmbeddedAssistantOptions, embeddedAssistant, type NoodleManagedModel, noodleManaged, type OpenAICompatibleModel, type OpenAICompatibleModelInput, type OpenAICompatibleTransport, openAICompatible, type PublicMessagingAccess, type PublicMessagingInput, type PublicWebsiteAccess, type PublicWebsiteInput, publicMessaging, publicWebsite, } from './assistant.js';
 export { type ConfigRef, type ConfigRefKind, type DeclaredVariableRef, secret, type VariableOptions, type VariableValueRef, variable, } from './config.js';
 export { type BoundConnectorRef, bind, type ConnectionBinding, type ConnectionRef, type ConnectionSource, clientCredentials, connection, externalExchange, type GoogleWorkloadIdentityAccess, googleWorkloadIdentity, managedSecret, } from './connections.js';
 export { type ComputeHost, type ComputeLimits, type ComputeOperationOptions, ConnectorBuilder, type ConnectorCatalogDoc, type ConnectorOpDefinition, type ConnectorOperationOptions, type ConnectorRef, connector, type HttpConnectorOptions, type McpAuthOptions, type McpConnectorOptions, } from './connectors.js';

package/node_modules/@noodle-borg/authoring/dist/index.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export { authenticatedWebsite, embeddedAssistant, noodleManaged, openAICompatible, publicWebsite, } from './assistant.js';
+export { authenticatedWebsite, embeddedAssistant, noodleManaged, openAICompatible, publicMessaging, publicWebsite, } from './assistant.js';
 export { secret, variable, } from './config.js';
 export { bind, clientCredentials, connection, externalExchange, googleWorkloadIdentity, managedSecret, } from './connections.js';
 export { ConnectorBuilder, connector, } from './connectors.js';

package/node_modules/@noodle-borg/authoring/dist/load-authored.js

@@ -33,7 +33,7 @@ export function prepareAuthoringRuntimeDir(dir, options) {
             './react': './react.mjs',
         },
     }));
-    writeFileSync(join(self, 'index.mjs'), "export { algolia, annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, firecrawl, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedCollection, managedSecret, meilisearch, noodleManaged, noodlePlatform, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tavily, tool, variable, webExtract, when, z } from '@noodle-borg/authoring';\n");
+    writeFileSync(join(self, 'index.mjs'), "export { algolia, annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, firecrawl, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedCollection, managedSecret, meilisearch, noodleManaged, noodlePlatform, openAICompatible, prompt, publicMessaging, publicWebsite, resource, secret, server, site, tavily, tool, variable, webExtract, when, z } from '@noodle-borg/authoring';\n");
     writeFileSync(join(self, 'platform.mjs'), "export { noodlePlatform, noodlePlatformCatalog } from '@noodle-borg/authoring';\n");
     writeFileSync(join(self, 'react.mjs'), "export * from '@noodle-borg/authoring/react';\n");
 }