@noodleseed/one 0.169.0 → 0.171.0

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

@@ -1,8 +1,9 @@
 import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
 import { assistantCoreModelMessages, assistantTurnModelContextMessages, requestAssistantSuggestedPrompts, requestModelCompletion, resolveAssistantContextProviderModelResult, } from '@noodle-borg/assistant-gateway/model-runtime';
-import { assistantGuideModelContext, assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, assistantOmittedToolResult, assistantViewAvailableData, dispatchAssistantTool, projectAssistantGuide, publicSurfaceOf, recoverableAssistantView, remainingTurnTokens, selectAssistantModelTools, toolTouchesDelegatedAuth, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { assistantGuideModelContext, assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, assistantOmittedToolResult, assistantViewAvailableData, dispatchAssistantTool, dispatchMessagingReadTool, isMessagingTurn, projectAssistantGuide, publicSurfaceOf, recoverableAssistantView, remainingTurnTokens, selectAssistantModelTools, toolTouchesDelegatedAuth, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { guardedFetch } from '@noodle-borg/connector-http';
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { evaluateToolAuthorization } from '@noodle-borg/protocol';
 import { interceptForElevation, offersSignIn } from './assistant-elevation.js';
 import { assistantKnowledgeModelTools, executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, KNOWLEDGE_CITATION_GUIDANCE, resolveAssistantKnowledge, } from './assistant-knowledge.js';
@@ -33,14 +34,15 @@ export function createAssistantTurnStats() {
     };
 }
 /** Run one model/tool loop against the immutable invocation-context snapshot for this turn. */
-export async function runAgentTurn(target, session, message, context, deps, emit, modelContext, pageContext, stats = createAssistantTurnStats(), suggestions = false) {
+export async function runAgentTurn(target, session, message, context, deps, emit, modelContext, pageContext, stats = createAssistantTurnStats(), suggestions = false, transport) {
     // Every terminal failure in this loop is one shape: a code, and the turn ends. Naming it keeps the
     // dozen sites readable and stops a new one inventing a different envelope.
     const fail = (code) => emit({ event: 'error', data: { code } });
     const assistant = target.served.artifact.server.assistant;
     if (!assistant)
         return fail('assistant_unavailable');
-    const binding = await resolveAssistantModelBinding(target, session.tenant, session.deploymentId, deps);
+    const binding = transport?.binding ??
+        (await resolveAssistantModelBinding(target, session.tenant, session.deploymentId, deps));
     if (!binding) {
         return emit({
             event: 'error',
@@ -98,12 +100,15 @@ export async function runAgentTurn(target, session, message, context, deps, emit
     // Across every step of this turn, not per step: eight tool calls is eight, however the model splits
     // them, or a model that loops one call per step would spend the budget a step at a time.
     let toolCallsThisTurn = 0;
+    const capabilityBudget = new CapabilityBudget();
     let omittedToolRecoveries = 0;
     let remainingTokens = binding.requestPolicy?.maxTokensPerTurn;
     const turnSignal = binding.requestPolicy?.maxTurnMs === undefined
         ? undefined
         : AbortSignal.timeout(binding.requestPolicy.maxTurnMs);
     for (let step = 0; step < bounds.steps; step += 1) {
+        await transport?.beforeStep();
+        transport?.signal.throwIfAborted();
         if (remainingTokens !== undefined && remainingTokens <= 0)
             return fail('model_token_budget_exhausted');
         const requestTokenLimit = Math.min(binding.requestPolicy?.maxCompletionTokens ?? Number.MAX_SAFE_INTEGER, remainingTokens ?? Number.MAX_SAFE_INTEGER);
@@ -116,7 +121,11 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 streamedContent += delta;
                 emit({ event: 'content', data: { delta } });
             }
-            : () => undefined, requiredToolForStep === undefined ? assistantKnowledgeModelTools(knowledge) : [], stepModelTools, requestTokenLimit === Number.MAX_SAFE_INTEGER ? undefined : requestTokenLimit, turnSignal, requiredToolForStep === undefined ? undefined : 'required');
+            : () => undefined, requiredToolForStep === undefined ? assistantKnowledgeModelTools(knowledge) : [], stepModelTools, requestTokenLimit === Number.MAX_SAFE_INTEGER ? undefined : requestTokenLimit, transport
+            ? turnSignal
+                ? AbortSignal.any([transport.signal, turnSignal])
+                : transport.signal
+            : turnSignal, requiredToolForStep === undefined ? undefined : 'required');
         stats.promptTokens += completion.usage?.promptTokens ?? 0;
         stats.completionTokens += completion.usage?.completionTokens ?? 0;
         stats.reasoningTokens += completion.usage?.reasoningTokens ?? 0;
@@ -135,7 +144,10 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             const assistantContent = response.content || streamedContent;
             if (assistantContent)
                 messages.push({ role: 'assistant', content: assistantContent });
-            if (suggestions && step + 1 < bounds.steps && (remainingTokens ?? 1) > 0) {
+            if (!isMessagingTurn(session) &&
+                suggestions &&
+                step + 1 < bounds.steps &&
+                (remainingTokens ?? 1) > 0) {
                 try {
                     const prompts = await requestAssistantSuggestedPrompts(binding, messages, assistantModelFetcher(deps.modelFetch), stats, remainingTokens, turnSignal);
                     if (prompts.length > 0) {
@@ -162,6 +174,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             stats.toolCalls += 1;
             if (toolCallsThisTurn > bounds.toolCalls)
                 return fail('tool_call_budget_exhausted');
+            await transport?.beforeStep();
             const knowledgeComponent = findAssistantKnowledgeComponent(knowledge, call.function.name);
             if (knowledge !== undefined && knowledgeComponent !== undefined) {
                 let knowledgeArgs;
@@ -203,21 +216,23 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             // The hosted broker exposes its delegated binding keys so the intercept can classify on
             // connector auth kind too; a broker without the method leaves the base classification alone.
             const delegatedKeys = target.served.deps.broker.assistantDelegatedAuthKeys?.();
-            const elevation = await interceptForElevation({
-                tool,
-                session,
-                assistant,
-                ...(target.served.artifact.server.state === undefined
-                    ? {}
-                    : { state: target.served.artifact.server.state }),
-                elevations: deps.elevations,
-                ...(delegatedKeys !== undefined && delegatedKeys.size > 0
-                    ? {
-                        requiresDelegatedIdentity: (candidate) => toolTouchesDelegatedAuth(candidate, delegatedKeys),
-                    }
-                    : {}),
-                now: deps.clock?.() ?? new Date(),
-            });
+            const elevation = isMessagingTurn(session)
+                ? undefined
+                : await interceptForElevation({
+                    tool,
+                    session,
+                    assistant,
+                    ...(target.served.artifact.server.state === undefined
+                        ? {}
+                        : { state: target.served.artifact.server.state }),
+                    elevations: deps.elevations,
+                    ...(delegatedKeys !== undefined && delegatedKeys.size > 0
+                        ? {
+                            requiresDelegatedIdentity: (candidate) => toolTouchesDelegatedAuth(candidate, delegatedKeys),
+                        }
+                        : {}),
+                    now: deps.clock?.() ?? new Date(),
+                });
             if (elevation) {
                 stats.interactionCount += 1;
                 emit(elevation.event);
@@ -243,19 +258,34 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             if (coerced.issues.length > 0)
                 return fail('invalid_tool_arguments');
             args = coerced.value;
-            const dispatch = await dispatchAssistantTool({
-                artifact: target.served.artifact,
-                tool,
-                arguments: args,
-                executeDeps: withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
-                caller: session.caller,
-                context,
-                session,
-                store: deps.store,
-                audit: deps.audit,
-                now: () => deps.clock?.() ?? new Date(),
-                onToolStarted: () => emit({ event: 'tool_started', data: { id: call.id, tool: tool.name } }),
-            });
+            await transport?.beforeStep();
+            const dispatch = isMessagingTurn(session)
+                ? await dispatchMessagingReadTool({
+                    artifact: target.served.artifact,
+                    tool,
+                    arguments: args,
+                    executeDeps: {
+                        ...target.served.deps,
+                        capabilityBudget,
+                        ...(transport?.signal ? { signal: transport.signal } : {}),
+                    },
+                    context,
+                    session,
+                    claimTool: transport?.claimTool ?? (async () => false),
+                })
+                : await dispatchAssistantTool({
+                    artifact: target.served.artifact,
+                    tool,
+                    arguments: args,
+                    executeDeps: withAssistantSessionExecutionAuthority({ ...target.served.deps, capabilityBudget }, target.served.artifact, session),
+                    caller: session.caller,
+                    context,
+                    session,
+                    store: deps.store,
+                    audit: deps.audit,
+                    now: () => deps.clock?.() ?? new Date(),
+                    onToolStarted: () => emit({ event: 'tool_started', data: { id: call.id, tool: tool.name } }),
+                });
             if (assistantModelToolOncePerSession(tool) &&
                 (dispatch.kind !== 'event' || dispatch.event !== 'error')) {
                 modelTools = modelTools.filter((candidate) => candidate.name !== tool.name);
@@ -272,8 +302,9 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 result: dispatch.output,
                 arguments: args,
             }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
-            if (view) {
-                await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
+            if (view && !isMessagingTurn(session)) {
+                if (!dispatch.ephemeral)
+                    await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
                 emit({ event: 'view_available', data: { ...view } });
             }
             messages.push({

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

@@ -1,5 +1,5 @@
 import { AssistantInteractionCapacityError, assistantConfirmationReview, assistantConfirmationTransition, assistantInputTransition, assistantInteractionTool, assistantPreparedArgumentReview, assistantPreparedToolContinuation, assistantSafeOutput, assistantToolContinuation, assistantViewAvailableData, auditAssistantInteraction, boundedAssistantExecution, recoverableAssistantView, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
-import { executePreparedTool, executeToolInteractive, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
+import { executePreparedTool, executeToolInteractive, hasEphemeralEvidence, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { applyBrowserCors, authenticateSession, now, } from './assistant.js';
 import { replayOrConflict, writeUnknownOutcome } from './assistant-interaction-replay.js';
@@ -347,7 +347,9 @@ async function finishExecution(res, deps, session, interaction, context, result,
     }
     const completedTool = target.served.artifact.tools.find((tool) => tool.name === toolName);
     const safeOutput = assistantSafeOutput(completedTool?.outputSchema, result.output);
-    const completed = await completeAssistantInteractionExecution(deps, session, interaction, 'succeeded', 'tool_completed', toolName, { result: safeOutput });
+    const ephemeral = hasEphemeralEvidence(result.output);
+    const retainedOutput = ephemeral ? { evidenceRetained: false } : safeOutput;
+    const completed = await completeAssistantInteractionExecution(deps, session, interaction, 'succeeded', 'tool_completed', toolName, { result: retainedOutput });
     if (!completed)
         return writeUnknownOutcome(res, deps, session, interaction, 'accept');
     await auditAssistantInteraction({
@@ -364,7 +366,7 @@ async function finishExecution(res, deps, session, interaction, context, result,
         // Model-facing scaffolding: the panel saw the tool_completed card, never this row's tool JSON.
         {
             role: 'assistant',
-            content: `Completed ${toolName}: ${JSON.stringify(safeOutput)}`,
+            content: `Completed ${toolName}: ${JSON.stringify(retainedOutput)}`,
             kind: 'narration',
         },
     ]);
@@ -377,7 +379,8 @@ async function finishExecution(res, deps, session, interaction, context, result,
         result: safeOutput,
     }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
     if (view) {
-        await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
+        if (!ephemeral)
+            await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
         writeViewAvailable(res, view);
     }
     await narrateResolvedInteraction(res, deps, target, session, toolName, 'accept', safeOutput, context, suggestions);

package/node_modules/@noodle-borg/service/dist/routes/assistant-model-binding.js

@@ -1,11 +1,15 @@
 import { resolveManagedVariablesInString } from '../managed-config-expressions.js';
 import { resolveConfigScope } from '../store.js';
-export async function resolveAssistantModelBinding(target, tenant, deploymentId, deps) {
+export async function resolveAssistantModelBinding(target, tenant, deploymentId, deps, channel) {
     const declaration = target.served.artifact.server.assistant?.model;
     if (declaration === undefined)
         return undefined;
     if (declaration.kind === 'noodle-managed') {
-        return deps.managedModelResolver?.resolve({ tenant, deploymentId });
+        return deps.managedModelResolver?.resolve({
+            tenant,
+            deploymentId,
+            ...(channel ? { channel } : {}),
+        });
     }
     const scope = resolveConfigScope(tenant);
     const [variables, secrets] = await Promise.all([

package/node_modules/@noodle-borg/service/dist/routes/business-information-channels.js

@@ -59,7 +59,20 @@ export async function projectBusinessChannels(installation, canEdit, base, deps)
     };
     const registered = await deps.registry.getActiveByTenant(tenant);
     const target = registered && (await resolveTargetOrigins(registered));
-    const shared = { revision: installation.revision, active: installation.intakeActive, canEdit };
+    const whatsapp = await deps.readWhatsApp?.(tenant);
+    const shared = {
+        revision: installation.revision,
+        active: installation.intakeActive,
+        canEdit,
+        ...(whatsapp
+            ? {
+                whatsapp: {
+                    ...whatsapp,
+                    ...(!installation.intakeActive ? { status: 'paused' } : {}),
+                },
+            }
+            : {}),
+    };
     if (!target?.deploymentId)
         return {
             ...shared,

package/node_modules/@noodle-borg/service/dist/routes/whatsapp.js

@@ -0,0 +1,238 @@
+import { ChannelError, channelParticipantId, recordChannelDelivery, } from '@noodle-borg/assistant-gateway/portable';
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import * as wire from '@noodle-borg/wire-contracts';
+import { parseWhatsAppWebhook, verifyWhatsAppWebhookSecret, WHATSAPP_CALLBACK_HEADER, } from '../channels/360dialog.js';
+import { authorizeTenantControl, developerGrantRouteAccess } from './control-plane.js';
+const participant = /^p_[a-f0-9]{64}$/;
+const eventId = /^e_[0-9_]+$/;
+function eventView(event) {
+    return {
+        id: event.id,
+        participantId: event.participantId,
+        state: event.state,
+        eventAt: event.eventAt,
+        receivedAt: event.receivedAt,
+        attempts: event.attempts,
+        deploymentId: event.deploymentId,
+        ...(event.code ? { code: event.code } : {}),
+    };
+}
+function respond(res, schema, data) {
+    sendJson(res, 200, schema.parse({ ok: true, data }));
+}
+async function body(req, schema) {
+    const input = await readJsonBody(req, 16_384);
+    if (!input.ok)
+        throw new ChannelError('request_invalid');
+    const parsed = schema.safeParse(input.value);
+    if (!parsed.success)
+        throw new ChannelError('request_invalid');
+    return parsed.data;
+}
+export function dispatchWhatsAppRoutes(req, res, url, runtime, grants) {
+    const callback = /^\/v1\/channels\/whatsapp\/webhooks\/([a-z0-9-]+)$/.exec(url.pathname);
+    const operator = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/channels\/whatsapp(?:\/(.*))?$/.exec(url.pathname);
+    if (!callback && !operator)
+        return false;
+    res.setHeader('Cache-Control', 'no-store');
+    if (!runtime) {
+        sendJson(res, 503, {
+            error: 'WhatsApp is unavailable on this service',
+            code: 'whatsapp_unavailable',
+        });
+        return true;
+    }
+    const run = Promise.resolve().then(() => callback
+        ? webhook(req, res, callback[1], runtime)
+        : operate(req, res, url, {
+            org: decodeURIComponent(operator[1]),
+            app: decodeURIComponent(operator[2]),
+            env: decodeURIComponent(operator[3]),
+        }, operator[4] ?? '', runtime, grants));
+    void run.catch((error) => {
+        const code = error instanceof ChannelError ? error.code : 'channel_unavailable';
+        const status = code === 'channel_not_found'
+            ? 404
+            : [
+                'revision_conflict',
+                'idempotency_conflict',
+                'asset_in_use',
+                'not_ready',
+                'deployment_changed',
+            ].includes(code)
+                ? 409
+                : code === 'channel_unavailable' || code === 'ingress_capacity'
+                    ? 503
+                    : 400;
+        if (!res.headersSent)
+            sendJson(res, status, { error: code, code });
+    });
+    return true;
+}
+async function webhook(req, res, id, runtime) {
+    if (req.method !== 'POST')
+        return sendJson(res, 405, { error: 'method_not_allowed' });
+    const binding = await runtime.channels.internal(id);
+    const { webhookSecret } = await runtime.provider(binding);
+    if (!verifyWhatsAppWebhookSecret(req.headers[WHATSAPP_CALLBACK_HEADER], webhookSecret))
+        return sendJson(res, 401, { error: 'unauthorized' });
+    const input = await readJsonBody(req, 1 << 20);
+    if (!input.ok)
+        return sendJson(res, input.status, { error: 'webhook_invalid' });
+    const batch = parseWhatsAppWebhook(input.value, binding.phoneNumberId);
+    await runtime.channels.receive(id, batch.messages, await runtime.retention(binding));
+    for (const status of batch.statuses)
+        await recordChannelDelivery(runtime.channels.store, id, status.providerMessageId, status.state, runtime.channels.now());
+    sendJson(res, 200, { ok: true });
+    runtime.options.worker.wake();
+}
+async function operate(req, res, url, tenant, path, runtime, grants) {
+    const { deps, channels } = runtime;
+    const read = req.method === 'GET';
+    const identity = await authorizeTenantControl(req, res, deps.gate, deps.controlPlane, tenant.org, developerGrantRouteAccess(grants, read ? 'cloud:read' : 'config:write'));
+    if (identity === false)
+        return;
+    const member = await deps.controlPlane.getOrgMember({
+        org: tenant.org,
+        subject: identity.subject,
+    });
+    if (!read && !identity.superAdmin && member?.role !== 'owner' && member?.role !== 'developer')
+        return sendJson(res, 403, { error: 'operator_required' });
+    const key = req.headers['idempotency-key'];
+    if (!read && (typeof key !== 'string' || !key || key.length > 200))
+        throw new ChannelError('idempotency_key_invalid');
+    const idempotency = typeof key === 'string' ? key : '';
+    const visible = await channels.get(tenant);
+    const audit = async (action) => deps.audit.emit({
+        eventType: `assistant.channel.${action}`,
+        ...tenant,
+        actorSubject: identity.subject,
+        decision: 'allow',
+        status: 200,
+    });
+    if (!path && req.method === 'GET')
+        return respond(res, wire.WhatsAppBindingResponseSchema, visible ?? null);
+    if (!path && req.method === 'PUT') {
+        const parsed = await body(req, wire.WhatsAppConfigureRequestSchema);
+        const target = await deps.registry.getActiveByTenant(tenant);
+        if (!target?.deploymentId)
+            throw new ChannelError('deployment_missing');
+        const { expectedRevision, ...configuration } = parsed;
+        const configured = await channels.configure({ ...configuration, tenant, deploymentId: target.deploymentId }, identity.subject, idempotency, expectedRevision);
+        await audit('configured');
+        return respond(res, wire.WhatsAppBindingResponseSchema, configured);
+    }
+    if (!visible)
+        throw new ChannelError('channel_not_found');
+    const id = visible.id;
+    if (path === 'readiness' && req.method === 'POST') {
+        await body(req, wire.WhatsAppEmptyRequestSchema);
+        return respond(res, wire.WhatsAppReadinessResponseSchema, await runtime.doctor(id, req));
+    }
+    if ((path === 'state' && req.method === 'PATCH') || (!path && req.method === 'DELETE')) {
+        const parsed = path
+            ? await body(req, wire.WhatsAppStateRequestSchema)
+            : {
+                ...(await body(req, wire.WhatsAppRevisionRequestSchema)),
+                state: 'disconnected',
+            };
+        const updated = await channels.setState(id, parsed.state, identity.subject, idempotency, parsed.expectedRevision);
+        await audit(parsed.state);
+        return respond(res, wire.WhatsAppBindingResponseSchema, updated);
+    }
+    if (path === 'limits' && req.method === 'GET')
+        return respond(res, wire.WhatsAppBindingResponseSchema, visible);
+    if (path === 'limits' && req.method === 'PATCH') {
+        const parsed = await body(req, wire.WhatsAppLimitsRequestSchema);
+        const updated = await channels.updateLimits(id, parsed.limits, identity.subject, idempotency, parsed.expectedRevision);
+        await audit('limits_changed');
+        return respond(res, wire.WhatsAppBindingResponseSchema, updated);
+    }
+    if (path === 'usage' && read)
+        return respond(res, wire.WhatsAppUsageResponseSchema, await channels.usage(id));
+    if (path === 'webhook' && (read || req.method === 'POST')) {
+        if (!read) {
+            const parsed = await body(req, wire.WhatsAppRevisionRequestSchema);
+            if (parsed.expectedRevision !== visible.revision)
+                throw new ChannelError('revision_conflict');
+            await runtime.configureWebhook(id, req);
+            await audit('webhook_configured');
+        }
+        return respond(res, wire.WhatsAppWebhookResponseSchema, await runtime.webhook(id, req));
+    }
+    if (path === 'blocks' && read) {
+        const after = url.searchParams.get('after') ?? undefined;
+        if (after && !participant.test(after))
+            throw new ChannelError('request_invalid');
+        return sendJson(res, 200, wire.WhatsAppBlocksResponseSchema.parse({ ok: true, ...(await runtime.blocks(id, after)) }));
+    }
+    if (path === 'blocks' && req.method === 'POST') {
+        const parsed = await body(req, wire.WhatsAppBlockRequestSchema);
+        const participantId = parsed.participantId ??
+            channelParticipantId(await channels.internal(id), {
+                kind: 'phone',
+                value: parsed.phone.slice(1),
+            });
+        await channels.block(id, participantId, identity.subject, idempotency, parsed.until);
+        if (parsed.scope === 'provider')
+            await runtime.providerBlock(id, participantId, true, identity.subject, idempotency);
+        await audit('blocked');
+        return sendJson(res, 200, wire.WhatsAppMutationResponseSchema.parse({ ok: true }));
+    }
+    const [kind, value, action] = path.split('/');
+    if (kind === 'blocks' && value && participant.test(value) && req.method === 'DELETE') {
+        const parsed = await body(req, wire.WhatsAppUnblockRequestSchema);
+        if (parsed.scope === 'provider')
+            await runtime.providerBlock(id, value, false, identity.subject, idempotency, parsed.phone);
+        else
+            await channels.unblock(id, value, identity.subject, idempotency);
+        await audit('unblocked');
+        return sendJson(res, 200, { ok: true });
+    }
+    if (kind === 'cooldowns' &&
+        value &&
+        participant.test(value) &&
+        (read || req.method === 'DELETE')) {
+        if (!read) {
+            await body(req, wire.WhatsAppEmptyRequestSchema);
+            await channels.clearCooldown(id, value, identity.subject, idempotency);
+            await audit('cooldown_cleared');
+        }
+        return respond(res, wire.WhatsAppCooldownResponseSchema, await channels.cooldown(id, value));
+    }
+    if (kind === 'participants' &&
+        value &&
+        participant.test(value) &&
+        action === 'forget' &&
+        req.method === 'POST') {
+        await body(req, wire.WhatsAppEmptyRequestSchema);
+        await channels.forget(id, value, identity.subject, idempotency);
+        await audit('conversation_forgotten');
+        return sendJson(res, 200, { ok: true });
+    }
+    if (kind === 'events' &&
+        (!value || eventId.test(value)) &&
+        (read || (action === 'reconcile' && req.method === 'POST'))) {
+        if (!read) {
+            await body(req, wire.WhatsAppEmptyRequestSchema);
+            await audit('receipt_inspected');
+        }
+        if (value) {
+            const event = await channels.event(id, value);
+            if (!event)
+                throw new ChannelError('event_not_found');
+            return respond(res, wire.WhatsAppEventsResponseSchema, [eventView(event)]);
+        }
+        const after = url.searchParams.get('after') ?? undefined;
+        if (after && !eventId.test(after))
+            throw new ChannelError('cursor_invalid');
+        const events = await channels.events(id, after);
+        return sendJson(res, 200, wire.WhatsAppEventsResponseSchema.parse({
+            ok: true,
+            data: events.map(eventView),
+            ...(events.length === 100 ? { next: events.at(-1).id } : {}),
+        }));
+    }
+    sendJson(res, 404, { error: 'not_found' });
+}
+//# sourceMappingURL=whatsapp.js.map

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

@@ -3,6 +3,7 @@ import { InMemoryControlPlaneStore } from '@noodle-borg/control-plane/portable';
 import { InMemoryAssetStore } from './assets.js';
 import { createCustomerVerifierFactory, createHostedCustomerVerifierFactory, createLocalDevtoolsCustomerVerifierFactory, } from './customer-verifier.js';
 import { createLocalDevtoolsDelegatedCredentialSource } from './local-devtools-delegated-credentials.js';
+import { localWebCapabilities } from './local-web-capabilities.js';
 import { ServerRegistry } from './registry.js';
 import { isLoopbackHost } from './serve-resource-auth.js';
 import { createServiceHandler } from './service.js';
@@ -48,7 +49,9 @@ export async function serveLocalService(options = {}) {
     const delegatedCredentials = directCustomerAuth
         ? createLocalDevtoolsDelegatedCredentialSource()
         : undefined;
+    const capabilities = options.runtime?.capabilities ?? localWebCapabilities();
     const registry = new ServerRegistry(undefined, undefined, configStore, {
+        capabilities,
         customerVerifierFactory,
         ...(delegatedCredentials === undefined
             ? {}
@@ -62,6 +65,17 @@ export async function serveLocalService(options = {}) {
             : { localDevtoolsDelegatedExchange: options.localDevtoolsDelegatedExchange }),
     });
     const handler = createServiceHandler(registry, {
+        capabilities,
+        deployGate: {
+            authorize: () => ({
+                ok: true,
+                identity: {
+                    subject: 'local-operator',
+                    email: 'local-operator@localhost',
+                    superAdmin: true,
+                },
+            }),
+        },
         controlPlaneStore,
         configStore,
         assetStore: new InMemoryAssetStore(),

package/node_modules/@noodle-borg/service/dist/serve-resource-auth.js

@@ -1,10 +1,20 @@
 import { resolveMcpSubdomainTenant } from '@noodle-borg/control-plane/portable';
 import { normalizePublicBaseDomain, parseCanonicalPublicMcpUrl, parseLegacyTenantMcpPath, } from '@noodle-borg/module';
 import { resolveTenantBridgeAuthVariables } from './managed-config-expressions.js';
+import { createHostedMcpRequestStateManager } from './mcp-protocol-runtime.js';
 import { resolveConfigScope, } from './store.js';
 export function isLoopbackHost(host) {
     return host === '127.0.0.1' || host === '::1' || host === 'localhost';
 }
+export function resolveMcpRequestState(options, secretBox) {
+    return (options.mcpRequestState ??
+        createHostedMcpRequestStateManager({
+            ...(options.wrappingMasterKey === undefined && options.secretMasterKey !== undefined
+                ? { secretMasterKey: options.secretMasterKey }
+                : {}),
+            ...(secretBox === undefined ? {} : { secretBox }),
+        }));
+}
 export function assertLocalDevtoolsServiceBoundary(host, options) {
     if (options.localDevtoolsDirectFirebaseAuth === true && !isLoopbackHost(host)) {
         throw new Error('local Devtools Firebase verification requires a loopback service bind');