@noodleseed/one 0.169.0 → 0.171.0

package/node_modules/@noodle-borg/runtime/dist/postgres-state-handles.js

@@ -0,0 +1,311 @@
+import { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, createMutableStateHandleRecord, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
+/** Covers a request admitted just before the anonymous session's absolute expiry. */
+const STATE_OWNER_REDIRECT_GRACE_MS = 5 * 60 * 1000;
+export class PostgresStateHandleStore {
+    #pool;
+    #deploymentId;
+    #state;
+    #now;
+    constructor(pool, options) {
+        this.#pool = pool;
+        this.#deploymentId = options.deploymentId;
+        this.#state = options.state;
+        this.#now = options.now ?? (() => new Date());
+    }
+    async read(input) {
+        const def = this.#definition(input.handle);
+        const owner = ownerKey(def, input);
+        const key = input.key ?? 'default';
+        const read = async (client) => {
+            const nowDate = this.#now();
+            const resolvedOwner = def.claimOnAuthentication === true
+                ? await resolveOperationOwner(client, this.#deploymentId, input.handle, owner, nowDate)
+                : owner;
+            const row = await selectRow(client, this.#deploymentId, input.handle, resolvedOwner, key);
+            const now = nowDate.getTime();
+            if (row === undefined) {
+                return toPublicStateHandleRecord(createMutableStateHandleRecord(input.handle, key, def.ttlSeconds, now), now);
+            }
+            assertVersion(row, def);
+            return toPublicStateHandleRecord(mutableFromRow(row), now);
+        };
+        return def.claimOnAuthentication === true
+            ? this.#withTransaction((client) => read(client))
+            : read(this.#pool);
+    }
+    async patch(input) {
+        return this.#withTransaction(async (client) => {
+            const def = this.#definition(input.handle);
+            const owner = ownerKey(def, input);
+            const key = input.key ?? 'default';
+            const nowDate = this.#now();
+            const resolvedOwner = def.claimOnAuthentication === true
+                ? await resolveOperationOwner(client, this.#deploymentId, input.handle, owner, nowDate)
+                : owner;
+            const row = await selectRow(client, this.#deploymentId, input.handle, resolvedOwner, key, true);
+            if (row !== undefined)
+                assertVersion(row, def);
+            const now = nowDate.getTime();
+            const current = stateHandleRecordForMutation(row ? mutableFromRow(row) : undefined, input.handle, key, def.ttlSeconds, now);
+            assertStateHandleNotCompleted(current);
+            assertExpectedStateRevision(current, input.expectedRevision);
+            assertNoSecretValue(input.value);
+            const value = { ...current.value, ...input.value };
+            assertSchemaValue(def.schema, value);
+            const next = {
+                ...current,
+                value,
+                revision: current.revision + 1,
+                updatedAt: now,
+            };
+            await upsertRow(client, this.#deploymentId, resolvedOwner, def.version, next);
+            return toPublicStateHandleRecord(next, now);
+        });
+    }
+    async complete(input) {
+        return this.#withTransaction(async (client) => {
+            const def = this.#definition(input.handle);
+            const owner = ownerKey(def, input);
+            const key = input.key ?? 'default';
+            const nowDate = this.#now();
+            const resolvedOwner = def.claimOnAuthentication === true
+                ? await resolveOperationOwner(client, this.#deploymentId, input.handle, owner, nowDate)
+                : owner;
+            const row = await selectRow(client, this.#deploymentId, input.handle, resolvedOwner, key, true);
+            if (row !== undefined)
+                assertVersion(row, def);
+            const now = nowDate.getTime();
+            const current = stateHandleRecordForMutation(row ? mutableFromRow(row) : undefined, input.handle, key, def.ttlSeconds, now);
+            assertStateHandleNotCompleted(current);
+            assertExpectedStateRevision(current, input.expectedRevision);
+            const next = {
+                ...current,
+                status: 'completed',
+                revision: current.revision + 1,
+                updatedAt: now,
+            };
+            await upsertRow(client, this.#deploymentId, resolvedOwner, def.version, next);
+            return toPublicStateHandleRecord(next, now);
+        });
+    }
+    async pruneExpired() {
+        const result = await this.#pool.query(`DELETE FROM state_handle_records
+       WHERE deployment_id = $1 AND expires_at IS NOT NULL AND expires_at <= $2`, [this.#deploymentId, this.#now()]);
+        await this.#pool.query(`DELETE FROM state_handle_owner_redirects
+       WHERE deployment_id = $1 AND expires_at <= $2`, [this.#deploymentId, new Date(this.#now().getTime() - STATE_OWNER_REDIRECT_GRACE_MS)]);
+        return result.rowCount ?? 0;
+    }
+    #definition(handle) {
+        const def = this.#state.handles[handle];
+        if (def === undefined)
+            throw new Error(`unknown state handle "${handle}"`);
+        return def;
+    }
+    async #withTransaction(work) {
+        const client = await this.#pool.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await work(client);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+export async function ensureStateHandleSchema(pool) {
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS state_handle_records (
+      deployment_id   text NOT NULL,
+      handle_name     text NOT NULL,
+      owner_key       text NOT NULL,
+      state_key       text NOT NULL,
+      handle_version  text NOT NULL,
+      value           jsonb NOT NULL,
+      revision        bigint NOT NULL,
+      status          text NOT NULL CHECK (status IN ('active', 'completed')),
+      created_at      timestamptz NOT NULL,
+      updated_at      timestamptz NOT NULL,
+      expires_at      timestamptz,
+      PRIMARY KEY (deployment_id, handle_name, owner_key, state_key)
+    )
+  `);
+    await pool.query(`
+    CREATE INDEX IF NOT EXISTS state_handle_records_expiry_idx
+    ON state_handle_records (expires_at)
+    WHERE expires_at IS NOT NULL
+  `);
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS state_handle_owner_redirects (
+      deployment_id   text NOT NULL,
+      handle_name     text NOT NULL,
+      source_owner_key text NOT NULL,
+      target_owner_key text NOT NULL,
+      created_at      timestamptz NOT NULL,
+      expires_at      timestamptz NOT NULL,
+      PRIMARY KEY (deployment_id, handle_name, source_owner_key),
+      CHECK (source_owner_key <> target_owner_key)
+    )
+  `);
+    await pool.query(`
+    CREATE INDEX IF NOT EXISTS state_handle_owner_redirects_expiry_idx
+    ON state_handle_owner_redirects (expires_at)
+  `);
+}
+/**
+ * Rebind opted-in caller state inside the elevation transaction supplied by assistant-gateway.
+ * Values are never decoded or rewritten: changing only `owner_key` preserves every lifecycle field.
+ */
+export async function adoptCallerState(client, input) {
+    if (input.sourceCallerSubject === input.targetCallerSubject) {
+        return { ok: true, adoptedHandles: [], adoptedRecords: 0 };
+    }
+    const handles = [...new Set(input.handles)].sort();
+    for (const handle of handles) {
+        // Anonymous -> authenticated is directional. Every opted state operation takes the source
+        // lock before following its redirect and then takes the target lock, so the adoption uses the
+        // same order while still serializing concurrent creates under either owner.
+        await lockOwner(client, input.deploymentId, handle, input.sourceCallerSubject);
+        await lockOwner(client, input.deploymentId, handle, input.targetCallerSubject);
+    }
+    if (handles.length === 0) {
+        return { ok: true, adoptedHandles: [], adoptedRecords: 0 };
+    }
+    const redirect = await client.query(`SELECT handle_name, target_owner_key
+     FROM state_handle_owner_redirects
+     WHERE deployment_id = $1
+       AND handle_name = ANY($2::text[])
+       AND source_owner_key = $3
+       AND expires_at > $4`, [
+        input.deploymentId,
+        handles,
+        input.sourceCallerSubject,
+        new Date(input.now.getTime() - STATE_OWNER_REDIRECT_GRACE_MS),
+    ]);
+    if (redirect.rows.some((row) => row.target_owner_key !== input.targetCallerSubject)) {
+        return { ok: false, reason: 'state_key_conflict' };
+    }
+    const collision = await client.query(`SELECT 1
+     FROM state_handle_records AS source
+     JOIN state_handle_records AS target
+       ON target.deployment_id = source.deployment_id
+      AND target.handle_name = source.handle_name
+      AND target.state_key = source.state_key
+     WHERE source.deployment_id = $1
+       AND source.handle_name = ANY($2::text[])
+       AND source.owner_key = $3
+       AND target.owner_key = $4
+     LIMIT 1`, [input.deploymentId, handles, input.sourceCallerSubject, input.targetCallerSubject]);
+    if ((collision.rowCount ?? 0) > 0) {
+        return { ok: false, reason: 'state_key_conflict' };
+    }
+    const moved = await client.query(`UPDATE state_handle_records
+     SET owner_key = $4
+     WHERE deployment_id = $1
+       AND handle_name = ANY($2::text[])
+       AND owner_key = $3`, [input.deploymentId, handles, input.sourceCallerSubject, input.targetCallerSubject]);
+    await client.query(`INSERT INTO state_handle_owner_redirects
+       (deployment_id, handle_name, source_owner_key, target_owner_key, created_at, expires_at)
+     SELECT $1, handle_name, $3, $4, $5, $6
+     FROM unnest($2::text[]) AS handle_name
+     ON CONFLICT (deployment_id, handle_name, source_owner_key) DO UPDATE SET
+       target_owner_key = EXCLUDED.target_owner_key,
+       created_at = EXCLUDED.created_at,
+       expires_at = EXCLUDED.expires_at`, [
+        input.deploymentId,
+        handles,
+        input.sourceCallerSubject,
+        input.targetCallerSubject,
+        input.now,
+        input.redirectExpiresAt,
+    ]);
+    return {
+        ok: true,
+        adoptedHandles: handles,
+        adoptedRecords: moved.rowCount ?? 0,
+    };
+}
+async function selectRow(client, deploymentId, handle, owner, key, forUpdate = false) {
+    const result = await client.query(`SELECT handle_name, state_key, handle_version, value, revision, status,
+            created_at, updated_at, expires_at
+     FROM state_handle_records
+     WHERE deployment_id = $1 AND handle_name = $2 AND owner_key = $3 AND state_key = $4
+     ${forUpdate ? 'FOR UPDATE' : ''}`, [deploymentId, handle, owner, key]);
+    return result.rows[0];
+}
+async function upsertRow(client, deploymentId, owner, version, record) {
+    await client.query(`INSERT INTO state_handle_records
+       (deployment_id, handle_name, owner_key, state_key, handle_version, value, revision,
+        status, created_at, updated_at, expires_at)
+     VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7, $8, $9, $10, $11)
+     ON CONFLICT (deployment_id, handle_name, owner_key, state_key) DO UPDATE SET
+       handle_version = EXCLUDED.handle_version,
+       value          = EXCLUDED.value,
+       revision       = EXCLUDED.revision,
+       status         = EXCLUDED.status,
+       created_at     = EXCLUDED.created_at,
+       updated_at     = EXCLUDED.updated_at,
+       expires_at     = EXCLUDED.expires_at`, [
+        deploymentId,
+        record.handle,
+        owner,
+        record.key,
+        version,
+        JSON.stringify(record.value),
+        record.revision,
+        record.status,
+        new Date(record.createdAt),
+        new Date(record.updatedAt),
+        record.expiresAt === undefined ? null : new Date(record.expiresAt),
+    ]);
+}
+function ownerKey(def, input) {
+    return def.scope === 'caller' ? (input.callerSubject ?? 'anonymous') : 'deployment';
+}
+async function lockOwner(client, deploymentId, handle, owner) {
+    await client.query('SELECT pg_advisory_xact_lock(hashtextextended($1, 0))', [
+        stateOwnerLockKey(deploymentId, handle, owner),
+    ]);
+}
+/** PostgreSQL text rejects NUL, so length-prefix each untrusted segment instead of using a sentinel. */
+function stateOwnerLockKey(deploymentId, handle, owner) {
+    return `state-owner:${deploymentId.length}:${deploymentId}:${handle.length}:${handle}:${owner.length}:${owner}`;
+}
+async function resolveOperationOwner(client, deploymentId, handle, owner, now) {
+    await lockOwner(client, deploymentId, handle, owner);
+    const redirect = await client.query(`SELECT target_owner_key
+     FROM state_handle_owner_redirects
+     WHERE deployment_id = $1 AND handle_name = $2 AND source_owner_key = $3 AND expires_at > $4`, [deploymentId, handle, owner, new Date(now.getTime() - STATE_OWNER_REDIRECT_GRACE_MS)]);
+    const target = redirect.rows[0]?.target_owner_key;
+    if (target === undefined)
+        return owner;
+    await lockOwner(client, deploymentId, handle, target);
+    return target;
+}
+function assertVersion(row, def) {
+    if (row.handle_version !== def.version) {
+        throw new Error(`state handle version mismatch for "${row.handle_name}": stored ${row.handle_version}, current ${def.version}`);
+    }
+}
+function mutableFromRow(row) {
+    const value = typeof row.value === 'object' && row.value !== null && !Array.isArray(row.value)
+        ? row.value
+        : {};
+    const expiresAt = row.expires_at === null ? undefined : new Date(row.expires_at).getTime();
+    return {
+        handle: row.handle_name,
+        key: row.state_key,
+        value,
+        revision: Number(row.revision),
+        status: row.status,
+        createdAt: new Date(row.created_at).getTime(),
+        updatedAt: new Date(row.updated_at).getTime(),
+        ...(expiresAt !== undefined ? { expiresAt } : {}),
+    };
+}
+//# sourceMappingURL=postgres-state-handles.js.map

package/node_modules/@noodle-borg/runtime/dist/postgres.js

@@ -0,0 +1,4 @@
+/** PostgreSQL state-handle persistence for hosted composition. */
+export * from './postgres-state-handles.js';
+export * from './state-handle-ownership.js';
+//# sourceMappingURL=postgres.js.map

package/node_modules/@noodle-borg/runtime/dist/result-meta.d.ts

@@ -1,3 +1,5 @@
+/** Ephemeral extraction evidence is usable in the current turn but never replay/persistence data. */
+export declare function hasEphemeralEvidence(output: unknown): boolean;
 /** @internal Shared with suspension-aware execution and surface adapters. */
 export declare function splitResultMeta(output: unknown): {
     readonly visible: unknown;

package/node_modules/@noodle-borg/runtime/dist/result-meta.js

@@ -1,4 +1,8 @@
 const RESULT_META_KEY = '__noodleResultMeta';
+/** Ephemeral extraction evidence is usable in the current turn but never replay/persistence data. */
+export function hasEphemeralEvidence(output) {
+    return splitResultMeta(output).meta?.['noodle/ephemeralEvidence'] === true;
+}
 /** @internal Shared with suspension-aware execution and surface adapters. */
 export function splitResultMeta(output) {
     if (output === null || typeof output !== 'object' || Array.isArray(output)) {
@@ -31,6 +35,8 @@ export function attachResultMeta(output, metas) {
 }
 function mergeRecords(target, source) {
     for (const [key, value] of Object.entries(source)) {
+        if (key === 'noodle/ephemeralEvidence' && target[key] === true)
+            continue;
         const existing = target[key];
         if (isPlainRecord(existing) && isPlainRecord(value)) {
             mergeRecords(existing, value);

package/node_modules/@noodle-borg/runtime/dist/result.d.ts

@@ -1,4 +1,5 @@
 import type { CredentialProfile } from '@noodle-borg/compiler';
+import type { CapabilityBudgetSnapshot } from '@noodle-borg/managed-capabilities';
 import type { ConnectorFailureCategory } from './connector/types.js';
 import type { CustomerRouteBinding } from './customer-routing.js';
 /** Why a tool call could not be fulfilled. Protocol and embedded adapters map this internal contract. */
@@ -60,6 +61,7 @@ export type ElicitationResponse = {
  * never be serialized into MCP or embedded-assistant client payloads.
  */
 export interface ToolContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly version: 1;
     readonly artifact: {
         readonly manifestName: string;
@@ -86,6 +88,7 @@ interface ContinuationArtifactIdentity {
  * can evaluate pure maps and request more input, but cannot execute a connector operation.
  */
 export interface ToolPreparationContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly kind: 'confirmation_preparation';
     readonly version: 1;
     readonly artifact: ContinuationArtifactIdentity;
@@ -102,6 +105,7 @@ export interface ToolPreparationContinuation {
  * behind an opaque interaction id and release it to {@code executePreparedTool} only after approval.
  */
 export interface PreparedToolContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly kind: 'prepared_confirmation';
     /** Private hosting snapshot; never projected into a model-visible confirmation. */
     readonly executionRevision?: string;

package/node_modules/@noodle-borg/runtime/dist/web-capabilities.d.ts

@@ -0,0 +1,71 @@
+import type { WebCapability, WebExtractResult } from '@noodle-borg/managed-capabilities';
+import { type Connector, type ConnectorCall } from './connector/types.js';
+export type WebCapabilityExecutionPort = (declaration: WebCapability, request: unknown, call: ConnectorCall) => Promise<WebExtractResult>;
+/** Thin ordinary connector; deployment binding and policy authority are injected by the service. */
+export declare class WebCapabilityConnector implements Connector {
+    private readonly declarations;
+    private readonly execute;
+    readonly id = "noodle_web";
+    readonly version = "1.0.0";
+    constructor(declarations: readonly WebCapability[], execute: WebCapabilityExecutionPort);
+    signature(operation: string): {
+        type: "read";
+        input: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            request: import("zod").ZodObject<{
+                urls: import("zod").ZodArray<import("zod").ZodString>;
+                domains: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>>;
+        output: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            status: import("zod").ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+            }>;
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                requestIndex: import("zod").ZodNumber;
+                sourceRef: import("zod").ZodString;
+                content: import("zod").ZodObject<{
+                    format: import("zod").ZodLiteral<"text">;
+                    text: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                links: import("zod").ZodArray<import("zod").ZodObject<{
+                    url: import("zod").ZodString;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>>;
+                truncated: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strict>>;
+            sources: import("zod").ZodArray<import("zod").ZodObject<{
+                ref: import("zod").ZodString;
+                url: import("zod").ZodString;
+                title: import("zod").ZodOptional<import("zod").ZodString>;
+                retrievedAt: import("zod").ZodISODateTime;
+                publishedAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                observedAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                attribution: import("zod").ZodOptional<import("zod").ZodString>;
+                rights: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            warnings: import("zod").ZodArray<import("zod").ZodObject<{
+                requestIndex: import("zod").ZodNumber;
+                code: import("zod").ZodEnum<{
+                    capability_unavailable: "capability_unavailable";
+                    capability_binding_invalid: "capability_binding_invalid";
+                    capability_requirement_unsupported: "capability_requirement_unsupported";
+                    capability_policy_denied: "capability_policy_denied";
+                    capability_budget_exhausted: "capability_budget_exhausted";
+                    capability_source_rejected: "capability_source_rejected";
+                    capability_provider_failed: "capability_provider_failed";
+                    capability_result_invalid: "capability_result_invalid";
+                    capability_cancelled: "capability_cancelled";
+                    content_truncated: "content_truncated";
+                }>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+    } | undefined;
+    executionBoundMs(): number;
+    invoke(call: ConnectorCall): Promise<WebExtractResult & {
+        readonly __noodleResultMeta: Readonly<Record<string, unknown>>;
+    }>;
+}
+//# sourceMappingURL=web-capabilities.d.ts.map

package/node_modules/@noodle-borg/runtime/dist/web-capabilities.js

@@ -0,0 +1,41 @@
+import { CapabilityError, WEB_CONNECTOR_ID, WEB_CONNECTOR_VERSION, WEB_OPERATION_SIGNATURE, webOperationInputSchema, } from '@noodle-borg/managed-capabilities';
+import { ConnectorInvocationError } from './connector/types.js';
+/** Thin ordinary connector; deployment binding and policy authority are injected by the service. */
+export class WebCapabilityConnector {
+    declarations;
+    execute;
+    id = WEB_CONNECTOR_ID;
+    version = WEB_CONNECTOR_VERSION;
+    constructor(declarations, execute) {
+        this.declarations = declarations;
+        this.execute = execute;
+    }
+    signature(operation) {
+        return operation === 'extract' ? WEB_OPERATION_SIGNATURE : undefined;
+    }
+    executionBoundMs() {
+        return 30_000;
+    }
+    async invoke(call) {
+        const input = webOperationInputSchema.safeParse(call.args);
+        const declaration = input.success
+            ? this.declarations.find((value) => value.name === input.data.name)
+            : undefined;
+        if (call.operation !== 'extract' ||
+            declaration === undefined ||
+            !input.success ||
+            call.capabilityBudget === undefined) {
+            throw new ConnectorInvocationError('capability_policy_denied', { retryable: false });
+        }
+        try {
+            return {
+                ...(await this.execute(declaration, input.data.request, call)),
+                __noodleResultMeta: { 'noodle/ephemeralEvidence': true },
+            };
+        }
+        catch (error) {
+            throw new ConnectorInvocationError(error instanceof CapabilityError ? error.code : 'capability_unavailable', { retryable: false });
+        }
+    }
+}
+//# sourceMappingURL=web-capabilities.js.map

package/node_modules/@noodle-borg/runtime/package.json

@@ -26,6 +26,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "@noodle-borg/managed-capabilities": "0.0.0",
     "@noodle-borg/compiler": "0.0.0",
     "@noodle-borg/module": "0.0.0"
   },

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

@@ -0,0 +1,18 @@
+/** Browser and messaging resolve model, execution and tenant policy from one composition. */
+export function assistantRouteDependencies(options, core) {
+    return {
+        ...core,
+        ...(options.publicEmbeds ? { publicEmbeds: options.publicEmbeds } : {}),
+        ...(options.elevations ? { elevations: options.elevations } : {}),
+        ...(options.elevationCoordinator ? { elevationCoordinator: options.elevationCoordinator } : {}),
+        ...(options.admissionCounters ? { admissionCounters: options.admissionCounters } : {}),
+        ...(options.admissionEnvelope ? { admissionEnvelope: options.admissionEnvelope } : {}),
+        ...(options.assistantModelFetch ? { modelFetch: options.assistantModelFetch } : {}),
+        ...(options.managedAssistantModelResolver
+            ? { managedModelResolver: options.managedAssistantModelResolver }
+            : {}),
+        ...(options.captureRequestEvent ? { captureRequestEvent: options.captureRequestEvent } : {}),
+        ...(options.clock ? { clock: options.clock } : {}),
+    };
+}
+//# sourceMappingURL=assistant-composition.js.map

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

@@ -1,10 +1,13 @@
 import { MIXED_CUSTOMER_AUTH_FEATURE_VERSION, serviceInfoResponseSchema, } from '@noodle-borg/wire-contracts';
-export function serviceInfoPayload(buildInfo, developerMcp) {
+export function serviceInfoPayload(buildInfo, developerMcp, whatsapp = false) {
     return serviceInfoResponseSchema.parse({
         ok: true,
         status: 'ok',
         ...buildInfo,
-        features: { mixedCustomerAuth: MIXED_CUSTOMER_AUTH_FEATURE_VERSION },
+        features: {
+            mixedCustomerAuth: MIXED_CUSTOMER_AUTH_FEATURE_VERSION,
+            ...(whatsapp ? { whatsapp: 1 } : {}),
+        },
         ...(developerMcp
             ? { developerPlugin: { mcpCapabilityVersion: DEVELOPER_MCP_CAPABILITY_VERSION } }
             : {}),

package/node_modules/@noodle-borg/service/dist/business-information/source-ingestion-coordinator.js

@@ -133,4 +133,11 @@ function boundedToken(label, value, maximum) {
     }
     return normalized;
 }
+export async function drainSourceIngestion(coordinator) {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const result = await coordinator.runOne();
+        if (result.disposition !== 'completed')
+            return;
+    }
+}
 //# sourceMappingURL=source-ingestion-coordinator.js.map