@noodleseed/one 0.169.0 → 0.171.0

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

@@ -0,0 +1,337 @@
+import { beginChannelProviderBlock, CHANNEL_RETENTION_MS, ChannelCoordinator, ChannelError, channelDigest, channelProviderBlocks, finishChannelProviderBlock, messagingSurfaceOf, projectArtifactForSurface, resolveInvocationContextSnapshot, withAssistantTurnExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { runAgentTurn } from '../routes/assistant-agent.js';
+import { resolveAssistantKnowledge } from '../routes/assistant-knowledge.js';
+import { resolveAssistantModelBinding } from '../routes/assistant-model-binding.js';
+import { activeAssistantTarget } from '../routes/assistant-session-target.js';
+import { resolveConfigScope } from '../store.js';
+import { Dialog360, verifyWhatsAppWebhookSecret, WHATSAPP_CALLBACK_HEADER } from './360dialog.js';
+import { verifiedInferenceBound, withChannelInferenceGuard } from './inference-guard.js';
+export class WhatsAppRuntime {
+    options;
+    deps;
+    channels;
+    cursor;
+    constructor(options, deps) {
+        this.options = options;
+        this.deps = deps;
+        this.channels = new ChannelCoordinator(options.store, () => deps.clock?.().getTime() ?? Date.now());
+        options.worker.attach(() => this.sweep());
+    }
+    async provider(binding) {
+        const values = await this.deps.registry.configStore.resolveConfigValues('secret', resolveConfigScope(binding.tenant));
+        const apiKey = values[binding.apiKeySecret], webhookSecret = values[binding.webhookSecret];
+        if (!apiKey ||
+            !webhookSecret ||
+            apiKey === webhookSecret ||
+            !verifyWhatsAppWebhookSecret(webhookSecret, webhookSecret))
+            throw new ChannelError('channel_credentials_missing');
+        await this.channels.checkCredentials(binding.id, channelDigest(JSON.stringify([apiKey, webhookSecret])));
+        return { adapter: new Dialog360(apiKey, this.options.providerFetch), webhookSecret };
+    }
+    webhookUrl(req, binding) {
+        return `${this.deps.serviceBase(req).replace(/\/$/, '')}/v1/channels/whatsapp/webhooks/${binding.id}`;
+    }
+    async target(binding) {
+        const target = await activeAssistantTarget(this.deps, binding.tenant);
+        if (!target || target.deploymentId !== binding.deploymentId)
+            throw new ChannelError('deployment_changed');
+        const surface = messagingSurfaceOf(target.served.artifact.server.assistant);
+        if (!surface)
+            throw new ChannelError('messaging_surface_missing');
+        if (binding.capabilities.some((cap) => !surface.capabilities.some((authored) => authored.kind === cap.kind && authored.name === cap.name)))
+            throw new ChannelError('capability_not_authored');
+        const artifact = projectArtifactForSurface(target.served.artifact, binding.capabilities);
+        if (artifact.tools.some((tool) => tool.annotations?.readOnlyHint !== true || tool._meta?.ui))
+            throw new ChannelError('messaging_action_unsupported');
+        // This first slice has no separately budgeted connector-backed inference. Pure reads and
+        // the existing corpus search remain available; external lookups require their owning slice.
+        const external = (fulfilment) => fulfilment.kind === 'operation' || fulfilment.steps.some((step) => step.kind === 'operation');
+        if (artifact.tools.some((tool) => external(tool.fulfilment)) ||
+            (artifact.server.context?.ambient && external(artifact.server.context.ambient.fulfilment)))
+            throw new ChannelError('external_lookup_not_enabled');
+        return { ...target, served: { ...target.served, artifact } };
+    }
+    async doctor(id, req) {
+        const binding = await this.channels.internal(id);
+        const checks = [];
+        const check = async (name, work) => {
+            try {
+                await work();
+                checks.push({ name, status: 'ready' });
+            }
+            catch (error) {
+                checks.push({
+                    name,
+                    status: 'unavailable',
+                    code: error instanceof ChannelError ? error.code : 'check_unavailable',
+                });
+            }
+        };
+        await check('durability', async () => {
+            if (!this.options.store.durable)
+                throw new ChannelError('durable_storage_required');
+        });
+        await check('worker', async () => {
+            if (!this.options.worker.ready())
+                throw new ChannelError('worker_unavailable');
+        });
+        await check('deployment', async () => {
+            await this.target(binding);
+        });
+        await check('model_cost', async () => {
+            const model = await resolveAssistantModelBinding(await this.target(binding), binding.tenant, binding.deploymentId, this.deps, 'whatsapp');
+            if (!model)
+                throw new ChannelError('model_not_configured');
+            verifiedInferenceBound(model, this.channels.now());
+        });
+        await check('history_policy', async () => {
+            await this.retention(binding);
+        });
+        await check('knowledge', async () => {
+            const target = await this.target(binding);
+            if ((target.served.artifact.server.knowledge?.length ?? 0) > 0 &&
+                !(await resolveAssistantKnowledge(target.served)))
+                throw new ChannelError('knowledge_unavailable');
+        });
+        await check('provider_asset', async () => {
+            const health = await (await this.provider(binding)).adapter.health();
+            if (health.phoneNumberId !== binding.phoneNumberId)
+                throw new ChannelError('asset_mismatch');
+            if (!health.canSend)
+                throw new ChannelError('provider_messaging_unavailable');
+        });
+        await check('webhook', async () => {
+            const state = await this.webhook(id, req);
+            if (!state.matches || !state.authenticated)
+                throw new ChannelError('webhook_not_configured');
+        });
+        const ready = checks.every((check) => check.status === 'ready');
+        if (ready)
+            await this.channels.markReady(id, binding.revision);
+        return { ready, revision: binding.revision, checks, webhookUrl: this.webhookUrl(req, binding) };
+    }
+    async webhook(id, req) {
+        const binding = await this.channels.internal(id);
+        const { adapter, webhookSecret } = await this.provider(binding);
+        const current = await adapter.webhook();
+        return {
+            url: this.webhookUrl(req, binding),
+            matches: current.url === this.webhookUrl(req, binding),
+            authenticated: verifyWhatsAppWebhookSecret(current.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret),
+        };
+    }
+    async configureWebhook(id, req) {
+        const binding = await this.channels.internal(id);
+        if (binding.state !== 'paused')
+            throw new ChannelError('pause_before_webhook_change');
+        const { adapter, webhookSecret } = await this.provider(binding);
+        const existing = await adapter.webhook();
+        const url = this.webhookUrl(req, binding);
+        if (existing.url && existing.url !== url)
+            throw new ChannelError('webhook_ownership_conflict');
+        if (existing.url !== url ||
+            !verifyWhatsAppWebhookSecret(existing.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret))
+            await adapter.configureWebhook(url, webhookSecret);
+    }
+    async projection(tenant) {
+        const binding = await this.channels.get(tenant);
+        if (!binding)
+            return {
+                status: 'unavailable',
+                capabilities: [],
+                reason: 'WhatsApp is not configured.',
+            };
+        const view = {
+            bindingId: binding.id,
+            revision: binding.revision,
+            capabilities: binding.capabilities.map((cap) => `${cap.kind}:${cap.name}`),
+        };
+        if (binding.state !== 'enabled')
+            return { ...view, status: 'paused' };
+        try {
+            await this.target(await this.channels.internal(binding.id));
+            return { ...view, status: 'ready' };
+        }
+        catch {
+            return {
+                ...view,
+                status: 'unavailable',
+                reason: 'The active deployment or installation is unavailable.',
+            };
+        }
+    }
+    async providerBlock(id, participantId, blocked, actor, key, protectedPhone) {
+        const operation = await beginChannelProviderBlock(this.channels.store, id, participantId, blocked ? 'blocked' : 'unblocked', actor, key, this.channels.now(), protectedPhone);
+        if (!operation)
+            return;
+        try {
+            const binding = await this.channels.internal(id);
+            if (binding.generation !== operation.generation)
+                throw new ChannelError('authority_changed');
+            const { adapter } = await this.provider(binding);
+            const result = await adapter.setBlocked(operation.address.value, blocked);
+            await finishChannelProviderBlock(this.channels.store, id, participantId, operation.revision, result.state, this.channels.now(), result.code);
+        }
+        catch {
+            await finishChannelProviderBlock(this.channels.store, id, participantId, operation.revision, 'unknown', this.channels.now(), 'provider_outcome_unknown');
+        }
+    }
+    async blocks(id, after) {
+        const local = await this.channels.blocks(id, after);
+        const provider = await channelProviderBlocks(this.channels.store, id, this.channels.now(), after);
+        const ids = [
+            ...new Set([
+                ...local.map((item) => item.participantId),
+                ...provider.map((item) => item.participantId),
+            ]),
+        ];
+        const data = ids
+            .sort()
+            .slice(0, 100)
+            .map((participantId) => {
+            const block = local.find((item) => item.participantId === participantId);
+            const match = provider.find((item) => item.participantId === participantId);
+            return {
+                ...(block ?? {
+                    participantId,
+                    actor: match.actor,
+                    reason: 'operator',
+                    until: null,
+                }),
+                local: !!block && (block.until === null || block.until > this.channels.now()),
+                ...(match
+                    ? {
+                        provider: {
+                            desired: match.desired,
+                            state: match.state,
+                            updatedAt: match.updatedAt,
+                            ...(match.code ? { code: match.code } : {}),
+                        },
+                    }
+                    : {}),
+            };
+        });
+        return { data, ...(data.length === 100 ? { next: data.at(-1).participantId } : {}) };
+    }
+    async retention(binding) {
+        const days = (await this.options.historyDays?.(binding.tenant)) ?? 7;
+        if (!Number.isInteger(days) || days < 1)
+            throw new ChannelError('history_policy_unavailable');
+        return Math.min(CHANNEL_RETENTION_MS, days * 86_400_000);
+    }
+    async sweep() {
+        const page = await this.channels.bindingPage(this.cursor);
+        this.cursor = page.after;
+        // Bounded parallelism and rotating registry pages prevent a busy tenant starving later ones.
+        for (let offset = 0; offset < page.ids.length; offset += 5) {
+            await Promise.all(page.ids.slice(offset, offset + 5).map((id) => this.process(id)));
+        }
+        await this.options.store.prune(this.channels.now(), 1000);
+    }
+    async process(id) {
+        try {
+            if (this.options.worker.signal.aborted)
+                return;
+            const binding = await this.channels.internal(id);
+            const retention = await this.retention(binding);
+            await this.channels.expireHistory(id, retention);
+            const work = await this.channels.claim(id, retention);
+            if (work)
+                await this.answer(work);
+            for (let n = 0; n < 5 && !this.options.worker.signal.aborted; n++) {
+                const send = await this.channels.prepareSend(id);
+                if (!send)
+                    break;
+                await this.target(await this.channels.internal(id));
+                const { adapter } = await this.provider(send.binding);
+                await this.channels.assertSend(id, send.event.id, send.event.lease);
+                this.options.worker.signal.throwIfAborted();
+                await this.channels.sent(id, send.event.id, send.event.lease, await adapter.send({ to: send.participant.address, text: send.event.reply }));
+            }
+        }
+        catch {
+            this.deps.logger?.warn('assistant.channel.worker', { code: 'channel_work_failed' });
+        }
+    }
+    async answer(work) {
+        const { binding, participant, event } = work;
+        const abort = new AbortController();
+        const signal = AbortSignal.any([
+            abort.signal,
+            this.options.worker.signal,
+            AbortSignal.timeout(60_000),
+        ]);
+        const historyRetention = await this.retention(binding);
+        const beforeStep = async () => {
+            if ((await this.retention(binding)) !== historyRetention)
+                throw new ChannelError('history_policy_changed');
+            signal.throwIfAborted();
+            await this.provider(await this.channels.internal(binding.id));
+            await this.channels.renew(binding.id, event.id, event.lease);
+            await this.target(await this.channels.internal(binding.id));
+        };
+        const timer = setInterval(() => {
+            void beforeStep().catch(() => abort.abort());
+        }, 10_000);
+        timer.unref?.();
+        try {
+            const target = await this.target(binding);
+            const model = await resolveAssistantModelBinding(target, binding.tenant, binding.deploymentId, this.deps, 'whatsapp');
+            if (!model)
+                throw new ChannelError('model_not_configured');
+            const session = {
+                kind: 'messaging',
+                channel: 'whatsapp',
+                id: event.id,
+                bindingId: binding.id,
+                participantId: participant.id,
+                tenant: binding.tenant,
+                deploymentId: binding.deploymentId,
+                caller: { identityKind: 'anonymous', subject: participant.id, roles: [], scopes: [] },
+                history: participant.history.map(({ role, content }) => ({ role, content })),
+                modelToolUses: participant.modelToolUses ?? [],
+            };
+            const context = await resolveInvocationContextSnapshot({
+                artifact: target.served.artifact,
+                executeDeps: withAssistantTurnExecutionAuthority({ ...target.served.deps, signal }, target.served.artifact, session),
+                caller: session.caller,
+                instant: new Date(this.channels.now()),
+            });
+            let text = '', failure;
+            await runAgentTurn(target, session, event.text, context, this.deps, (result) => {
+                if (result.event === 'content' && typeof result.data.delta === 'string')
+                    text += result.data.delta;
+                if (result.event === 'error')
+                    failure = String(result.data.code ?? 'answer_failed');
+            }, undefined, undefined, undefined, false, {
+                binding: withChannelInferenceGuard(model, this.channels, binding.id, event.id, beforeStep),
+                beforeStep,
+                claimTool: (name) => this.channels.claimTool(binding.id, participant.id, name),
+                signal,
+            });
+            if (failure || !text.trim())
+                throw new ChannelError(failure ?? 'answer_unavailable');
+            const disclosure = participant.history.length === 0
+                ? `I’m ${target.served.artifact.server.branding?.name ?? target.served.artifact.server.title}’s AI assistant.\n\n`
+                : '';
+            const answer = disclosure + text.trim();
+            const bounded = answer.length <= 3500
+                ? answer
+                : `${answer.slice(0, 3350).replace(/[\uD800-\uDBFF]$/u, '')}\n\nAsk me to expand on any part.`;
+            await this.channels.complete(binding.id, event.id, event.lease, bounded, historyRetention);
+        }
+        catch (error) {
+            const code = error instanceof ChannelError ? error.code : 'answer_failed';
+            try {
+                await this.channels.complete(binding.id, event.id, event.lease, `I couldn’t complete that request. For help, contact ${binding.supportEmail}.`, historyRetention, code);
+            }
+            catch {
+                await this.channels.fail(binding.id, event.id, event.lease, code);
+            }
+        }
+        finally {
+            clearInterval(timer);
+        }
+    }
+}
+//# sourceMappingURL=runtime.js.map

package/node_modules/@noodle-borg/service/dist/channels/worker-loop.js

@@ -0,0 +1,50 @@
+/** A process scheduler, never the owner of acknowledged work. PostgreSQL leases own recovery. */
+export class ChannelWorkerLoop {
+    onError;
+    run;
+    timer;
+    running;
+    stopped = true;
+    tickAt = 0;
+    abort = new AbortController();
+    get signal() {
+        return this.abort.signal;
+    }
+    constructor(onError = () => undefined) {
+        this.onError = onError;
+    }
+    attach(run) {
+        this.run = run;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.stopped = false;
+        this.abort = new AbortController();
+        this.timer = setInterval(() => this.wake(), 1000);
+        this.timer.unref?.();
+        this.wake();
+    }
+    ready() {
+        return !this.stopped && !!this.run && Date.now() - this.tickAt < 90_000;
+    }
+    wake() {
+        if (this.stopped || this.running || !this.run)
+            return;
+        this.tickAt = Date.now();
+        this.running = this.run()
+            .catch(() => this.onError('channel_worker_failed'))
+            .finally(() => {
+            this.running = undefined;
+        });
+    }
+    async stop() {
+        this.stopped = true;
+        this.abort.abort();
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        await this.running;
+    }
+}
+//# sourceMappingURL=worker-loop.js.map

package/node_modules/@noodle-borg/service/dist/local-options.d.ts

@@ -6,6 +6,7 @@ import type { LocalDevtoolsDelegatedExchangeRuntime } from './local-devtools-del
 import type { ServerRegistry } from './registry.js';
 import type { ConfigStore, TenantBridgeAuthConfig } from './store.js';
 type LocalRuntimeOptions = {
+    readonly capabilities?: import('@noodle-borg/managed-capabilities').CapabilityService;
     readonly assistantStore?: import('@noodle-borg/assistant-gateway/portable').AssistantStore;
     readonly assistantAppearance?: import('@noodle-borg/assistant-gateway/portable').AssistantAppearanceSettingsStore;
     readonly publicEmbeds?: import('@noodle-borg/assistant-gateway/portable').PublicEmbedStore;

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

@@ -0,0 +1,13 @@
+import { InMemoryDailyCounterStore } from '@noodle-borg/admission-limits/portable';
+import { PublicPageReader } from '@noodle-borg/knowledge-crawl';
+import { CapabilityService, InMemoryCapabilityPolicyStore, } from '@noodle-borg/managed-capabilities';
+/** Loopback-only composition. Keep PostgreSQL imports out of the published CLI graph. */
+export function localWebCapabilities() {
+    return new CapabilityService({
+        profile: 'development',
+        policies: new InMemoryCapabilityPolicyStore(),
+        counters: new InMemoryDailyCounterStore(),
+        reader: new PublicPageReader(),
+    });
+}
+//# sourceMappingURL=local-web-capabilities.js.map

package/node_modules/@noodle-borg/service/dist/mcp-protocol-runtime.js

@@ -0,0 +1,21 @@
+import { RequestStateManager, requestStateSecretBox, } from '@noodle-borg/protocol';
+/**
+ * Build the fleet-shared request-state manager. Static-key deployments use an HKDF domain-separated key;
+ * KMS deployments reuse the configured envelope-encryption custodian because its raw KEK cannot be
+ * exported for HKDF.
+ */
+export function createHostedMcpRequestStateManager(input) {
+    if (input.secretMasterKey !== undefined) {
+        return new RequestStateManager(requestStateSecretBox(Buffer.from(input.secretMasterKey, 'base64')));
+    }
+    return input.secretBox === undefined ? undefined : new RequestStateManager(input.secretBox);
+}
+/** Resolve the temporary origin-wide rollout gate from operator configuration. */
+export function resolveMcpProtocolMode(value) {
+    if (value === undefined || value === 'dual')
+        return 'dual';
+    if (value === 'legacy-only')
+        return value;
+    throw new Error('NOODLE_MCP_PROTOCOL_MODE must be dual or legacy-only');
+}
+//# sourceMappingURL=mcp-protocol-runtime.js.map

package/node_modules/@noodle-borg/service/dist/modules/route-dispatch.js

@@ -14,6 +14,19 @@ export function createModuleRouteContext(hostRequest, deps) {
         logger: deps.logger ?? noopModuleLogger,
         controlPlane: deps.gate,
         audit: deps.audit,
+        capabilityDeployments: {
+            get: async (request, scope) => {
+                if (request !== hostRequest || !authorizedOrgs.has(scope.org))
+                    return undefined;
+                const target = await deps.registry.getActiveByTenant(scope);
+                if (target?.deploymentId === undefined)
+                    return undefined;
+                return {
+                    deploymentId: target.deploymentId,
+                    declarations: target.served.artifact.server.capabilities ?? [],
+                };
+            },
+        },
         platformIdentityRecovery: {
             reconcile: (plan) => deps.registry.reconcilePlatformAccountReset(plan),
             customerAuthRestoreProjections: async (deploymentIds) => (await deps.registry.customerAuthRestoreProjections(deploymentIds)).map((projection) => ({

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

@@ -14,6 +14,7 @@ import { missingCapabilityErrors, missingSecretErrors, missingVariableErrors, }
 import { servedTargetFor } from './registry-targets.js';
 import { createDeploymentStateConnector, } from './state-connector-factory.js';
 import { resolveConfigScope, } from './store.js';
+import { deploymentWebConnector } from './web-capabilities.js';
 /** Reject unsupported persisted semantics before constructing executable runtime dependencies. */
 export async function compilePersistedRegistryRecord(record, compileTarget) {
     const versionError = deploymentRecordVersionError(record);
@@ -197,11 +198,13 @@ export async function compileRegistryTarget(context, input) {
             artifact,
             ...(boundDeploymentId === undefined ? {} : { deploymentId: boundDeploymentId }),
         });
+        const webConnector = deploymentWebConnector(artifact, tenant, boundDeploymentId, context.capabilities);
         return {
             artifact,
             deps: {
                 connectors: new InMemoryConnectorRegistry([
                     ...context.platformConnectors,
+                    ...(webConnector === undefined ? [] : [webConnector]),
                     ...(nativeRecords === undefined ? [] : [nativeRecords]),
                     ...(stateConnector !== undefined ? [stateConnector] : []),
                     ...httpConnectors,

package/node_modules/@noodle-borg/service/dist/registry-types.d.ts

@@ -96,6 +96,7 @@ export interface AccessUpdateOptions {
     readonly serverVersion?: string | undefined;
 }
 export interface ServerRegistryOptions {
+    readonly capabilities?: import('@noodle-borg/managed-capabilities').CapabilityService;
     readonly nativeRecords?: NativeRecordConnectorFactory;
     /** Pure renderer injection used for deployment-bound package construction and failure testing. */
     readonly renderAppPackage?: AppPackageRenderer;

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

@@ -32,6 +32,7 @@ export class ServerRegistry {
     #platformCatalog;
     #platformConnectors;
     #nativeRecords;
+    #capabilities;
     #stateHandleStoreFactory;
     #delegatedCredentialStore;
     #sealCustomerCredential;
@@ -61,6 +62,7 @@ export class ServerRegistry {
         this.#platformCatalog = withBuiltinStateCatalog(options.platformCatalog ?? []);
         this.#platformConnectors = options.platformConnectors ?? [];
         this.#nativeRecords = options.nativeRecords;
+        this.#capabilities = options.capabilities;
         this.#stateHandleStoreFactory = options.stateHandleStoreFactory;
         this.#delegatedCredentialStore = options.delegatedCredentialStore;
         this.#sealCustomerCredential = options.sealCustomerCredential;
@@ -311,6 +313,7 @@ export class ServerRegistry {
             stateHandleStoreFactory: this.#stateHandleStoreFactory,
             platformConnectors: this.#platformConnectors,
             nativeRecords: this.#nativeRecords,
+            capabilities: this.#capabilities,
             policyGate: this.#policyGate,
             appPackageRenderer: this.#appPackageRenderer,
             knowledgeSearch: this.#knowledgeSearch,